Easy to use Rev constants.

9 files changed, 43 insertions, 43 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))
diff --git a/stdlib/source/spec/lux/abstract/apply.lux b/stdlib/source/spec/lux/abstract/apply.lux
index 4220de34c..a9925b928 100644
--- a/stdlib/source/spec/lux/abstract/apply.lux
+++ b/stdlib/source/spec/lux/abstract/apply.lux
@@ -17,8 +17,8 @@
 
 (def: (identity injection comparison (^open "_@."))
   (All [f] (-> (Injection f) (Comparison f) (Apply f) Test))
-  (do {@ random.monad}
-    [sample (:: @ map injection random.nat)]
+  (do {! random.monad}
+    [sample (:: ! map injection random.nat)]
     (_.test "Identity."
             ((comparison n.=)
              (_@apply (injection function.identity) sample)
@@ -26,9 +26,9 @@
 
 (def: (homomorphism injection comparison (^open "_@."))
   (All [f] (-> (Injection f) (Comparison f) (Apply f) Test))
-  (do {@ random.monad}
+  (do {! random.monad}
     [sample random.nat
-     increase (:: @ map n.+ random.nat)]
+     increase (:: ! map n.+ random.nat)]
     (_.test "Homomorphism."
             ((comparison n.=)
              (_@apply (injection increase) (injection sample))
@@ -36,9 +36,9 @@
 
 (def: (interchange injection comparison (^open "_@."))
   (All [f] (-> (Injection f) (Comparison f) (Apply f) Test))
-  (do {@ random.monad}
+  (do {! random.monad}
     [sample random.nat
-     increase (:: @ map n.+ random.nat)]
+     increase (:: ! map n.+ random.nat)]
     (_.test "Interchange."
             ((comparison n.=)
              (_@apply (injection increase) (injection sample))
@@ -46,10 +46,10 @@
 
 (def: (composition injection comparison (^open "_@."))
   (All [f] (-> (Injection f) (Comparison f) (Apply f) Test))
-  (do {@ random.monad}
+  (do {! random.monad}
     [sample random.nat
-     increase (:: @ map n.+ random.nat)
-     decrease (:: @ map n.- random.nat)]
+     increase (:: ! map n.+ random.nat)
+     decrease (:: ! map n.- random.nat)]
     (_.test "Composition."
             ((comparison n.=)
              (_$ _@apply
diff --git a/stdlib/source/spec/lux/abstract/comonad.lux b/stdlib/source/spec/lux/abstract/comonad.lux
index e434f6ab1..b69581037 100644
--- a/stdlib/source/spec/lux/abstract/comonad.lux
+++ b/stdlib/source/spec/lux/abstract/comonad.lux
@@ -15,9 +15,9 @@
 
 (def: (left-identity injection (^open "_@."))
   (All [f] (-> (Injection f) (CoMonad f) Test))
-  (do {@ random.monad}
+  (do {! random.monad}
     [sample random.nat
-     morphism (:: @ map (function (_ diff)
+     morphism (:: ! map (function (_ diff)
                           (|>> _@unwrap (n.+ diff)))
                   random.nat)
      #let [start (injection sample)]]
@@ -37,12 +37,12 @@
 
 (def: (associativity injection comparison (^open "_@."))
   (All [f] (-> (Injection f) (Comparison f) (CoMonad f) Test))
-  (do {@ random.monad}
+  (do {! random.monad}
     [sample random.nat
-     increase (:: @ map (function (_ diff)
+     increase (:: ! map (function (_ diff)
                           (|>> _@unwrap (n.+ diff)))
                   random.nat)
-     decrease (:: @ map (function (_ diff)
+     decrease (:: ! map (function (_ diff)
                           (|>> _@unwrap(n.- diff)))
                   random.nat)
      #let [start (injection sample)
diff --git a/stdlib/source/spec/lux/abstract/functor.lux b/stdlib/source/spec/lux/abstract/functor.lux
index 2cb086b7a..d40ded1a2 100644
--- a/stdlib/source/spec/lux/abstract/functor.lux
+++ b/stdlib/source/spec/lux/abstract/functor.lux
@@ -24,8 +24,8 @@
 
 (def: (identity injection comparison (^open "/@."))
   (All [f] (-> (Injection f) (Comparison f) (Functor f) Test))
-  (do {@ random.monad}
-    [sample (:: @ map injection random.nat)]
+  (do {! random.monad}
+    [sample (:: ! map injection random.nat)]
     (_.test "Identity."
             ((comparison n.=)
              (/@map function.identity sample)
@@ -33,9 +33,9 @@
 
 (def: (homomorphism injection comparison (^open "/@."))
   (All [f] (-> (Injection f) (Comparison f) (Functor f) Test))
-  (do {@ random.monad}
+  (do {! random.monad}
     [sample random.nat
-     increase (:: @ map n.+ random.nat)]
+     increase (:: ! map n.+ random.nat)]
     (_.test "Homomorphism."
             ((comparison n.=)
              (/@map increase (injection sample))
@@ -43,10 +43,10 @@
 
 (def: (composition injection comparison (^open "/@."))
   (All [f] (-> (Injection f) (Comparison f) (Functor f) Test))
-  (do {@ random.monad}
-    [sample (:: @ map injection random.nat)
-     increase (:: @ map n.+ random.nat)
-     decrease (:: @ map n.- random.nat)]
+  (do {! random.monad}
+    [sample (:: ! map injection random.nat)
+     increase (:: ! map n.+ random.nat)
+     decrease (:: ! map n.- random.nat)]
     (_.test "Composition."
             ((comparison n.=)
              (|> sample (/@map increase) (/@map decrease))
diff --git a/stdlib/source/spec/lux/abstract/monad.lux b/stdlib/source/spec/lux/abstract/monad.lux
index d2eac535f..c9abf9b25 100644
--- a/stdlib/source/spec/lux/abstract/monad.lux
+++ b/stdlib/source/spec/lux/abstract/monad.lux
@@ -13,9 +13,9 @@
 
 (def: (left-identity injection comparison (^open "_@."))
   (All [f] (-> (Injection f) (Comparison f) (Monad f) Test))
-  (do {@ random.monad}
+  (do {! random.monad}
     [sample random.nat
-     morphism (:: @ map (function (_ diff)
+     morphism (:: ! map (function (_ diff)
                           (|>> (n.+ diff) _@wrap))
                   random.nat)]
     (_.test "Left identity."
@@ -34,12 +34,12 @@
 
 (def: (associativity injection comparison (^open "_@."))
   (All [f] (-> (Injection f) (Comparison f) (Monad f) Test))
-  (do {@ random.monad}
+  (do {! random.monad}
     [sample random.nat
-     increase (:: @ map (function (_ diff)
+     increase (:: ! map (function (_ diff)
                           (|>> (n.+ diff) _@wrap))
                   random.nat)
-     decrease (:: @ map (function (_ diff)
+     decrease (:: ! map (function (_ diff)
                           (|>> (n.- diff) _@wrap))
                   random.nat)]
     (_.test "Associativity."