De-sigil-ification: ^

1 files changed, 15 insertions, 70 deletions

diff --git a/stdlib/source/test/lux.lux b/stdlib/source/test/lux.lux
index bd30cf30e..751655065 100644
--- a/stdlib/source/test/lux.lux
+++ b/stdlib/source/test/lux.lux
@@ -26,6 +26,7 @@
                 ["[0]" plist]]]]
              ["[0]" macro
               [syntax {"+" syntax:}]
+              ["^" pattern]
               ["[0]" code ("[1]#[0]" equivalence)]
               ["[0]" template]]
              ["[0]" math
@@ -172,7 +173,7 @@
     ($_ _.and
         (_.cover [/.list]
                  (case (/.list e/0 e/1)
-                   (^ (/.list a/0 a/1))
+                   (pattern (/.list a/0 a/1))
                    (and (n.= e/0 a/0)
                         (n.= e/1 a/1))
 
@@ -180,7 +181,7 @@
                    false))
         (_.cover [/.list&]
                  (case (/.list& e/0 e/1 (/.list e/2 e/3))
-                   (^ (/.list& a/0 a/1 (/.list a/2 a/3)))
+                   (pattern (/.list& a/0 a/1 (/.list a/2 a/3)))
                    (and (n.= e/0 a/0)
                         (n.= e/1 a/1)
                         (n.= e/2 a/2)
@@ -221,8 +222,8 @@
                         (n.= expected (# local_returner return [])))
                (_.cover [/.open:]
                         (n.= static_return (global#return [])))
-               (_.cover [/.^open]
-                        (let [(/.^open "local#[0]") local_returner]
+               (_.cover [/.open]
+                        (let [(/.open "local#[0]") local_returner]
                           (n.= expected (local#return []))))
                (_.cover [/.#]
                         (n.= expected (/.# local_returner return [])))
@@ -455,15 +456,15 @@
                                                                  (function (_ _)
                                                                    ... TODO: Remove this hack once Jython is no longer being used as the Python interpreter.
                                                                    (`` (for @.python (case (' [<input>'])
-                                                                                       (^code [<module>
-                                                                                               ("lux def" (~ [_ {.#Symbol ["" _]}]) [] #0)
-                                                                                               (~~ (template.spliced <referrals>))])
+                                                                                       (^.` [<module>
+                                                                                             ("lux def" (~ [_ {.#Symbol ["" _]}]) [] #0)
+                                                                                             (~~ (template.spliced <referrals>))])
                                                                                        true
 
                                                                                        _
                                                                                        false)
                                                                             (case (' [<input>'])
-                                                                              (^code [<module> (~~ (template.spliced <referrals>))])
+                                                                              (^.` [<module> (~~ (template.spliced <referrals>))])
                                                                               true
 
                                                                               _
@@ -588,7 +589,7 @@
                      (same? /.Nat (/.:of expected)))
             (_.cover [/.Primitive]
                      (case (/.Primitive "foo" [expected/0 expected/1])
-                       (^ {.#Primitive "foo" (list actual/0 actual/1)})
+                       (pattern {.#Primitive "foo" (list actual/0 actual/1)})
                        (and (same? expected/0 actual/0)
                             (same? expected/1 actual/1))
 
@@ -704,16 +705,6 @@
             (_.cover [/.template:]
                      (n.= (n.+ left right)
                           (!n/+ left right))))
-          (do [! random.monad]
-            [sample (# ! each (n.% 5) random.nat)]
-            (_.cover [/.^template]
-                     (case sample
-                       (/.^template [<case>]
-                         [<case> true])
-                       ([0] [1] [2] [3] [4])
-
-                       _
-                       false)))
           )))
 
 (def: option/0 "0")
@@ -728,8 +719,8 @@
     ($_ _.and
         (_.cover [/.static]
                  (case sample
-                   (^ (/.static option/0)) true
-                   (^ (/.static option/1)) true
+                   (pattern (/.static option/0)) true
+                   (pattern (/.static option/1)) true
                    _ false))
         (_.cover [/.char]
                  (|> (`` (/.char (~~ (/.static static_char))))
@@ -1028,55 +1019,9 @@
                         {.#Right +0} true
                         _ false)
                       ))
-        (_.cover [/.^or]
-                 (and (/.case expected_rev
-                        (/.^or .5 .25) true
-                        _ false)
-                      (/.case expected_frac
-                        (/.^or +0.5 +1.25) true
-                        _ false)
-                      (/.case expected_text
-                        (/.^or "+0.5" "+1.25") true
-                        _ false)))
-        (_.cover [/.^]
+        (_.cover [/.pattern]
                  (/.case [..#left expected_nat ..#right expected_int]
-                   (/.^ (!pair 0 +0)) true
-                   _ false))
-        (_.cover [/.^let]
-                 (let [expected_pair (: (Pair Nat Int)
-                                        [..#left expected_nat ..#right expected_int])]
-                   (/.case expected_pair
-                     (/.^let actual_pair (/.^ (!pair actual_left actual_right)))
-                     (and (/.same? expected_pair actual_pair)
-                          (/.same? expected_nat actual_left)
-                          (/.same? expected_int actual_right)))))
-        (_.cover [/.^multi]
-                 (let [expected_pair (: (Pair Nat Int)
-                                        [..#left expected_nat ..#right expected_int])]
-                   (and (/.case expected_pair
-                          (/.^multi (/.^ (!pair 0 actual_right))
-                                    [actual_right
-                                     +0])
-                          true
-
-                          _
-                          false)
-                        (/.case expected_pair
-                          (/.^multi (/.^ (!pair 0 actual_right))
-                                    (i.= +0 actual_right))
-                          true
-
-                          _
-                          false))))
-        (_.cover [/.^|>]
-                 (case expected_frac
-                   (/.^|> actual_frac [(f.* +2.0) (f.* +2.0)])
-                   (f.= (f.* +4.0 expected_frac)
-                        actual_frac)))
-        (_.cover [/.^code]
-                 (case (code.text expected_text)
-                   (/.^code "+0.5") true
-                   (/.^code "+1.25") true
+                   (/.pattern (!pair 0 +0)) true
                    _ false))
         (_.cover [/.let]
                  (and (/.let [actual_nat expected_nat]
@@ -1193,7 +1138,7 @@
 
                                          let/3 <code>.local_symbol])
               (in (list (code.bit (case (the .#scopes *lux*)
-                                    (^ (list& scope/2 _))
+                                    (pattern (list& scope/2 _))
                                     (let [locals/2 (the .#locals scope/2)
                                           expected_locals/2 (set.of_list text.hash (list fn/2 var/2 let/2
                                                                                          let/3))