diff options
Diffstat (limited to '')
| -rw-r--r-- | new-luxc/test/test/luxc/lang/analysis/host.jvm.lux (renamed from stdlib/test/test/lux/language/compiler/analysis/procedure/host.jvm.lux) | 0 | ||||
| -rw-r--r-- | stdlib/test/test/lux/language/compiler/analysis/case.lux | 26 | ||||
| -rw-r--r-- | stdlib/test/test/lux/language/compiler/analysis/function.lux | 29 | ||||
| -rw-r--r-- | stdlib/test/test/lux/language/compiler/analysis/primitive.lux | 22 | ||||
| -rw-r--r-- | stdlib/test/test/lux/language/compiler/analysis/procedure/common.lux | 36 | ||||
| -rw-r--r-- | stdlib/test/test/lux/language/compiler/analysis/reference.lux | 59 | ||||
| -rw-r--r-- | stdlib/test/test/lux/language/compiler/analysis/structure.lux | 88 | ||||
| -rw-r--r-- | stdlib/test/test/lux/language/compiler/synthesis/case.lux | 28 | ||||
| -rw-r--r-- | stdlib/test/test/lux/language/compiler/synthesis/function.lux | 44 | ||||
| -rw-r--r-- | stdlib/test/test/lux/language/compiler/synthesis/primitive.lux | 32 | ||||
| -rw-r--r-- | stdlib/test/test/lux/language/compiler/synthesis/structure.lux | 35 |
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" |