Migrated variants to the new syntax.

1 files changed, 102 insertions, 102 deletions

diff --git a/stdlib/source/test/lux/meta.lux b/stdlib/source/test/lux/meta.lux
index fa5e55c24..86af8bc90 100644
--- a/stdlib/source/test/lux/meta.lux
+++ b/stdlib/source/test/lux/meta.lux
@@ -54,13 +54,13 @@
                                             #.mode    #.Build]
                          #.source          [location.dummy 0 source_code]
                          #.location         location.dummy
-                         #.current_module  (#.Some expected_current_module)
+                         #.current_module  {#.Some expected_current_module}
                          #.modules         (list)
                          #.scopes          (list)
                          #.type_context    [#.ex_counter 0
                                             #.var_counter 0
                                             #.var_bindings (list)]
-                         #.expected        (#.Some (#.Primitive primitive_type (list)))
+                         #.expected        {#.Some {#.Primitive primitive_type (list)}}
                          #.seed            expected_seed
                          #.scope_type_vars (list)
                          #.extensions      []
@@ -70,18 +70,18 @@
         (_.cover [/.result]
                  (|> (\ /.monad in expected)
                      (/.result expected_lux)
-                     (!expect (^multi (#try.Success actual)
+                     (!expect (^multi {#try.Success actual}
                                       (n.= expected actual)))))
         (_.cover [/.result']
                  (|> (\ /.monad in expected)
                      (/.result' expected_lux)
-                     (!expect (^multi (#try.Success [actual_lux actual])
+                     (!expect (^multi {#try.Success [actual_lux actual]}
                                       (and (same? expected_lux actual_lux)
                                            (n.= expected actual))))))
         (_.cover [/.compiler_state]
                  (|> /.compiler_state
                      (/.result expected_lux)
-                     (!expect (^multi (#try.Success actual_lux)
+                     (!expect (^multi {#try.Success actual_lux}
                                       (same? expected_lux actual_lux)))))
         )))
 
@@ -102,13 +102,13 @@
                                             #.mode    #.Build]
                          #.source          [location.dummy 0 source_code]
                          #.location         location.dummy
-                         #.current_module  (#.Some expected_current_module)
+                         #.current_module  {#.Some expected_current_module}
                          #.modules         (list)
                          #.scopes          (list)
                          #.type_context    [#.ex_counter 0
                                             #.var_counter 0
                                             #.var_bindings (list)]
-                         #.expected        (#.Some (#.Primitive primitive_type (list)))
+                         #.expected        {#.Some {#.Primitive primitive_type (list)}}
                          #.seed            expected_seed
                          #.scope_type_vars (list)
                          #.extensions      []
@@ -119,43 +119,43 @@
                  (|> (/.failure expected_error)
                      (: (Meta Any))
                      (/.result expected_lux)
-                     (!expect (^multi (#try.Failure actual_error)
+                     (!expect (^multi {#try.Failure actual_error}
                                       (text\= (location.with location.dummy expected_error)
                                               actual_error)))))
         (_.cover [/.assertion]
                  (and (|> (/.assertion expected_error true)
                           (: (Meta Any))
                           (/.result expected_lux)
-                          (!expect (#try.Success [])))
+                          (!expect {#try.Success []}))
                       (|> (/.assertion expected_error false)
                           (/.result expected_lux)
-                          (!expect (^multi (#try.Failure actual_error)
+                          (!expect (^multi {#try.Failure actual_error}
                                            (text\= expected_error actual_error))))))
         (_.cover [/.either]
                  (and (|> (/.either (\ /.monad in expected)
                                     (: (Meta Nat)
                                        (/.failure expected_error)))
                           (/.result expected_lux)
-                          (!expect (^multi (#try.Success actual)
+                          (!expect (^multi {#try.Success actual}
                                            (n.= expected actual))))
                       (|> (/.either (: (Meta Nat)
                                        (/.failure expected_error))
                                     (\ /.monad in expected))
                           (/.result expected_lux)
-                          (!expect (^multi (#try.Success actual)
+                          (!expect (^multi {#try.Success actual}
                                            (n.= expected actual))))
                       (|> (/.either (: (Meta Nat)
                                        (/.failure expected_error))
                                     (: (Meta Nat)
                                        (/.failure expected_error)))
                           (/.result expected_lux)
-                          (!expect (^multi (#try.Failure actual_error)
+                          (!expect (^multi {#try.Failure actual_error}
                                            (text\= (location.with location.dummy expected_error)
                                                    actual_error))))
                       (|> (/.either (\ /.monad in expected)
                                     (\ /.monad in dummy))
                           (/.result expected_lux)
-                          (!expect (^multi (#try.Success actual)
+                          (!expect (^multi {#try.Success actual}
                                            (n.= expected actual))))
                       ))
         )))
@@ -197,13 +197,13 @@
                                             #.mode    #.Build]
                          #.source          [location.dummy 0 source_code]
                          #.location         location.dummy
-                         #.current_module  (#.Some expected_current_module)
+                         #.current_module  {#.Some expected_current_module}
                          #.modules         expected_modules
                          #.scopes          (list)
                          #.type_context    [#.ex_counter 0
                                             #.var_counter 0
                                             #.var_bindings (list)]
-                         #.expected        (#.Some (#.Primitive primitive_type (list)))
+                         #.expected        {#.Some {#.Primitive primitive_type (list)}}
                          #.seed            expected_seed
                          #.scope_type_vars (list)
                          #.extensions      []
@@ -214,29 +214,29 @@
             (_.cover [/.current_module_name]
                      (|> /.current_module_name
                          (/.result expected_lux)
-                         (!expect (^multi (#try.Success actual_current_module)
+                         (!expect (^multi {#try.Success actual_current_module}
                                           (text\= expected_current_module actual_current_module)))))
             (_.cover [/.current_module]
                      (|> /.current_module
                          (/.result expected_lux)
-                         (!expect (^multi (#try.Success actual_module)
+                         (!expect (^multi {#try.Success actual_module}
                                           (same? expected_module actual_module)))))
             (_.cover [/.module]
                      (|> (/.module expected_current_module)
                          (/.result expected_lux)
-                         (!expect (^multi (#try.Success actual_module)
+                         (!expect (^multi {#try.Success actual_module}
                                           (same? expected_module actual_module)))))
             (_.cover [/.module_exists?]
                      (and (|> (/.module_exists? expected_current_module)
                               (/.result expected_lux)
-                              (!expect (#try.Success #1)))
+                              (!expect {#try.Success #1}))
                           (|> (/.module_exists? dummy_module)
                               (/.result expected_lux)
-                              (!expect (#try.Success #0)))))
+                              (!expect {#try.Success #0}))))
             (_.cover [/.modules]
                      (|> /.modules
                          (/.result expected_lux)
-                         (!expect (^multi (#try.Success actual_modules)
+                         (!expect (^multi {#try.Success actual_modules}
                                           (same? expected_modules actual_modules)))))
             (_.cover [/.imported_modules]
                      (and (|> (/.imported_modules expected_current_module)
@@ -260,12 +260,12 @@
             (_.cover [/.normal]
                      (and (|> (/.normal ["" expected_short])
                               (/.result expected_lux)
-                              (!expect (^multi (#try.Success [actual_module actual_short])
+                              (!expect (^multi {#try.Success [actual_module actual_short]}
                                                (and (text\= expected_current_module actual_module)
                                                     (same? expected_short actual_short)))))
                           (|> (/.normal [dummy_module expected_short])
                               (/.result expected_lux)
-                              (!expect (^multi (#try.Success [actual_module actual_short])
+                              (!expect (^multi {#try.Success [actual_module actual_short]}
                                                (and (text\= dummy_module actual_module)
                                                     (same? expected_short actual_short)))))))
             ))))
@@ -284,7 +284,7 @@
      source_code (random.ascii/upper 1)
      expected_current_module (random.ascii/upper 1)
      expected_type (\ ! each (function (_ name)
-                               (#.Primitive name (list)))
+                               {#.Primitive name (list)})
                       (random.ascii/upper 1))
      expected_seed random.nat
      expected random.nat
@@ -298,11 +298,11 @@
                                             #.mode    #.Build]
                          #.source          [location.dummy 0 source_code]
                          #.location         expected_location
-                         #.current_module  (#.Some expected_current_module)
+                         #.current_module  {#.Some expected_current_module}
                          #.modules         (list)
                          #.scopes          (list)
                          #.type_context    type_context
-                         #.expected        (#.Some expected_type)
+                         #.expected        {#.Some expected_type}
                          #.seed            expected_seed
                          #.scope_type_vars (list)
                          #.extensions      []
@@ -315,18 +315,18 @@
                         post /.seed]
                        (in [pre post]))
                      (/.result expected_lux)
-                     (!expect (^multi (#try.Success [actual_pre actual_post])
+                     (!expect (^multi {#try.Success [actual_pre actual_post]}
                                       (and (n.= expected_seed actual_pre)
                                            (n.= (++ expected_seed) actual_post))))))
         (_.cover [/.location]
                  (|> /.location
                      (/.result expected_lux)
-                     (!expect (^multi (#try.Success actual_location)
+                     (!expect (^multi {#try.Success actual_location}
                                       (same? expected_location actual_location)))))
         (_.cover [/.expected_type]
                  (|> /.expected_type
                      (/.result expected_lux)
-                     (!expect (^multi (#try.Success actual_type)
+                     (!expect (^multi {#try.Success actual_type}
                                       (same? expected_type actual_type)))))
         (_.cover [.Type_Context /.type_context]
                  (|> /.type_context
@@ -343,7 +343,7 @@
                                         (random.ascii/upper 1))
      expected_short (random.ascii/upper 1)
      expected_type (\ ! each (function (_ name)
-                               (#.Primitive name (list)))
+                               {#.Primitive name (list)})
                       (random.ascii/upper 1))
      expected_value (random.either (in .def:)
                                    (in .macro:))
@@ -355,12 +355,12 @@
               (function (_ exported? def_type)
                 (let [current_globals (: (List [Text .Global])
                                          (list [expected_short
-                                                (#.Alias [expected_macro_module expected_short])]))
+                                                {#.Alias [expected_macro_module expected_short]}]))
                       macro_globals (: (List [Text .Global])
                                        (case def_type
-                                         (#.Some def_type)
+                                         {#.Some def_type}
                                          (list [expected_short
-                                                (#.Definition [exported? def_type expected_value])])
+                                                {#.Definition [exported? def_type expected_value]}])
 
                                          #.None
                                          (list)))]
@@ -371,7 +371,7 @@
                                        #.mode    #.Build]
                     #.source          [location.dummy 0 ""]
                     #.location         location.dummy
-                    #.current_module  (#.Some expected_current_module)
+                    #.current_module  {#.Some expected_current_module}
                     #.modules         (list [expected_current_module
                                              [#.module_hash        0
                                               #.module_aliases     (list)
@@ -397,54 +397,54 @@
     ($_ _.and
         (_.cover [.Global .Alias /.globals]
                  (let [[current_globals macro_globals expected_lux]
-                       (expected_lux true (#.Some .Macro))
+                       (expected_lux true {#.Some .Macro})
 
                        current_globals!
                        (|> (/.globals expected_current_module)
                            (/.result expected_lux)
-                           (!expect (^multi (#try.Success actual_globals)
+                           (!expect (^multi {#try.Success actual_globals}
                                             (same? current_globals actual_globals))))
 
                        macro_globals!
                        (|> (/.globals expected_macro_module)
                            (/.result expected_lux)
-                           (!expect (^multi (#try.Success actual_globals)
+                           (!expect (^multi {#try.Success actual_globals}
                                             (same? macro_globals actual_globals))))]
                    (and current_globals!
                         macro_globals!)))
         (_.cover [.Definition /.definitions]
                  (let [[current_globals macro_globals expected_lux]
-                       (expected_lux true (#.Some .Macro))]
+                       (expected_lux true {#.Some .Macro})]
                    (and (|> (/.definitions expected_current_module)
                             (/.result expected_lux)
-                            (!expect (^multi (#try.Success actual_definitions)
+                            (!expect (^multi {#try.Success actual_definitions}
                                              (n.= 0 (list.size actual_definitions)))))
                         (|> (/.definitions expected_macro_module)
                             (/.result expected_lux)
-                            (!expect (^multi (#try.Success actual_definitions)
+                            (!expect (^multi {#try.Success actual_definitions}
                                              (n.= 1 (list.size actual_definitions)))))
                         )))
         (_.cover [/.exports]
                  (and (let [[current_globals macro_globals expected_lux]
-                            (expected_lux true (#.Some .Macro))]
+                            (expected_lux true {#.Some .Macro})]
                         (and (|> (/.exports expected_current_module)
                                  (/.result expected_lux)
-                                 (!expect (^multi (#try.Success actual_definitions)
+                                 (!expect (^multi {#try.Success actual_definitions}
                                                   (n.= 0 (list.size actual_definitions)))))
                              (|> (/.exports expected_macro_module)
                                  (/.result expected_lux)
-                                 (!expect (^multi (#try.Success actual_definitions)
+                                 (!expect (^multi {#try.Success actual_definitions}
                                                   (n.= 1 (list.size actual_definitions)))))
                              ))
                       (let [[current_globals macro_globals expected_lux]
-                            (expected_lux false (#.Some .Macro))]
+                            (expected_lux false {#.Some .Macro})]
                         (and (|> (/.exports expected_current_module)
                                  (/.result expected_lux)
-                                 (!expect (^multi (#try.Success actual_definitions)
+                                 (!expect (^multi {#try.Success actual_definitions}
                                                   (n.= 0 (list.size actual_definitions)))))
                              (|> (/.exports expected_macro_module)
                                  (/.result expected_lux)
-                                 (!expect (^multi (#try.Success actual_definitions)
+                                 (!expect (^multi {#try.Success actual_definitions}
                                                   (n.= 0 (list.size actual_definitions)))))
                              ))))
         )))
@@ -458,7 +458,7 @@
                                         (random.ascii/upper 1))
      expected_short (random.ascii/upper 1)
      expected_type (\ ! each (function (_ name)
-                               (#.Primitive name (list)))
+                               {#.Primitive name (list)})
                       (random.ascii/upper 1))
      expected_value (random.either (in .def:)
                                    (in .macro:))
@@ -470,12 +470,12 @@
               (function (_ exported? def_type)
                 (let [current_globals (: (List [Text .Global])
                                          (list [expected_short
-                                                (#.Alias [expected_macro_module expected_short])]))
+                                                {#.Alias [expected_macro_module expected_short]}]))
                       macro_globals (: (List [Text .Global])
                                        (case def_type
-                                         (#.Some def_type)
+                                         {#.Some def_type}
                                          (list [expected_short
-                                                (#.Definition [exported? def_type expected_value])])
+                                                {#.Definition [exported? def_type expected_value]}])
 
                                          #.None
                                          (list)))]
@@ -486,7 +486,7 @@
                                        #.mode    #.Build]
                     #.source          [location.dummy 0 ""]
                     #.location         location.dummy
-                    #.current_module  (#.Some expected_current_module)
+                    #.current_module  {#.Some expected_current_module}
                     #.modules         (list [expected_current_module
                                              [#.module_hash        0
                                               #.module_aliases     (list)
@@ -512,44 +512,44 @@
     ($_ _.and
         (_.cover [/.export]
                  (and (let [[current_globals macro_globals expected_lux]
-                            (expected_lux true (#.Some expected_type))]
+                            (expected_lux true {#.Some expected_type})]
                         (|> (/.export [expected_macro_module expected_short])
                             (/.result expected_lux)
-                            (!expect (#try.Success _))))
+                            (!expect {#try.Success _})))
                       (let [[current_globals macro_globals expected_lux]
-                            (expected_lux false (#.Some expected_type))]
+                            (expected_lux false {#.Some expected_type})]
                         (|> (/.export [expected_macro_module expected_short])
                             (/.result expected_lux)
-                            (!expect (#try.Failure _))))))
+                            (!expect {#try.Failure _})))))
         (_.cover [/.macro]
                  (let [same_module!
                        (let [[current_globals macro_globals expected_lux]
-                             (expected_lux true (#.Some .Macro))]
+                             (expected_lux true {#.Some .Macro})]
                          (|> (/.macro [expected_macro_module expected_short])
                              (/.result expected_lux)
-                             (!expect (^multi (#try.Success (#.Some actual_value))
+                             (!expect (^multi {#try.Success {#.Some actual_value}}
                                               (same? expected_value actual_value)))))
 
                        not_macro!
                        (let [[current_globals macro_globals expected_lux]
-                             (expected_lux true (#.Some expected_type))]
+                             (expected_lux true {#.Some expected_type})]
                          (|> (/.macro [expected_macro_module expected_short])
                              (/.result expected_lux)
-                             (!expect (#try.Success #.None))))
+                             (!expect {#try.Success #.None})))
 
                        not_found!
                        (let [[current_globals macro_globals expected_lux]
                              (expected_lux true #.None)]
                          (|> (/.macro [expected_macro_module expected_short])
                              (/.result expected_lux)
-                             (!expect (#try.Success #.None))))
+                             (!expect {#try.Success #.None})))
 
                        aliasing!
                        (let [[current_globals macro_globals expected_lux]
-                             (expected_lux true (#.Some .Macro))]
+                             (expected_lux true {#.Some .Macro})]
                          (|> (/.macro [expected_current_module expected_short])
                              (/.result expected_lux)
-                             (!expect (^multi (#try.Success (#.Some actual_value))
+                             (!expect (^multi {#try.Success {#.Some actual_value}}
                                               (same? expected_value actual_value)))))]
                    (and same_module!
                         not_macro!
@@ -557,7 +557,7 @@
                         aliasing!)))
         (_.cover [/.de_aliased]
                  (let [[current_globals macro_globals expected_lux]
-                       (expected_lux true (#.Some .Macro))]
+                       (expected_lux true {#.Some .Macro})]
                    (and (|> (/.de_aliased [expected_macro_module expected_short])
                             (/.result expected_lux)
                             (try\each (name\= [expected_macro_module expected_short]))
@@ -568,12 +568,12 @@
                             (try.else false)))))
         (_.cover [/.definition]
                  (let [[current_globals macro_globals expected_lux]
-                       (expected_lux expected_exported? (#.Some expected_type))
+                       (expected_lux expected_exported? {#.Some expected_type})
 
                        definition!
                        (|> (/.definition [expected_macro_module expected_short])
                            (/.result expected_lux)
-                           (!expect (^multi (#try.Success (#.Definition [actual_exported? actual_type actual_value]))
+                           (!expect (^multi {#try.Success {#.Definition [actual_exported? actual_type actual_value]}}
                                             (and (bit\= expected_exported? actual_exported?)
                                                  (same? expected_type actual_type)
                                                  (same? (:as Any expected_value) actual_value)))))
@@ -581,42 +581,42 @@
                        alias!
                        (|> (/.definition [expected_current_module expected_short])
                            (/.result expected_lux)
-                           (!expect (^multi (#try.Success (#.Alias [actual_module actual_short]))
+                           (!expect (^multi {#try.Success {#.Alias [actual_module actual_short]}}
                                             (and (same? expected_macro_module actual_module)
                                                  (same? expected_short actual_short)))))]
                    (and definition!
                         alias!)))
         (_.cover [/.definition_type]
                  (let [[current_globals macro_globals expected_lux]
-                       (expected_lux expected_exported? (#.Some expected_type))
+                       (expected_lux expected_exported? {#.Some expected_type})
 
                        definition!
                        (|> (/.definition_type [expected_macro_module expected_short])
                            (/.result expected_lux)
-                           (!expect (^multi (#try.Success actual_type)
+                           (!expect (^multi {#try.Success actual_type}
                                             (same? expected_type actual_type))))
 
                        alias!
                        (|> (/.definition_type [expected_current_module expected_short])
                            (/.result expected_lux)
-                           (!expect (^multi (#try.Success actual_type)
+                           (!expect (^multi {#try.Success actual_type}
                                             (same? expected_type actual_type))))]
                    (and definition!
                         alias!)))
         (_.cover [/.type_definition]
                  (let [[current_globals macro_globals expected_lux]
-                       (expected_lux expected_exported? (#.Some .Type))
+                       (expected_lux expected_exported? {#.Some .Type})
 
                        definition!
                        (|> (/.type_definition [expected_macro_module expected_short])
                            (/.result expected_lux)
-                           (!expect (^multi (#try.Success actual_value)
+                           (!expect (^multi {#try.Success actual_value}
                                             (same? (:as .Type expected_value) actual_value))))
 
                        alias!
                        (|> (/.type_definition [expected_current_module expected_short])
                            (/.result expected_lux)
-                           (!expect (^multi (#try.Success actual_value)
+                           (!expect (^multi {#try.Success actual_value}
                                             (same? (:as .Type expected_value) actual_value))))]
                    (and definition!
                         alias!)))
@@ -644,11 +644,11 @@
                                   (\ ! each set.list)
                                   (random.and (in head)))))]
      tags_0 random_labels
-     tags_1 (let [set/0 (set.of_list text.hash (#.Item tags_0))]
+     tags_1 (let [set/0 (set.of_list text.hash {#.Item tags_0})]
               (random.only (|>> #.Item (list.any? (set.member? set/0))not)
                            random_labels))
-     .let [type_0 (#.Primitive name_0 (list))
-           type_1 (#.Primitive name_1 (list))
+     .let [type_0 {#.Primitive name_0 (list)}
+           type_1 {#.Primitive name_1 (list)}
            
            expected_lux
            (: Lux
@@ -657,7 +657,7 @@
                                   #.mode    #.Build]
                #.source          [location.dummy 0 ""]
                #.location        location.dummy
-               #.current_module  (#.Some current_module)
+               #.current_module  {#.Some current_module}
                #.modules         (list [current_module
                                         [#.module_hash        0
                                          #.module_aliases     (list)
@@ -667,17 +667,17 @@
                                        [tag_module
                                         [#.module_hash        0
                                          #.module_aliases     (list)
-                                         #.definitions        (list& [name_0 (#.Type [false type_0 (#.Left tags_0)])]
-                                                                     [name_1 (#.Type [true type_1 (#.Right tags_1)])]
+                                         #.definitions        (list& [name_0 {#.Type [false type_0 {#.Left tags_0}]}]
+                                                                     [name_1 {#.Type [true type_1 {#.Right tags_1}]}]
                                                                      ($_ list\composite
-                                                                         (|> (#.Item tags_0)
+                                                                         (|> {#.Item tags_0}
                                                                              list.enumeration
                                                                              (list\each (function (_ [index short])
-                                                                                          [(format "#" short) (#.Label [false type_0 (#.Item tags_0) index])])))
-                                                                         (|> (#.Item tags_1)
+                                                                                          [(format "#" short) {#.Label [false type_0 {#.Item tags_0} index]}])))
+                                                                         (|> {#.Item tags_1}
                                                                              list.enumeration
                                                                              (list\each (function (_ [index short])
-                                                                                          [(format "#" short) (#.Slot [true type_1 (#.Item tags_1) index])])))))
+                                                                                          [(format "#" short) {#.Slot [true type_1 {#.Item tags_1} index]}])))))
                                          #.imports            (list)
                                          #.module_state       #.Active]])
                #.scopes          (list)
@@ -698,29 +698,29 @@
                                      type.equivalence))]
                    (|> (/.tag_lists tag_module)
                        (/.result expected_lux)
-                       (try\each (\ equivalence = (list [(list\each (|>> [tag_module]) (#.Item tags_1))
+                       (try\each (\ equivalence = (list [(list\each (|>> [tag_module]) {#.Item tags_1})
                                                          type_1])))
                        (try.else false))))
         (_.cover [/.tags_of]
                  (|> (/.tags_of [tag_module name_1])
                      (/.result expected_lux)
-                     (try\each (\ (maybe.equivalence (list.equivalence name.equivalence)) = (#.Some (list\each (|>> [tag_module]) (#.Item tags_1)))))
+                     (try\each (\ (maybe.equivalence (list.equivalence name.equivalence)) = {#.Some (list\each (|>> [tag_module]) {#.Item tags_1})}))
                      (try.else false)))
         (_.cover [/.slot]
-                 (|> (#.Item tags_1)
+                 (|> {#.Item tags_1}
                      list.enumeration
                      (list.every? (function (_ [expected_index tag])
                                     (|> [tag_module tag]
                                         /.slot
                                         (/.result expected_lux)
-                                        (!expect (^multi (#try.Success [actual_index actual_tags actual_type])
+                                        (!expect (^multi {#try.Success [actual_index actual_tags actual_type]}
                                                          (let [correct_index!
                                                                (n.= expected_index
                                                                     actual_index)
 
                                                                correct_tags!
                                                                (\ (list.equivalence name.equivalence) =
-                                                                  (list\each (|>> [tag_module]) (#.Item tags_1))
+                                                                  (list\each (|>> [tag_module]) {#.Item tags_1})
                                                                   actual_tags)
 
                                                                correct_type!
@@ -742,19 +742,19 @@
                                               (random.one (function (_ values)
                                                             (case values
                                                               (^ (list name_0 name_1 name_2 name_3 name_4))
-                                                              (#.Some [name_0 name_1 name_2 name_3 name_4])
+                                                              {#.Some [name_0 name_1 name_2 name_3 name_4]}
 
                                                               _
                                                               #.None))))
-     .let [type_0 (#.Primitive name_0 (list))
-           type_1 (#.Primitive name_1 (list))
-           type_2 (#.Primitive name_2 (list))
-           type_3 (#.Primitive name_3 (list))
-           type_4 (#.Primitive name_4 (list))
+     .let [type_0 {#.Primitive name_0 (list)}
+           type_1 {#.Primitive name_1 (list)}
+           type_2 {#.Primitive name_2 (list)}
+           type_3 {#.Primitive name_3 (list)}
+           type_4 {#.Primitive name_4 (list)}
 
            globals (: (List [Text .Global])
                       (list [name_4
-                             (#.Definition [false type_4 []])]))
+                             {#.Definition [false type_4 []]}]))
 
            scopes (list [#.name     (list)
                          #.inner    0
@@ -782,7 +782,7 @@
                                   #.mode    #.Build]
                #.source          [location.dummy 0 ""]
                #.location        location.dummy
-               #.current_module  (#.Some current_module)
+               #.current_module  {#.Some current_module}
                #.modules         (list [current_module
                                         [#.module_hash        0
                                          #.module_aliases     (list)
@@ -866,7 +866,7 @@
   (function (_ == left right)
     (case [(/.result init left)
            (/.result init right)]
-      [(#try.Success left) (#try.Success right)]
+      [{#try.Success left} {#try.Success right}]
       (== left right)
       
       _
@@ -883,7 +883,7 @@
              source_code (random.ascii/upper 1)
              expected_current_module (random.ascii/upper 1)
              expected_type (\ ! each (function (_ name)
-                                       (#.Primitive name (list)))
+                                       {#.Primitive name (list)})
                               (random.ascii/upper 1))
              expected_seed random.nat
              expected random.nat
@@ -894,13 +894,13 @@
                                                     #.mode    #.Build]
                                  #.source          [expected_location 0 source_code]
                                  #.location         expected_location
-                                 #.current_module  (#.Some expected_current_module)
+                                 #.current_module  {#.Some expected_current_module}
                                  #.modules         (list)
                                  #.scopes          (list)
                                  #.type_context    [#.ex_counter 0
                                                     #.var_counter 0
                                                     #.var_bindings (list)]
-                                 #.expected        (#.Some expected_type)
+                                 #.expected        {#.Some expected_type}
                                  #.seed            expected_seed
                                  #.scope_type_vars (list)
                                  #.extensions      []
@@ -923,7 +923,7 @@
                                     (: (Try Nat))
                                     /.lifted
                                     (/.result expected_lux)
-                                    (!expect (^multi (#try.Failure actual)
+                                    (!expect (^multi {#try.Failure actual}
                                                      (text\= (location.with expected_location expected_error)
                                                              actual))))
                                 (|> expected_value
@@ -931,7 +931,7 @@
                                     (: (Try Nat))
                                     /.lifted
                                     (/.result expected_lux)
-                                    (!expect (^multi (#try.Success actual)
+                                    (!expect (^multi {#try.Success actual}
                                                      (same? expected_value actual)))))))
                 
                 ..compiler_related