From cd71a864ad5be13ed6ec6d046e0a2cb1087bdf94 Mon Sep 17 00:00:00 2001
From: Eduardo Julian
Date: Fri, 10 Sep 2021 01:21:23 -0400
Subject: Migrated variants to the new syntax.

---
 stdlib/source/test/lux.lux | 62 +++++++++++++++++++++++-----------------------
 1 file changed, 31 insertions(+), 31 deletions(-)

(limited to 'stdlib/source/test/lux.lux')

diff --git a/stdlib/source/test/lux.lux b/stdlib/source/test/lux.lux
index fefe5270e..6a6ef3fac 100644
--- a/stdlib/source/test/lux.lux
+++ b/stdlib/source/test/lux.lux
@@ -176,24 +176,24 @@
     ($_ _.and
         (_.cover [/.try]
                  (case (/.try expected)
-                   (#.Left _)
+                   {#.Left _}
                    false
                    
-                   (#.Right actual)
+                   {#.Right actual}
                    (n.= expected actual)))
         (_.cover [/.undefined]
                  (case (/.try (/.undefined))
-                   (#.Left _)
+                   {#.Left _}
                    true
                    
-                   (#.Right _)
+                   {#.Right _}
                    false))
         (_.cover [/.panic!]
                  (case (/.try (/.panic! expected_error))
-                   (#.Left actual_error)
+                   {#.Left actual_error}
                    (text.contains? expected_error actual_error)
                    
-                   (#.Right _)
+                   {#.Right _}
                    false))
         )))
 
@@ -437,13 +437,13 @@
 
 (/.macro: (found_crosshair? tokens lux)
   (let [[_ _ source_code] (value@ #.source lux)]
-    (#.Right [lux (list (code.bit (text.contains? ..crosshair source_code)))])))
+    {#.Right [lux (list (code.bit (text.contains? ..crosshair source_code)))]}))
 
 (def: for_macro
   Test
   (let [macro (: /.Macro'
                  (function (_ tokens lux)
-                   (#.Right [lux (list)])))]
+                   {#.Right [lux (list)]}))]
     (do random.monad
       [expected random.nat]
       (with_expansions [<found_crosshair?> (for [@.old (~~ (as_is))]
@@ -468,8 +468,8 @@
 (/.type: for_type/variant
   (Variant
    #Case/0
-   (#Case/1 Nat)
-   (#Case/2 Int Text)))
+   {#Case/1 Nat}
+   {#Case/2 Int Text}))
 
 (/.type: for_type/record
   (Record
@@ -518,7 +518,7 @@
                      (same? /.Nat (/.:of expected)))
             (_.cover [/.primitive]
                      (case (/.primitive "foo" [expected/0 expected/1])
-                       (^ (#.Primitive "foo" (list actual/0 actual/1)))
+                       (^ {#.Primitive "foo" (list actual/0 actual/1)})
                        (and (same? expected/0 actual/0)
                             (same? expected/1 actual/1))
 
@@ -526,28 +526,28 @@
                        false))
             (_.cover [/.type]
                      (and (case (/.type [expected/0 expected/1])
-                            (#.Product actual/0 actual/1)
+                            {#.Product actual/0 actual/1}
                             (and (same? expected/0 actual/0)
                                  (same? expected/1 actual/1))
 
                             _
                             false)
                           (case (/.type (/.Or expected/0 expected/1))
-                            (#.Sum actual/0 actual/1)
+                            {#.Sum actual/0 actual/1}
                             (and (same? expected/0 actual/0)
                                  (same? expected/1 actual/1))
 
                             _
                             false)
                           (case (/.type (-> expected/0 expected/1))
-                            (#.Function actual/0 actual/1)
+                            {#.Function actual/0 actual/1}
                             (and (same? expected/0 actual/0)
                                  (same? expected/1 actual/1))
 
                             _
                             false)
                           (case (/.type (expected/0 expected/1))
-                            (#.Apply actual/1 actual/0)
+                            {#.Apply actual/1 actual/0}
                             (and (same? expected/0 actual/0)
                                  (same? expected/1 actual/1))
 
@@ -562,7 +562,7 @@
             (_.cover [/.Variant]
                      (exec
                        (: for_type/variant
-                          (#Case/1 expected_left))
+                          {#Case/1 expected_left})
                        true))
             (_.cover [/.Record]
                      (exec
@@ -836,11 +836,11 @@
         (_.cover [/.Either]
                  (and (exec
                         (: (/.Either Nat Text)
-                           (#.Left left))
+                           {#.Left left})
                         true)
                       (exec
                         (: (/.Either Nat Text)
-                           (#.Right right))
+                           {#.Right right})
                         true)))
         (_.cover [/.Any]
                  (and (exec
@@ -890,12 +890,12 @@
         (_.cover [/.Rec]
                  (let [list (: (/.Rec NList
                                  (Maybe [Nat NList]))
-                               (#.Some [item/0
-                                        (#.Some [item/1
-                                                 (#.Some [item/2
-                                                          #.None])])]))]
+                               {#.Some [item/0
+                                        {#.Some [item/1
+                                                 {#.Some [item/2
+                                                          #.None]}]}]})]
                    (case list
-                     (#.Some [actual/0 (#.Some [actual/1 (#.Some [actual/2 #.None])])])
+                     {#.Some [actual/0 {#.Some [actual/1 {#.Some [actual/2 #.None]}]}]}
                      (and (same? item/0 actual/0)
                           (same? item/1 actual/1)
                           (same? item/2 actual/2))
@@ -950,11 +950,11 @@
                       (/.case [#left expected_nat #right expected_int]
                         [#left 0 #right +0] true
                         _ false)
-                      (/.case (: (Either Nat Int) (#.Left expected_nat))
-                        (#.Left 0) true
+                      (/.case (: (Either Nat Int) {#.Left expected_nat})
+                        {#.Left 0} true
                         _ false)
-                      (/.case (: (Either Nat Int) (#.Right expected_int))
-                        (#.Right +0) true
+                      (/.case (: (Either Nat Int) {#.Right expected_int})
+                        {#.Right +0} true
                         _ false)
                       ))
         (_.cover [/.^or]
@@ -1083,8 +1083,8 @@
           (case (value@ #.mode info)
             #.Build true
             _ false)]
-      (#.Right [lux (list (code.bit (and conforming_target!
-                                         compiling!)))]))))
+      {#.Right [lux (list (code.bit (and conforming_target!
+                                         compiling!)))]})))
 
 (syntax: (for_meta|Module_State [])
   (do meta.monad
@@ -1146,8 +1146,8 @@
                                           local? (: (-> Ref Bit)
                                                     (function (_ ref)
                                                       (case ref
-                                                        (#.Local _) true
-                                                        (#.Captured _) false)))
+                                                        {#.Local _} true
+                                                        {#.Captured _} false)))
                                           captured? (: (-> Ref Bit)
                                                        (|>> local? not))
                                           binding? (: (-> (-> Ref Bit) Text Bit)
-- 
cgit v1.2.3