9 - shuffle operand type tag to after operand value

This organization should permit multiple metadata tags beyond just type.
Starting to feel some pain from code not being DRY.
Issues that took debugging: a poor search-and-replace, and shuffling offset in convert-braces.

1 files changed, 199 insertions, 199 deletions

diff --git a/mu.arc.t b/mu.arc.t
index 9bba48e3..a054a48e 100644
--- a/mu.arc.t
+++ b/mu.arc.t
@@ -2,16 +2,16 @@
 
 (clear)
 (add-fns '((test1
-  ((integer 1) <- literal 1))))
+  ((1 integer) <- literal 1))))
 (run function*!test1)
 (if (~iso memory* (obj 1 1))
   (prn "F - 'literal' writes a literal value (its lone 'arg' after the instruction name) to a location in memory (an address) specified by its lone 'oarg' or output arg before the arrow"))
 
 (clear)
 (add-fns '((test1
-  ((integer 1) <- literal 1)
-  ((integer 2) <- literal 3)
-  ((integer 3) <- add (integer 1) (integer 2)))))
+  ((1 integer) <- literal 1)
+  ((2 integer) <- literal 3)
+  ((3 integer) <- add (1 integer) (2 integer)))))
 (run function*!test1)
 (if (~iso memory* (obj 1 1  2 3  3 4))
   (prn "F - 'add' operates on two addresses"))
@@ -19,10 +19,10 @@
 (clear)
 (add-fns
   '((test1
-      ((integer 3) <- add (integer 1) (integer 2)))
+      ((3 integer) <- add (1 integer) (2 integer)))
     (main
-      ((integer 1) <- literal 1)
-      ((integer 2) <- literal 3)
+      ((1 integer) <- literal 1)
+      ((2 integer) <- literal 3)
       (test1))))
 (run function*!main)
 ;? (prn memory*)
@@ -32,12 +32,12 @@
 (clear)
 (add-fns
   '((test1
-      ((integer 3) <- add (integer 1) (integer 2))
+      ((3 integer) <- add (1 integer) (2 integer))
       (reply)
-      ((integer 4) <- literal 34))
+      ((4 integer) <- literal 34))
     (main
-      ((integer 1) <- literal 1)
-      ((integer 2) <- literal 3)
+      ((1 integer) <- literal 1)
+      ((2 integer) <- literal 3)
       (test1))))
 (run function*!main)
 ;? (prn memory*)
@@ -48,15 +48,15 @@
 (clear)
 (add-fns
   '((test1
-      ((integer 4) <- arg)
-      ((integer 5) <- arg)
-      ((integer 3) <- add (integer 4) (integer 5))
+      ((4 integer) <- arg)
+      ((5 integer) <- arg)
+      ((3 integer) <- add (4 integer) (5 integer))
       (reply)
-      ((integer 4) <- literal 34))
+      ((4 integer) <- literal 34))
     (main
-      ((integer 1) <- literal 1)
-      ((integer 2) <- literal 3)
-      (test1 (integer 1) (integer 2))
+      ((1 integer) <- literal 1)
+      ((2 integer) <- literal 3)
+      (test1 (1 integer) (2 integer))
     )))
 (run function*!main)
 ;? (prn memory*)
@@ -69,15 +69,15 @@
 (clear)
 (add-fns
   '((test1
-      ((integer 5) <- arg 1)
-      ((integer 4) <- arg 0)
-      ((integer 3) <- add (integer 4) (integer 5))
+      ((5 integer) <- arg 1)
+      ((4 integer) <- arg 0)
+      ((3 integer) <- add (4 integer) (5 integer))
       (reply)
-      ((integer 4) <- literal 34))
+      ((4 integer) <- literal 34))
     (main
-      ((integer 1) <- literal 1)
-      ((integer 2) <- literal 3)
-      (test1 (integer 1) (integer 2))
+      ((1 integer) <- literal 1)
+      ((2 integer) <- literal 3)
+      (test1 (1 integer) (2 integer))
     )))
 (run function*!main)
 ;? (prn memory*)
@@ -90,15 +90,15 @@
 (clear)
 (add-fns
   '((test1
-      ((integer 4) <- arg)
-      ((integer 5) <- arg)
-      ((integer 6) <- add (integer 4) (integer 5))
-      (reply (integer 6))
-      ((integer 4) <- literal 34))
+      ((4 integer) <- arg)
+      ((5 integer) <- arg)
+      ((6 integer) <- add (4 integer) (5 integer))
+      (reply (6 integer))
+      ((4 integer) <- literal 34))
     (main
-      ((integer 1) <- literal 1)
-      ((integer 2) <- literal 3)
-      ((integer 3) <- test1 (integer 1) (integer 2)))))
+      ((1 integer) <- literal 1)
+      ((2 integer) <- literal 3)
+      ((3 integer) <- test1 (1 integer) (2 integer)))))
 (run function*!main)
 ;? (prn memory*)
 (if (~iso memory* (obj 1 1  2 3  3 4
@@ -109,15 +109,15 @@
 (clear)
 (add-fns
   '((test1
-      ((integer 4) <- arg)
-      ((integer 5) <- arg)
-      ((integer 6) <- add (integer 4) (integer 5))
-      (reply (integer 6) (integer 5))
-      ((integer 4) <- literal 34))
+      ((4 integer) <- arg)
+      ((5 integer) <- arg)
+      ((6 integer) <- add (4 integer) (5 integer))
+      (reply (6 integer) (5 integer))
+      ((4 integer) <- literal 34))
     (main
-      ((integer 1) <- literal 1)
-      ((integer 2) <- literal 3)
-      ((integer 3) (integer 7) <- test1 (integer 1) (integer 2)))))
+      ((1 integer) <- literal 1)
+      ((2 integer) <- literal 3)
+      ((3 integer) (7 integer) <- test1 (1 integer) (2 integer)))))
 (run function*!main)
 ;? (prn memory*)
 (if (~iso memory* (obj 1 1  2 3  3 4    7 3
@@ -128,9 +128,9 @@
 (clear)
 (add-fns
   '((main
-      ((integer 1) <- literal 1)
-      ((integer 2) <- literal 3)
-      ((integer 3) <- sub (integer 1) (integer 2)))))
+      ((1 integer) <- literal 1)
+      ((2 integer) <- literal 3)
+      ((3 integer) <- sub (1 integer) (2 integer)))))
 (run function*!main)
 ;? (prn memory*)
 (if (~iso memory* (obj 1 1  2 3  3 -2))
@@ -139,9 +139,9 @@
 (clear)
 (add-fns
   '((main
-      ((integer 1) <- literal 2)
-      ((integer 2) <- literal 3)
-      ((integer 3) <- mul (integer 1) (integer 2)))))
+      ((1 integer) <- literal 2)
+      ((2 integer) <- literal 3)
+      ((3 integer) <- mul (1 integer) (2 integer)))))
 (run function*!main)
 ;? (prn memory*)
 (if (~iso memory* (obj 1 2  2 3  3 6))
@@ -150,9 +150,9 @@
 (clear)
 (add-fns
   '((main
-      ((integer 1) <- literal 8)
-      ((integer 2) <- literal 3)
-      ((integer 3) <- div (integer 1) (integer 2)))))
+      ((1 integer) <- literal 8)
+      ((2 integer) <- literal 3)
+      ((3 integer) <- div (1 integer) (2 integer)))))
 (run function*!main)
 ;? (prn memory*)
 (if (~iso memory* (obj 1 8  2 3  3 (/ real.8 3)))
@@ -161,9 +161,9 @@
 (clear)
 (add-fns
   '((main
-      ((integer 1) <- literal 8)
-      ((integer 2) <- literal 3)
-      ((integer 3) (integer 4) <- idiv (integer 1) (integer 2)))))
+      ((1 integer) <- literal 8)
+      ((2 integer) <- literal 3)
+      ((3 integer) (4 integer) <- idiv (1 integer) (2 integer)))))
 (run function*!main)
 ;? (prn memory*)
 (if (~iso memory* (obj 1 8  2 3  3 2  4 2))
@@ -172,9 +172,9 @@
 (clear)
 (add-fns
   '((main
-      ((boolean 1) <- literal t)
-      ((boolean 2) <- literal nil)
-      ((boolean 3) <- and (boolean 1) (boolean 2)))))
+      ((1 boolean) <- literal t)
+      ((2 boolean) <- literal nil)
+      ((3 boolean) <- and (1 boolean) (2 boolean)))))
 (run function*!main)
 ;? (prn memory*)
 (if (~iso memory* (obj 1 t  2 nil  3 nil))
@@ -183,9 +183,9 @@
 (clear)
 (add-fns
   '((main
-      ((boolean 1) <- literal 4)
-      ((boolean 2) <- literal 3)
-      ((boolean 3) <- lt (boolean 1) (boolean 2)))))
+      ((1 boolean) <- literal 4)
+      ((2 boolean) <- literal 3)
+      ((3 boolean) <- lt (1 boolean) (2 boolean)))))
 (run function*!main)
 ;? (prn memory*)
 (if (~iso memory* (obj 1 4  2 3  3 nil))
@@ -194,9 +194,9 @@
 (clear)
 (add-fns
   '((main
-      ((boolean 1) <- literal 4)
-      ((boolean 2) <- literal 3)
-      ((boolean 3) <- le (boolean 1) (boolean 2)))))
+      ((1 boolean) <- literal 4)
+      ((2 boolean) <- literal 3)
+      ((3 boolean) <- le (1 boolean) (2 boolean)))))
 (run function*!main)
 ;? (prn memory*)
 (if (~iso memory* (obj 1 4  2 3  3 nil))
@@ -205,9 +205,9 @@
 (clear)
 (add-fns
   '((main
-      ((boolean 1) <- literal 4)
-      ((boolean 2) <- literal 4)
-      ((boolean 3) <- le (boolean 1) (boolean 2)))))
+      ((1 boolean) <- literal 4)
+      ((2 boolean) <- literal 4)
+      ((3 boolean) <- le (1 boolean) (2 boolean)))))
 (run function*!main)
 ;? (prn memory*)
 (if (~iso memory* (obj 1 4  2 4  3 t))
@@ -216,9 +216,9 @@
 (clear)
 (add-fns
   '((main
-      ((boolean 1) <- literal 4)
-      ((boolean 2) <- literal 5)
-      ((boolean 3) <- le (boolean 1) (boolean 2)))))
+      ((1 boolean) <- literal 4)
+      ((2 boolean) <- literal 5)
+      ((3 boolean) <- le (1 boolean) (2 boolean)))))
 (run function*!main)
 ;? (prn memory*)
 (if (~iso memory* (obj 1 4  2 5  3 t))
@@ -227,9 +227,9 @@
 (clear)
 (add-fns
   '((main
-      ((integer 1) <- literal 8)
-      (jmp (offset 1))
-      ((integer 2) <- literal 3)
+      ((1 integer) <- literal 8)
+      (jmp (1 offset))
+      ((2 integer) <- literal 3)
       (reply))))
 (run function*!main)
 ;? (prn memory*)
@@ -239,11 +239,11 @@
 (clear)
 (add-fns
   '((main
-      ((integer 1) <- literal 8)
-      (jmp (offset 1))
-      ((integer 2) <- literal 3)
+      ((1 integer) <- literal 8)
+      (jmp (1 offset))
+      ((2 integer) <- literal 3)
       (reply)
-      ((integer 3) <- literal 34))))
+      ((3 integer) <- literal 34))))
 (run function*!main)
 ;? (prn memory*)
 (if (~iso memory* (obj 1 8))
@@ -252,13 +252,13 @@
 (clear)
 (add-fns
   '((main
-      ((integer 1) <- literal 1)
-      ((integer 2) <- literal 1)
-      ((boolean 3) <- eq (integer 1) (integer 2))
-      (jif (boolean 3) (offset 1))
-      ((integer 2) <- literal 3)
+      ((1 integer) <- literal 1)
+      ((2 integer) <- literal 1)
+      ((3 boolean) <- eq (1 integer) (2 integer))
+      (jif (3 boolean) (1 offset))
+      ((2 integer) <- literal 3)
       (reply)
-      ((integer 3) <- literal 34))))
+      ((3 integer) <- literal 34))))
 (run function*!main)
 ;? (prn memory*)
 (if (~iso memory* (obj 1 1  2 1  3 t))
@@ -267,13 +267,13 @@
 (clear)
 (add-fns
   '((main
-      ((integer 1) <- literal 1)
-      ((integer 2) <- literal 2)
-      ((boolean 3) <- eq (integer 1) (integer 2))
-      (jif (boolean 3) (offset 1))
-      ((integer 4) <- literal 3)
+      ((1 integer) <- literal 1)
+      ((2 integer) <- literal 2)
+      ((3 boolean) <- eq (1 integer) (2 integer))
+      (jif (3 boolean) (1 offset))
+      ((4 integer) <- literal 3)
       (reply)
-      ((integer 3) <- literal 34))))
+      ((3 integer) <- literal 34))))
 (run function*!main)
 ;? (prn memory*)
 (if (~iso memory* (obj 1 1  2 2  3 nil  4 3))
@@ -282,14 +282,14 @@
 (clear)
 (add-fns
   '((main
-      ((integer 1) <- literal 2)
-      ((integer 2) <- literal 1)
-      ((integer 2) <- add (integer 2) (integer 2))
-      ((boolean 3) <- eq (integer 1) (integer 2))
-      (jif (boolean 3) (offset -3))
-      ((integer 4) <- literal 3)
+      ((1 integer) <- literal 2)
+      ((2 integer) <- literal 1)
+      ((2 integer) <- add (2 integer) (2 integer))
+      ((3 boolean) <- eq (1 integer) (2 integer))
+      (jif (3 boolean) (-3 offset))
+      ((4 integer) <- literal 3)
       (reply)
-      ((integer 3) <- literal 34))))
+      ((3 integer) <- literal 34))))
 (run function*!main)
 ;? (prn memory*)
 (if (~iso memory* (obj 1 2  2 4  3 nil  4 3))
@@ -298,18 +298,18 @@
 (clear)
 (add-fns
   '((test1
-      ((type 4) <- otype 0)
-      ((type 5) <- literal integer)
-      ((boolean 6) <- neq (type 4) (type 5))
-      (jif (boolean 6) (offset 3))
-      ((integer 7) <- arg)
-      ((integer 8) <- arg)
-      ((integer 9) <- add (integer 7) (integer 8))
-      (reply (integer 9)))
+      ((4 type) <- otype 0)
+      ((5 type) <- literal integer)
+      ((6 boolean) <- neq (4 type) (5 type))
+      (jif (6 boolean) (3 offset))
+      ((7 integer) <- arg)
+      ((8 integer) <- arg)
+      ((9 integer) <- add (7 integer) (8 integer))
+      (reply (9 integer)))
     (main
-      ((integer 1) <- literal 1)
-      ((integer 2) <- literal 3)
-      ((integer 3) <- test1 (integer 1) (integer 2)))))
+      ((1 integer) <- literal 1)
+      ((2 integer) <- literal 3)
+      ((3 integer) <- test1 (1 integer) (2 integer)))))
 (run function*!main)
 ;? (prn memory*)
 (if (~iso memory* (obj 1 1  2 3                     3 4
@@ -320,25 +320,25 @@
 (clear)
 (add-fns
   '((add-fn
-      ((type 4) <- otype 0)
-      ((type 5) <- literal integer)
-      ((boolean 6) <- neq (type 4) (type 5))
-      (jif (boolean 6) (offset 4))
-      ((integer 7) <- arg)
-      ((integer 8) <- arg)
-      ((integer 9) <- add (integer 7) (integer 8))
-      (reply (integer 9))
-      ((type 5) <- literal boolean)
-      ((boolean 6) <- neq (type 4) (type 5))
-      (jif (boolean 6) (offset 6))
-      ((boolean 7) <- arg)
-      ((boolean 8) <- arg)
-      ((boolean 9) <- or (boolean 7) (boolean 8))
-      (reply (boolean 9)))
+      ((4 type) <- otype 0)
+      ((5 type) <- literal integer)
+      ((6 boolean) <- neq (4 type) (5 type))
+      (jif (6 boolean) (4 offset))
+      ((7 integer) <- arg)
+      ((8 integer) <- arg)
+      ((9 integer) <- add (7 integer) (8 integer))
+      (reply (9 integer))
+      ((5 type) <- literal boolean)
+      ((6 boolean) <- neq (4 type) (5 type))
+      (jif (6 boolean) (6 offset))
+      ((7 boolean) <- arg)
+      ((8 boolean) <- arg)
+      ((9 boolean) <- or (7 boolean) (8 boolean))
+      (reply (9 boolean)))
     (main
-      ((boolean 1) <- literal t)
-      ((boolean 2) <- literal t)
-      ((boolean 3) <- add-fn (boolean 1) (boolean 2)))))
+      ((1 boolean) <- literal t)
+      ((2 boolean) <- literal t)
+      ((3 boolean) <- add-fn (1 boolean) (2 boolean)))))
 (run function*!main)
 ;? (prn memory*)
 (if (~iso memory* (obj ; first call to add-fn
@@ -350,28 +350,28 @@
 (clear)
 (add-fns
   '((add-fn
-      ((type 4) <- otype 0)
-      ((type 5) <- literal integer)
-      ((boolean 6) <- neq (type 4) (type 5))
-      (jif (boolean 6) (offset 4))
-      ((integer 7) <- arg)
-      ((integer 8) <- arg)
-      ((integer 9) <- add (integer 7) (integer 8))
-      (reply (integer 9))
-      ((type 5) <- literal boolean)
-      ((boolean 6) <- neq (type 4) (type 5))
-      (jif (boolean 6) (offset 6))
-      ((boolean 7) <- arg)
-      ((boolean 8) <- arg)
-      ((boolean 9) <- or (boolean 7) (boolean 8))
-      (reply (boolean 9)))
+      ((4 type) <- otype 0)
+      ((5 type) <- literal integer)
+      ((6 boolean) <- neq (4 type) (5 type))
+      (jif (6 boolean) (4 offset))
+      ((7 integer) <- arg)
+      ((8 integer) <- arg)
+      ((9 integer) <- add (7 integer) (8 integer))
+      (reply (9 integer))
+      ((5 type) <- literal boolean)
+      ((6 boolean) <- neq (4 type) (5 type))
+      (jif (6 boolean) (6 offset))
+      ((7 boolean) <- arg)
+      ((8 boolean) <- arg)
+      ((9 boolean) <- or (7 boolean) (8 boolean))
+      (reply (9 boolean)))
     (main
-      ((boolean 1) <- literal t)
-      ((boolean 2) <- literal t)
-      ((boolean 3) <- add-fn (boolean 1) (boolean 2))
-      ((integer 10) <- literal 3)
-      ((integer 11) <- literal 4)
-      ((integer 12) <- add-fn (integer 10) (integer 11)))))
+      ((1 boolean) <- literal t)
+      ((2 boolean) <- literal t)
+      ((3 boolean) <- add-fn (1 boolean) (2 boolean))
+      ((10 integer) <- literal 3)
+      ((11 integer) <- literal 4)
+      ((12 integer) <- add-fn (10 integer) (11 integer)))))
 (run function*!main)
 ;? (prn memory*)
 (if (~iso memory* (obj ; first call to add-fn
@@ -382,88 +382,88 @@
                          4 'integer  5 'integer  6 nil  7 3  8 4  9 7))
   (prn "F - different calls can exercise different clauses of the same function"))
 
-(if (~iso (convert-braces '(((integer 1) <- literal 4)
-                            ((integer 2) <- literal 2)
-                            ((integer 3) <- add (integer 2) (integer 2))
+(if (~iso (convert-braces '(((1 integer) <- literal 4)
+                            ((2 integer) <- literal 2)
+                            ((3 integer) <- add (2 integer) (2 integer))
                             { begin  ; 'begin' is just a hack because racket turns curlies into parens
-                            ((boolean 4) <- neq (integer 1) (integer 3))
-                            (breakif (boolean 4))
-                            ((integer 5) <- literal 34)
+                            ((4 boolean) <- neq (1 integer) (3 integer))
+                            (breakif (4 boolean))
+                            ((5 integer) <- literal 34)
                             }
                             (reply)))
-          '(((integer 1) <- literal 4)
-            ((integer 2) <- literal 2)
-            ((integer 3) <- add (integer 2) (integer 2))
-            ((boolean 4) <- neq (integer 1) (integer 3))
-            (jif (boolean 4) (offset 1))
-            ((integer 5) <- literal 34)
+          '(((1 integer) <- literal 4)
+            ((2 integer) <- literal 2)
+            ((3 integer) <- add (2 integer) (2 integer))
+            ((4 boolean) <- neq (1 integer) (3 integer))
+            (jif (4 boolean) (1 offset))
+            ((5 integer) <- literal 34)
             (reply)))
   (prn "F - convert-braces replaces breakif with a jif to after the next close curly"))
 
-(if (~iso (convert-braces '(((integer 1) <- literal 4)
-                            ((integer 2) <- literal 2)
-                            ((integer 3) <- add (integer 2) (integer 2))
+(if (~iso (convert-braces '(((1 integer) <- literal 4)
+                            ((2 integer) <- literal 2)
+                            ((3 integer) <- add (2 integer) (2 integer))
                             { begin
                             (break)
                             }
                             (reply)))
-          '(((integer 1) <- literal 4)
-            ((integer 2) <- literal 2)
-            ((integer 3) <- add (integer 2) (integer 2))
-            (jmp (offset 0))
+          '(((1 integer) <- literal 4)
+            ((2 integer) <- literal 2)
+            ((3 integer) <- add (2 integer) (2 integer))
+            (jmp (0 offset))
             (reply)))
   (prn "F - convert-braces works for degenerate blocks"))
 
-(if (~iso (convert-braces '(((integer 1) <- literal 4)
-                            ((integer 2) <- literal 2)
-                            ((integer 3) <- add (integer 2) (integer 2))
+(if (~iso (convert-braces '(((1 integer) <- literal 4)
+                            ((2 integer) <- literal 2)
+                            ((3 integer) <- add (2 integer) (2 integer))
                             { begin
-                            ((boolean 4) <- neq (integer 1) (integer 3))
-                            (breakif (boolean 4))
+                            ((4 boolean) <- neq (1 integer) (3 integer))
+                            (breakif (4 boolean))
                             { begin
-                            ((integer 5) <- literal 34)
+                            ((5 integer) <- literal 34)
                             }
                             }
                             (reply)))
-          '(((integer 1) <- literal 4)
-            ((integer 2) <- literal 2)
-            ((integer 3) <- add (integer 2) (integer 2))
-            ((boolean 4) <- neq (integer 1) (integer 3))
-            (jif (boolean 4) (offset 1))
-            ((integer 5) <- literal 34)
+          '(((1 integer) <- literal 4)
+            ((2 integer) <- literal 2)
+            ((3 integer) <- add (2 integer) (2 integer))
+            ((4 boolean) <- neq (1 integer) (3 integer))
+            (jif (4 boolean) (1 offset))
+            ((5 integer) <- literal 34)
             (reply)))
   (prn "F - convert-braces balances curlies when converting break"))
 
-(if (~iso (convert-braces '(((integer 1) <- literal 4)
-                            ((integer 2) <- literal 2)
+(if (~iso (convert-braces '(((1 integer) <- literal 4)
+                            ((2 integer) <- literal 2)
                             { begin
-                            ((integer 3) <- add (integer 2) (integer 2))
+                            ((3 integer) <- add (2 integer) (2 integer))
                             { begin
-                            ((boolean 4) <- neq (integer 1) (integer 3))
+                            ((4 boolean) <- neq (1 integer) (3 integer))
                             }
-                            (continueif (boolean 4))
-                            ((integer 5) <- literal 34)
+                            (continueif (4 boolean))
+                            ((5 integer) <- literal 34)
                             }
                             (reply)))
-          '(((integer 1) <- literal 4)
-            ((integer 2) <- literal 2)
-            ((integer 3) <- add (integer 2) (integer 2))
-            ((boolean 4) <- neq (integer 1) (integer 3))
-            (jif (boolean 4) (offset -3))
-            ((integer 5) <- literal 34)
+          '(((1 integer) <- literal 4)
+            ((2 integer) <- literal 2)
+            ((3 integer) <- add (2 integer) (2 integer))
+            ((4 boolean) <- neq (1 integer) (3 integer))
+            (jif (4 boolean) (-3 offset))
+            ((5 integer) <- literal 34)
             (reply)))
   (prn "F - convert-braces balances curlies when converting continue"))
 
 (clear)
-(add-fns `((main ,@(convert-braces '(((integer 1) <- literal 4)
-                                     ((integer 2) <- literal 1)
+(add-fns `((main ,@(convert-braces '(((1 integer) <- literal 4)
+                                     ((2 integer) <- literal 1)
                                      { begin
-                                     ((integer 2) <- add (integer 2) (integer 2))
+                                     ((2 integer) <- add (2 integer) (2 integer))
                                      { begin
-                                     ((boolean 3) <- neq (integer 1) (integer 2))
+                                     ((3 boolean) <- neq (1 integer) (2 integer))
                                      }
-                                     (continueif (boolean 3))
-                                     ((integer 4) <- literal 34)
+                                     (continueif (3 boolean))
+                                     ((4 integer) <- literal 34)
                                      }
                                      (reply))))))
 (run function*!main)
@@ -472,15 +472,15 @@
   (prn "F - continue correctly loops"))
 
 (clear)
-(add-fns `((main ,@(convert-braces '(((integer 1) <- literal 4)
-                                     ((integer 2) <- literal 2)
+(add-fns `((main ,@(convert-braces '(((1 integer) <- literal 4)
+                                     ((2 integer) <- literal 2)
                                      { begin
-                                     ((integer 2) <- add (integer 2) (integer 2))
+                                     ((2 integer) <- add (2 integer) (2 integer))
                                      { begin
-                                     ((boolean 3) <- neq (integer 1) (integer 2))
+                                     ((3 boolean) <- neq (1 integer) (2 integer))
                                      }
-                                     (continueif (boolean 3))
-                                     ((integer 4) <- literal 34)
+                                     (continueif (3 boolean))
+                                     ((4 integer) <- literal 34)
                                      }
                                      (reply))))))
 (run function*!main)