- Fixes for compiler build [part 0].

11 files changed, 212 insertions, 187 deletions

diff --git a/stdlib/test/test/lux/language/compiler/analysis/procedure/host.jvm.lux b/new-luxc/test/test/luxc/lang/analysis/host.jvm.lux
index 02574a31a..02574a31a 100644
--- a/stdlib/test/test/lux/language/compiler/analysis/procedure/host.jvm.lux
+++ b/new-luxc/test/test/luxc/lang/analysis/host.jvm.lux
diff --git a/stdlib/test/test/lux/language/compiler/analysis/case.lux b/stdlib/test/test/lux/language/compiler/analysis/case.lux
index 66b1b0b12..4e01ae3bd 100644
--- a/stdlib/test/test/lux/language/compiler/analysis/case.lux
+++ b/stdlib/test/test/lux/language/compiler/analysis/case.lux
@@ -13,14 +13,14 @@
      [set]]]
    [math
     ["r" random ("random/" Monad<Random>)]]
-   [macro (#+ Monad<Meta>)
+   [macro
     [code]]
    [language
     ["." type
-     ["tc" check]]
-    [".L" module]
-    [compiler
+     [check]]
+    ["." compiler
      ["." analysis
+      [module]
       [".A" type]
       ["/" case]]]]
    test]
@@ -149,7 +149,7 @@
                variantTC (list.zip2 variant-tags+ primitivesC)]
          inputC (input variant-tags+ record-tags+ primitivesC)
          [outputT outputC] _primitive.primitive
-         [heterogeneousT heterogeneousC] (r.filter (|>> product.left (tc.checks? outputT) not)
+         [heterogeneousT heterogeneousC] (r.filter (|>> product.left (check.checks? outputT) not)
                                                    _primitive.primitive)
          exhaustive-patterns (exhaustive-branches true variantTC inputC)
          redundant-patterns (exhaustive-branches false variantTC inputC)
@@ -171,14 +171,14 @@
                analyse-pm (|>> (/.case _primitive.analyse inputC)
                                (typeA.with-type outputT)
                                analysis.with-scope
-                               (do Monad<Meta>
-                                 [_ (moduleL.declare-tags variant-tags false
-                                                          (#.Named [module-name variant-name]
-                                                                   (type.variant primitivesT)))
-                                  _ (moduleL.declare-tags record-tags false
-                                                          (#.Named [module-name record-name]
-                                                                   (type.tuple primitivesT)))])
-                               (moduleL.with-module +0 module-name))]]
+                               (do compiler.Monad<Operation>
+                                 [_ (module.declare-tags variant-tags false
+                                                         (#.Named [module-name variant-name]
+                                                                  (type.variant primitivesT)))
+                                  _ (module.declare-tags record-tags false
+                                                         (#.Named [module-name record-name]
+                                                                  (type.tuple primitivesT)))])
+                               (module.with-module +0 module-name))]]
         ($_ seq
             (test "Will reject empty pattern-matching (no branches)."
                   (|> (analyse-pm (list))
diff --git a/stdlib/test/test/lux/language/compiler/analysis/function.lux b/stdlib/test/test/lux/language/compiler/analysis/function.lux
index bc1a24811..1edbfd949 100644
--- a/stdlib/test/test/lux/language/compiler/analysis/function.lux
+++ b/stdlib/test/test/lux/language/compiler/analysis/function.lux
@@ -16,30 +16,31 @@
     ["r" random]]
    ["." macro
     [code]]
-   [language]
-   [language
-    [type ("type/" Equivalence<Type>)]
-    [".L" reference]
-    [compiler
-     [".L" init]
-     [".L" analysis (#+ Analysis)
+   ["." language
+    [type]
+    [reference]
+    ["." compiler
+     [init]
+     [analysis (#+ Analysis Operation)
       [".A" type]
-      [".A" expression]
-      ["/" function]]]]
+      [expression]
+      ["/" function]]
+     [extension
+      [".E" analysis]]]]
    test]
   [//
    ["_." primitive]
    ["_." structure]])
 
-(def: analyse (expressionA.analyser (:coerce language.Eval [])))
+(def: analyse (expression.analyser (:coerce language.Eval [])))
 
 (def: (check-apply expectedT num-args analysis)
-  (-> Type Nat (Meta Analysis) Bool)
+  (-> Type Nat (Operation Analysis) Bool)
   (|> analysis
       (typeA.with-type expectedT)
-      (macro.run (initL.compiler []))
+      (compiler.run [analysisE.bundle (init.compiler [])])
       (case> (#e.Success applyA)
-             (let [[funcA argsA] (analysisL.application applyA)]
+             (let [[funcA argsA] (analysis.application applyA)]
                (n/= num-args (list.size argsA)))
 
              (#e.Error error)
@@ -99,7 +100,7 @@
                partial-polyT2 (<| (type.univ-q +1)
                                   (type.function (#.Cons varT partial-poly-inputsT))
                                   varT)
-               dummy-function (#analysisL.Function (list) (#analysisL.Reference (referenceL.local +1)))]]
+               dummy-function (#analysis.Function (list) (#analysis.Reference (reference.local +1)))]]
         ($_ seq
             (test "Can analyse monomorphic type application."
                   (|> (/.apply ..analyse funcT dummy-function inputsC)
diff --git a/stdlib/test/test/lux/language/compiler/analysis/primitive.lux b/stdlib/test/test/lux/language/compiler/analysis/primitive.lux
index ba841fbfe..8cd764b00 100644
--- a/stdlib/test/test/lux/language/compiler/analysis/primitive.lux
+++ b/stdlib/test/test/lux/language/compiler/analysis/primitive.lux
@@ -10,18 +10,20 @@
     [text format]]
    [math
     ["r" random ("random/" Monad<Random>)]]
-   ["." macro
+   [macro
     [code]]
    ["." language
     [".L" type ("type/" Equivalence<Type>)]
-    [compiler
-     [".L" init]
-     [analysis (#+ Analysis)
+    ["." compiler
+     [init]
+     [analysis (#+ Analysis Operation)
       [".A" type]
-      [".A" expression]]]]
+      [expression]]
+     [extension
+      [".E" analysis]]]]
    test])
 
-(def: #export analyse (expressionA.analyser (:coerce language.Eval [])))
+(def: #export analyse (expression.analyser (:coerce language.Eval [])))
 
 (def: unit
   (r.Random Code)
@@ -47,10 +49,10 @@
              ["Inferred" (%type inferred)]))
 
 (def: (infer-primitive expected-type analysis)
-  (-> Type (Meta Analysis) (e.Error Analysis))
-  (|> (typeA.with-inference
-        analysis)
-      (macro.run (initL.compiler []))
+  (-> Type (Operation Analysis) (e.Error Analysis))
+  (|> analysis
+      typeA.with-inference
+      (compiler.run [analysisE.bundle (init.compiler [])])
       (case> (#e.Success [inferred-type output])
              (if (is? expected-type inferred-type)
                (#e.Success output)
diff --git a/stdlib/test/test/lux/language/compiler/analysis/procedure/common.lux b/stdlib/test/test/lux/language/compiler/analysis/procedure/common.lux
index 1f7021039..e3b8cc9b5 100644
--- a/stdlib/test/test/lux/language/compiler/analysis/procedure/common.lux
+++ b/stdlib/test/test/lux/language/compiler/analysis/procedure/common.lux
@@ -13,15 +13,17 @@
     [collection [array]]]
    [math
     ["r" random]]
-   [macro (#+ Monad<Meta>)
+   [macro
     [code]]
-   ["." language
+   [language
     [type ("type/" Equivalence<Type>)]
-    [".L" scope]
-    [compiler
-     [".L" init]
+    ["." compiler
+     [init]
      [analysis
-      [".A" type]]]]
+      [scope]
+      [".A" type]]
+     [extension
+      [".E" analysis]]]]
    test]
   [///
    ["_." primitive]])
@@ -29,10 +31,10 @@
 (do-template [<name> <success> <failure>]
   [(def: (<name> procedure params output-type)
      (-> Text (List Code) Type Bool)
-     (|> (scopeL.with-scope ""
+     (|> (scope.with-scope ""
            (typeA.with-type output-type
              (_primitive.analyse (` ((~ (code.text procedure)) (~+ params))))))
-         (macro.run (initL.compiler []))
+         (compiler.run [analysisE.bundle (init.compiler [])])
          (case> (#e.Success _)
                 <success>
 
@@ -177,11 +179,11 @@
          #let [arrayT (type (Array elemT))
                g!array (code.local-symbol var-name)
                array-operation (function (_ output-type code)
-                                 (|> (scopeL.with-scope ""
-                                       (scopeL.with-local [var-name arrayT]
+                                 (|> (scope.with-scope ""
+                                       (scope.with-local [var-name arrayT]
                                          (typeA.with-type output-type
                                            (_primitive.analyse code))))
-                                     (macro.run (initL.compiler []))
+                                     (compiler.run [analysisE.bundle (init.compiler [])])
                                      (case> (#e.Success _)
                                             true
 
@@ -247,25 +249,25 @@
             (test "Can create atomic reference."
                   (check-success+ "lux atom new" (list elemC) atomT))
             (test "Can read the value of an atomic reference."
-                  (|> (scopeL.with-scope ""
-                        (scopeL.with-local [var-name atomT]
+                  (|> (scope.with-scope ""
+                        (scope.with-local [var-name atomT]
                           (typeA.with-type elemT
                             (_primitive.analyse (` ("lux atom read" (~ (code.symbol ["" var-name]))))))))
-                      (macro.run (initL.compiler []))
+                      (compiler.run [analysisE.bundle (init.compiler [])])
                       (case> (#e.Success _)
                              true
 
                              (#e.Error _)
                              false)))
             (test "Can swap the value of an atomic reference."
-                  (|> (scopeL.with-scope ""
-                        (scopeL.with-local [var-name atomT]
+                  (|> (scope.with-scope ""
+                        (scope.with-local [var-name atomT]
                           (typeA.with-type Bool
                             (_primitive.analyse (` ("lux atom compare-and-swap"
                                                     (~ (code.symbol ["" var-name]))
                                                     (~ elemC)
                                                     (~ elemC)))))))
-                      (macro.run (initL.compiler []))
+                      (compiler.run [analysisE.bundle (init.compiler [])])
                       (case> (#e.Success _)
                              true
 
diff --git a/stdlib/test/test/lux/language/compiler/analysis/reference.lux b/stdlib/test/test/lux/language/compiler/analysis/reference.lux
index aaad40584..00ab606a3 100644
--- a/stdlib/test/test/lux/language/compiler/analysis/reference.lux
+++ b/stdlib/test/test/lux/language/compiler/analysis/reference.lux
@@ -10,23 +10,26 @@
     [text ("text/" Equivalence<Text>)]]
    [math
     ["r" random]]
-   [macro (#+ Monad<Meta>) [code]]
+   [macro
+    [code]]
    ["." language]
    [language
     [type ("type/" Equivalence<Type>)]
-    [".L" scope]
-    [".L" module]
-    [".L" reference]
-    [compiler
-     [".L" init]
-     [".L" analysis
+    [reference]
+    ["." compiler
+     [init]
+     ["." analysis
+      [scope]
+      [module]
       [".A" type]
-      [".A" expression]]]]
+      [expression]]
+     [extension
+      [".E" analysis]]]]
    test]
   [//
    ["_." primitive]])
 
-(def: analyse (expressionA.analyser (:coerce language.Eval [])))
+(def: analyse (expression.analyser (:coerce language.Eval [])))
 
 (type: Check (-> (e.Error Any) Bool))
 
@@ -45,21 +48,21 @@
 
 (def: (reach-test var-name [export? def-module] [import? dependent-module] check!)
   (-> Text [Bool Text] [Bool Text] Check Bool)
-  (|> (do Monad<Meta>
-        [_ (moduleL.with-module +0 def-module
-             (moduleL.define var-name [Any
-                                       (if export?
-                                         (' {#.export? true})
-                                         (' {}))
-                                       []]))]
-        (moduleL.with-module +0 dependent-module
+  (|> (do compiler.Monad<Operation>
+        [_ (module.with-module +0 def-module
+             (module.define var-name [Any
+                                      (if export?
+                                        (' {#.export? true})
+                                        (' {}))
+                                      []]))]
+        (module.with-module +0 dependent-module
           (do @
             [_ (if import?
-                 (moduleL.import def-module)
+                 (module.import def-module)
                  (wrap []))]
             (typeA.with-inference
               (..analyse (code.symbol [def-module var-name]))))))
-      (macro.run (initL.compiler []))
+      (compiler.run [analysisE.bundle (init.compiler [])])
       check!))
 
 (context: "References"
@@ -73,12 +76,12 @@
                               (r.filter (|>> (text/= def-module) not)))]
         ($_ seq
             (test "Can analyse variable."
-                  (|> (scopeL.with-scope scope-name
-                        (scopeL.with-local [var-name expectedT]
+                  (|> (scope.with-scope scope-name
+                        (scope.with-local [var-name expectedT]
                           (typeA.with-inference
                             (..analyse (code.local-symbol var-name)))))
-                      (macro.run (initL.compiler []))
-                      (case> (^ (#e.Success [inferredT (#analysisL.Reference (referenceL.local var))]))
+                      (compiler.run [analysisE.bundle (init.compiler [])])
+                      (case> (^ (#e.Success [inferredT (#analysis.Reference (reference.local var))]))
                              (and (type/= expectedT inferredT)
                                   (n/= +0 var))
 
@@ -86,13 +89,13 @@
                              false)))
             (test "Can analyse definition (in the same module)."
                   (let [def-name [def-module var-name]]
-                    (|> (do Monad<Meta>
-                          [_ (moduleL.define var-name [expectedT (' {}) []])]
+                    (|> (do compiler.Monad<Operation>
+                          [_ (module.define var-name [expectedT (' {}) []])]
                           (typeA.with-inference
                             (..analyse (code.symbol def-name))))
-                        (moduleL.with-module +0 def-module)
-                        (macro.run (initL.compiler []))
-                        (case> (^ (#e.Success [_ inferredT (#analysisL.Reference (referenceL.constant constant-name))]))
+                        (module.with-module +0 def-module)
+                        (compiler.run [analysisE.bundle (init.compiler [])])
+                        (case> (^ (#e.Success [_ inferredT (#analysis.Reference (reference.constant constant-name))]))
                                (and (type/= expectedT inferredT)
                                     (ident/= def-name constant-name))
 
diff --git a/stdlib/test/test/lux/language/compiler/analysis/structure.lux b/stdlib/test/test/lux/language/compiler/analysis/structure.lux
index 2777ad93b..664e6e29f 100644
--- a/stdlib/test/test/lux/language/compiler/analysis/structure.lux
+++ b/stdlib/test/test/lux/language/compiler/analysis/structure.lux
@@ -1,6 +1,5 @@
 (.module:
   [lux #*
-   [io]
    [control
     [monad (#+ do)]
     pipe]
@@ -9,35 +8,36 @@
     ["e" error]
     [product]
     [maybe]
-    ["." text
-     format]
+    ["." text]
     [collection
      [list ("list/" Functor<List>)]
      [set]]]
    [math
     ["r" random]]
-   ["." macro
+   [macro
     [code]]
    ["." language
     [type ("type/" Equivalence<Type>)
-     ["tc" check]]
-    [".L" module]
-    [compiler
-     [".L" init]
-     [".L" analysis (#+ Analysis Variant Tag)
+     [check]]
+    ["." compiler
+     [init]
+     [analysis (#+ Analysis Variant Tag Operation)
+      [module]
       [".A" type]
       ["/" structure]
-      [".A" expression]]]]
+      [expression]]
+     [extension
+      [".E" analysis]]]]
    test]
   [//
    ["_." primitive]])
 
-(def: analyse (expressionA.analyser (:coerce language.Eval [])))
+(def: analyse (expression.analyser (:coerce language.Eval [])))
 
 (do-template [<name> <on-success> <on-error>]
   [(def: #export <name>
-     (All [a] (-> (Meta a) Bool))
-     (|>> (macro.run (initL.compiler []))
+     (All [a] (-> (Operation a) Bool))
+     (|>> (compiler.run [analysisE.bundle (init.compiler [])])
           (case> (#e.Success _)
                  <on-success>
 
@@ -50,20 +50,20 @@
 
 (def: (check-sum' size tag variant)
   (-> Nat Tag (Variant Analysis) Bool)
-  (let [variant-tag (if (get@ #analysisL.right? variant)
-                      (inc (get@ #analysisL.lefts variant))
-                      (get@ #analysisL.lefts variant))]
+  (let [variant-tag (if (get@ #analysis.right? variant)
+                      (inc (get@ #analysis.lefts variant))
+                      (get@ #analysis.lefts variant))]
     (|> size dec (n/= tag)
-        (bool/= (get@ #analysisL.right? variant))
+        (bool/= (get@ #analysis.right? variant))
         (and (n/= tag variant-tag)))))
 
 (def: (check-sum type size tag analysis)
-  (-> Type Nat Tag (Meta Analysis) Bool)
+  (-> Type Nat Tag (Operation Analysis) Bool)
   (|> analysis
       (typeA.with-type type)
-      (macro.run (initL.compiler []))
+      (compiler.run [analysisE.bundle (init.compiler [])])
       (case> (^multi (#e.Success sumA)
-                     [(analysisL.variant sumA)
+                     [(analysis.variant sumA)
                       (#.Some variant)])
              (check-sum' size tag variant)
 
@@ -71,19 +71,19 @@
              false)))
 
 (def: (tagged module tags type)
-  (All [a] (-> Text (List moduleL.Tag) Type (Meta a) (Meta [Module a])))
-  (|>> (do macro.Monad<Meta>
-         [_ (moduleL.declare-tags tags false type)])
-       (moduleL.with-module +0 module)))
+  (All [a] (-> Text (List module.Tag) Type (Operation a) (Operation [Module a])))
+  (|>> (do compiler.Monad<Operation>
+         [_ (module.declare-tags tags false type)])
+       (module.with-module +0 module)))
 
 (def: (check-variant module tags type size tag analysis)
-  (-> Text (List moduleL.Tag) Type Nat Tag (Meta Analysis) Bool)
+  (-> Text (List module.Tag) Type Nat Tag (Operation Analysis) Bool)
   (|> analysis
       (tagged module tags type)
       (typeA.with-type type)
-      (macro.run (initL.compiler []))
+      (compiler.run [analysisE.bundle (init.compiler [])])
       (case> (^multi (#e.Success [_ sumA])
-                     [(analysisL.variant sumA)
+                     [(analysis.variant sumA)
                       (#.Some variant)])
              (check-sum' size tag variant)
 
@@ -92,13 +92,13 @@
 
 (def: (right-size? size)
   (-> Nat (-> Analysis Bool))
-  (|>> analysisL.tuple list.size (n/= size)))
+  (|>> analysis.tuple list.size (n/= size)))
 
 (def: (check-record-inference module tags type size analysis)
-  (-> Text (List moduleL.Tag) Type Nat (Meta [Type Analysis]) Bool)
+  (-> Text (List module.Tag) Type Nat (Operation [Type Analysis]) Bool)
   (|> analysis
       (tagged module tags type)
-      (macro.run (initL.compiler []))
+      (compiler.run [analysisE.bundle (init.compiler [])])
       (case> (#e.Success [_ productT productA])
              (and (type/= type productT)
                   (right-size? size productA))
@@ -127,23 +127,23 @@
                   (check-sum variantT size choice
                              (/.sum ..analyse choice valueC)))
             (test "Can analyse sum through bound type-vars."
-                  (|> (do macro.Monad<Meta>
-                        [[_ varT] (typeA.with-env tc.var)
+                  (|> (do compiler.Monad<Operation>
+                        [[_ varT] (typeA.with-env check.var)
                          _ (typeA.with-env
-                             (tc.check varT variantT))]
+                             (check.check varT variantT))]
                         (typeA.with-type varT
                           (/.sum ..analyse choice valueC)))
-                      (macro.run (initL.compiler []))
+                      (compiler.run [analysisE.bundle (init.compiler [])])
                       (case> (^multi (#e.Success sumA)
-                                     [(analysisL.variant sumA)
+                                     [(analysis.variant sumA)
                                       (#.Some variant)])
                              (check-sum' size choice variant)
 
                              _
                              false)))
             (test "Cannot analyse sum through unbound type-vars."
-                  (|> (do macro.Monad<Meta>
-                        [[_ varT] (typeA.with-env tc.var)]
+                  (|> (do compiler.Monad<Operation>
+                        [[_ varT] (typeA.with-env check.var)]
                         (typeA.with-type varT
                           (/.sum ..analyse choice valueC)))
                       check-fails))
@@ -177,7 +177,7 @@
             (test "Can analyse product."
                   (|> (typeA.with-type tupleT
                         (/.product ..analyse (list/map product.right primitives)))
-                      (macro.run (initL.compiler []))
+                      (compiler.run [analysisE.bundle (init.compiler [])])
                       (case> (#e.Success tupleA)
                              (right-size? size tupleA)
 
@@ -186,7 +186,7 @@
             (test "Can infer product."
                   (|> (typeA.with-inference
                         (/.product ..analyse (list/map product.right primitives)))
-                      (macro.run (initL.compiler []))
+                      (compiler.run [analysisE.bundle (init.compiler [])])
                       (case> (#e.Success [_type tupleA])
                              (and (type/= tupleT _type)
                                   (right-size? size tupleA))
@@ -198,13 +198,13 @@
                         (..analyse (` [(~ singletonC)])))
                       check-succeeds))
             (test "Can analyse product through bound type-vars."
-                  (|> (do macro.Monad<Meta>
-                        [[_ varT] (typeA.with-env tc.var)
+                  (|> (do compiler.Monad<Operation>
+                        [[_ varT] (typeA.with-env check.var)
                          _ (typeA.with-env
-                             (tc.check varT (type.tuple (list/map product.left primitives))))]
+                             (check.check varT (type.tuple (list/map product.left primitives))))]
                         (typeA.with-type varT
                           (/.product ..analyse (list/map product.right primitives))))
-                      (macro.run (initL.compiler []))
+                      (compiler.run [analysisE.bundle (init.compiler [])])
                       (case> (#e.Success tupleA)
                              (right-size? size tupleA)
 
@@ -290,7 +290,7 @@
                         (/.record ..analyse recordC))
                       (check-record-inference module-name tags named-polyT size)))
             (test "Can specialize generic records."
-                  (|> (do macro.Monad<Meta>
+                  (|> (do compiler.Monad<Operation>
                         [recordA (typeA.with-type tupleT
                                    (/.record ..analyse recordC))]
                         (wrap [tupleT recordA]))
diff --git a/stdlib/test/test/lux/language/compiler/synthesis/case.lux b/stdlib/test/test/lux/language/compiler/synthesis/case.lux
index 7ae02d943..264bc0967 100644
--- a/stdlib/test/test/lux/language/compiler/synthesis/case.lux
+++ b/stdlib/test/test/lux/language/compiler/synthesis/case.lux
@@ -1,16 +1,20 @@
 (.module:
-  lux
-  (lux (control [monad (#+ do)]
-                pipe)
-       (data [error ("error/" Functor<Error>)])
-       (language ["///." reference]
-                 ["///." compiler]
-                 [".L" analysis (#+ Branch Analysis)]
-                 ["//" synthesis (#+ Synthesis)]
-                 (synthesis [".S" expression])
-                 [".L" extension])
-       ["r" math/random]
-       test)
+  [lux #*
+   [control
+    [monad (#+ do)]
+    pipe]
+   [data
+    [error ("error/" Functor<Error>)]]
+   [language
+    ["///." reference]
+    ["///." compiler
+     [".L" analysis (#+ Branch Analysis)]
+     ["//" synthesis (#+ Synthesis)
+      [".S" expression]]
+     [".L" extension]]]
+   [math
+    ["r" random]]
+   test]
   [//primitive])
 
 (context: "Dummy variables."
diff --git a/stdlib/test/test/lux/language/compiler/synthesis/function.lux b/stdlib/test/test/lux/language/compiler/synthesis/function.lux
index 8bbc1401d..51b2a2e17 100644
--- a/stdlib/test/test/lux/language/compiler/synthesis/function.lux
+++ b/stdlib/test/test/lux/language/compiler/synthesis/function.lux
@@ -1,24 +1,28 @@
 (.module:
-  lux
-  (lux [io]
-       (control [monad (#+ do)]
-                pipe)
-       (data [product]
-             [maybe]
-             [error]
-             [number]
-             text/format
-             (collection [list ("list/" Functor<List> Fold<List>)]
-                         ["dict" dictionary (#+ Dictionary)]
-                         [set]))
-       (language ["///." reference (#+ Variable) ("variable/" Equivalence<Variable>)]
-                 ["///." compiler]
-                 [".L" analysis (#+ Arity Analysis)]
-                 ["//" synthesis (#+ Synthesis)]
-                 (synthesis [".S" expression])
-                 [".L" extension])
-       ["r" math/random]
-       test)
+  [lux #*
+   [io]
+   [control
+    [monad (#+ do)]
+    pipe]
+   [data
+    [product]
+    [maybe]
+    [error]
+    [number]
+    [text format]
+    [collection
+     [list ("list/" Functor<List> Fold<List>)]
+     ["dict" dictionary (#+ Dictionary)]
+     [set]]]
+   [language
+    ["///." reference (#+ Variable) ("variable/" Equivalence<Variable>)]
+    ["///." compiler
+     [".L" analysis (#+ Arity Analysis)]
+     ["//" synthesis (#+ Synthesis)
+      [".S" expression]]
+     [".L" extension]]]
+   [math ["r" random]]
+   test]
   [//primitive])
 
 (def: constant-function
diff --git a/stdlib/test/test/lux/language/compiler/synthesis/primitive.lux b/stdlib/test/test/lux/language/compiler/synthesis/primitive.lux
index e90d8cb26..3bea7682d 100644
--- a/stdlib/test/test/lux/language/compiler/synthesis/primitive.lux
+++ b/stdlib/test/test/lux/language/compiler/synthesis/primitive.lux
@@ -1,18 +1,22 @@
 (.module:
-  [lux (#- primitive)]
-  (lux [io]
-       (control [monad (#+ do)]
-                pipe)
-       (data [error]
-             text/format)
-       [language]
-       (language [".L" extension]
-                 ["///." compiler]
-                 [".L" analysis (#+ Analysis)]
-                 ["//" synthesis (#+ Synthesis)]
-                 (synthesis [".S" expression]))
-       ["r" math/random]
-       test))
+  [lux (#- primitive)
+   [io]
+   [control
+    [monad (#+ do)]
+    pipe]
+   [data
+    [error]
+    [text
+     format]]
+   ["." language
+    ["///." compiler
+     [".L" analysis (#+ Analysis)]
+     ["//" synthesis (#+ Synthesis)
+      [".S" expression]]
+     [".L" extension]]]
+   [math
+    ["r" random]]
+   test])
 
 (def: #export primitive
   (r.Random Analysis)
diff --git a/stdlib/test/test/lux/language/compiler/synthesis/structure.lux b/stdlib/test/test/lux/language/compiler/synthesis/structure.lux
index 8dba248e5..0b9f705ff 100644
--- a/stdlib/test/test/lux/language/compiler/synthesis/structure.lux
+++ b/stdlib/test/test/lux/language/compiler/synthesis/structure.lux
@@ -1,19 +1,24 @@
 (.module:
-  lux
-  (lux [io]
-       (control [monad (#+ do)]
-                pipe)
-       (data [bool ("bool/" Equivalence<Bool>)]
-             [product]
-             [error]
-             (collection [list]))
-       (language ["///." compiler]
-                 [".L" analysis]
-                 ["//" synthesis (#+ Synthesis)]
-                 (synthesis [".S" expression])
-                 [".L" extension])
-       (math ["r" random])
-       test)
+  [lux #*
+   [io]
+   [control
+    [monad (#+ do)]
+    pipe]
+   [data
+    [bool ("bool/" Equivalence<Bool>)]
+    [product]
+    [error]
+    [collection
+     [list]]]
+   [language
+    ["///." compiler
+     [".L" analysis]
+     ["//" synthesis (#+ Synthesis)
+      [".S" expression]]
+     [".L" extension]]]
+   [math
+    ["r" random]]
+   test]
   [//primitive])
 
 (context: "Variants"