Migrated variants to the new syntax.

5 files changed, 102 insertions, 102 deletions

diff --git a/lux-jvm/test/test/luxc/lang/analysis/host.jvm.lux b/lux-jvm/test/test/luxc/lang/analysis/host.jvm.lux
index ef12fcf25..81328faec 100644
--- a/lux-jvm/test/test/luxc/lang/analysis/host.jvm.lux
+++ b/lux-jvm/test/test/luxc/lang/analysis/host.jvm.lux
@@ -42,10 +42,10 @@
                              (_primitive.analyse (` ((~ (code.text procedure)) (~+ params)))))))
          (analysis.with-current-module "")
          (macro.result (initL.compiler []))
-         (case> (#e.Success _)
+         (case> {#e.Success _}
                 <success>
 
-                (#e.Error error)
+                {#e.Error error}
                 <failure>)))]
 
   [success #1 #0]
@@ -63,10 +63,10 @@
                              (_primitive.analyse syntax))))
          (analysis.with-current-module "")
          (macro.result (initL.compiler []))
-         (case> (#e.Success _)
+         (case> {#e.Success _}
                 <success>
 
-                (#e.Error error)
+                {#e.Error error}
                 <failure>)))]
 
   [success' #1 #0]
@@ -281,14 +281,14 @@
          size (|> r.nat (:: @ each cap))
          idx (|> r.nat (:: @ each (n/% size)))
          level (|> r.nat (:: @ each cap))
-         #let [unboxedT (#.Primitive unboxed (list))
-               arrayT (#.Primitive "#Array" (list unboxedT))
+         #let [unboxedT {#.Primitive unboxed (list)}
+               arrayT {#.Primitive "#Array" (list unboxedT)}
                arrayC (`' ("lux check" (+0 "#Array" (+1 (+0 (~ (code.text unboxed)) (+0)) (+0)))
                            ("jvm array new" (~ (code.nat size)))))
-               boxedT (#.Primitive boxed (list))
+               boxedT {#.Primitive boxed (list)}
                boxedTC (` (+0 (~ (code.text boxed)) (+0)))
                multi-arrayT (list/mix (function (_ _ innerT)
-                                        (|> innerT (list) (#.Primitive "#Array")))
+                                        (|> innerT (list) {#.Primitive "#Array"}))
                                       boxedT
                                       (list.n/range +1 level))]]
         ($_ seq
@@ -335,7 +335,7 @@
          [!unboxed !boxed] (|> array-type
                                (r.filter (function (_ [!unboxed !boxed])
                                            (not (text/= boxed !boxed)))))
-         #let [boxedT (#.Primitive boxed (list))
+         #let [boxedT {#.Primitive boxed (list)}
                boxedC (`' ("lux check" (+0 (~ (code.text boxed)) (+0))
                            ("jvm object null")))
                !boxedC (`' ("lux check" (+0 (~ (code.text !boxed)) (+0))
@@ -354,12 +354,12 @@
             (test "jvm object null"
                   (success "jvm object null"
                            (list)
-                           (#.Primitive boxed (list))))
+                           {#.Primitive boxed (list)}))
             (test "jvm object null (no primitives)"
                   (or (text/= "java.lang.Object" boxed)
                       (failure "jvm object null"
                                (list)
-                               (#.Primitive unboxed (list)))))
+                               {#.Primitive unboxed (list)})))
             (test "jvm object null?"
                   (success "jvm object null?"
                            (list boxedC)
@@ -381,7 +381,7 @@
             (test "jvm object class"
                   (success "jvm object class"
                            (list (code.text boxed))
-                           (#.Primitive "java.lang.Class" (list boxedT))))
+                           {#.Primitive "java.lang.Class" (list boxedT)}))
             (test "jvm object instance?"
                   (success "jvm object instance?"
                            (list (code.text boxed)
@@ -406,12 +406,12 @@
             (success "jvm member static get"
                      (list (code.text "java.lang.System")
                            (code.text "out"))
-                     (#.Primitive "java.io.PrintStream" (list))))
+                     {#.Primitive "java.io.PrintStream" (list)}))
       (test "jvm member static get (inheritance out)"
             (success "jvm member static get"
                      (list (code.text "java.lang.System")
                            (code.text "out"))
-                     (#.Primitive "java.lang.Object" (list))))
+                     {#.Primitive "java.lang.Object" (list)}))
       (test "jvm member static put"
             (success "jvm member static put"
                      (list (code.text "java.awt.datatransfer.DataFlavor")
@@ -444,14 +444,14 @@
                            (code.text "id")
                            (`' ("lux check" (+0 "org.omg.CORBA.ValueMember" (+0))
                                 ("jvm object null"))))
-                     (#.Primitive "java.lang.String" (list))))
+                     {#.Primitive "java.lang.String" (list)}))
       (test "jvm member virtual get (inheritance out)"
             (success "jvm member virtual get"
                      (list (code.text "org.omg.CORBA.ValueMember")
                            (code.text "id")
                            (`' ("lux check" (+0 "org.omg.CORBA.ValueMember" (+0))
                                 ("jvm object null"))))
-                     (#.Primitive "java.lang.Object" (list))))
+                     {#.Primitive "java.lang.Object" (list)}))
       (test "jvm member virtual put"
             (success "jvm member virtual put"
                      (list (code.text "org.omg.CORBA.ValueMember")
@@ -488,14 +488,14 @@
             (success "jvm member static get"
                      (list (code.text "java.util.GregorianCalendar")
                            (code.text "AD"))
-                     (#.Primitive "java.lang.Integer" (list))))
+                     {#.Primitive "java.lang.Integer" (list)}))
       (test "jvm member virtual get"
             (success "jvm member virtual get"
                      (list (code.text "javax.accessibility.AccessibleAttributeSequence")
                            (code.text "startIndex")
                            (`' ("lux check" (+0 "javax.accessibility.AccessibleAttributeSequence" (+0))
                                 ("jvm object null"))))
-                     (#.Primitive "java.lang.Integer" (list))))
+                     {#.Primitive "java.lang.Integer" (list)}))
       (test "jvm member virtual put"
             (success "jvm member virtual put"
                      (list (code.text "javax.accessibility.AccessibleAttributeSequence")
@@ -522,28 +522,28 @@
               (success' (` ("jvm member invoke static"
                             "java.lang.Long" "decode"
                             ["java.lang.String" (~ stringC)]))
-                        (#.Primitive "java.lang.Long" (list))))
+                        {#.Primitive "java.lang.Long" (list)}))
         (test "jvm member invoke virtual"
               (success' (` ("jvm object cast"
                             ("jvm member invoke virtual"
                              "java.lang.Object" "equals"
                              ("jvm object cast" (~ longC)) ["java.lang.Object" ("jvm object cast" (~ longC))])))
-                        (#.Primitive "java.lang.Boolean" (list))))
+                        {#.Primitive "java.lang.Boolean" (list)}))
         (test "jvm member invoke special"
               (success' (` ("jvm object cast"
                             ("jvm member invoke special"
                              "java.lang.Long" "equals"
                              ("jvm object cast" (~ longC)) ["java.lang.Object" ("jvm object cast" (~ longC))])))
-                        (#.Primitive "java.lang.Boolean" (list))))
+                        {#.Primitive "java.lang.Boolean" (list)}))
         (test "jvm member invoke interface"
               (success' (` ("jvm object cast"
                             ("jvm member invoke interface"
                              "java.util.Collection" "add"
                              ("jvm object cast" (~ objectC)) ["java.lang.Object" ("jvm object cast" (~ longC))])))
-                        (#.Primitive "java.lang.Boolean" (list))))
+                        {#.Primitive "java.lang.Boolean" (list)}))
         (test "jvm member invoke constructor"
               (success' (` ("jvm member invoke constructor"
                             "java.util.ArrayList"
                             ["int" ("jvm object cast" (~ intC))]))
-                        (All (_ a) (#.Primitive "java.util.ArrayList" (list a)))))
+                        (All (_ a) {#.Primitive "java.util.ArrayList" (list a)})))
         )))
diff --git a/lux-jvm/test/test/luxc/lang/synthesis/loop.lux b/lux-jvm/test/test/luxc/lang/synthesis/loop.lux
index ad2a67deb..b923a4e90 100644
--- a/lux-jvm/test/test/luxc/lang/synthesis/loop.lux
+++ b/lux-jvm/test/test/luxc/lang/synthesis/loop.lux
@@ -21,29 +21,29 @@
   (-> ls.Arity ls.Synthesis Bit)
   (loop [exprS exprS]
     (case exprS
-      (^ [_ (#.Form (list [_ (#.Text "lux case")] inputS pathS))])
+      (^ [_ {#.Form (list [_ {#.Text "lux case"}] inputS pathS)}])
       (loop [pathS pathS]
         (case pathS
-          (^ [_ (#.Form (list [_ (#.Text "lux case alt")] leftS rightS))])
+          (^ [_ {#.Form (list [_ {#.Text "lux case alt"}] leftS rightS)}])
           (or (recur leftS)
               (recur rightS))
 
-          (^ [_ (#.Form (list [_ (#.Text "lux case seq")] leftS rightS))])
+          (^ [_ {#.Form (list [_ {#.Text "lux case seq"}] leftS rightS)}])
           (recur rightS)
 
-          (^ [_ (#.Form (list [_ (#.Text "lux case exec")] bodyS))])
+          (^ [_ {#.Form (list [_ {#.Text "lux case exec"}] bodyS)}])
           (does-recursion? arity bodyS)
           
           _
           #0))
 
-      (^ [_ (#.Form (list& [_ (#.Text "lux recur")] argsS))])
+      (^ [_ {#.Form (list& [_ {#.Text "lux recur"}] argsS)}])
       (n/= arity (list.size argsS))
 
-      (^ [_ (#.Form (list [_ (#.Text "lux let")] register inputS bodyS))])
+      (^ [_ {#.Form (list [_ {#.Text "lux let"}] register inputS bodyS)}])
       (recur bodyS)
 
-      (^ [_ (#.Form (list [_ (#.Text "lux if")] inputS thenS elseS))])
+      (^ [_ {#.Form (list [_ {#.Text "lux if"}] inputS thenS elseS)}])
       (or (recur thenS)
           (recur elseS))
 
@@ -132,7 +132,7 @@
             (test "Can accurately identify (and then reify) tail recursion."
                   (case (expressionS.synthesize extensionL.no-syntheses
                                                 analysis)
-                    (^ [_ (#.Form (list [_ (#.Text "lux function")] [_ (#.Nat _arity)] [_ (#.Tuple _env)] _body))])
+                    (^ [_ {#.Form (list [_ {#.Text "lux function"}] [_ {#.Nat _arity}] [_ {#.Tuple _env}] _body)}])
                     (|> _body
                         (does-recursion? arity)
                         (bit/= prediction)
@@ -149,13 +149,13 @@
             (test "Can reify loops."
                   (case (expressionS.synthesize extensionL.no-syntheses
                                                 (la.apply (list.repeat arity (' [])) analysis))
-                    (^ [_ (#.Form (list [_ (#.Text "lux loop")] [_ (#.Nat in_register)] [_ (#.Tuple _inits)] _body))])
+                    (^ [_ {#.Form (list [_ {#.Text "lux loop"}] [_ {#.Nat in_register}] [_ {#.Tuple _inits}] _body)}])
                     (and (n/= arity (list.size _inits))
                          (not (loopS.contains-self-reference? _body)))
 
-                    (^ [_ (#.Form (list& [_ (#.Text "lux call")]
-                                         [_ (#.Form (list [_ (#.Text "lux function")] _arity _env _bodyS))]
-                                         argsS))])
+                    (^ [_ {#.Form (list& [_ {#.Text "lux call"}]
+                                         [_ {#.Form (list [_ {#.Text "lux function"}] _arity _env _bodyS)}]
+                                         argsS)}])
                     (loopS.contains-self-reference? _bodyS)
 
                     _
diff --git a/lux-jvm/test/test/luxc/lang/synthesis/procedure.lux b/lux-jvm/test/test/luxc/lang/synthesis/procedure.lux
index 1262f2252..0d73b1038 100644
--- a/lux-jvm/test/test/luxc/lang/synthesis/procedure.lux
+++ b/lux-jvm/test/test/luxc/lang/synthesis/procedure.lux
@@ -24,7 +24,7 @@
             (test "Can synthesize procedure calls."
                   (|> (expressionS.synthesize extensionL.no-syntheses
                                               (la.procedure nameA argsA))
-                      (case> (^ [_ (#.Form (list& [_ (#.Text procedure)] argsS))])
+                      (case> (^ [_ {#.Form (list& [_ {#.Text procedure}] argsS)}])
                              (and (text/= nameA procedure)
                                   (list.every? (product.uncurried corresponds?)
                                                (list.zip2 argsA argsS)))
diff --git a/lux-jvm/test/test/luxc/lang/translation/js.lux b/lux-jvm/test/test/luxc/lang/translation/js.lux
index effad7726..69bcd7ecd 100644
--- a/lux-jvm/test/test/luxc/lang/translation/js.lux
+++ b/lux-jvm/test/test/luxc/lang/translation/js.lux
@@ -22,7 +22,7 @@
 (def: (test-primitive-identity synthesis)
   (-> Synthesis Bit)
   (|> (run-js (` ("lux is" (~ synthesis) (~ synthesis))))
-      (case> (#e.Success valueV)
+      (case> {#e.Success valueV}
              (:coerce Bit valueV)
 
              _
@@ -33,10 +33,10 @@
 (template [<name> <type> <pre> <=>]
   [(def: (<name> angle)
      (-> <type> Check)
-     (|>> (case> (#e.Success valueV)
+     (|>> (case> {#e.Success valueV}
                  (<=> (<pre> angle) (:coerce <type> valueV))
                  
-                 (#e.Error error)
+                 {#e.Error error}
                  #0)))]
 
   [sin-check    Frac math.sin f/=]
@@ -73,7 +73,7 @@
         ($_ seq
             (test "Cannot get non-existing fields from objects."
                   (|> (run-js (` ("js object get" (~ field) (~ empty-object))))
-                      (case> (^multi (#e.Success valueV)
+                      (case> (^multi {#e.Success valueV}
                                      [(:coerce (Maybe Int) valueV) #.None])
                              #1
 
@@ -81,8 +81,8 @@
                              #0)))
             (test "Can get fields from objects."
                   (|> (run-js (` ("js object get" (~ field) (~ object))))
-                      (case> (^multi (#e.Success valueV)
-                                     [(:coerce (Maybe Int) valueV) (#.Some valueV)])
+                      (case> (^multi {#e.Success valueV}
+                                     [(:coerce (Maybe Int) valueV) {#.Some valueV}])
                              (i/= value (:coerce Int valueV))
 
                              _
@@ -90,7 +90,7 @@
             (test "Can delete fields from objects."
                   (|> (run-js (let [post-delete (` ("js object delete" (~ field) (~ object)))]
                                 (` ("js object get" (~ field) (~ post-delete)))))
-                      (case> (^multi (#e.Success valueV)
+                      (case> (^multi {#e.Success valueV}
                                      [(:coerce (Maybe Int) valueV) #.None])
                              #1
 
@@ -99,10 +99,10 @@
             (test "Can instance new objects."
                   (let [base (` ("js object new" ("js global" "Number") (~ (code.text (%f frac-value)))))]
                     (|> (run-js (` ("lux frac +" (~ base) 0.0)))
-                        (case> (#e.Success valueV)
+                        (case> {#e.Success valueV}
                                (f/= frac-value (:coerce Frac valueV))
 
-                               (#e.Error error)
+                               {#e.Error error}
                                #0))))
             (test "Can call methods on objects."
                   (|> (run-js (` ("js object call" ("js global" "Math") "sin" (~ (code.text (%f frac-value))))))
@@ -124,9 +124,9 @@
                       (length-check length)))
             (test "Can get an element from an array."
                   (|> (run-js (` ("js array read" (~ (code.nat idx)) (~ arrayS))))
-                      (case> (^multi (#e.Success elemV)
+                      (case> (^multi {#e.Success elemV}
                                      [[(list.nth idx elems) (:coerce (Maybe Nat) elemV)]
-                                      [(#.Some reference) (#.Some sample)]])
+                                      [{#.Some reference} {#.Some sample}]])
                              (n/= reference sample)
 
                              _
@@ -136,9 +136,9 @@
                         overwriteS (code.nat overwrite)]
                     (|> (run-js (` ("js array read" (~ idxS)
                                     ("js array write" (~ idxS) (~ overwriteS) (~ arrayS)))))
-                        (case> (^multi (#e.Success elemV)
+                        (case> (^multi {#e.Success elemV}
                                        [(:coerce (Maybe Nat) elemV)
-                                        (#.Some sample)])
+                                        {#.Some sample}])
                                (n/= overwrite sample)
 
                                _
@@ -149,7 +149,7 @@
                     (and (|> (run-js (` ("js array length" (~ deleteS))))
                              (length-check length))
                          (|> (run-js (` ("js array read" (~ idxS) (~ deleteS))))
-                             (case> (^multi (#e.Success elemV)
+                             (case> (^multi {#e.Success elemV}
                                             [(:coerce (Maybe Nat) elemV)
                                              #.None])
                                     #1
diff --git a/lux-jvm/test/test/luxc/lang/translation/jvm.lux b/lux-jvm/test/test/luxc/lang/translation/jvm.lux
index 95812e6ca..86c8253e4 100644
--- a/lux-jvm/test/test/luxc/lang/translation/jvm.lux
+++ b/lux-jvm/test/test/luxc/lang/translation/jvm.lux
@@ -36,10 +36,10 @@
                                                  (evalT.eval sampleI))
                                                (lang.with-current-module "")
                                                (macro.result (io.run! init-jvm))
-                                               (case> (#e.Success valueT)
+                                               (case> {#e.Success valueT}
                                                       (<test> <sample> (:coerce <cast> valueT))
 
-                                                      (#e.Error error)
+                                                      {#e.Error error}
                                                       #0)))]
 
                                     ["jvm convert double-to-float" "jvm convert float-to-double" code.frac frac-sample Frac f/=]
@@ -68,10 +68,10 @@
                                    (evalT.eval sampleI))
                                  (lang.with-current-module "")
                                  (macro.result (io.run! init-jvm))
-                                 (case> (#e.Success valueT)
+                                 (case> {#e.Success valueT}
                                         (<test> <sample> (:coerce <cast> valueT))
 
-                                        (#e.Error error)
+                                        {#e.Error error}
                                         #0)))]
 
                       ["jvm convert long-to-int"   "jvm convert int-to-char"  "jvm convert char-to-long"  code.int int-sample Int i/=]
@@ -95,10 +95,10 @@
                                    (evalT.eval sampleI))
                                  (lang.with-current-module "")
                                  (macro.result (io.run! init-jvm))
-                                 (case> (#e.Success valueT)
+                                 (case> {#e.Success valueT}
                                         (<test> <sample> (:coerce <cast> valueT))
 
-                                        (#e.Error error)
+                                        {#e.Error error}
                                         #0)))]
 
                       ["jvm convert long-to-int" "jvm convert int-to-char" "jvm convert char-to-byte" "jvm convert byte-to-long" code.int int-sample Int i/=]
@@ -136,11 +136,11 @@
                                                     (evalT.eval sampleI))
                                                   (lang.with-current-module "")
                                                   (macro.result (io.run! init-jvm))
-                                                  (case> (#e.Success valueT)
+                                                  (case> {#e.Success valueT}
                                                          (<test> (<reference> param subject)
                                                                  (:coerce <type> valueT))
 
-                                                         (#e.Error error)
+                                                         {#e.Error error}
                                                          #0)))]
 
                                        [(format "jvm " <domain> " +") <+>]
@@ -175,11 +175,11 @@
                                       (evalT.eval sampleI))
                                     (lang.with-current-module "")
                                     (macro.result (io.run! init-jvm))
-                                    (case> (#e.Success valueT)
+                                    (case> {#e.Success valueT}
                                            (n/= (<reference> param subject)
                                                 (:coerce Nat valueT))
 
-                                           (#e.Error error)
+                                           {#e.Error error}
                                            #0)))]
 
                          [(format "jvm " <domain> " and") bit.and]
@@ -209,11 +209,11 @@
                                       (evalT.eval sampleI))
                                     (lang.with-current-module "")
                                     (macro.result (io.run! init-jvm))
-                                    (case> (#e.Success valueT)
+                                    (case> {#e.Success valueT}
                                            (<test> (<reference> shift (<pre-subject> subject))
                                                    (:coerce <type> valueT))
 
-                                           (#e.Error error)
+                                           {#e.Error error}
                                            #0)))]
 
                          [(format "jvm " <domain> " shl") bit.left-shift Nat n/= id code.nat]
@@ -241,11 +241,11 @@
                                                     (evalT.eval sampleI))
                                                   (lang.with-current-module "")
                                                   (macro.result (io.run! init-jvm))
-                                                  (case> (#e.Success valueT)
+                                                  (case> {#e.Success valueT}
                                                          (bit/= (<reference> param subject)
                                                                 (:coerce Bit valueT))
 
-                                                         (#e.Error error)
+                                                         {#e.Error error}
                                                          #0)))]
 
                                        [(format "jvm " <domain> " =") <=>]
@@ -297,10 +297,10 @@
                                                  (evalT.eval sampleI))
                                                (lang.with-current-module "")
                                                (macro.result (io.run! init-jvm))
-                                               (case> (#e.Success outputZ)
+                                               (case> {#e.Success outputZ}
                                                       (<test> <value> (:coerce <type> outputZ))
 
-                                                      (#e.Error error)
+                                                      {#e.Error error}
                                                       #0)))]
 
                                     ["boolean" Bit valueZ bit/= (code.bit valueZ)
@@ -345,10 +345,10 @@
                                                  (evalT.eval sampleI))
                                                (lang.with-current-module "")
                                                (macro.result (io.run! init-jvm))
-                                               (case> (#e.Success outputT)
+                                               (case> {#e.Success outputT}
                                                       (<test> <value> (:coerce <type> outputT))
 
-                                                      (#e.Error error)
+                                                      {#e.Error error}
                                                       #0)))]
 
                                     ["char" Int valueC i/=
@@ -373,10 +373,10 @@
                                          (evalT.eval sampleI))
                                        (lang.with-current-module "")
                                        (macro.result (io.run! init-jvm))
-                                       (case> (#e.Success outputT)
+                                       (case> {#e.Success outputT}
                                               (f/= valueD (:coerce Frac outputT))
 
-                                              (#e.Error error)
+                                              {#e.Error error}
                                               #0)))
                              (test "jvm array length"
                                    (|> (do macro.Monad<Meta>
@@ -384,10 +384,10 @@
                                          (evalT.eval sampleI))
                                        (lang.with-current-module "")
                                        (macro.result (io.run! init-jvm))
-                                       (case> (#e.Success outputT)
+                                       (case> {#e.Success outputT}
                                               (n/= size (:coerce Nat outputT))
 
-                                              (#e.Error error)
+                                              {#e.Error error}
                                               #0)))
                              )))))
 
@@ -435,10 +435,10 @@
                         (evalT.eval sampleI))
                       (lang.with-current-module "")
                       (macro.result (io.run! init-jvm))
-                      (case> (#e.Success outputT)
+                      (case> {#e.Success outputT}
                              (:coerce Bit outputT)
 
-                             (#e.Error error)
+                             {#e.Error error}
                              #0)))
             (test "jvm object null?"
                   (|> (do macro.Monad<Meta>
@@ -446,10 +446,10 @@
                         (evalT.eval sampleI))
                       (lang.with-current-module "")
                       (macro.result (io.run! init-jvm))
-                      (case> (#e.Success outputT)
+                      (case> {#e.Success outputT}
                              (not (:coerce Bit outputT))
 
-                             (#e.Error error)
+                             {#e.Error error}
                              #0)))
             (test "jvm object synchronized"
                   (|> (do macro.Monad<Meta>
@@ -457,10 +457,10 @@
                         (evalT.eval sampleI))
                       (lang.with-current-module "")
                       (macro.result (io.run! init-jvm))
-                      (case> (#e.Success outputT)
+                      (case> {#e.Success outputT}
                              (i/= sample (:coerce Int outputT))
 
-                             (#e.Error error)
+                             {#e.Error error}
                              #0)))
             (test "jvm object throw"
                   (|> (do macro.Monad<Meta>
@@ -472,15 +472,15 @@
                         (evalT.eval sampleI))
                       (lang.with-current-module "")
                       (macro.result (io.run! init-jvm))
-                      (case> (#e.Success outputT)
+                      (case> {#e.Success outputT}
                              (case (:coerce (e.Error Any) outputT)
-                               (#e.Error error)
+                               {#e.Error error}
                                (text.contains? exception-message error)
 
-                               (#e.Success outputT)
+                               {#e.Success outputT}
                                #0)
 
-                             (#e.Error error)
+                             {#e.Error error}
                              #0)))
             (test "jvm object class"
                   (|> (do macro.Monad<Meta>
@@ -488,10 +488,10 @@
                         (evalT.eval sampleI))
                       (lang.with-current-module "")
                       (macro.result (io.run! init-jvm))
-                      (case> (#e.Success outputT)
+                      (case> {#e.Success outputT}
                              (|> outputT (:coerce Class) (Class::getName []) (text/= class))
 
-                             (#e.Error error)
+                             {#e.Error error}
                              #0)))
             (test "jvm object instance?"
                   (|> (do macro.Monad<Meta>
@@ -499,10 +499,10 @@
                         (evalT.eval sampleI))
                       (lang.with-current-module "")
                       (macro.result (io.run! init-jvm))
-                      (case> (#e.Success outputT)
+                      (case> {#e.Success outputT}
                              (:coerce Bit outputT)
 
-                             (#e.Error error)
+                             {#e.Error error}
                              #0)))
             ))))
 
@@ -531,10 +531,10 @@
                         (evalT.eval sampleI))
                       (lang.with-current-module "")
                       (macro.result (io.run! init-jvm))
-                      (case> (#e.Success outputT)
+                      (case> {#e.Success outputT}
                              (i/= GregorianCalendar::AD (:coerce Int outputT))
 
-                             (#e.Error error)
+                             {#e.Error error}
                              #0)))
             (test "jvm member static put"
                   (|> (do macro.Monad<Meta>
@@ -543,10 +543,10 @@
                         (evalT.eval sampleI))
                       (lang.with-current-module "")
                       (macro.result (io.run! init-jvm))
-                      (case> (#e.Success outputT)
+                      (case> {#e.Success outputT}
                              (same? hostL.unit (:coerce Text outputT))
 
-                             (#e.Error error)
+                             {#e.Error error}
                              #0)))
             (test "jvm member virtual get"
                   (|> (do macro.Monad<Meta>
@@ -554,10 +554,10 @@
                         (evalT.eval sampleI))
                       (lang.with-current-module "")
                       (macro.result (io.run! init-jvm))
-                      (case> (#e.Success outputT)
+                      (case> {#e.Success outputT}
                              (text/= sample-string (:coerce Text outputT))
 
-                             (#e.Error error)
+                             {#e.Error error}
                              #0)))
             (test "jvm member virtual put"
                   (|> (do macro.Monad<Meta>
@@ -567,10 +567,10 @@
                         (evalT.eval sampleI))
                       (lang.with-current-module "")
                       (macro.result (io.run! init-jvm))
-                      (case> (#e.Success outputT)
+                      (case> {#e.Success outputT}
                              (text/= other-sample-string (:coerce Text outputT))
 
-                             (#e.Error error)
+                             {#e.Error error}
                              #0)))
             ))))
 
@@ -596,10 +596,10 @@
                         (evalT.eval sampleI))
                       (lang.with-current-module "")
                       (macro.result (io.run! init-jvm))
-                      (case> (#e.Success outputT)
+                      (case> {#e.Success outputT}
                              (i/= sample (:coerce Int outputT))
 
-                             (#e.Error error)
+                             {#e.Error error}
                              #0)))
             (test "jvm member invoke virtual"
                   (|> (do macro.Monad<Meta>
@@ -609,10 +609,10 @@
                         (evalT.eval sampleI))
                       (lang.with-current-module "")
                       (macro.result (io.run! init-jvm))
-                      (case> (#e.Success outputT)
+                      (case> {#e.Success outputT}
                              (:coerce Bit outputT)
 
-                             (#e.Error error)
+                             {#e.Error error}
                              #0)))
             (test "jvm member invoke interface"
                   (|> (do macro.Monad<Meta>
@@ -622,10 +622,10 @@
                         (evalT.eval sampleI))
                       (lang.with-current-module "")
                       (macro.result (io.run! init-jvm))
-                      (case> (#e.Success outputT)
+                      (case> {#e.Success outputT}
                              (:coerce Bit outputT)
 
-                             (#e.Error error)
+                             {#e.Error error}
                              #0)))
             (test "jvm member invoke constructor"
                   (|> (do macro.Monad<Meta>
@@ -633,9 +633,9 @@
                         (evalT.eval sampleI))
                       (lang.with-current-module "")
                       (macro.result (io.run! init-jvm))
-                      (case> (#e.Success outputT)
+                      (case> {#e.Success outputT}
                              (host.instance? ArrayList (:coerce Object outputT))
 
-                             (#e.Error error)
+                             {#e.Error error}
                              #0)))
             ))))