Easy to use Rev constants.

5 files changed, 16 insertions, 16 deletions

diff --git a/stdlib/source/spec/compositor/generation/case.lux b/stdlib/source/spec/compositor/generation/case.lux
index b4fa47b99..764d7351b 100644
--- a/stdlib/source/spec/compositor/generation/case.lux
+++ b/stdlib/source/spec/compositor/generation/case.lux
@@ -64,9 +64,9 @@
                     [r.i64         synthesis.i64  synthesis.path/i64]
                     [r.frac        synthesis.f64  synthesis.path/f64]
                     [(r.unicode 5) synthesis.text synthesis.path/text]))
-              (do {@ r.monad}
+              (do {! r.monad}
                 [size ..size
-                 idx (|> r.nat (:: @ map (n.% size)))
+                 idx (|> r.nat (:: ! map (n.% size)))
                  [subS subP] case
                  #let [unitS (synthesis.text synthesis.unit)
                        caseS (synthesis.tuple
@@ -79,9 +79,9 @@
                                    (synthesis.member/left idx))
                                  subP)]]
                 (wrap [caseS caseP]))
-              (do {@ r.monad}
+              (do {! r.monad}
                 [size ..size
-                 idx (|> r.nat (:: @ map (n.% size)))
+                 idx (|> r.nat (:: ! map (n.% size)))
                  [subS subP] case
                  #let [right? (tail? size idx)
                        caseS (synthesis.variant
diff --git a/stdlib/source/spec/compositor/generation/common.lux b/stdlib/source/spec/compositor/generation/common.lux
index 5868191c4..9060675f6 100644
--- a/stdlib/source/spec/compositor/generation/common.lux
+++ b/stdlib/source/spec/compositor/generation/common.lux
@@ -174,13 +174,13 @@
 
 (def: (text run)
   (-> Runner Test)
-  (do {@ r.monad}
-    [sample-size (|> r.nat (:: @ map (|>> (n.% 10) (n.max 1))))
+  (do {! r.monad}
+    [sample-size (|> r.nat (:: ! map (|>> (n.% 10) (n.max 1))))
      sample-lower (r.ascii/lower-alpha sample-size)
      sample-upper (r.ascii/upper-alpha sample-size)
      sample-alpha (|> (r.ascii/alpha sample-size)
                       (r.filter (|>> (text@= sample-upper) not)))
-     char-idx (|> r.nat (:: @ map (n.% sample-size)))
+     char-idx (|> r.nat (:: ! map (n.% sample-size)))
      #let [sample-lowerS (synthesis.text sample-lower)
            sample-upperS (synthesis.text sample-upper)
            sample-alphaS (synthesis.text sample-alpha)
diff --git a/stdlib/source/spec/compositor/generation/function.lux b/stdlib/source/spec/compositor/generation/function.lux
index e3112d799..fefe039f7 100644
--- a/stdlib/source/spec/compositor/generation/function.lux
+++ b/stdlib/source/spec/compositor/generation/function.lux
@@ -47,9 +47,9 @@
 
 (def: #export (spec run)
   (-> Runner Test)
-  (do {@ r.monad}
+  (do {! r.monad}
     [[arity local functionS] ..function
-     partial-arity (|> r.nat (:: @ map (|>> (n.% arity) (n.max 1))))
+     partial-arity (|> r.nat (:: ! map (|>> (n.% arity) (n.max 1))))
      inputs (r.list arity r.safe-frac)
      #let [expectation (maybe.assume (list.nth (dec local) inputs))
            inputsS (list@map (|>> synthesis.f64) inputs)]]
diff --git a/stdlib/source/spec/compositor/generation/reference.lux b/stdlib/source/spec/compositor/generation/reference.lux
index 8c53db6c6..f1e12ff96 100644
--- a/stdlib/source/spec/compositor/generation/reference.lux
+++ b/stdlib/source/spec/compositor/generation/reference.lux
@@ -39,8 +39,8 @@
 
 (def: (variable run)
   (-> Runner Test)
-  (do {@ r.monad}
-    [register (|> r.nat (:: @ map (n.% 100)))
+  (do {! r.monad}
+    [register (|> r.nat (:: ! map (n.% 100)))
      expected r.safe-frac]
     (_.test "Local variables."
             (|> (synthesis.branch/let [(synthesis.f64 expected)
diff --git a/stdlib/source/spec/compositor/generation/structure.lux b/stdlib/source/spec/compositor/generation/structure.lux
index c0539a975..cd790c6d2 100644
--- a/stdlib/source/spec/compositor/generation/structure.lux
+++ b/stdlib/source/spec/compositor/generation/structure.lux
@@ -30,9 +30,9 @@
 
 (def: (variant run)
   (-> Runner Test)
-  (do {@ r.monad}
-    [num-tags (|> r.nat (:: @ map (|>> (n.% 10) (n.max 2))))
-     tag-in (|> r.nat (:: @ map (n.% num-tags)))
+  (do {! r.monad}
+    [num-tags (|> r.nat (:: ! map (|>> (n.% 10) (n.max 2))))
+     tag-in (|> r.nat (:: ! map (n.% num-tags)))
      #let [last?-in (|> num-tags dec (n.= tag-in))]
      value-in r.i64]
     (_.test (%.name (name-of synthesis.variant))
@@ -65,8 +65,8 @@
 
 (def: (tuple run)
   (-> Runner Test)
-  (do {@ r.monad}
-    [size (|> r.nat (:: @ map (|>> (n.% 10) (n.max 2))))
+  (do {! r.monad}
+    [size (|> r.nat (:: ! map (|>> (n.% 10) (n.max 2))))
      tuple-in (r.list size r.i64)]
     (_.test (%.name (name-of synthesis.tuple))
             (|> (synthesis.tuple (list@map (|>> synthesis.i64) tuple-in))