From 84a71e373e01f36c57d1bf42b7946f3a8b212d4f Mon Sep 17 00:00:00 2001 From: Eduardo Julian Date: Fri, 1 Dec 2017 18:13:05 -0400 Subject: - Got the tests to compile again. --- new-luxc/test/test/luxc/common.lux | 8 +- new-luxc/test/test/luxc/lang/analysis/case.lux | 234 ++++----- new-luxc/test/test/luxc/lang/analysis/common.lux | 36 +- new-luxc/test/test/luxc/lang/analysis/function.lux | 136 ++--- .../test/test/luxc/lang/analysis/primitive.lux | 48 +- .../test/luxc/lang/analysis/procedure/common.lux | 184 +++---- .../test/luxc/lang/analysis/procedure/host.jvm.lux | 290 +++++------ .../test/test/luxc/lang/analysis/reference.lux | 42 +- .../test/test/luxc/lang/analysis/structure.lux | 410 +++++++-------- new-luxc/test/test/luxc/lang/analysis/type.lux | 70 +-- .../test/test/luxc/lang/synthesis/case/special.lux | 32 +- new-luxc/test/test/luxc/lang/synthesis/common.lux | 32 +- .../test/test/luxc/lang/synthesis/function.lux | 124 ++--- new-luxc/test/test/luxc/lang/synthesis/loop.lux | 136 ++--- .../test/test/luxc/lang/synthesis/primitive.lux | 32 +- .../test/test/luxc/lang/synthesis/procedure.lux | 20 +- .../test/test/luxc/lang/synthesis/structure.lux | 30 +- new-luxc/test/test/luxc/lang/translation/case.lux | 90 ++-- .../test/test/luxc/lang/translation/function.lux | 114 ++--- .../test/test/luxc/lang/translation/primitive.lux | 58 +-- .../luxc/lang/translation/procedure/common.jvm.lux | 344 ++++++------- .../luxc/lang/translation/procedure/host.jvm.lux | 568 ++++++++++----------- .../test/test/luxc/lang/translation/reference.lux | 84 +-- .../test/test/luxc/lang/translation/structure.lux | 104 ++-- new-luxc/test/tests.lux | 46 +- 25 files changed, 1636 insertions(+), 1636 deletions(-) (limited to 'new-luxc') diff --git a/new-luxc/test/test/luxc/common.lux b/new-luxc/test/test/luxc/common.lux index 1215e669f..914e31893 100644 --- a/new-luxc/test/test/luxc/common.lux +++ b/new-luxc/test/test/luxc/common.lux @@ -1,9 +1,9 @@ -(;module: +(.module: lux (lux [io]) - (luxc (lang ["&;" host] - [";L" translation]))) + (luxc (lang ["&." host] + [".L" translation]))) (def: #export (init-compiler _) (-> Top Compiler) - (translationL;init-compiler (io;run &host;init-host))) + (translationL.init-compiler (io.run &host.init-host))) diff --git a/new-luxc/test/test/luxc/lang/analysis/case.lux b/new-luxc/test/test/luxc/lang/analysis/case.lux index f99c034e8..50d31a86e 100644 --- a/new-luxc/test/test/luxc/lang/analysis/case.lux +++ b/new-luxc/test/test/luxc/lang/analysis/case.lux @@ -1,4 +1,4 @@ -(;module: +(.module: lux (lux [io] (control [monad #+ do] @@ -18,80 +18,80 @@ (type ["tc" check])) test) (luxc ["&" lang] - (lang ["@;" module] + (lang ["@." module] ["la" analysis] - (analysis [";A" expression] + (analysis [".A" expression] ["@" case] - ["@;" common]))) - (.. common) + ["@." common]))) + (// common) (test/luxc common)) (def: (exhaustive-weaving branchings) (-> (List (List Code)) (List (List Code))) (case branchings - #;Nil - #;Nil + #.Nil + #.Nil - (#;Cons head+ #;Nil) - (L/map (|>. list) head+) + (#.Cons head+ #.Nil) + (L/map (|>> list) head+) - (#;Cons head+ tail++) - (do list;Monad + (#.Cons head+ tail++) + (do list.Monad [tail+ (exhaustive-weaving tail++) head head+] - (wrap (#;Cons head tail+))))) + (wrap (#.Cons head tail+))))) (def: #export (exhaustive-branches allow-literals? variantTC inputC) - (-> Bool (List [Code Code]) Code (r;Random (List Code))) + (-> Bool (List [Code Code]) Code (r.Random (List Code))) (case inputC - [_ (#;Bool _)] + [_ (#.Bool _)] (r/wrap (list (' true) (' false))) (^template [ ] [_ ( _)] (if allow-literals? - (do r;Monad - [?sample (r;maybe )] + (do r.Monad + [?sample (r.maybe )] (case ?sample - (#;Some sample) + (#.Some sample) (do @ [else (exhaustive-branches allow-literals? variantTC inputC)] (wrap (list& ( sample) else))) - #;None + #.None (wrap (list (' _))))) (r/wrap (list (' _))))) - ([#;Nat r;nat code;nat] - [#;Int r;int code;int] - [#;Deg r;deg code;deg] - [#;Frac r;frac code;frac] - [#;Text (r;text +5) code;text]) + ([#.Nat r.nat code.nat] + [#.Int r.int code.int] + [#.Deg r.deg code.deg] + [#.Frac r.frac code.frac] + [#.Text (r.text +5) code.text]) - (^ [_ (#;Tuple (list))]) + (^ [_ (#.Tuple (list))]) (r/wrap (list (' []))) - (^ [_ (#;Record (list))]) + (^ [_ (#.Record (list))]) (r/wrap (list (' {}))) - [_ (#;Tuple members)] - (do r;Monad - [member-wise-patterns (monad;map @ (exhaustive-branches allow-literals? variantTC) members)] + [_ (#.Tuple members)] + (do r.Monad + [member-wise-patterns (monad.map @ (exhaustive-branches allow-literals? variantTC) members)] (wrap (|> member-wise-patterns exhaustive-weaving - (L/map code;tuple)))) + (L/map code.tuple)))) - [_ (#;Record kvs)] - (do r;Monad - [#let [ks (L/map product;left kvs) - vs (L/map product;right kvs)] - member-wise-patterns (monad;map @ (exhaustive-branches allow-literals? variantTC) vs)] + [_ (#.Record kvs)] + (do r.Monad + [#let [ks (L/map product.left kvs) + vs (L/map product.right kvs)] + member-wise-patterns (monad.map @ (exhaustive-branches allow-literals? variantTC) vs)] (wrap (|> member-wise-patterns exhaustive-weaving - (L/map (|>. (list;zip2 ks) code;record))))) + (L/map (|>> (list.zip2 ks) code.record))))) - (^ [_ (#;Form (list [_ (#;Tag _)] _))]) - (do r;Monad - [bundles (monad;map @ + (^ [_ (#.Form (list [_ (#.Tag _)] _))]) + (do r.Monad + [bundles (monad.map @ (function [[_tag _code]] (do @ [v-branches (exhaustive-branches allow-literals? variantTC _code)] @@ -105,21 +105,21 @@ )) (def: #export (input variant-tags record-tags primitivesC) - (-> (List Code) (List Code) (List Code) (r;Random Code)) - (r;rec + (-> (List Code) (List Code) (List Code) (r.Random Code)) + (r.rec (function [input] - ($_ r;either - (r/map product;right gen-primitive) - (do r;Monad - [choice (|> r;nat (:: @ map (n.% (list;size variant-tags)))) - #let [choiceT (maybe;assume (list;nth choice variant-tags)) - choiceC (maybe;assume (list;nth choice primitivesC))]] + ($_ r.either + (r/map product.right gen-primitive) + (do r.Monad + [choice (|> r.nat (:: @ map (n/% (list.size variant-tags)))) + #let [choiceT (maybe.assume (list.nth choice variant-tags)) + choiceC (maybe.assume (list.nth choice primitivesC))]] (wrap (` ((~ choiceT) (~ choiceC))))) - (do r;Monad - [size (|> r;nat (:: @ map (n.% +3))) - elems (r;list size input)] - (wrap (code;tuple elems))) - (r/wrap (code;record (list;zip2 record-tags primitivesC))) + (do r.Monad + [size (|> r.nat (:: @ map (n/% +3))) + elems (r.list size input)] + (wrap (code.tuple elems))) + (r/wrap (code.record (list.zip2 record-tags primitivesC))) )))) (def: (branch body pattern) @@ -132,96 +132,96 @@ (<| (seed +5004137551292836565) ## (times +100) (do @ - [module-name (r;text +5) - variant-name (r;text +5) - record-name (|> (r;text +5) (r;filter (|>. (T/= variant-name) not))) - size (|> r;nat (:: @ map (|>. (n.% +10) (n.max +2)))) - variant-tags (|> (r;set text;Hash size (r;text +5)) (:: @ map S;to-list)) - record-tags (|> (r;set text;Hash size (r;text +5)) (:: @ map S;to-list)) - primitivesTC (r;list size gen-primitive) - #let [primitivesT (L/map product;left primitivesTC) - primitivesC (L/map product;right primitivesTC) - variant-tags+ (L/map (|>. [module-name] code;tag) variant-tags) - record-tags+ (L/map (|>. [module-name] code;tag) record-tags) - variantTC (list;zip2 variant-tags+ primitivesC)] + [module-name (r.text +5) + variant-name (r.text +5) + record-name (|> (r.text +5) (r.filter (|>> (T/= variant-name) not))) + size (|> r.nat (:: @ map (|>> (n/% +10) (n/max +2)))) + variant-tags (|> (r.set text.Hash size (r.text +5)) (:: @ map S.to-list)) + record-tags (|> (r.set text.Hash size (r.text +5)) (:: @ map S.to-list)) + primitivesTC (r.list size gen-primitive) + #let [primitivesT (L/map product.left primitivesTC) + primitivesC (L/map product.right primitivesTC) + variant-tags+ (L/map (|>> [module-name] code.tag) variant-tags) + record-tags+ (L/map (|>> [module-name] code.tag) record-tags) + variantTC (list.zip2 variant-tags+ primitivesC)] inputC (input variant-tags+ record-tags+ primitivesC) [outputT outputC] gen-primitive [heterogeneousT heterogeneousC] (|> gen-primitive - (r;filter (|>. product;left (tc;checks? outputT) not))) + (r.filter (|>> product.left (tc.checks? outputT) not))) exhaustive-patterns (exhaustive-branches true variantTC inputC) redundant-patterns (exhaustive-branches false variantTC inputC) - redundancy-idx (|> r;nat (:: @ map (n.% (list;size redundant-patterns)))) - heterogeneous-idx (|> r;nat (:: @ map (n.% (list;size exhaustive-patterns)))) + redundancy-idx (|> r.nat (:: @ map (n/% (list.size redundant-patterns)))) + heterogeneous-idx (|> r.nat (:: @ map (n/% (list.size exhaustive-patterns)))) #let [exhaustive-branchesC (L/map (branch outputC) exhaustive-patterns) - non-exhaustive-branchesC (list;take (n.dec (list;size exhaustive-branchesC)) + non-exhaustive-branchesC (list.take (n/dec (list.size exhaustive-branchesC)) exhaustive-branchesC) redundant-branchesC (<| (L/map (branch outputC)) - list;concat - (list (list;take redundancy-idx redundant-patterns) - (list (maybe;assume (list;nth redundancy-idx redundant-patterns))) - (list;drop redundancy-idx redundant-patterns))) - heterogeneous-branchesC (list;concat (list (list;take heterogeneous-idx exhaustive-branchesC) - (list (let [[_pattern _body] (maybe;assume (list;nth heterogeneous-idx exhaustive-branchesC))] + list.concat + (list (list.take redundancy-idx redundant-patterns) + (list (maybe.assume (list.nth redundancy-idx redundant-patterns))) + (list.drop redundancy-idx redundant-patterns))) + heterogeneous-branchesC (list.concat (list (list.take heterogeneous-idx exhaustive-branchesC) + (list (let [[_pattern _body] (maybe.assume (list.nth heterogeneous-idx exhaustive-branchesC))] [_pattern heterogeneousC])) - (list;drop (n.inc heterogeneous-idx) exhaustive-branchesC))) + (list.drop (n/inc heterogeneous-idx) exhaustive-branchesC))) ]] ($_ seq (test "Will reject empty pattern-matching (no branches)." - (|> (&;with-scope - (&;with-type outputT - (@;analyse-case analyse inputC (list)))) + (|> (&.with-scope + (&.with-type outputT + (@.analyse-case analyse inputC (list)))) check-failure)) (test "Can analyse exhaustive pattern-matching." - (|> (@module;with-module +0 module-name + (|> (@module.with-module +0 module-name (do Monad - [_ (@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)))] - (&;with-scope - (&;with-type outputT - (@;analyse-case analyse inputC exhaustive-branchesC))))) + [_ (@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)))] + (&.with-scope + (&.with-type outputT + (@.analyse-case analyse inputC exhaustive-branchesC))))) check-success)) (test "Will reject non-exhaustive pattern-matching." - (|> (@module;with-module +0 module-name + (|> (@module.with-module +0 module-name (do Monad - [_ (@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)))] - (&;with-scope - (&;with-type outputT - (@;analyse-case analyse inputC non-exhaustive-branchesC))))) + [_ (@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)))] + (&.with-scope + (&.with-type outputT + (@.analyse-case analyse inputC non-exhaustive-branchesC))))) check-failure)) (test "Will reject redundant pattern-matching." - (|> (@module;with-module +0 module-name + (|> (@module.with-module +0 module-name (do Monad - [_ (@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)))] - (&;with-scope - (&;with-type outputT - (@;analyse-case analyse inputC redundant-branchesC))))) + [_ (@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)))] + (&.with-scope + (&.with-type outputT + (@.analyse-case analyse inputC redundant-branchesC))))) check-failure)) (test "Will reject pattern-matching if the bodies of the branches do not all have the same type." - (|> (@module;with-module +0 module-name + (|> (@module.with-module +0 module-name (do Monad - [_ (@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)))] - (&;with-scope - (&;with-type outputT - (@;analyse-case analyse inputC heterogeneous-branchesC))))) + [_ (@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)))] + (&.with-scope + (&.with-type outputT + (@.analyse-case analyse inputC heterogeneous-branchesC))))) check-failure)) )))) diff --git a/new-luxc/test/test/luxc/lang/analysis/common.lux b/new-luxc/test/test/luxc/lang/analysis/common.lux index e7b9dc486..38c712972 100644 --- a/new-luxc/test/test/luxc/lang/analysis/common.lux +++ b/new-luxc/test/test/luxc/lang/analysis/common.lux @@ -1,4 +1,4 @@ -(;module: +(.module: lux (lux (control pipe) ["r" math/random "r/" Monad] @@ -6,45 +6,45 @@ [macro] (macro [code])) (luxc ["&" lang] - (lang (analysis [";A" expression]) + (lang (analysis [".A" expression]) [eval])) (test/luxc common)) (def: gen-unit - (r;Random Code) + (r.Random Code) (r/wrap (' []))) (def: #export gen-primitive - (r;Random [Type Code]) + (r.Random [Type Code]) (with-expansions [ (do-template [ ] - [(r;seq (r/wrap ) (r/map ))] + [(r.seq (r/wrap ) (r/map ))] - [Unit code;tuple (r;list +0 gen-unit)] - [Bool code;bool r;bool] - [Nat code;nat r;nat] - [Int code;int r;int] - [Deg code;deg r;deg] - [Frac code;frac r;frac] - [Text code;text (r;text +5)] + [Unit code.tuple (r.list +0 gen-unit)] + [Bool code.bool r.bool] + [Nat code.nat r.nat] + [Int code.int r.int] + [Deg code.deg r.deg] + [Frac code.frac r.frac] + [Text code.text (r.text +5)] )] - ($_ r;either + ($_ r.either ))) (def: #export analyse - &;Analyser - (expressionA;analyser eval;eval)) + &.Analyser + (expressionA.analyser eval.eval)) (do-template [ ] [(def: #export ( analysis) (All [a] (-> (Meta a) Bool)) (|> analysis - (macro;run (init-compiler [])) - (case> (#e;Success _) + (macro.run (init-compiler [])) + (case> (#e.Success _) - (#e;Error error) + (#e.Error error) )))] [check-success true false] diff --git a/new-luxc/test/test/luxc/lang/analysis/function.lux b/new-luxc/test/test/luxc/lang/analysis/function.lux index b99e5e2ee..3f8a17505 100644 --- a/new-luxc/test/test/luxc/lang/analysis/function.lux +++ b/new-luxc/test/test/luxc/lang/analysis/function.lux @@ -1,4 +1,4 @@ -(;module: +(.module: lux (lux [io] (control [monad #+ do] @@ -15,140 +15,140 @@ (lang [type "type/" Eq]) test) (luxc ["&" lang] - (lang ["@;" module] + (lang ["@." module] ["la" analysis] - (analysis [";A" expression] + (analysis [".A" expression] ["@" function] - ["@;" common]))) - (.. common) + ["@." common]))) + (// common) (test/luxc common)) (def: (check-type expectedT error) - (-> Type (e;Error [Type la;Analysis]) Bool) + (-> Type (e.Error [Type la.Analysis]) Bool) (case error - (#e;Success [exprT exprA]) + (#e.Success [exprT exprA]) (type/= expectedT exprT) _ false)) (def: (succeeds? error) - (All [a] (-> (e;Error a) Bool)) + (All [a] (-> (e.Error a) Bool)) (case error - (#e;Success _) + (#e.Success _) true - (#e;Error _) + (#e.Error _) false)) (def: (flatten-apply analysis) - (-> la;Analysis [la;Analysis (List la;Analysis)]) + (-> la.Analysis [la.Analysis (List la.Analysis)]) (case analysis (^code ("lux apply" (~ head) (~ func))) (let [[func' tail] (flatten-apply func)] - [func' (#;Cons head tail)]) + [func' (#.Cons head tail)]) _ [analysis (list)])) (def: (check-apply expectedT num-args analysis) - (-> Type Nat (Meta [Type la;Analysis]) Bool) + (-> Type Nat (Meta [Type la.Analysis]) Bool) (|> analysis - (macro;run (init-compiler [])) - (case> (#e;Success [applyT applyA]) + (macro.run (init-compiler [])) + (case> (#e.Success [applyT applyA]) (let [[funcA argsA] (flatten-apply applyA)] (and (type/= expectedT applyT) - (n.= num-args (list;size argsA)))) + (n/= num-args (list.size argsA)))) - (#e;Error error) + (#e.Error error) false))) (context: "Function definition." (<| (times +100) (do @ - [func-name (r;text +5) - arg-name (|> (r;text +5) (r;filter (|>. (text/= func-name) not))) + [func-name (r.text +5) + arg-name (|> (r.text +5) (r.filter (|>> (text/= func-name) not))) [outputT outputC] gen-primitive [inputT _] gen-primitive] ($_ seq (test "Can analyse function." - (|> (&;with-type (type (All [a] (-> a outputT))) - (@;analyse-function analyse func-name arg-name outputC)) - (macro;run (init-compiler [])) + (|> (&.with-type (type (All [a] (-> a outputT))) + (@.analyse-function analyse func-name arg-name outputC)) + (macro.run (init-compiler [])) succeeds?)) (test "Generic functions can always be specialized." - (and (|> (&;with-type (-> inputT outputT) - (@;analyse-function analyse func-name arg-name outputC)) - (macro;run (init-compiler [])) + (and (|> (&.with-type (-> inputT outputT) + (@.analyse-function analyse func-name arg-name outputC)) + (macro.run (init-compiler [])) succeeds?) - (|> (&;with-type (-> inputT inputT) - (@;analyse-function analyse func-name arg-name (code;symbol ["" arg-name]))) - (macro;run (init-compiler [])) + (|> (&.with-type (-> inputT inputT) + (@.analyse-function analyse func-name arg-name (code.symbol ["" arg-name]))) + (macro.run (init-compiler [])) succeeds?))) (test "Can infer function (constant output and unused input)." - (|> (@common;with-unknown-type - (@;analyse-function analyse func-name arg-name outputC)) - (macro;run (init-compiler [])) + (|> (@common.with-unknown-type + (@.analyse-function analyse func-name arg-name outputC)) + (macro.run (init-compiler [])) (check-type (type (All [a] (-> a outputT)))))) (test "Can infer function (output = input)." - (|> (@common;with-unknown-type - (@;analyse-function analyse func-name arg-name (code;symbol ["" arg-name]))) - (macro;run (init-compiler [])) + (|> (@common.with-unknown-type + (@.analyse-function analyse func-name arg-name (code.symbol ["" arg-name]))) + (macro.run (init-compiler [])) (check-type (type (All [a] (-> a a)))))) (test "The function's name is bound to the function's type." - (|> (&;with-type (type (Rec self (-> inputT self))) - (@;analyse-function analyse func-name arg-name (code;symbol ["" func-name]))) - (macro;run (init-compiler [])) + (|> (&.with-type (type (Rec self (-> inputT self))) + (@.analyse-function analyse func-name arg-name (code.symbol ["" func-name]))) + (macro.run (init-compiler [])) succeeds?)) )))) (context: "Function application." (<| (times +100) (do @ - [full-args (|> r;nat (:: @ map (|>. (n.% +10) (n.max +2)))) - partial-args (|> r;nat (:: @ map (n.% full-args))) - var-idx (|> r;nat (:: @ map (|>. (n.% full-args) (n.max +1)))) - inputsTC (r;list full-args gen-primitive) - #let [inputsT (list/map product;left inputsTC) - inputsC (list/map product;right inputsTC)] + [full-args (|> r.nat (:: @ map (|>> (n/% +10) (n/max +2)))) + partial-args (|> r.nat (:: @ map (n/% full-args))) + var-idx (|> r.nat (:: @ map (|>> (n/% full-args) (n/max +1)))) + inputsTC (r.list full-args gen-primitive) + #let [inputsT (list/map product.left inputsTC) + inputsC (list/map product.right inputsTC)] [outputT outputC] gen-primitive - #let [funcT (type;function inputsT outputT) - partialT (type;function (list;drop partial-args inputsT) outputT) - varT (#;Bound +1) - polyT (<| (type;univ-q +1) - (type;function (list;concat (list (list;take var-idx inputsT) + #let [funcT (type.function inputsT outputT) + partialT (type.function (list.drop partial-args inputsT) outputT) + varT (#.Bound +1) + polyT (<| (type.univ-q +1) + (type.function (list.concat (list (list.take var-idx inputsT) (list varT) - (list;drop (n.inc var-idx) inputsT)))) + (list.drop (n/inc var-idx) inputsT)))) varT) - poly-inputT (maybe;assume (list;nth var-idx inputsT)) - partial-poly-inputsT (list;drop (n.inc var-idx) inputsT) - partial-polyT1 (<| (type;function partial-poly-inputsT) + poly-inputT (maybe.assume (list.nth var-idx inputsT)) + partial-poly-inputsT (list.drop (n/inc var-idx) inputsT) + partial-polyT1 (<| (type.function partial-poly-inputsT) poly-inputT) - partial-polyT2 (<| (type;univ-q +1) - (type;function (#;Cons varT partial-poly-inputsT)) + partial-polyT2 (<| (type.univ-q +1) + (type.function (#.Cons varT partial-poly-inputsT)) varT)]] ($_ seq (test "Can analyse monomorphic type application." - (|> (@common;with-unknown-type - (@;analyse-apply analyse funcT (' []) inputsC)) + (|> (@common.with-unknown-type + (@.analyse-apply analyse funcT (' []) inputsC)) (check-apply outputT full-args))) (test "Can partially apply functions." - (|> (@common;with-unknown-type - (@;analyse-apply analyse funcT (' []) - (list;take partial-args inputsC))) + (|> (@common.with-unknown-type + (@.analyse-apply analyse funcT (' []) + (list.take partial-args inputsC))) (check-apply partialT partial-args))) (test "Can apply polymorphic functions." - (|> (@common;with-unknown-type - (@;analyse-apply analyse polyT (' []) inputsC)) + (|> (@common.with-unknown-type + (@.analyse-apply analyse polyT (' []) inputsC)) (check-apply poly-inputT full-args))) (test "Polymorphic partial application propagates found type-vars." - (|> (@common;with-unknown-type - (@;analyse-apply analyse polyT (' []) - (list;take (n.inc var-idx) inputsC))) - (check-apply partial-polyT1 (n.inc var-idx)))) + (|> (@common.with-unknown-type + (@.analyse-apply analyse polyT (' []) + (list.take (n/inc var-idx) inputsC))) + (check-apply partial-polyT1 (n/inc var-idx)))) (test "Polymorphic partial application preserves quantification for type-vars." - (|> (@common;with-unknown-type - (@;analyse-apply analyse polyT (' []) - (list;take var-idx inputsC))) + (|> (@common.with-unknown-type + (@.analyse-apply analyse polyT (' []) + (list.take var-idx inputsC))) (check-apply partial-polyT2 var-idx))) )))) diff --git a/new-luxc/test/test/luxc/lang/analysis/primitive.lux b/new-luxc/test/test/luxc/lang/analysis/primitive.lux index cf60d64fe..d8ba4561f 100644 --- a/new-luxc/test/test/luxc/lang/analysis/primitive.lux +++ b/new-luxc/test/test/luxc/lang/analysis/primitive.lux @@ -1,4 +1,4 @@ -(;module: +(.module: lux (lux [io] (control [monad #+ do] @@ -11,29 +11,29 @@ (lang [type "type/" Eq]) test) (luxc ["&" lang] - (lang ["&;" module] + (lang ["&." module] ["~" analysis] - (analysis [";A" expression] + (analysis [".A" expression] ["@" primitive] - ["@;" common]))) - (.. common) + ["@." common]))) + (// common) (test/luxc common)) (context: "Primitives" (<| (times +100) (do @ - [%bool% r;bool - %nat% r;nat - %int% r;int - %deg% r;deg - %frac% r;frac - %text% (r;text +5)] + [%bool% r.bool + %nat% r.nat + %int% r.int + %deg% r.deg + %frac% r.frac + %text% (r.text +5)] (`` ($_ seq (test "Can analyse unit." - (|> (@common;with-unknown-type - @;analyse-unit) - (macro;run (init-compiler [])) - (case> (^ (#e;Success [_type (^code [])])) + (|> (@common.with-unknown-type + @.analyse-unit) + (macro.run (init-compiler [])) + (case> (^ (#e.Success [_type (^code [])])) (type/= Unit _type) _ @@ -41,10 +41,10 @@ ) (~~ (do-template [ ] [(test (format "Can analyse " ".") - (|> (@common;with-unknown-type + (|> (@common.with-unknown-type ( )) - (macro;run (init-compiler [])) - (case> (#e;Success [_type [_ ( value)]]) + (macro.run (init-compiler [])) + (case> (#e.Success [_type [_ ( value)]]) (and (type/= _type) (is value)) @@ -52,10 +52,10 @@ false)) )] - ["bool" Bool #;Bool %bool% @;analyse-bool] - ["nat" Nat #;Nat %nat% @;analyse-nat] - ["int" Int #;Int %int% @;analyse-int] - ["deg" Deg #;Deg %deg% @;analyse-deg] - ["frac" Frac #;Frac %frac% @;analyse-frac] - ["text" Text #;Text %text% @;analyse-text] + ["bool" Bool #.Bool %bool% @.analyse-bool] + ["nat" Nat #.Nat %nat% @.analyse-nat] + ["int" Int #.Int %int% @.analyse-int] + ["deg" Deg #.Deg %deg% @.analyse-deg] + ["frac" Frac #.Frac %frac% @.analyse-frac] + ["text" Text #.Text %text% @.analyse-text] ))))))) diff --git a/new-luxc/test/test/luxc/lang/analysis/procedure/common.lux b/new-luxc/test/test/luxc/lang/analysis/procedure/common.lux index 91e5267f8..8d2494db7 100644 --- a/new-luxc/test/test/luxc/lang/analysis/procedure/common.lux +++ b/new-luxc/test/test/luxc/lang/analysis/procedure/common.lux @@ -1,4 +1,4 @@ -(;module: +(.module: lux (lux [io] (control [monad #+ do] @@ -14,27 +14,27 @@ (lang [type "type/" Eq]) test) (luxc ["&" lang] - (lang ["&;" scope] - ["&;" module] + (lang ["&." scope] + ["&." module] ["~" analysis] - (analysis [";A" expression] + (analysis [".A" expression] ["@" procedure] - ["@;" common]) - [";L" eval])) - (../.. common) + ["@." common]) + [".L" eval])) + (/// common) (test/luxc common)) (do-template [ ] [(def: ( procedure params output-type) (-> Text (List Code) Type Bool) - (|> (&;with-scope - (&;with-type output-type - (@;analyse-procedure analyse evalL;eval procedure params))) - (macro;run (init-compiler [])) - (case> (#e;Success _) + (|> (&.with-scope + (&.with-type output-type + (@.analyse-procedure analyse evalL.eval procedure params))) + (macro.run (init-compiler [])) + (case> (#e.Success _) - (#e;Error error) + (#e.Error error) )))] [check-success+ true false] @@ -46,7 +46,7 @@ (do @ [[primT primC] gen-primitive [antiT antiC] (|> gen-primitive - (r;filter (|>. product;left (type/= primT) not)))] + (r.filter (|>> product.left (type/= primT) not)))] ($_ seq (test "Can test for reference equality." (check-success+ "lux is" (list primC primC) Bool)) @@ -61,9 +61,9 @@ (context: "Bit procedures" (<| (times +100) (do @ - [subjectC (|> r;nat (:: @ map code;nat)) - signedC (|> r;int (:: @ map code;int)) - paramC (|> r;nat (:: @ map code;nat))] + [subjectC (|> r.nat (:: @ map code.nat)) + signedC (|> r.int (:: @ map code.int)) + paramC (|> r.nat (:: @ map code.nat))] ($_ seq (test "Can count the number of 1 bits in a bit pattern." (check-success+ "lux bit count" (list subjectC) Nat)) @@ -84,8 +84,8 @@ (context: "Nat procedures" (<| (times +100) (do @ - [subjectC (|> r;nat (:: @ map code;nat)) - paramC (|> r;nat (:: @ map code;nat))] + [subjectC (|> r.nat (:: @ map code.nat)) + paramC (|> r.nat (:: @ map code.nat))] ($_ seq (test "Can add natural numbers." (check-success+ "lux nat +" (list subjectC paramC) Nat)) @@ -114,8 +114,8 @@ (context: "Int procedures" (<| (times +100) (do @ - [subjectC (|> r;int (:: @ map code;int)) - paramC (|> r;int (:: @ map code;int))] + [subjectC (|> r.int (:: @ map code.int)) + paramC (|> r.int (:: @ map code.int))] ($_ seq (test "Can add integers." (check-success+ "lux int +" (list subjectC paramC) Int)) @@ -144,9 +144,9 @@ (context: "Deg procedures" (<| (times +100) (do @ - [subjectC (|> r;deg (:: @ map code;deg)) - paramC (|> r;deg (:: @ map code;deg)) - natC (|> r;nat (:: @ map code;nat))] + [subjectC (|> r.deg (:: @ map code.deg)) + paramC (|> r.deg (:: @ map code.deg)) + natC (|> r.nat (:: @ map code.nat))] ($_ seq (test "Can add degrees." (check-success+ "lux deg +" (list subjectC paramC) Deg)) @@ -177,9 +177,9 @@ (context: "Frac procedures" (<| (times +100) (do @ - [subjectC (|> r;frac (:: @ map code;frac)) - paramC (|> r;frac (:: @ map code;frac)) - encodedC (|> (r;text +5) (:: @ map code;text))] + [subjectC (|> r.frac (:: @ map code.frac)) + paramC (|> r.frac (:: @ map code.frac)) + encodedC (|> (r.text +5) (:: @ map code.text))] ($_ seq (test "Can add frac numbers." (check-success+ "lux frac +" (list subjectC paramC) Frac)) @@ -220,11 +220,11 @@ (context: "Text procedures" (<| (times +100) (do @ - [subjectC (|> (r;text +5) (:: @ map code;text)) - paramC (|> (r;text +5) (:: @ map code;text)) - replacementC (|> (r;text +5) (:: @ map code;text)) - fromC (|> r;nat (:: @ map code;nat)) - toC (|> r;nat (:: @ map code;nat))] + [subjectC (|> (r.text +5) (:: @ map code.text)) + paramC (|> (r.text +5) (:: @ map code.text)) + replacementC (|> (r.text +5) (:: @ map code.text)) + fromC (|> r.nat (:: @ map code.nat)) + toC (|> r.nat (:: @ map code.nat))] ($_ seq (test "Can test text equality." (check-success+ "lux text =" (list subjectC paramC) Bool)) @@ -252,72 +252,72 @@ (<| (times +100) (do @ [[elemT elemC] gen-primitive - sizeC (|> r;nat (:: @ map code;nat)) - idxC (|> r;nat (:: @ map code;nat)) - var-name (r;text +5) + sizeC (|> r.nat (:: @ map code.nat)) + idxC (|> r.nat (:: @ map code.nat)) + var-name (r.text +5) #let [arrayT (type (Array elemT))]] ($_ seq (test "Can create arrays." (check-success+ "lux array new" (list sizeC) arrayT)) (test "Can get a value inside an array." - (|> (&scope;with-scope "" - (&scope;with-local [var-name arrayT] - (&;with-type elemT - (@;analyse-procedure analyse evalL;eval "lux array get" + (|> (&scope.with-scope "" + (&scope.with-local [var-name arrayT] + (&.with-type elemT + (@.analyse-procedure analyse evalL.eval "lux array get" (list idxC - (code;symbol ["" var-name])))))) - (macro;run (init-compiler [])) - (case> (#e;Success _) + (code.symbol ["" var-name])))))) + (macro.run (init-compiler [])) + (case> (#e.Success _) true - (#e;Error _) + (#e.Error _) false))) (test "Can put a value inside an array." - (|> (&scope;with-scope "" - (&scope;with-local [var-name arrayT] - (&;with-type arrayT - (@;analyse-procedure analyse evalL;eval "lux array put" + (|> (&scope.with-scope "" + (&scope.with-local [var-name arrayT] + (&.with-type arrayT + (@.analyse-procedure analyse evalL.eval "lux array put" (list idxC elemC - (code;symbol ["" var-name])))))) - (macro;run (init-compiler [])) - (case> (#e;Success _) + (code.symbol ["" var-name])))))) + (macro.run (init-compiler [])) + (case> (#e.Success _) true - (#e;Error _) + (#e.Error _) false))) (test "Can remove a value from an array." - (|> (&scope;with-scope "" - (&scope;with-local [var-name arrayT] - (&;with-type arrayT - (@;analyse-procedure analyse evalL;eval "lux array remove" + (|> (&scope.with-scope "" + (&scope.with-local [var-name arrayT] + (&.with-type arrayT + (@.analyse-procedure analyse evalL.eval "lux array remove" (list idxC - (code;symbol ["" var-name])))))) - (macro;run (init-compiler [])) - (case> (#e;Success _) + (code.symbol ["" var-name])))))) + (macro.run (init-compiler [])) + (case> (#e.Success _) true - (#e;Error _) + (#e.Error _) false))) (test "Can query the size of an array." - (|> (&scope;with-scope "" - (&scope;with-local [var-name arrayT] - (&;with-type Nat - (@;analyse-procedure analyse evalL;eval "lux array size" - (list (code;symbol ["" var-name])))))) - (macro;run (init-compiler [])) - (case> (#e;Success _) + (|> (&scope.with-scope "" + (&scope.with-local [var-name arrayT] + (&.with-type Nat + (@.analyse-procedure analyse evalL.eval "lux array size" + (list (code.symbol ["" var-name])))))) + (macro.run (init-compiler [])) + (case> (#e.Success _) true - (#e;Error _) + (#e.Error _) false))) )))) (context: "Math procedures" (<| (times +100) (do @ - [subjectC (|> r;frac (:: @ map code;frac)) - paramC (|> r;frac (:: @ map code;frac))] + [subjectC (|> r.frac (:: @ map code.frac)) + paramC (|> r.frac (:: @ map code.frac))] (with-expansions [ (do-template [ ] [(test (format "Can calculate " ".") (check-success+ (list subjectC) Frac))] @@ -352,38 +352,38 @@ (<| (times +100) (do @ [[elemT elemC] gen-primitive - sizeC (|> r;nat (:: @ map code;nat)) - idxC (|> r;nat (:: @ map code;nat)) - var-name (r;text +5) - #let [atomT (type (atom;Atom elemT))]] + sizeC (|> r.nat (:: @ map code.nat)) + idxC (|> r.nat (:: @ map code.nat)) + var-name (r.text +5) + #let [atomT (type (atom.Atom elemT))]] ($_ seq (test "Can create atomic reference." (check-success+ "lux atom new" (list elemC) atomT)) (test "Can read the value of an atomic reference." - (|> (&scope;with-scope "" - (&scope;with-local [var-name atomT] - (&;with-type elemT - (@;analyse-procedure analyse evalL;eval "lux atom read" - (list (code;symbol ["" var-name])))))) - (macro;run (init-compiler [])) - (case> (#e;Success _) + (|> (&scope.with-scope "" + (&scope.with-local [var-name atomT] + (&.with-type elemT + (@.analyse-procedure analyse evalL.eval "lux atom read" + (list (code.symbol ["" var-name])))))) + (macro.run (init-compiler [])) + (case> (#e.Success _) true - (#e;Error _) + (#e.Error _) false))) (test "Can swap the value of an atomic reference." - (|> (&scope;with-scope "" - (&scope;with-local [var-name atomT] - (&;with-type Bool - (@;analyse-procedure analyse evalL;eval "lux atom compare-and-swap" + (|> (&scope.with-scope "" + (&scope.with-local [var-name atomT] + (&.with-type Bool + (@.analyse-procedure analyse evalL.eval "lux atom compare-and-swap" (list elemC elemC - (code;symbol ["" var-name])))))) - (macro;run (init-compiler [])) - (case> (#e;Success _) + (code.symbol ["" var-name])))))) + (macro.run (init-compiler [])) + (case> (#e.Success _) true - (#e;Error _) + (#e.Error _) false))) )))) @@ -391,7 +391,7 @@ (<| (times +100) (do @ [[primT primC] gen-primitive - timeC (|> r;nat (:: @ map code;nat))] + timeC (|> r.nat (:: @ map code.nat))] ($_ seq (test "Can query the level of concurrency." (check-success+ "lux process concurrency-level" (list) Nat)) @@ -409,8 +409,8 @@ (context: "IO procedures" (<| (times +100) (do @ - [logC (|> (r;text +5) (:: @ map code;text)) - exitC (|> r;nat (:: @ map code;nat))] + [logC (|> (r.text +5) (:: @ map code.text)) + exitC (|> r.nat (:: @ map code.nat))] ($_ seq (test "Can log messages to standard output." (check-success+ "lux io log" (list logC) Unit)) diff --git a/new-luxc/test/test/luxc/lang/analysis/procedure/host.jvm.lux b/new-luxc/test/test/luxc/lang/analysis/procedure/host.jvm.lux index 13645840e..72d1e8bc9 100644 --- a/new-luxc/test/test/luxc/lang/analysis/procedure/host.jvm.lux +++ b/new-luxc/test/test/luxc/lang/analysis/procedure/host.jvm.lux @@ -1,4 +1,4 @@ -(;module: +(.module: lux (lux [io] (control [monad #+ do] @@ -18,31 +18,31 @@ (lang [type]) test) (luxc ["&" lang] - (lang ["&;" scope] - ["&;" module] + (lang ["&." scope] + ["&." module] ["~" analysis] - (analysis [";A" expression] - ["@;" common] + (analysis [".A" expression] + ["@." common] ["@" procedure] - (procedure ["@;" host])) - (translation ["@;" runtime]) - [";L" eval])) - (../.. common) + (procedure ["@." host])) + (translation ["@." runtime]) + [".L" eval])) + (/// common) (test/luxc common)) (do-template [ ] [(def: ( procedure params output-type) (-> Text (List Code) Type Bool) (|> (do Monad - [runtime-bytecode @runtime;translate] - (&;with-scope - (&;with-type output-type - (@;analyse-procedure analyse evalL;eval procedure params)))) - (macro;run (init-compiler [])) - (case> (#e;Success _) + [runtime-bytecode @runtime.translate] + (&.with-scope + (&.with-type output-type + (@.analyse-procedure analyse evalL.eval procedure params)))) + (macro.run (init-compiler [])) + (case> (#e.Success _) - (#e;Error error) + (#e.Error error) )))] [success true false] @@ -56,12 +56,12 @@ (test (format " FAILURE") (failure (list (' [])) ))] - ["jvm convert double-to-float" "java.lang.Double" @host;Float] - ["jvm convert double-to-int" "java.lang.Double" @host;Integer] - ["jvm convert double-to-long" "java.lang.Double" @host;Long] - ["jvm convert float-to-double" "java.lang.Float" @host;Double] - ["jvm convert float-to-int" "java.lang.Float" @host;Integer] - ["jvm convert float-to-long" "java.lang.Float" @host;Long] + ["jvm convert double-to-float" "java.lang.Double" @host.Float] + ["jvm convert double-to-int" "java.lang.Double" @host.Integer] + ["jvm convert double-to-long" "java.lang.Double" @host.Long] + ["jvm convert float-to-double" "java.lang.Float" @host.Double] + ["jvm convert float-to-int" "java.lang.Float" @host.Integer] + ["jvm convert float-to-long" "java.lang.Float" @host.Long] )] ($_ seq @@ -74,12 +74,12 @@ (test (format " FAILURE") (failure (list (' [])) ))] - ["jvm convert int-to-byte" "java.lang.Integer" @host;Byte] - ["jvm convert int-to-char" "java.lang.Integer" @host;Character] - ["jvm convert int-to-double" "java.lang.Integer" @host;Double] - ["jvm convert int-to-float" "java.lang.Integer" @host;Float] - ["jvm convert int-to-long" "java.lang.Integer" @host;Long] - ["jvm convert int-to-short" "java.lang.Integer" @host;Short] + ["jvm convert int-to-byte" "java.lang.Integer" @host.Byte] + ["jvm convert int-to-char" "java.lang.Integer" @host.Character] + ["jvm convert int-to-double" "java.lang.Integer" @host.Double] + ["jvm convert int-to-float" "java.lang.Integer" @host.Float] + ["jvm convert int-to-long" "java.lang.Integer" @host.Long] + ["jvm convert int-to-short" "java.lang.Integer" @host.Short] )] ($_ seq @@ -92,11 +92,11 @@ (test (format " FAILURE") (failure (list (' [])) ))] - ["jvm convert long-to-double" "java.lang.Long" @host;Double] - ["jvm convert long-to-float" "java.lang.Long" @host;Float] - ["jvm convert long-to-int" "java.lang.Long" @host;Integer] - ["jvm convert long-to-short" "java.lang.Long" @host;Short] - ["jvm convert long-to-byte" "java.lang.Long" @host;Byte] + ["jvm convert long-to-double" "java.lang.Long" @host.Double] + ["jvm convert long-to-float" "java.lang.Long" @host.Float] + ["jvm convert long-to-int" "java.lang.Long" @host.Integer] + ["jvm convert long-to-short" "java.lang.Long" @host.Short] + ["jvm convert long-to-byte" "java.lang.Long" @host.Byte] )] ($_ seq @@ -109,12 +109,12 @@ (test (format " FAILURE") (failure (list (' [])) ))] - ["jvm convert char-to-byte" "java.lang.Character" @host;Byte] - ["jvm convert char-to-short" "java.lang.Character" @host;Short] - ["jvm convert char-to-int" "java.lang.Character" @host;Integer] - ["jvm convert char-to-long" "java.lang.Character" @host;Long] - ["jvm convert byte-to-long" "java.lang.Byte" @host;Long] - ["jvm convert short-to-long" "java.lang.Short" @host;Long] + ["jvm convert char-to-byte" "java.lang.Character" @host.Byte] + ["jvm convert char-to-short" "java.lang.Character" @host.Short] + ["jvm convert char-to-int" "java.lang.Character" @host.Integer] + ["jvm convert char-to-long" "java.lang.Character" @host.Long] + ["jvm convert byte-to-long" "java.lang.Byte" @host.Long] + ["jvm convert short-to-long" "java.lang.Short" @host.Long] )] ($_ seq @@ -147,8 +147,8 @@ (' ("lux coerce" (+0 (+0)) []))) ))] - [(format "jvm " " =") @host;Boolean] - [(format "jvm " " <") @host;Boolean] + [(format "jvm " " =") @host.Boolean] + [(format "jvm " " <") @host.Boolean] )] ($_ seq @@ -174,8 +174,8 @@ )))] - ["int" "java.lang.Integer" @host;Integer] - ["long" "java.lang.Long" @host;Long] + ["int" "java.lang.Integer" @host.Integer] + ["long" "java.lang.Long" @host.Long] ) (do-template [ ] @@ -205,16 +205,16 @@ (' ("lux coerce" (+0 (+0)) []))) ))] - [(format "jvm " " =") @host;Boolean] - [(format "jvm " " <") @host;Boolean] + [(format "jvm " " =") @host.Boolean] + [(format "jvm " " <") @host.Boolean] )] ($_ seq )))] - ["float" "java.lang.Float" @host;Float] - ["double" "java.lang.Double" @host;Double] + ["float" "java.lang.Float" @host.Float] + ["double" "java.lang.Double" @host.Double] ) (do-template [ ] @@ -226,59 +226,59 @@ (' ("lux coerce" (+0 (+0)) []))) ))] - [(format "jvm " " =") @host;Boolean] - [(format "jvm " " <") @host;Boolean] + [(format "jvm " " =") @host.Boolean] + [(format "jvm " " <") @host.Boolean] )] ($_ seq )))] - ["char" "java.lang.Character" @host;Character] + ["char" "java.lang.Character" @host.Character] ) (def: array-type - (r;Random [Text Text]) - (let [entries (dict;entries @host;boxes) - num-entries (list;size entries)] - (do r;Monad - [choice (|> r;nat (:: @ map (n.% (n.inc num-entries)))) + (r.Random [Text Text]) + (let [entries (dict.entries @host.boxes) + num-entries (list.size entries)] + (do r.Monad + [choice (|> r.nat (:: @ map (n/% (n/inc num-entries)))) #let [[unboxed boxed] (: [Text Text] (|> entries - (list;nth choice) - (maybe;default ["java.lang.Object" "java.lang.Object"])))]] + (list.nth choice) + (maybe.default ["java.lang.Object" "java.lang.Object"])))]] (wrap [unboxed boxed])))) (context: "Array." (<| (times +100) (do @ - [#let [cap (|>. (n.% +10) (n.max +1))] + [#let [cap (|>> (n/% +10) (n/max +1))] [unboxed boxed] array-type - size (|> r;nat (:: @ map cap)) - idx (|> r;nat (:: @ map (n.% size))) - level (|> r;nat (:: @ map cap)) - #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)) - boxedTC (` (+0 (~ (code;text boxed)) (+0))) + size (|> r.nat (:: @ map cap)) + idx (|> r.nat (:: @ map (n/% size))) + level (|> r.nat (:: @ map cap)) + #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)) + boxedTC (` (+0 (~ (code.text boxed)) (+0))) multi-arrayT (list/fold (function [_ innerT] - (|> innerT (list) (#;Primitive "#Array"))) + (|> innerT (list) (#.Primitive "#Array"))) boxedT - (list;n.range +1 level))]] + (list.n/range +1 level))]] ($_ seq (test "jvm array new" (success "jvm array new" - (list (code;nat size)) + (list (code.nat size)) arrayT)) (test "jvm array new (no nesting)" (failure "jvm array new" - (list (code;nat size)) + (list (code.nat size)) unboxedT)) (test "jvm array new (nested/multi-level)" (success "jvm array new" - (list (code;nat size)) + (list (code.nat size)) multi-arrayT)) (test "jvm array length" (success "jvm array length" @@ -286,11 +286,11 @@ Nat)) (test "jvm array read" (success "jvm array read" - (list arrayC (code;nat idx)) + (list arrayC (code.nat idx)) boxedT)) (test "jvm array write" (success "jvm array write" - (list arrayC (code;nat idx) (`' ("lux coerce" (~ boxedTC) []))) + (list arrayC (code.nat idx) (`' ("lux coerce" (~ boxedTC) []))) arrayT)) )))) @@ -309,33 +309,33 @@ (do @ [[unboxed boxed] array-type [!unboxed !boxed] (|> array-type - (r;filter (function [[!unboxed !boxed]] + (r.filter (function [[!unboxed !boxed]] (not (text/= boxed !boxed))))) - #let [boxedT (#;Primitive boxed (list)) - boxedC (`' ("lux check" (+0 (~ (code;text boxed)) (+0)) + #let [boxedT (#.Primitive boxed (list)) + boxedC (`' ("lux check" (+0 (~ (code.text boxed)) (+0)) ("jvm object null"))) - !boxedC (`' ("lux check" (+0 (~ (code;text !boxed)) (+0)) + !boxedC (`' ("lux check" (+0 (~ (code.text !boxed)) (+0)) ("jvm object null"))) - unboxedC (`' ("lux check" (+0 (~ (code;text unboxed)) (+0)) + unboxedC (`' ("lux check" (+0 (~ (code.text unboxed)) (+0)) ("jvm object null")))] - throwable (|> r;nat - (:: @ map (n.% (n.inc (list;size throwables)))) + throwable (|> r.nat + (:: @ map (n/% (n/inc (list.size throwables)))) (:: @ map (function [idx] (|> throwables - (list;nth idx) - (maybe;default "java.lang.Object"))))) - #let [throwableC (`' ("lux check" (+0 (~ (code;text throwable)) (+0)) + (list.nth idx) + (maybe.default "java.lang.Object"))))) + #let [throwableC (`' ("lux check" (+0 (~ (code.text throwable)) (+0)) ("jvm object null")))]] ($_ seq (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) @@ -356,11 +356,11 @@ Bottom))) (test "jvm object class" (success "jvm object class" - (list (code;text boxed)) - (#;Primitive "java.lang.Class" (list boxedT)))) + (list (code.text boxed)) + (#.Primitive "java.lang.Class" (list boxedT)))) (test "jvm object instance?" (success "jvm object instance?" - (list (code;text boxed) + (list (code.text boxed) boxedC) Bool)) (test "jvm object instance? (lineage)" @@ -371,7 +371,7 @@ (test "jvm object instance? (no lineage)" (or (text/= "java.lang.Object" boxed) (failure "jvm object instance?" - (list (code;text boxed) + (list (code.text boxed) !boxedC) Bool))) )))) @@ -380,32 +380,32 @@ ($_ seq (test "jvm member static get" (success "jvm member static get" - (list (code;text "java.lang.System") - (code;text "out")) - (#;Primitive "java.io.PrintStream" (list)))) + (list (code.text "java.lang.System") + (code.text "out")) + (#.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)))) + (list (code.text "java.lang.System") + (code.text "out")) + (#.Primitive "java.lang.Object" (list)))) (test "jvm member static put" (success "jvm member static put" - (list (code;text "java.awt.datatransfer.DataFlavor") - (code;text "allHtmlFlavor") + (list (code.text "java.awt.datatransfer.DataFlavor") + (code.text "allHtmlFlavor") (`' ("lux check" (+0 "java.awt.datatransfer.DataFlavor" (+0)) ("jvm object null")))) Unit)) (test "jvm member static put (final)" (failure "jvm member static put" - (list (code;text "java.lang.System") - (code;text "out") + (list (code.text "java.lang.System") + (code.text "out") (`' ("lux check" (+0 "java.io.PrintStream" (+0)) ("jvm object null")))) Unit)) (test "jvm member static put (inheritance in)" (success "jvm member static put" - (list (code;text "java.awt.datatransfer.DataFlavor") - (code;text "allHtmlFlavor") + (list (code.text "java.awt.datatransfer.DataFlavor") + (code.text "allHtmlFlavor") (`' ("lux check" (+0 "javax.activation.ActivationDataFlavor" (+0)) ("jvm object null")))) Unit)) @@ -415,70 +415,70 @@ ($_ seq (test "jvm member virtual get" (success "jvm member virtual get" - (list (code;text "org.omg.CORBA.ValueMember") - (code;text "id") + (list (code.text "org.omg.CORBA.ValueMember") + (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") + (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") - (code;text "id") + (list (code.text "org.omg.CORBA.ValueMember") + (code.text "id") (`' ("lux check" (+0 "java.lang.String" (+0)) ("jvm object null"))) (`' ("lux check" (+0 "org.omg.CORBA.ValueMember" (+0)) ("jvm object null")))) - (primitive org.omg.CORBA.ValueMember))) + (primitive "org.omg.CORBA.ValueMember"))) (test "jvm member virtual put (final)" (failure "jvm member virtual put" - (list (code;text "javax.swing.text.html.parser.DTD") - (code;text "applet") + (list (code.text "javax.swing.text.html.parser.DTD") + (code.text "applet") (`' ("lux check" (+0 "javax.swing.text.html.parser.Element" (+0)) ("jvm object null"))) (`' ("lux check" (+0 "javax.swing.text.html.parser.DTD" (+0)) ("jvm object null")))) - (primitive javax.swing.text.html.parser.DTD))) + (primitive "javax.swing.text.html.parser.DTD"))) (test "jvm member virtual put (inheritance in)" (success "jvm member virtual put" - (list (code;text "java.awt.GridBagConstraints") - (code;text "insets") + (list (code.text "java.awt.GridBagConstraints") + (code.text "insets") (`' ("lux check" (+0 "javax.swing.plaf.InsetsUIResource" (+0)) ("jvm object null"))) (`' ("lux check" (+0 "java.awt.GridBagConstraints" (+0)) ("jvm object null")))) - (primitive java.awt.GridBagConstraints))) + (primitive "java.awt.GridBagConstraints"))) )) (context: "Boxing/Unboxing." ($_ seq (test "jvm member static get" (success "jvm member static get" - (list (code;text "java.util.GregorianCalendar") - (code;text "AD")) - (#;Primitive "java.lang.Integer" (list)))) + (list (code.text "java.util.GregorianCalendar") + (code.text "AD")) + (#.Primitive "java.lang.Integer" (list)))) (test "jvm member virtual get" (success "jvm member virtual get" - (list (code;text "javax.accessibility.AccessibleAttributeSequence") - (code;text "startIndex") + (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") - (code;text "startIndex") + (list (code.text "javax.accessibility.AccessibleAttributeSequence") + (code.text "startIndex") (`' ("lux check" (+0 "java.lang.Integer" (+0)) ("jvm object null"))) (`' ("lux check" (+0 "javax.accessibility.AccessibleAttributeSequence" (+0)) ("jvm object null")))) - (primitive javax.accessibility.AccessibleAttributeSequence))) + (primitive "javax.accessibility.AccessibleAttributeSequence"))) )) (context: "Member [Method]." @@ -491,39 +491,39 @@ ($_ seq (test "jvm member invoke static" (success "jvm member invoke static" - (list (code;text "java.lang.Long") - (code;text "decode") - (code;tuple (list (' "java.lang.String") + (list (code.text "java.lang.Long") + (code.text "decode") + (code.tuple (list (' "java.lang.String") (' ("lux coerce" (+0 "java.lang.String" (+0)) "YOLO"))))) - (#;Primitive "java.lang.Long" (list)))) + (#.Primitive "java.lang.Long" (list)))) (test "jvm member invoke virtual" (success "jvm member invoke virtual" - (list (code;text "java.lang.Object") - (code;text "equals") + (list (code.text "java.lang.Object") + (code.text "equals") longC - (code;tuple (list (' "java.lang.Object") + (code.tuple (list (' "java.lang.Object") longC))) - (#;Primitive "java.lang.Boolean" (list)))) + (#.Primitive "java.lang.Boolean" (list)))) (test "jvm member invoke special" (success "jvm member invoke special" - (list (code;text "java.lang.Long") - (code;text "equals") + (list (code.text "java.lang.Long") + (code.text "equals") longC - (code;tuple (list (' "java.lang.Object") + (code.tuple (list (' "java.lang.Object") longC))) - (#;Primitive "java.lang.Boolean" (list)))) + (#.Primitive "java.lang.Boolean" (list)))) (test "jvm member invoke interface" (success "jvm member invoke interface" - (list (code;text "java.util.Collection") - (code;text "add") + (list (code.text "java.util.Collection") + (code.text "add") objectC - (code;tuple (list (' "java.lang.Object") + (code.tuple (list (' "java.lang.Object") longC))) - (#;Primitive "java.lang.Boolean" (list)))) + (#.Primitive "java.lang.Boolean" (list)))) (test "jvm member invoke constructor" (success "jvm member invoke constructor" - (list (code;text "java.util.ArrayList") - (code;tuple (list (' "int") intC))) - (All [a] (#;Primitive "java.util.ArrayList" (list a))))) + (list (code.text "java.util.ArrayList") + (code.tuple (list (' "int") intC))) + (All [a] (#.Primitive "java.util.ArrayList" (list a))))) ))) diff --git a/new-luxc/test/test/luxc/lang/analysis/reference.lux b/new-luxc/test/test/luxc/lang/analysis/reference.lux index 14079c6b8..45e1eb0e8 100644 --- a/new-luxc/test/test/luxc/lang/analysis/reference.lux +++ b/new-luxc/test/test/luxc/lang/analysis/reference.lux @@ -1,4 +1,4 @@ -(;module: +(.module: lux (lux [io] (control [monad #+ do] @@ -8,43 +8,43 @@ [macro #+ Monad] (lang [type "type/" Eq]) test) - (luxc (lang ["&;" scope] - ["&;" module] + (luxc (lang ["&." scope] + ["&." module] ["~" analysis] - (analysis [";A" expression] + (analysis [".A" expression] ["@" reference] - ["@;" common]))) - (.. common) + ["@." common]))) + (// common) (test/luxc common)) (context: "References" (<| (times +100) (do @ [[ref-type _] gen-primitive - module-name (r;text +5) - scope-name (r;text +5) - var-name (r;text +5)] + module-name (r.text +5) + scope-name (r.text +5) + var-name (r.text +5)] ($_ seq (test "Can analyse variable." - (|> (&scope;with-scope scope-name - (&scope;with-local [var-name ref-type] - (@common;with-unknown-type - (@;analyse-reference ["" var-name])))) - (macro;run (init-compiler [])) - (case> (^ (#e;Success [_type (^code ((~ [_ (#;Int var)])))])) + (|> (&scope.with-scope scope-name + (&scope.with-local [var-name ref-type] + (@common.with-unknown-type + (@.analyse-reference ["" var-name])))) + (macro.run (init-compiler [])) + (case> (^ (#e.Success [_type (^code ((~ [_ (#.Int var)])))])) (type/= ref-type _type) _ false))) (test "Can analyse definition." (|> (do Monad - [_ (&module;create +0 module-name) - _ (&module;define [module-name var-name] + [_ (&module.create +0 module-name) + _ (&module.define [module-name var-name] [ref-type (' {}) (:! Void [])])] - (@common;with-unknown-type - (@;analyse-reference [module-name var-name]))) - (macro;run (init-compiler [])) - (case> (#e;Success [_type [_ (#;Symbol def-name)]]) + (@common.with-unknown-type + (@.analyse-reference [module-name var-name]))) + (macro.run (init-compiler [])) + (case> (#e.Success [_type [_ (#.Symbol def-name)]]) (type/= ref-type _type) _ diff --git a/new-luxc/test/test/luxc/lang/analysis/structure.lux b/new-luxc/test/test/luxc/lang/analysis/structure.lux index 58212359e..5694c0927 100644 --- a/new-luxc/test/test/luxc/lang/analysis/structure.lux +++ b/new-luxc/test/test/luxc/lang/analysis/structure.lux @@ -1,4 +1,4 @@ -(;module: +(.module: lux (lux [io] (control [monad #+ do] @@ -18,196 +18,196 @@ (type ["tc" check])) test) (luxc ["&" lang] - (lang ["@;" module] + (lang ["@." module] ["la" analysis] - (analysis [";A" expression] + (analysis [".A" expression] ["@" structure] - ["@;" common]))) - (.. common) + ["@." common]))) + (// common) (test/luxc common)) (context: "Sums" (<| (times +100) (do @ - [size (|> r;nat (:: @ map (|>. (n.% +10) (n.max +2)))) - choice (|> r;nat (:: @ map (n.% size))) - primitives (r;list size gen-primitive) - +choice (|> r;nat (:: @ map (n.% (n.inc size)))) + [size (|> r.nat (:: @ map (|>> (n/% +10) (n/max +2)))) + choice (|> r.nat (:: @ map (n/% size))) + primitives (r.list size gen-primitive) + +choice (|> r.nat (:: @ map (n/% (n/inc size)))) [_ +valueC] gen-primitive - #let [variantT (type;variant (list/map product;left primitives)) - [valueT valueC] (maybe;assume (list;nth choice primitives)) - +size (n.inc size) - +primitives (list;concat (list (list;take choice primitives) - (list [(#;Bound +1) +valueC]) - (list;drop choice primitives))) - [+valueT +valueC] (maybe;assume (list;nth +choice +primitives)) - +variantT (type;variant (list/map product;left +primitives))]] + #let [variantT (type.variant (list/map product.left primitives)) + [valueT valueC] (maybe.assume (list.nth choice primitives)) + +size (n/inc size) + +primitives (list.concat (list (list.take choice primitives) + (list [(#.Bound +1) +valueC]) + (list.drop choice primitives))) + [+valueT +valueC] (maybe.assume (list.nth +choice +primitives)) + +variantT (type.variant (list/map product.left +primitives))]] ($_ seq (test "Can analyse sum." - (|> (&;with-scope - (&;with-type variantT - (@;analyse-sum analyse choice valueC))) - (macro;run (init-compiler [])) - (case> (^multi (#e;Success [_ sumA]) - [(la;unfold-variant sumA) - (#;Some [tag last? valueA])]) - (and (n.= tag choice) - (bool/= last? (n.= (n.dec size) choice))) + (|> (&.with-scope + (&.with-type variantT + (@.analyse-sum analyse choice valueC))) + (macro.run (init-compiler [])) + (case> (^multi (#e.Success [_ sumA]) + [(la.unfold-variant sumA) + (#.Some [tag last? valueA])]) + (and (n/= tag choice) + (bool/= last? (n/= (n/dec size) choice))) _ false))) (test "Can analyse sum through bound type-vars." - (|> (&;with-scope - (do macro;Monad - [[_ varT] (&;with-type-env tc;var) - _ (&;with-type-env - (tc;check varT variantT))] - (&;with-type varT - (@;analyse-sum analyse choice valueC)))) - (macro;run (init-compiler [])) - (case> (^multi (#e;Success [_ sumA]) - [(la;unfold-variant sumA) - (#;Some [tag last? valueA])]) - (and (n.= tag choice) - (bool/= last? (n.= (n.dec size) choice))) + (|> (&.with-scope + (do macro.Monad + [[_ varT] (&.with-type-env tc.var) + _ (&.with-type-env + (tc.check varT variantT))] + (&.with-type varT + (@.analyse-sum analyse choice valueC)))) + (macro.run (init-compiler [])) + (case> (^multi (#e.Success [_ sumA]) + [(la.unfold-variant sumA) + (#.Some [tag last? valueA])]) + (and (n/= tag choice) + (bool/= last? (n/= (n/dec size) choice))) _ false))) (test "Cannot analyse sum through unbound type-vars." - (|> (&;with-scope - (do macro;Monad - [[_ varT] (&;with-type-env tc;var)] - (&;with-type varT - (@;analyse-sum analyse choice valueC)))) - (macro;run (init-compiler [])) - (case> (#e;Success _) + (|> (&.with-scope + (do macro.Monad + [[_ varT] (&.with-type-env tc.var)] + (&.with-type varT + (@.analyse-sum analyse choice valueC)))) + (macro.run (init-compiler [])) + (case> (#e.Success _) false _ true))) (test "Can analyse sum through existential quantification." - (|> (&;with-scope - (&;with-type (type;ex-q +1 +variantT) - (@;analyse-sum analyse +choice +valueC))) - (macro;run (init-compiler [])) - (case> (#e;Success _) + (|> (&.with-scope + (&.with-type (type.ex-q +1 +variantT) + (@.analyse-sum analyse +choice +valueC))) + (macro.run (init-compiler [])) + (case> (#e.Success _) true - (#e;Error error) + (#e.Error error) false))) (test "Can analyse sum through universal quantification." - (|> (&;with-scope - (&;with-type (type;univ-q +1 +variantT) - (@;analyse-sum analyse +choice +valueC))) - (macro;run (init-compiler [])) - (case> (#e;Success _) - (not (n.= choice +choice)) + (|> (&.with-scope + (&.with-type (type.univ-q +1 +variantT) + (@.analyse-sum analyse +choice +valueC))) + (macro.run (init-compiler [])) + (case> (#e.Success _) + (not (n/= choice +choice)) - (#e;Error error) - (n.= choice +choice)))) + (#e.Error error) + (n/= choice +choice)))) )))) (context: "Products" (<| (times +100) (do @ - [size (|> r;nat (:: @ map (|>. (n.% +10) (n.max +2)))) - primitives (r;list size gen-primitive) - choice (|> r;nat (:: @ map (n.% size))) + [size (|> r.nat (:: @ map (|>> (n/% +10) (n/max +2)))) + primitives (r.list size gen-primitive) + choice (|> r.nat (:: @ map (n/% size))) [_ +valueC] gen-primitive - #let [[singletonT singletonC] (|> primitives (list;nth choice) maybe;assume) - +primitives (list;concat (list (list;take choice primitives) - (list [(#;Bound +1) +valueC]) - (list;drop choice primitives))) - +tupleT (type;tuple (list/map product;left +primitives))]] + #let [[singletonT singletonC] (|> primitives (list.nth choice) maybe.assume) + +primitives (list.concat (list (list.take choice primitives) + (list [(#.Bound +1) +valueC]) + (list.drop choice primitives))) + +tupleT (type.tuple (list/map product.left +primitives))]] ($_ seq (test "Can analyse product." - (|> (&;with-type (type;tuple (list/map product;left primitives)) - (@;analyse-product analyse (list/map product;right primitives))) - (macro;run (init-compiler [])) - (case> (#e;Success tupleA) - (n.= size (list;size (la;unfold-tuple tupleA))) + (|> (&.with-type (type.tuple (list/map product.left primitives)) + (@.analyse-product analyse (list/map product.right primitives))) + (macro.run (init-compiler [])) + (case> (#e.Success tupleA) + (n/= size (list.size (la.unfold-tuple tupleA))) _ false))) (test "Can infer product." - (|> (@common;with-unknown-type - (@;analyse-product analyse (list/map product;right primitives))) - (macro;run (init-compiler [])) - (case> (#e;Success [_type tupleA]) - (and (type/= (type;tuple (list/map product;left primitives)) + (|> (@common.with-unknown-type + (@.analyse-product analyse (list/map product.right primitives))) + (macro.run (init-compiler [])) + (case> (#e.Success [_type tupleA]) + (and (type/= (type.tuple (list/map product.left primitives)) _type) - (n.= size (list;size (la;unfold-tuple tupleA)))) + (n/= size (list.size (la.unfold-tuple tupleA)))) _ false))) (test "Can analyse pseudo-product (singleton tuple)" - (|> (&;with-type singletonT + (|> (&.with-type singletonT (analyse (` [(~ singletonC)]))) - (macro;run (init-compiler [])) - (case> (#e;Success singletonA) + (macro.run (init-compiler [])) + (case> (#e.Success singletonA) true - (#e;Error error) + (#e.Error error) false))) (test "Can analyse product through bound type-vars." - (|> (&;with-scope - (do macro;Monad - [[_ varT] (&;with-type-env tc;var) - _ (&;with-type-env - (tc;check varT (type;tuple (list/map product;left primitives))))] - (&;with-type varT - (@;analyse-product analyse (list/map product;right primitives))))) - (macro;run (init-compiler [])) - (case> (#e;Success [_ tupleA]) - (n.= size (list;size (la;unfold-tuple tupleA))) + (|> (&.with-scope + (do macro.Monad + [[_ varT] (&.with-type-env tc.var) + _ (&.with-type-env + (tc.check varT (type.tuple (list/map product.left primitives))))] + (&.with-type varT + (@.analyse-product analyse (list/map product.right primitives))))) + (macro.run (init-compiler [])) + (case> (#e.Success [_ tupleA]) + (n/= size (list.size (la.unfold-tuple tupleA))) _ false))) (test "Can analyse product through existential quantification." - (|> (&;with-scope - (&;with-type (type;ex-q +1 +tupleT) - (@;analyse-product analyse (list/map product;right +primitives)))) - (macro;run (init-compiler [])) - (case> (#e;Success _) + (|> (&.with-scope + (&.with-type (type.ex-q +1 +tupleT) + (@.analyse-product analyse (list/map product.right +primitives)))) + (macro.run (init-compiler [])) + (case> (#e.Success _) true - (#e;Error error) + (#e.Error error) false))) (test "Cannot analyse product through universal quantification." - (|> (&;with-scope - (&;with-type (type;univ-q +1 +tupleT) - (@;analyse-product analyse (list/map product;right +primitives)))) - (macro;run (init-compiler [])) - (case> (#e;Success _) + (|> (&.with-scope + (&.with-type (type.univ-q +1 +tupleT) + (@.analyse-product analyse (list/map product.right +primitives)))) + (macro.run (init-compiler [])) + (case> (#e.Success _) false - (#e;Error error) + (#e.Error error) true))) )))) (def: (check-variant-inference variantT choice size analysis) - (-> Type Nat Nat (Meta [Module Scope Type la;Analysis]) Bool) + (-> Type Nat Nat (Meta [Module Scope Type la.Analysis]) Bool) (|> analysis - (macro;run (init-compiler [])) - (case> (^multi (#e;Success [_ _ sumT sumA]) - [(la;unfold-variant sumA) - (#;Some [tag last? valueA])]) + (macro.run (init-compiler [])) + (case> (^multi (#e.Success [_ _ sumT sumA]) + [(la.unfold-variant sumA) + (#.Some [tag last? valueA])]) (and (type/= variantT sumT) - (n.= tag choice) - (bool/= last? (n.= (n.dec size) choice))) + (n/= tag choice) + (bool/= last? (n/= (n/dec size) choice))) _ false))) (def: (check-record-inference tupleT size analysis) - (-> Type Nat (Meta [Module Scope Type la;Analysis]) Bool) + (-> Type Nat (Meta [Module Scope Type la.Analysis]) Bool) (|> analysis - (macro;run (init-compiler [])) - (case> (^multi (#e;Success [_ _ productT productA]) - [(la;unfold-tuple productA) + (macro.run (init-compiler [])) + (case> (^multi (#e.Success [_ _ productT productA]) + [(la.unfold-tuple productA) membersA]) (and (type/= tupleT productT) - (n.= size (list;size membersA))) + (n/= size (list.size membersA))) _ false))) @@ -215,64 +215,64 @@ (context: "Tagged Sums" (<| (times +100) (do @ - [size (|> r;nat (:: @ map (|>. (n.% +10) (n.max +2)))) - tags (|> (r;set text;Hash size (r;text +5)) (:: @ map S;to-list)) - choice (|> r;nat (:: @ map (n.% size))) - other-choice (|> r;nat (:: @ map (n.% size)) (r;filter (|>. (n.= choice) not))) - primitives (r;list size gen-primitive) - module-name (r;text +5) - type-name (r;text +5) - #let [varT (#;Bound +1) - primitivesT (list/map product;left primitives) - [choiceT choiceC] (maybe;assume (list;nth choice primitives)) - [other-choiceT other-choiceC] (maybe;assume (list;nth other-choice primitives)) - variantT (type;variant primitivesT) - namedT (#;Named [module-name type-name] variantT) - polyT (|> (type;variant (list;concat (list (list;take choice primitivesT) + [size (|> r.nat (:: @ map (|>> (n/% +10) (n/max +2)))) + tags (|> (r.set text.Hash size (r.text +5)) (:: @ map S.to-list)) + choice (|> r.nat (:: @ map (n/% size))) + other-choice (|> r.nat (:: @ map (n/% size)) (r.filter (|>> (n/= choice) not))) + primitives (r.list size gen-primitive) + module-name (r.text +5) + type-name (r.text +5) + #let [varT (#.Bound +1) + primitivesT (list/map product.left primitives) + [choiceT choiceC] (maybe.assume (list.nth choice primitives)) + [other-choiceT other-choiceC] (maybe.assume (list.nth other-choice primitives)) + variantT (type.variant primitivesT) + namedT (#.Named [module-name type-name] variantT) + polyT (|> (type.variant (list.concat (list (list.take choice primitivesT) (list varT) - (list;drop (n.inc choice) primitivesT)))) - (type;univ-q +1)) - named-polyT (#;Named [module-name type-name] polyT) - choice-tag (maybe;assume (list;nth choice tags)) - other-choice-tag (maybe;assume (list;nth other-choice tags))]] + (list.drop (n/inc choice) primitivesT)))) + (type.univ-q +1)) + named-polyT (#.Named [module-name type-name] polyT) + choice-tag (maybe.assume (list.nth choice tags)) + other-choice-tag (maybe.assume (list.nth other-choice tags))]] ($_ seq (test "Can infer tagged sum." - (|> (@module;with-module +0 module-name - (do macro;Monad - [_ (@module;declare-tags tags false namedT)] - (&;with-scope - (@common;with-unknown-type - (@;analyse-tagged-sum analyse [module-name choice-tag] choiceC))))) + (|> (@module.with-module +0 module-name + (do macro.Monad + [_ (@module.declare-tags tags false namedT)] + (&.with-scope + (@common.with-unknown-type + (@.analyse-tagged-sum analyse [module-name choice-tag] choiceC))))) (check-variant-inference variantT choice size))) (test "Tagged sums specialize when type-vars get bound." - (|> (@module;with-module +0 module-name - (do macro;Monad - [_ (@module;declare-tags tags false named-polyT)] - (&;with-scope - (@common;with-unknown-type - (@;analyse-tagged-sum analyse [module-name choice-tag] choiceC))))) + (|> (@module.with-module +0 module-name + (do macro.Monad + [_ (@module.declare-tags tags false named-polyT)] + (&.with-scope + (@common.with-unknown-type + (@.analyse-tagged-sum analyse [module-name choice-tag] choiceC))))) (check-variant-inference variantT choice size))) (test "Tagged sum inference retains universal quantification when type-vars are not bound." - (|> (@module;with-module +0 module-name - (do macro;Monad - [_ (@module;declare-tags tags false named-polyT)] - (&;with-scope - (@common;with-unknown-type - (@;analyse-tagged-sum analyse [module-name other-choice-tag] other-choiceC))))) + (|> (@module.with-module +0 module-name + (do macro.Monad + [_ (@module.declare-tags tags false named-polyT)] + (&.with-scope + (@common.with-unknown-type + (@.analyse-tagged-sum analyse [module-name other-choice-tag] other-choiceC))))) (check-variant-inference polyT other-choice size))) (test "Can specialize generic tagged sums." - (|> (@module;with-module +0 module-name - (do macro;Monad - [_ (@module;declare-tags tags false named-polyT)] - (&;with-scope - (&;with-type variantT - (@;analyse-tagged-sum analyse [module-name other-choice-tag] other-choiceC))))) - (macro;run (init-compiler [])) - (case> (^multi (#e;Success [_ _ sumA]) - [(la;unfold-variant sumA) - (#;Some [tag last? valueA])]) - (and (n.= tag other-choice) - (bool/= last? (n.= (n.dec size) other-choice))) + (|> (@module.with-module +0 module-name + (do macro.Monad + [_ (@module.declare-tags tags false named-polyT)] + (&.with-scope + (&.with-type variantT + (@.analyse-tagged-sum analyse [module-name other-choice-tag] other-choiceC))))) + (macro.run (init-compiler [])) + (case> (^multi (#e.Success [_ _ sumA]) + [(la.unfold-variant sumA) + (#.Some [tag last? valueA])]) + (and (n/= tag other-choice) + (bool/= last? (n/= (n/dec size) other-choice))) _ false))) @@ -281,53 +281,53 @@ (context: "Records" (<| (times +100) (do @ - [size (|> r;nat (:: @ map (|>. (n.% +10) (n.max +2)))) - tags (|> (r;set text;Hash size (r;text +5)) (:: @ map S;to-list)) - primitives (r;list size gen-primitive) - module-name (r;text +5) - type-name (r;text +5) - choice (|> r;nat (:: @ map (n.% size))) - #let [varT (#;Bound +1) - tagsC (list/map (|>. [module-name] code;tag) tags) - primitivesT (list/map product;left primitives) - primitivesC (list/map product;right primitives) - tupleT (type;tuple primitivesT) - namedT (#;Named [module-name type-name] tupleT) - recordC (list;zip2 tagsC primitivesC) - polyT (|> (type;tuple (list;concat (list (list;take choice primitivesT) + [size (|> r.nat (:: @ map (|>> (n/% +10) (n/max +2)))) + tags (|> (r.set text.Hash size (r.text +5)) (:: @ map S.to-list)) + primitives (r.list size gen-primitive) + module-name (r.text +5) + type-name (r.text +5) + choice (|> r.nat (:: @ map (n/% size))) + #let [varT (#.Bound +1) + tagsC (list/map (|>> [module-name] code.tag) tags) + primitivesT (list/map product.left primitives) + primitivesC (list/map product.right primitives) + tupleT (type.tuple primitivesT) + namedT (#.Named [module-name type-name] tupleT) + recordC (list.zip2 tagsC primitivesC) + polyT (|> (type.tuple (list.concat (list (list.take choice primitivesT) (list varT) - (list;drop (n.inc choice) primitivesT)))) - (type;univ-q +1)) - named-polyT (#;Named [module-name type-name] polyT)]] + (list.drop (n/inc choice) primitivesT)))) + (type.univ-q +1)) + named-polyT (#.Named [module-name type-name] polyT)]] ($_ seq (test "Can infer record." - (|> (@module;with-module +0 module-name - (do macro;Monad - [_ (@module;declare-tags tags false namedT)] - (&;with-scope - (@common;with-unknown-type - (@;analyse-record analyse recordC))))) + (|> (@module.with-module +0 module-name + (do macro.Monad + [_ (@module.declare-tags tags false namedT)] + (&.with-scope + (@common.with-unknown-type + (@.analyse-record analyse recordC))))) (check-record-inference tupleT size))) (test "Records specialize when type-vars get bound." - (|> (@module;with-module +0 module-name - (do macro;Monad - [_ (@module;declare-tags tags false named-polyT)] - (&;with-scope - (@common;with-unknown-type - (@;analyse-record analyse recordC))))) + (|> (@module.with-module +0 module-name + (do macro.Monad + [_ (@module.declare-tags tags false named-polyT)] + (&.with-scope + (@common.with-unknown-type + (@.analyse-record analyse recordC))))) (check-record-inference tupleT size))) (test "Can specialize generic records." - (|> (@module;with-module +0 module-name - (do macro;Monad - [_ (@module;declare-tags tags false named-polyT)] - (&;with-scope - (&;with-type tupleT - (@;analyse-record analyse recordC))))) - (macro;run (init-compiler [])) - (case> (^multi (#e;Success [_ _ productA]) - [(la;unfold-tuple productA) + (|> (@module.with-module +0 module-name + (do macro.Monad + [_ (@module.declare-tags tags false named-polyT)] + (&.with-scope + (&.with-type tupleT + (@.analyse-record analyse recordC))))) + (macro.run (init-compiler [])) + (case> (^multi (#e.Success [_ _ productA]) + [(la.unfold-tuple productA) membersA]) - (n.= size (list;size membersA)) + (n/= size (list.size membersA)) _ false))) diff --git a/new-luxc/test/test/luxc/lang/analysis/type.lux b/new-luxc/test/test/luxc/lang/analysis/type.lux index b159870c8..6f8a1343a 100644 --- a/new-luxc/test/test/luxc/lang/analysis/type.lux +++ b/new-luxc/test/test/luxc/lang/analysis/type.lux @@ -1,4 +1,4 @@ -(;module: +(.module: lux (lux [io] (control [monad #+ do] @@ -17,33 +17,33 @@ (lang [type "type/" Eq]) test) (luxc ["&" lang] - (lang ["&;" module] + (lang ["&." module] ["~" analysis] - (analysis [";A" expression] + (analysis [".A" expression] ["@" type] - ["@;" common]) - (translation ["@;" runtime]) + ["@." common]) + (translation ["@." runtime]) [eval])) - (.. common) + (// common) (test/luxc common)) (def: check - (r;Random [Code Type Code]) + (r.Random [Code Type Code]) (with-expansions [ (do-template [ ] - [(do r;Monad + [(do r.Monad [value ] (wrap [(` ) ( value)]))] - [r;bool (+0 "#Bool" (+0)) code;bool] - [r;nat (+0 "#Nat" (+0)) code;nat] - [r;int (+0 "#Int" (+0)) code;int] - [r;deg (+0 "#Deg" (+0)) code;deg] - [r;frac (+0 "#Frac" (+0)) code;frac] - [(r;text +5) (+0 "#Text" (+0)) code;text] + [r.bool (+0 "#Bool" (+0)) code.bool] + [r.nat (+0 "#Nat" (+0)) code.nat] + [r.int (+0 "#Int" (+0)) code.int] + [r.deg (+0 "#Deg" (+0)) code.deg] + [r.frac (+0 "#Frac" (+0)) code.frac] + [(r.text +5) (+0 "#Text" (+0)) code.text] )] - ($_ r;either + ($_ r.either ))) (context: "Type checking/coercion." @@ -53,39 +53,39 @@ ($_ seq (test (format "Can analyse type-checking.") (|> (do Monad - [runtime-bytecode @runtime;translate] - (&;with-scope - (@common;with-unknown-type - (@;analyse-check analyse eval;eval typeC exprC)))) - (macro;run (init-compiler [])) - (case> (#e;Success [_ [analysisT analysisA]]) + [runtime-bytecode @runtime.translate] + (&.with-scope + (@common.with-unknown-type + (@.analyse-check analyse eval.eval typeC exprC)))) + (macro.run (init-compiler [])) + (case> (#e.Success [_ [analysisT analysisA]]) (and (type/= codeT analysisT) (case [exprC analysisA] (^template [ ] [[_ ( expected)] [_ ( actual)]] ( expected actual)) - ([#;Bool bool/=] - [#;Nat n.=] - [#;Int i.=] - [#;Deg d.=] - [#;Frac f.=] - [#;Text text/=]) + ([#.Bool bool/=] + [#.Nat n/=] + [#.Int i/=] + [#.Deg d/=] + [#.Frac f/=] + [#.Text text/=]) _ false)) - (#e;Error error) + (#e.Error error) false))) (test (format "Can analyse type-coercion.") (|> (do Monad - [runtime-bytecode @runtime;translate] - (&;with-scope - (@common;with-unknown-type - (@;analyse-coerce analyse eval;eval typeC exprC)))) - (macro;run (init-compiler [])) - (case> (#e;Success [_ [analysisT analysisA]]) + [runtime-bytecode @runtime.translate] + (&.with-scope + (@common.with-unknown-type + (@.analyse-coerce analyse eval.eval typeC exprC)))) + (macro.run (init-compiler [])) + (case> (#e.Success [_ [analysisT analysisA]]) (type/= codeT analysisT) - (#e;Error error) + (#e.Error error) false))) )))) diff --git a/new-luxc/test/test/luxc/lang/synthesis/case/special.lux b/new-luxc/test/test/luxc/lang/synthesis/case/special.lux index 1ae6ad030..4e00163ae 100644 --- a/new-luxc/test/test/luxc/lang/synthesis/case/special.lux +++ b/new-luxc/test/test/luxc/lang/synthesis/case/special.lux @@ -1,4 +1,4 @@ -(;module: +(.module: lux (lux [io] (control [monad #+ do] @@ -8,35 +8,35 @@ test) (luxc (lang ["la" analysis] ["ls" synthesis] - (synthesis [";S" expression]) - [";L" variable #+ Variable])) - (../.. common)) + (synthesis [".S" expression]) + [".L" variable #+ Variable])) + (/// common)) (context: "Dummy variables." (<| (times +100) (do @ [maskedA gen-primitive - temp (|> r;nat (:: @ map (n.% +100))) + temp (|> r.nat (:: @ map (n/% +100))) #let [maskA (` ("lux case" (~ maskedA) - {("lux case bind" (~ (code;nat temp))) - (~ (la;var (variableL;local temp)))}))]] + {("lux case bind" (~ (code.nat temp))) + (~ (la.var (variableL.local temp)))}))]] (test "Dummy variables created to mask expressions get eliminated during synthesis." - (|> (expressionS;synthesize maskA) + (|> (expressionS.synthesize maskA) (corresponds? maskedA)))))) (context: "Let expressions." (<| (times +100) (do @ - [registerA r;nat + [registerA r.nat inputA gen-primitive outputA gen-primitive #let [letA (` ("lux case" (~ inputA) - {("lux case bind" (~ (code;nat registerA))) + {("lux case bind" (~ (code.nat registerA))) (~ outputA)}))]] (test "Can detect and reify simple 'let' expressions." - (|> (expressionS;synthesize letA) - (case> (^ [_ (#;Form (list [_ (#;Text "lux let")] [_ (#;Nat registerS)] inputS outputS))]) - (and (n.= registerA registerS) + (|> (expressionS.synthesize letA) + (case> (^ [_ (#.Form (list [_ (#.Text "lux let")] [_ (#.Nat registerS)] inputS outputS))]) + (and (n/= registerA registerS) (corresponds? inputA inputS) (corresponds? outputA outputS)) @@ -46,7 +46,7 @@ (context: "If expressions." (<| (times +100) (do @ - [then|else r;bool + [then|else r.bool inputA gen-primitive thenA gen-primitive elseA gen-primitive @@ -58,8 +58,8 @@ {false (~ elseA) true (~ thenA)})))]] (test "Can detect and reify simple 'if' expressions." - (|> (expressionS;synthesize ifA) - (case> (^ [_ (#;Form (list [_ (#;Text "lux if")] inputS thenS elseS))]) + (|> (expressionS.synthesize ifA) + (case> (^ [_ (#.Form (list [_ (#.Text "lux if")] inputS thenS elseS))]) (and (corresponds? inputA inputS) (corresponds? thenA thenS) (corresponds? elseA elseS)) diff --git a/new-luxc/test/test/luxc/lang/synthesis/common.lux b/new-luxc/test/test/luxc/lang/synthesis/common.lux index caa2d09dc..3379fe7fd 100644 --- a/new-luxc/test/test/luxc/lang/synthesis/common.lux +++ b/new-luxc/test/test/luxc/lang/synthesis/common.lux @@ -1,4 +1,4 @@ -(;module: +(.module: lux (lux (data [bool "bool/" Eq] [text "text/" Eq]) @@ -8,17 +8,17 @@ ["ls" synthesis]))) (def: #export gen-primitive - (r;Random la;Analysis) - (r;either (r;either (r;either (r/wrap (' [])) - (r/map code;bool r;bool)) - (r;either (r/map code;nat r;nat) - (r/map code;int r;int))) - (r;either (r;either (r/map code;deg r;deg) - (r/map code;frac r;frac)) - (r/map code;text (r;text +5))))) + (r.Random la.Analysis) + (r.either (r.either (r.either (r/wrap (' [])) + (r/map code.bool r.bool)) + (r.either (r/map code.nat r.nat) + (r/map code.int r.int))) + (r.either (r.either (r/map code.deg r.deg) + (r/map code.frac r.frac)) + (r/map code.text (r.text +5))))) (def: #export (corresponds? analysis synthesis) - (-> la;Analysis ls;Synthesis Bool) + (-> la.Analysis ls.Synthesis Bool) (case [analysis synthesis] (^ [(^code []) (^code [])]) true @@ -26,12 +26,12 @@ (^template [ ] [[_ ( valueA)] [_ ( valueS)]] ( valueA valueS)) - ([#;Bool bool/=] - [#;Nat n.=] - [#;Int i.=] - [#;Deg d.=] - [#;Frac f.=] - [#;Text text/=]) + ([#.Bool bool/=] + [#.Nat n/=] + [#.Int i/=] + [#.Deg d/=] + [#.Frac f/=] + [#.Text text/=]) _ false)) diff --git a/new-luxc/test/test/luxc/lang/synthesis/function.lux b/new-luxc/test/test/luxc/lang/synthesis/function.lux index 259bf5a4e..eaae351f0 100644 --- a/new-luxc/test/test/luxc/lang/synthesis/function.lux +++ b/new-luxc/test/test/luxc/lang/synthesis/function.lux @@ -1,4 +1,4 @@ -(;module: +(.module: lux (lux [io] (control [monad #+ do] @@ -15,20 +15,20 @@ test) (luxc (lang ["la" analysis] ["ls" synthesis] - (synthesis [";S" expression]) - [";L" variable #+ Variable])) - (.. common)) + (synthesis [".S" expression]) + [".L" variable #+ Variable])) + (// common)) (def: gen-function//constant - (r;Random [Nat la;Analysis la;Analysis]) - (r;rec + (r.Random [Nat la.Analysis la.Analysis]) + (r.rec (function [gen-function//constant] - (do r;Monad - [function? r;bool] + (do r.Monad + [function? r.bool] (if function? (do @ [[num-args outputA subA] gen-function//constant] - (wrap [(n.inc num-args) + (wrap [(n/inc num-args) outputA (` ("lux function" [] (~ subA)))])) (do @ @@ -36,62 +36,62 @@ (wrap [+0 outputA outputA]))))))) (def: (pick scope-size) - (-> Nat (r;Random Nat)) - (|> r;nat (:: r;Monad map (n.% scope-size)))) + (-> Nat (r.Random Nat)) + (|> r.nat (:: r.Monad map (n/% scope-size)))) (def: gen-function//captured - (r;Random [Nat Int la;Analysis]) - (do r;Monad - [num-locals (|> r;nat (:: @ map (|>. (n.% +100) (n.max +10)))) - #let [indices (list;n.range +0 (n.dec num-locals)) - absolute-env (list/map variableL;local indices) - relative-env (list/map variableL;captured indices)] - [total-args prediction bodyA] (: (r;Random [Nat Int la;Analysis]) + (r.Random [Nat Int la.Analysis]) + (do r.Monad + [num-locals (|> r.nat (:: @ map (|>> (n/% +100) (n/max +10)))) + #let [indices (list.n/range +0 (n/dec num-locals)) + absolute-env (list/map variableL.local indices) + relative-env (list/map variableL.captured indices)] + [total-args prediction bodyA] (: (r.Random [Nat Int la.Analysis]) (loop [num-args +1 global-env relative-env] - (let [env-size (list;size global-env) + (let [env-size (list.size global-env) resolver (list/fold (function [[idx var] resolver] - (dict;put idx var resolver)) + (dict.put idx var resolver)) (: (Dict Nat Int) - (dict;new number;Hash)) - (list;zip2 (list;n.range +0 (n.dec env-size)) + (dict.new number.Hash)) + (list.zip2 (list.n/range +0 (n/dec env-size)) global-env))] (do @ - [nest? r;bool] + [nest? r.bool] (if nest? (do @ - [num-picks (:: @ map (n.max +1) (pick (n.inc env-size))) - picks (|> (r;set number;Hash num-picks (pick env-size)) - (:: @ map set;to-list)) - [total-args prediction bodyA] (recur (n.inc num-args) - (list/map (function [pick] (maybe;assume (list;nth pick global-env))) + [num-picks (:: @ map (n/max +1) (pick (n/inc env-size))) + picks (|> (r.set number.Hash num-picks (pick env-size)) + (:: @ map set.to-list)) + [total-args prediction bodyA] (recur (n/inc num-args) + (list/map (function [pick] (maybe.assume (list.nth pick global-env))) picks))] - (wrap [total-args prediction (` ("lux function" [(~@ (list/map (|>. variableL;captured code;int) picks))] + (wrap [total-args prediction (` ("lux function" [(~@ (list/map (|>> variableL.captured code.int) picks))] (~ bodyA)))])) (do @ - [chosen (pick (list;size global-env))] + [chosen (pick (list.size global-env))] (wrap [num-args - (maybe;assume (dict;get chosen resolver)) - (la;var (variableL;captured chosen))])))))))] + (maybe.assume (dict.get chosen resolver)) + (la.var (variableL.captured chosen))])))))))] (wrap [total-args prediction (` ("lux function" - [(~@ (list/map code;int absolute-env))] + [(~@ (list/map code.int absolute-env))] (~ bodyA)))]) )) (def: gen-function//local - (r;Random [Nat Int la;Analysis]) + (r.Random [Nat Int la.Analysis]) (loop [num-args +0 nest? true] (if nest? - (do r;Monad - [nest?' r;bool - [total-args prediction bodyA] (recur (n.inc num-args) nest?')] + (do r.Monad + [nest?' r.bool + [total-args prediction bodyA] (recur (n/inc num-args) nest?')] (wrap [total-args prediction (` ("lux function" [] (~ bodyA)))])) - (do r;Monad - [chosen (|> r;nat (:: @ map (|>. (n.% +100) (n.max +2))))] + (do r.Monad + [chosen (|> r.nat (:: @ map (|>> (n/% +100) (n/max +2))))] (wrap [num-args - (|> chosen (n.+ (n.dec num-args)) nat-to-int) - (la;var (variableL;local chosen))]))))) + (|> chosen (n/+ (n/dec num-args)) nat-to-int) + (la.var (variableL.local chosen))]))))) (context: "Function definition." (<| (times +100) @@ -101,28 +101,28 @@ [args3 prediction3 function3] gen-function//local] ($_ seq (test "Nested functions will get folded together." - (|> (expressionS;synthesize function1) - (case> (^ [_ (#;Form (list [_ (#;Text "lux function")] [_ (#;Nat args)] [_ (#;Tuple captured)] output))]) - (and (n.= args1 args) + (|> (expressionS.synthesize function1) + (case> (^ [_ (#.Form (list [_ (#.Text "lux function")] [_ (#.Nat args)] [_ (#.Tuple captured)] output))]) + (and (n/= args1 args) (corresponds? prediction1 output)) _ - (n.= +0 args1)))) + (n/= +0 args1)))) (test "Folded functions provide direct access to captured variables." - (|> (expressionS;synthesize function2) - (case> (^ [_ (#;Form (list [_ (#;Text "lux function")] [_ (#;Nat args)] [_ (#;Tuple captured)] - [_ (#;Form (list [_ (#;Int output)]))]))]) - (and (n.= args2 args) - (i.= prediction2 output)) + (|> (expressionS.synthesize function2) + (case> (^ [_ (#.Form (list [_ (#.Text "lux function")] [_ (#.Nat args)] [_ (#.Tuple captured)] + [_ (#.Form (list [_ (#.Int output)]))]))]) + (and (n/= args2 args) + (i/= prediction2 output)) _ false))) (test "Folded functions properly offset local variables." - (|> (expressionS;synthesize function3) - (case> (^ [_ (#;Form (list [_ (#;Text "lux function")] [_ (#;Nat args)] [_ (#;Tuple captured)] - [_ (#;Form (list [_ (#;Int output)]))]))]) - (and (n.= args3 args) - (i.= prediction3 output)) + (|> (expressionS.synthesize function3) + (case> (^ [_ (#.Form (list [_ (#.Text "lux function")] [_ (#.Nat args)] [_ (#.Tuple captured)] + [_ (#.Form (list [_ (#.Int output)]))]))]) + (and (n/= args3 args) + (i/= prediction3 output)) _ false))) @@ -131,20 +131,20 @@ (context: "Function application." (<| (times +100) (do @ - [num-args (|> r;nat (:: @ map (|>. (n.% +10) (n.max +1)))) + [num-args (|> r.nat (:: @ map (|>> (n/% +10) (n/max +1)))) funcA gen-primitive - argsA (r;list num-args gen-primitive)] + argsA (r.list num-args gen-primitive)] ($_ seq (test "Can synthesize function application." - (|> (expressionS;synthesize (la;apply argsA funcA)) - (case> (^ [_ (#;Form (list& [_ (#;Text "lux call")] funcS argsS))]) + (|> (expressionS.synthesize (la.apply argsA funcA)) + (case> (^ [_ (#.Form (list& [_ (#.Text "lux call")] funcS argsS))]) (and (corresponds? funcA funcS) - (list;every? (product;uncurry corresponds?) - (list;zip2 argsA argsS))) + (list.every? (product.uncurry corresponds?) + (list.zip2 argsA argsS))) _ false))) (test "Function application on no arguments just synthesizes to the function itself." - (|> (expressionS;synthesize (la;apply (list) funcA)) + (|> (expressionS.synthesize (la.apply (list) funcA)) (corresponds? funcA))) )))) diff --git a/new-luxc/test/test/luxc/lang/synthesis/loop.lux b/new-luxc/test/test/luxc/lang/synthesis/loop.lux index 386b06dcd..805c66190 100644 --- a/new-luxc/test/test/luxc/lang/synthesis/loop.lux +++ b/new-luxc/test/test/luxc/lang/synthesis/loop.lux @@ -1,4 +1,4 @@ -(;module: +(.module: lux (lux [io] (control [monad #+ do]) @@ -12,37 +12,37 @@ test) (luxc (lang ["la" analysis] ["ls" synthesis] - (synthesis [";S" expression] - [";S" loop]))) - (.. common)) + (synthesis [".S" expression] + [".S" loop]))) + (// common)) (def: (does-recursion? arity exprS) - (-> ls;Arity ls;Synthesis Bool) + (-> ls.Arity ls.Synthesis Bool) (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) _ false)) - (^ [_ (#;Form (list& [_ (#;Text "lux recur")] argsS))]) - (n.= arity (list;size 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)) @@ -51,73 +51,73 @@ ))) (def: (gen-body arity output) - (-> Nat la;Analysis (r;Random la;Analysis)) - (r;either (r;either (r/wrap output) - (do r;Monad - [inputA (|> r;nat (:: @ map code;nat)) - num-cases (|> r;nat (:: @ map (|>. (n.% +10) (n.max +1)))) - tests (|> (r;set number;Hash num-cases r;nat) - (:: @ map (|>. s;to-list (list/map code;nat)))) - #let [bad-bodies (list;repeat num-cases (' []))] + (-> Nat la.Analysis (r.Random la.Analysis)) + (r.either (r.either (r/wrap output) + (do r.Monad + [inputA (|> r.nat (:: @ map code.nat)) + num-cases (|> r.nat (:: @ map (|>> (n/% +10) (n/max +1)))) + tests (|> (r.set number.Hash num-cases r.nat) + (:: @ map (|>> s.to-list (list/map code.nat)))) + #let [bad-bodies (list.repeat num-cases (' []))] good-body (gen-body arity output) - where-to-set (|> r;nat (:: @ map (n.% num-cases))) - #let [bodies (list;concat (list (list;take where-to-set bad-bodies) + where-to-set (|> r.nat (:: @ map (n/% num-cases))) + #let [bodies (list.concat (list (list.take where-to-set bad-bodies) (list good-body) - (list;drop (n.inc where-to-set) bad-bodies)))]] + (list.drop (n/inc where-to-set) bad-bodies)))]] (wrap (` ("lux case" (~ inputA) - (~ (code;record (list;zip2 tests bodies)))))))) - (r;either (do r;Monad - [valueS r;bool - output' (gen-body (n.inc arity) output)] - (wrap (` ("lux case" (~ (code;bool valueS)) - {("lux case bind" (~ (code;nat arity))) (~ output')})))) - (do r;Monad - [valueS r;bool - then|else r;bool + (~ (code.record (list.zip2 tests bodies)))))))) + (r.either (do r.Monad + [valueS r.bool + output' (gen-body (n/inc arity) output)] + (wrap (` ("lux case" (~ (code.bool valueS)) + {("lux case bind" (~ (code.nat arity))) (~ output')})))) + (do r.Monad + [valueS r.bool + then|else r.bool output' (gen-body arity output) #let [thenA (if then|else output' (' [])) elseA (if (not then|else) output' (' []))]] - (wrap (` ("lux case" (~ (code;bool valueS)) - {(~ (code;bool then|else)) (~ thenA) - (~ (code;bool (not then|else))) (~ elseA)}))))) + (wrap (` ("lux case" (~ (code.bool valueS)) + {(~ (code.bool then|else)) (~ thenA) + (~ (code.bool (not then|else))) (~ elseA)}))))) )) (def: (make-function arity body) - (-> ls;Arity la;Analysis la;Analysis) + (-> ls.Arity la.Analysis la.Analysis) (case arity +0 body - _ (` ("lux function" [] (~ (make-function (n.dec arity) body)))))) + _ (` ("lux function" [] (~ (make-function (n/dec arity) body)))))) (def: gen-recursion - (r;Random [Bool Nat la;Analysis]) - (do r;Monad - [arity (|> r;nat (:: @ map (|>. (n.% +10) (n.max +1)))) - recur? r;bool + (r.Random [Bool Nat la.Analysis]) + (do r.Monad + [arity (|> r.nat (:: @ map (|>> (n/% +10) (n/max +1)))) + recur? r.bool outputS (if recur? - (wrap (la;apply (list;repeat arity (' [])) (la;var 0))) + (wrap (la.apply (list.repeat arity (' [])) (la.var 0))) (do @ - [plus-or-minus? r;bool - how-much (|> r;nat (:: @ map (|>. (n.% arity) (n.max +1)))) - #let [shift (if plus-or-minus? n.+ n.-)]] - (wrap (la;apply (list;repeat (shift how-much arity) (' [])) (la;var 0))))) + [plus-or-minus? r.bool + how-much (|> r.nat (:: @ map (|>> (n/% arity) (n/max +1)))) + #let [shift (if plus-or-minus? n/+ n/-)]] + (wrap (la.apply (list.repeat (shift how-much arity) (' [])) (la.var 0))))) bodyS (gen-body arity outputS)] (wrap [recur? arity (make-function arity bodyS)]))) (def: gen-loop - (r;Random [Bool Nat la;Analysis]) - (do r;Monad - [arity (|> r;nat (:: @ map (|>. (n.% +10) (n.max +1)))) - recur? r;bool - self-ref? r;bool - #let [selfA (la;var 0) + (r.Random [Bool Nat la.Analysis]) + (do r.Monad + [arity (|> r.nat (:: @ map (|>> (n/% +10) (n/max +1)))) + recur? r.bool + self-ref? r.bool + #let [selfA (la.var 0) argA (if self-ref? selfA (' []))] outputS (if recur? - (wrap (la;apply (list;repeat arity argA) selfA)) + (wrap (la.apply (list.repeat arity argA) selfA)) (do @ - [plus-or-minus? r;bool - how-much (|> r;nat (:: @ map (|>. (n.% arity) (n.max +1)))) - #let [shift (if plus-or-minus? n.+ n.-)]] - (wrap (la;apply (list;repeat (shift how-much arity) (' [])) selfA)))) + [plus-or-minus? r.bool + how-much (|> r.nat (:: @ map (|>> (n/% arity) (n/max +1)))) + #let [shift (if plus-or-minus? n/+ n/-)]] + (wrap (la.apply (list.repeat (shift how-much arity) (' [])) selfA)))) bodyS (gen-body arity outputS)] (wrap [(and recur? (not self-ref?)) arity @@ -129,12 +129,12 @@ [[prediction arity analysis] gen-recursion] ($_ seq (test "Can accurately identify (and then reify) tail recursion." - (case (expressionS;synthesize analysis) - (^ [_ (#;Form (list [_ (#;Text "lux function")] [_ (#;Nat _arity)] [_ (#;Tuple _env)] _body))]) + (case (expressionS.synthesize analysis) + (^ [_ (#.Form (list [_ (#.Text "lux function")] [_ (#.Nat _arity)] [_ (#.Tuple _env)] _body))]) (|> _body (does-recursion? arity) (bool/= prediction) - (and (n.= arity _arity))) + (and (n/= arity _arity))) _ false)))))) @@ -145,15 +145,15 @@ [[prediction arity analysis] gen-recursion] ($_ seq (test "Can reify loops." - (case (expressionS;synthesize (la;apply (list;repeat arity (' [])) analysis)) - (^ [_ (#;Form (list [_ (#;Text "lux loop")] [_ (#;Nat in_register)] [_ (#;Tuple _inits)] _body))]) - (and (n.= arity (list;size _inits)) - (not (loopS;contains-self-reference? _body))) + (case (expressionS.synthesize (la.apply (list.repeat arity (' [])) analysis)) + (^ [_ (#.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))] + (^ [_ (#.Form (list& [_ (#.Text "lux call")] + [_ (#.Form (list [_ (#.Text "lux function")] _arity _env _bodyS))] argsS))]) - (loopS;contains-self-reference? _bodyS) + (loopS.contains-self-reference? _bodyS) _ false)))))) diff --git a/new-luxc/test/test/luxc/lang/synthesis/primitive.lux b/new-luxc/test/test/luxc/lang/synthesis/primitive.lux index 47f394117..157a9c1c3 100644 --- a/new-luxc/test/test/luxc/lang/synthesis/primitive.lux +++ b/new-luxc/test/test/luxc/lang/synthesis/primitive.lux @@ -1,4 +1,4 @@ -(;module: +(.module: lux (lux [io] (control [monad #+ do] @@ -9,20 +9,20 @@ test) (luxc (lang ["la" analysis] ["ls" synthesis] - (synthesis [";S" expression])))) + (synthesis [".S" expression])))) (context: "Primitives" (<| (times +100) (do @ - [%bool% r;bool - %nat% r;nat - %int% r;int - %deg% r;deg - %frac% r;frac - %text% (r;text +5)] + [%bool% r.bool + %nat% r.nat + %int% r.int + %deg% r.deg + %frac% r.frac + %text% (r.text +5)] (`` ($_ seq (test (format "Can synthesize unit.") - (|> (expressionS;synthesize (' [])) + (|> (expressionS.synthesize (' [])) (case> (^code []) true @@ -30,16 +30,16 @@ false))) (~~ (do-template [ ] [(test (format "Can synthesize " ".") - (|> (expressionS;synthesize ( )) + (|> (expressionS.synthesize ( )) (case> [_ ( value)] (is value) _ false)))] - ["bool" code;bool #;Bool %bool%] - ["nat" code;nat #;Nat %nat%] - ["int" code;int #;Int %int%] - ["deg" code;deg #;Deg %deg%] - ["frac" code;frac #;Frac %frac%] - ["text" code;text #;Text %text%]))))))) + ["bool" code.bool #.Bool %bool%] + ["nat" code.nat #.Nat %nat%] + ["int" code.int #.Int %int%] + ["deg" code.deg #.Deg %deg%] + ["frac" code.frac #.Frac %frac%] + ["text" code.text #.Text %text%]))))))) diff --git a/new-luxc/test/test/luxc/lang/synthesis/procedure.lux b/new-luxc/test/test/luxc/lang/synthesis/procedure.lux index 2263a1616..7b8923248 100644 --- a/new-luxc/test/test/luxc/lang/synthesis/procedure.lux +++ b/new-luxc/test/test/luxc/lang/synthesis/procedure.lux @@ -1,4 +1,4 @@ -(;module: +(.module: lux (lux [io] (control [monad #+ do] @@ -10,22 +10,22 @@ test) (luxc (lang ["la" analysis] ["ls" synthesis] - (synthesis [";S" expression]))) - (.. common)) + (synthesis [".S" expression]))) + (// common)) (context: "Procedures" (<| (times +100) (do @ - [num-args (|> r;nat (:: @ map (n.% +10))) - nameA (r;text +5) - argsA (r;list num-args gen-primitive)] + [num-args (|> r.nat (:: @ map (n/% +10))) + nameA (r.text +5) + argsA (r.list num-args gen-primitive)] ($_ seq (test "Can synthesize procedure calls." - (|> (expressionS;synthesize (la;procedure nameA argsA)) - (case> (^ [_ (#;Form (list& [_ (#;Text procedure)] argsS))]) + (|> (expressionS.synthesize (la.procedure nameA argsA)) + (case> (^ [_ (#.Form (list& [_ (#.Text procedure)] argsS))]) (and (text/= nameA procedure) - (list;every? (product;uncurry corresponds?) - (list;zip2 argsA argsS))) + (list.every? (product.uncurry corresponds?) + (list.zip2 argsA argsS))) _ false))) diff --git a/new-luxc/test/test/luxc/lang/synthesis/structure.lux b/new-luxc/test/test/luxc/lang/synthesis/structure.lux index eab568bbe..e401149ec 100644 --- a/new-luxc/test/test/luxc/lang/synthesis/structure.lux +++ b/new-luxc/test/test/luxc/lang/synthesis/structure.lux @@ -1,4 +1,4 @@ -(;module: +(.module: lux (lux [io] (control [monad #+ do] @@ -10,21 +10,21 @@ test) (luxc (lang ["la" analysis] ["ls" synthesis] - (synthesis [";S" expression]))) - (.. common)) + (synthesis [".S" expression]))) + (// common)) (context: "Variants" (<| (times +100) (do @ - [size (|> r;nat (:: @ map (|>. (n.% +10) (n.max +2)))) - tagA (|> r;nat (:: @ map (n.% size))) + [size (|> r.nat (:: @ map (|>> (n/% +10) (n/max +2)))) + tagA (|> r.nat (:: @ map (n/% size))) memberA gen-primitive] ($_ seq (test "Can synthesize variants." - (|> (expressionS;synthesize (la;sum tagA size +0 memberA)) - (case> (^ [_ (#;Form (list [_ (#;Nat tagS)] [_ (#;Bool last?S)] memberS))]) - (and (n.= tagA tagS) - (B/= (n.= (n.dec size) tagA) + (|> (expressionS.synthesize (la.sum tagA size +0 memberA)) + (case> (^ [_ (#.Form (list [_ (#.Nat tagS)] [_ (#.Bool last?S)] memberS))]) + (and (n/= tagA tagS) + (B/= (n/= (n/dec size) tagA) last?S) (corresponds? memberA memberS)) @@ -35,14 +35,14 @@ (context: "Tuples" (<| (times +100) (do @ - [size (|> r;nat (:: @ map (|>. (n.% +10) (n.max +2)))) - membersA (r;list size gen-primitive)] + [size (|> r.nat (:: @ map (|>> (n/% +10) (n/max +2)))) + membersA (r.list size gen-primitive)] ($_ seq (test "Can synthesize tuple." - (|> (expressionS;synthesize (la;product membersA)) - (case> [_ (#;Tuple membersS)] - (and (n.= size (list;size membersS)) - (list;every? (product;uncurry corresponds?) (list;zip2 membersA membersS))) + (|> (expressionS.synthesize (la.product membersA)) + (case> [_ (#.Tuple membersS)] + (and (n/= size (list.size membersS)) + (list.every? (product.uncurry corresponds?) (list.zip2 membersA membersS))) _ false))) diff --git a/new-luxc/test/test/luxc/lang/translation/case.lux b/new-luxc/test/test/luxc/lang/translation/case.lux index d843e6e1c..9921a2797 100644 --- a/new-luxc/test/test/luxc/lang/translation/case.lux +++ b/new-luxc/test/test/luxc/lang/translation/case.lux @@ -1,4 +1,4 @@ -(;module: +(.module: lux (lux [io] (control [monad #+ do] @@ -12,53 +12,53 @@ test) (luxc (lang ["ls" synthesis] (translation ["@" case] - [";T" expression] - ["@;" eval] - ["@;" runtime] - ["@;" common]))) + [".T" expression] + ["@." eval] + ["@." runtime] + ["@." common]))) (test/luxc common)) (def: struct-limit Nat +10) (def: (tail? size idx) (-> Nat Nat Bool) - (n.= (n.dec size) idx)) + (n/= (n/dec size) idx)) (def: gen-case - (r;Random [ls;Synthesis ls;Path]) - (<| r;rec (function [gen-case]) - (`` ($_ r;either + (r.Random [ls.Synthesis ls.Path]) + (<| r.rec (function [gen-case]) + (`` ($_ r.either (r/wrap [(' []) (' ("lux case pop"))]) (~~ (do-template [ ] - [(do r;Monad + [(do r.Monad [value ] (wrap [( value) ( value)]))] - [r;bool code;bool] - [r;nat code;nat] - [r;int code;int] - [r;deg code;deg] - [r;frac code;frac] - [(r;text +5) code;text])) - (do r;Monad - [size (|> r;nat (:: @ map (|>. (n.% struct-limit) (n.max +2)))) - idx (|> r;nat (:: @ map (n.% size))) + [r.bool code.bool] + [r.nat code.nat] + [r.int code.int] + [r.deg code.deg] + [r.frac code.frac] + [(r.text +5) code.text])) + (do r.Monad + [size (|> r.nat (:: @ map (|>> (n/% struct-limit) (n/max +2)))) + idx (|> r.nat (:: @ map (n/% size))) [subS subP] gen-case - #let [caseS (` [(~@ (list;concat (list (list;repeat idx (' [])) + #let [caseS (` [(~@ (list.concat (list (list.repeat idx (' [])) (list subS) - (list;repeat (|> size n.dec (n.- idx)) (' [])))))]) + (list.repeat (|> size n/dec (n/- idx)) (' [])))))]) caseP (if (tail? size idx) - (` ("lux case tuple right" (~ (code;nat idx)) (~ subP))) - (` ("lux case tuple left" (~ (code;nat idx)) (~ subP))))]] + (` ("lux case tuple right" (~ (code.nat idx)) (~ subP))) + (` ("lux case tuple left" (~ (code.nat idx)) (~ subP))))]] (wrap [caseS caseP])) - (do r;Monad - [size (|> r;nat (:: @ map (|>. (n.% struct-limit) (n.max +2)))) - idx (|> r;nat (:: @ map (n.% size))) + (do r.Monad + [size (|> r.nat (:: @ map (|>> (n/% struct-limit) (n/max +2)))) + idx (|> r.nat (:: @ map (n/% size))) [subS subP] gen-case - #let [caseS (` ((~ (code;nat idx)) (~ (code;bool (tail? size idx))) (~ subS))) + #let [caseS (` ((~ (code.nat idx)) (~ (code.bool (tail? size idx))) (~ subS))) caseP (if (tail? size idx) - (` ("lux case variant right" (~ (code;nat idx)) (~ subP))) - (` ("lux case variant left" (~ (code;nat idx)) (~ subP))))]] + (` ("lux case variant right" (~ (code.nat idx)) (~ subP))) + (` ("lux case variant left" (~ (code.nat idx)) (~ subP))))]] (wrap [caseS caseP])) )))) @@ -67,36 +67,36 @@ ## (times +100) (do @ [[valueS pathS] gen-case - to-bind r;nat] + to-bind r.nat] ($_ seq (test "Can translate pattern-matching." - (|> (do macro;Monad - [runtime-bytecode @runtime;translate - sampleI (@;translate-case expressionT;translate + (|> (do macro.Monad + [runtime-bytecode @runtime.translate + sampleI (@.translate-case expressionT.translate valueS (` ("lux case alt" ("lux case seq" (~ pathS) ("lux case exec" true)) ("lux case seq" ("lux case bind" +0) ("lux case exec" false)))))] - (@eval;eval sampleI)) - (macro;run (init-compiler [])) - (case> (#e;Success valueT) + (@eval.eval sampleI)) + (macro.run (init-compiler [])) + (case> (#e.Success valueT) (:! Bool valueT) - (#e;Error error) + (#e.Error error) false))) (test "Can bind values." - (|> (do macro;Monad - [runtime-bytecode @runtime;translate - sampleI (@;translate-case expressionT;translate - (code;nat to-bind) + (|> (do macro.Monad + [runtime-bytecode @runtime.translate + sampleI (@.translate-case expressionT.translate + (code.nat to-bind) (` ("lux case seq" ("lux case bind" +0) ("lux case exec" (0)))))] - (@eval;eval sampleI)) - (macro;run (init-compiler [])) - (case> (#e;Success valueT) - (n.= to-bind (:! Nat valueT)) + (@eval.eval sampleI)) + (macro.run (init-compiler [])) + (case> (#e.Success valueT) + (n/= to-bind (:! Nat valueT)) _ false))))))) diff --git a/new-luxc/test/test/luxc/lang/translation/function.lux b/new-luxc/test/test/luxc/lang/translation/function.lux index 726b51b58..1c3dc6f83 100644 --- a/new-luxc/test/test/luxc/lang/translation/function.lux +++ b/new-luxc/test/test/luxc/lang/translation/function.lux @@ -1,4 +1,4 @@ -(;module: +(.module: lux (lux [io] (control [monad #+ do] @@ -14,86 +14,86 @@ [host] test) (luxc (lang ["ls" synthesis] - (translation [";T" expression] - ["@;" eval] - ["@;" runtime] - ["@;" common]))) + (translation [".T" expression] + ["@." eval] + ["@." runtime] + ["@." common]))) (test/luxc common)) (def: arity-limit Nat +10) (def: arity - (r;Random ls;Arity) - (|> r;nat (r/map (|>. (n.% arity-limit) (n.max +1))))) + (r.Random ls.Arity) + (|> r.nat (r/map (|>> (n/% arity-limit) (n/max +1))))) (def: gen-function - (r;Random [ls;Arity Nat ls;Synthesis]) - (do r;Monad + (r.Random [ls.Arity Nat ls.Synthesis]) + (do r.Monad [arity arity - arg (|> r;nat (:: @ map (n.% arity))) - #let [functionS (` ("lux function" (~ (code;nat arity)) [] - ((~ (code;int (nat-to-int (n.inc arg)))))))]] + arg (|> r.nat (:: @ map (n/% arity))) + #let [functionS (` ("lux function" (~ (code.nat arity)) [] + ((~ (code.int (nat-to-int (n/inc arg)))))))]] (wrap [arity arg functionS]))) (context: "Function." (<| (times +100) (do @ [[arity arg functionS] gen-function - cut-off (|> r;nat (:: @ map (n.% arity))) - args (r;list arity r;nat) - #let [arg-value (maybe;assume (list;nth arg args)) - argsS (list/map code;nat args) - last-arg (n.dec arity) - cut-off (|> cut-off (n.min (n.dec last-arg)))]] + cut-off (|> r.nat (:: @ map (n/% arity))) + args (r.list arity r.nat) + #let [arg-value (maybe.assume (list.nth arg args)) + argsS (list/map code.nat args) + last-arg (n/dec arity) + cut-off (|> cut-off (n/min (n/dec last-arg)))]] ($_ seq (test "Can read arguments." - (|> (do macro;Monad - [runtime-bytecode @runtime;translate - sampleI (expressionT;translate (` ("lux call" (~ functionS) (~@ argsS))))] - (@eval;eval sampleI)) - (macro;run (init-compiler [])) - (case> (#e;Success valueT) - (n.= arg-value (:! Nat valueT)) + (|> (do macro.Monad + [runtime-bytecode @runtime.translate + sampleI (expressionT.translate (` ("lux call" (~ functionS) (~@ argsS))))] + (@eval.eval sampleI)) + (macro.run (init-compiler [])) + (case> (#e.Success valueT) + (n/= arg-value (:! Nat valueT)) - (#e;Error error) + (#e.Error error) false))) (test "Can partially apply functions." - (or (n.= +1 arity) - (|> (do macro;Monad - [#let [partial-arity (n.inc cut-off) - preS (list;take partial-arity argsS) - postS (list;drop partial-arity argsS)] - runtime-bytecode @runtime;translate - sampleI (expressionT;translate (` ("lux call" + (or (n/= +1 arity) + (|> (do macro.Monad + [#let [partial-arity (n/inc cut-off) + preS (list.take partial-arity argsS) + postS (list.drop partial-arity argsS)] + runtime-bytecode @runtime.translate + sampleI (expressionT.translate (` ("lux call" ("lux call" (~ functionS) (~@ preS)) (~@ postS))))] - (@eval;eval sampleI)) - (macro;run (init-compiler [])) - (case> (#e;Success valueT) - (n.= arg-value (:! Nat valueT)) + (@eval.eval sampleI)) + (macro.run (init-compiler [])) + (case> (#e.Success valueT) + (n/= arg-value (:! Nat valueT)) - (#e;Error error) + (#e.Error error) false)))) (test "Can read environment." - (or (n.= +1 arity) - (|> (do macro;Monad - [#let [env (|> (list;n.range +0 cut-off) - (list/map (|>. n.inc nat-to-int))) - super-arity (n.inc cut-off) - arg-var (if (n.<= cut-off arg) - (|> arg n.inc nat-to-int (i.* -1)) - (|> arg n.inc (n.- super-arity) nat-to-int)) - sub-arity (|> arity (n.- super-arity)) - functionS (` ("lux function" (~ (code;nat super-arity)) [] - ("lux function" (~ (code;nat sub-arity)) [(~@ (list/map code;int env))] - ((~ (code;int arg-var))))))] - runtime-bytecode @runtime;translate - sampleI (expressionT;translate (` ("lux call" (~ functionS) (~@ argsS))))] - (@eval;eval sampleI)) - (macro;run (init-compiler [])) - (case> (#e;Success valueT) - (n.= arg-value (:! Nat valueT)) + (or (n/= +1 arity) + (|> (do macro.Monad + [#let [env (|> (list.n/range +0 cut-off) + (list/map (|>> n/inc nat-to-int))) + super-arity (n/inc cut-off) + arg-var (if (n/<= cut-off arg) + (|> arg n/inc nat-to-int (i/* -1)) + (|> arg n/inc (n/- super-arity) nat-to-int)) + sub-arity (|> arity (n/- super-arity)) + functionS (` ("lux function" (~ (code.nat super-arity)) [] + ("lux function" (~ (code.nat sub-arity)) [(~@ (list/map code.int env))] + ((~ (code.int arg-var))))))] + runtime-bytecode @runtime.translate + sampleI (expressionT.translate (` ("lux call" (~ functionS) (~@ argsS))))] + (@eval.eval sampleI)) + (macro.run (init-compiler [])) + (case> (#e.Success valueT) + (n/= arg-value (:! Nat valueT)) - (#e;Error error) + (#e.Error error) false)))) )))) diff --git a/new-luxc/test/test/luxc/lang/translation/primitive.lux b/new-luxc/test/test/luxc/lang/translation/primitive.lux index ad4f57107..0d02c5ae7 100644 --- a/new-luxc/test/test/luxc/lang/translation/primitive.lux +++ b/new-luxc/test/test/luxc/lang/translation/primitive.lux @@ -1,4 +1,4 @@ -(;module: +(.module: lux (lux [io] (control [monad #+ do] @@ -11,50 +11,50 @@ [macro] (macro [code]) test) - (luxc (lang [";L" host] + (luxc (lang [".L" host] ["ls" synthesis] - (translation [";T" expression] - ["@;" runtime] - ["@;" eval] - ["@;" common]))) + (translation [".T" expression] + ["@." runtime] + ["@." eval] + ["@." common]))) (test/luxc common)) (context: "Primitives." (<| (times +100) (do @ - [%bool% r;bool - %nat% r;nat - %int% r;int - %deg% r;deg - %frac% r;frac - %text% (r;text +5)] + [%bool% r.bool + %nat% r.nat + %int% r.int + %deg% r.deg + %frac% r.frac + %text% (r.text +5)] (with-expansions [ (do-template [ ] [(test (format "Can translate " ".") - (|> (do macro;Monad - [sampleI (expressionT;translate ( ))] - (@eval;eval sampleI)) - (macro;run (init-compiler [])) - (case> (#e;Success valueT) + (|> (do macro.Monad + [sampleI (expressionT.translate ( ))] + (@eval.eval sampleI)) + (macro.run (init-compiler [])) + (case> (#e.Success valueT) ( (:! valueT)) _ false)))] - ["bool" Bool code;bool %bool% B/=] - ["nat" Nat code;nat %nat% n.=] - ["int" Int code;int %int% i.=] - ["deg" Deg code;deg %deg% d.=] - ["frac" Frac code;frac %frac% f.=] - ["text" Text code;text %text% T/=])] + ["bool" Bool code.bool %bool% B/=] + ["nat" Nat code.nat %nat% n/=] + ["int" Int code.int %int% i/=] + ["deg" Deg code.deg %deg% d/=] + ["frac" Frac code.frac %frac% f/=] + ["text" Text code.text %text% T/=])] ($_ seq (test "Can translate unit." - (|> (do macro;Monad - [sampleI (expressionT;translate (' []))] - (@eval;eval sampleI)) - (macro;run (init-compiler [])) - (case> (#e;Success valueT) - (is hostL;unit (:! Text valueT)) + (|> (do macro.Monad + [sampleI (expressionT.translate (' []))] + (@eval.eval sampleI)) + (macro.run (init-compiler [])) + (case> (#e.Success valueT) + (is hostL.unit (:! Text valueT)) _ false))) diff --git a/new-luxc/test/test/luxc/lang/translation/procedure/common.jvm.lux b/new-luxc/test/test/luxc/lang/translation/procedure/common.jvm.lux index 9eb5050bb..bdfae3a78 100644 --- a/new-luxc/test/test/luxc/lang/translation/procedure/common.jvm.lux +++ b/new-luxc/test/test/luxc/lang/translation/procedure/common.jvm.lux @@ -1,4 +1,4 @@ -(;module: +(.module: lux (lux [io] (control [monad #+ do] @@ -17,58 +17,58 @@ [host] test) (luxc (lang ["ls" synthesis] - (translation [";T" expression] - ["@;" eval] - ["@;" runtime] - ["@;" common]))) + (translation [".T" expression] + ["@." eval] + ["@." runtime] + ["@." common]))) (test/luxc common)) (context: "Bit procedures" (<| (times +100) (do @ - [param r;nat - subject r;nat] + [param r.nat + subject r.nat] (with-expansions [ (do-template [ ] [(test - (|> (do macro;Monad - [sampleI (expressionT;translate (` ( (~ (code;nat subject)) - (~ (code;nat param)))))] - (@eval;eval sampleI)) - (macro;run (init-compiler [])) - (case> (#e;Success valueT) - (n.= ( param subject) (:! Nat valueT)) + (|> (do macro.Monad + [sampleI (expressionT.translate (` ( (~ (code.nat subject)) + (~ (code.nat param)))))] + (@eval.eval sampleI)) + (macro.run (init-compiler [])) + (case> (#e.Success valueT) + (n/= ( param subject) (:! Nat valueT)) _ false)))] - ["lux bit and" bit;and] - ["lux bit or" bit;or] - ["lux bit xor" bit;xor] - ["lux bit shift-left" bit;shift-left] - ["lux bit unsigned-shift-right" bit;shift-right] + ["lux bit and" bit.and] + ["lux bit or" bit.or] + ["lux bit xor" bit.xor] + ["lux bit shift-left" bit.shift-left] + ["lux bit unsigned-shift-right" bit.shift-right] )] ($_ seq (test "bit count" - (|> (do macro;Monad - [sampleI (expressionT;translate (` ("lux bit count" (~ (code;nat subject)))))] - (@eval;eval sampleI)) - (macro;run (init-compiler [])) - (case> (#e;Success valueT) - (n.= (bit;count subject) (:! Nat valueT)) + (|> (do macro.Monad + [sampleI (expressionT.translate (` ("lux bit count" (~ (code.nat subject)))))] + (@eval.eval sampleI)) + (macro.run (init-compiler [])) + (case> (#e.Success valueT) + (n/= (bit.count subject) (:! Nat valueT)) _ false))) (test "bit shift-right" - (|> (do macro;Monad - [sampleI (expressionT;translate (` ("lux bit shift-right" - (~ (code;int (nat-to-int subject))) - (~ (code;nat param)))))] - (@eval;eval sampleI)) - (macro;run (init-compiler [])) - (case> (#e;Success valueT) - (i.= (bit;signed-shift-right param (nat-to-int subject)) + (|> (do macro.Monad + [sampleI (expressionT.translate (` ("lux bit shift-right" + (~ (code.int (nat-to-int subject))) + (~ (code.nat param)))))] + (@eval.eval sampleI)) + (macro.run (init-compiler [])) + (case> (#e.Success valueT) + (i/= (bit.signed-shift-right param (nat-to-int subject)) (:! Int valueT)) _ @@ -78,17 +78,17 @@ (context: "Nat procedures" (<| (times +100) (do @ - [param (|> r;nat (r;filter (|>. (n.= +0) not))) - subject r;nat] + [param (|> r.nat (r.filter (|>> (n/= +0) not))) + subject r.nat] (`` ($_ seq (~~ (do-template [ ] [(test - (|> (do macro;Monad - [sampleI (expressionT;translate (` ()))] - (@eval;eval sampleI)) - (macro;run (init-compiler [])) - (case> (#e;Success valueT) - (n.= (:! Nat valueT)) + (|> (do macro.Monad + [sampleI (expressionT.translate (` ()))] + (@eval.eval sampleI)) + (macro.run (init-compiler [])) + (case> (#e.Success valueT) + (n/= (:! Nat valueT)) _ false)))] @@ -98,55 +98,55 @@ )) (~~ (do-template [ ] [(test - (|> (do macro;Monad - [sampleI (expressionT;translate (` ( (~ (code;nat subject)))))] - (@eval;eval sampleI)) - (macro;run (init-compiler [])) - (case> (#e;Success valueT) + (|> (do macro.Monad + [sampleI (expressionT.translate (` ( (~ (code.nat subject)))))] + (@eval.eval sampleI)) + (macro.run (init-compiler [])) + (case> (#e.Success valueT) ( ( subject) (:! valueT)) _ false)))] - ["lux nat to-int" Int nat-to-int i.=] - ["lux nat to-char" Text text;from-code text/=] + ["lux nat to-int" Int nat-to-int i/=] + ["lux nat to-char" Text text.from-code text/=] )) (~~ (do-template [ ] [(test - (|> (do macro;Monad - [runtime-bytecode @runtime;translate - sampleI (expressionT;translate (` ( (~ (code;nat subject)) (~ (code;nat param)))))] - (@eval;eval sampleI)) - (macro;run (init-compiler [])) - (case> (#e;Success valueT) + (|> (do macro.Monad + [runtime-bytecode @runtime.translate + sampleI (expressionT.translate (` ( (~ (code.nat subject)) (~ (code.nat param)))))] + (@eval.eval sampleI)) + (macro.run (init-compiler [])) + (case> (#e.Success valueT) ( ( param subject) (:! valueT)) _ false)))] - ["lux nat +" n.+ Nat n.=] - ["lux nat -" n.- Nat n.=] - ["lux nat *" n.* Nat n.=] - ["lux nat /" n./ Nat n.=] - ["lux nat %" n.% Nat n.=] - ["lux nat =" n.= Bool bool/=] - ["lux nat <" n.< Bool bool/=] + ["lux nat +" n/+ Nat n/=] + ["lux nat -" n/- Nat n/=] + ["lux nat *" n/* Nat n/=] + ["lux nat /" n// Nat n/=] + ["lux nat %" n/% Nat n/=] + ["lux nat =" n/= Bool bool/=] + ["lux nat <" n/< Bool bool/=] )) ))))) (context: "Int procedures" (<| (times +100) (do @ - [param (|> r;int (r;filter (|>. (i.= 0) not))) - subject r;int] + [param (|> r.int (r.filter (|>> (i/= 0) not))) + subject r.int] (with-expansions [ (do-template [ ] [(test - (|> (do macro;Monad - [sampleI (expressionT;translate (` ()))] - (@eval;eval sampleI)) - (macro;run (init-compiler [])) - (case> (#e;Success valueT) - (i.= (:! Int valueT)) + (|> (do macro.Monad + [sampleI (expressionT.translate (` ()))] + (@eval.eval sampleI)) + (macro.run (init-compiler [])) + (case> (#e.Success valueT) + (i/= (:! Int valueT)) _ false)))] @@ -156,39 +156,39 @@ ) (do-template [ ] [(test - (|> (do macro;Monad - [sampleI (expressionT;translate (` ( (~ (code;int subject)))))] - (@eval;eval sampleI)) - (macro;run (init-compiler [])) - (case> (#e;Success valueT) + (|> (do macro.Monad + [sampleI (expressionT.translate (` ( (~ (code.int subject)))))] + (@eval.eval sampleI)) + (macro.run (init-compiler [])) + (case> (#e.Success valueT) ( ( subject) (:! valueT)) _ false)))] - ["lux int to-nat" Nat int-to-nat n.=] - ["lux int to-frac" Frac int-to-frac f.=] + ["lux int to-nat" Nat int-to-nat n/=] + ["lux int to-frac" Frac int-to-frac f/=] ) (do-template [ ] [(test - (|> (do macro;Monad - [runtime-bytecode @runtime;translate - sampleI (expressionT;translate (` ( (~ (code;int subject)) (~ (code;int param)))))] - (@eval;eval sampleI)) - (macro;run (init-compiler [])) - (case> (#e;Success valueT) + (|> (do macro.Monad + [runtime-bytecode @runtime.translate + sampleI (expressionT.translate (` ( (~ (code.int subject)) (~ (code.int param)))))] + (@eval.eval sampleI)) + (macro.run (init-compiler [])) + (case> (#e.Success valueT) ( ( param subject) (:! valueT)) _ false)))] - ["lux int +" i.+ Int i.=] - ["lux int -" i.- Int i.=] - ["lux int *" i.* Int i.=] - ["lux int /" i./ Int i.=] - ["lux int %" i.% Int i.=] - ["lux int =" i.= Bool bool/=] - ["lux int <" i.< Bool bool/=] + ["lux int +" i/+ Int i/=] + ["lux int -" i/- Int i/=] + ["lux int *" i/* Int i/=] + ["lux int /" i// Int i/=] + ["lux int %" i/% Int i/=] + ["lux int =" i/= Bool bool/=] + ["lux int <" i/< Bool bool/=] )] ($_ seq @@ -199,28 +199,28 @@ (context: "Frac procedures [Part 1]" (<| (times +100) (do @ - [param (|> r;frac (r;filter (|>. (f.= 0.0) not))) - subject r;frac] + [param (|> r.frac (r.filter (|>> (f/= 0.0) not))) + subject r.frac] (with-expansions [ (do-template [ ] [(test - (|> (do macro;Monad - [runtime-bytecode @runtime;translate - sampleI (expressionT;translate (` ( (~ (code;frac subject)) (~ (code;frac param)))))] - (@eval;eval sampleI)) - (macro;run (init-compiler [])) - (case> (#e;Success valueT) + (|> (do macro.Monad + [runtime-bytecode @runtime.translate + sampleI (expressionT.translate (` ( (~ (code.frac subject)) (~ (code.frac param)))))] + (@eval.eval sampleI)) + (macro.run (init-compiler [])) + (case> (#e.Success valueT) ( ( param subject) (:! valueT)) _ false)))] - ["lux frac +" f.+ Frac f.=] - ["lux frac -" f.- Frac f.=] - ["lux frac *" f.* Frac f.=] - ["lux frac /" f./ Frac f.=] - ["lux frac %" f.% Frac f.=] - ["lux frac =" f.= Bool bool/=] - ["lux frac <" f.< Bool bool/=] + ["lux frac +" f/+ Frac f/=] + ["lux frac -" f/- Frac f/=] + ["lux frac *" f/* Frac f/=] + ["lux frac /" f// Frac f/=] + ["lux frac %" f/% Frac f/=] + ["lux frac =" f/= Bool bool/=] + ["lux frac <" f/< Bool bool/=] )] ($_ seq @@ -229,55 +229,55 @@ (context: "Frac procedures [Part 2]" (<| (times +100) (do @ - [param (|> r;frac (r;filter (|>. (f.= 0.0) not))) - subject r;frac] + [param (|> r.frac (r.filter (|>> (f/= 0.0) not))) + subject r.frac] (with-expansions [ (do-template [ ] [(test - (|> (do macro;Monad - [sampleI (expressionT;translate (` ()))] - (@eval;eval sampleI)) - (macro;run (init-compiler [])) - (case> (#e;Success valueT) + (|> (do macro.Monad + [sampleI (expressionT.translate (` ()))] + (@eval.eval sampleI)) + (macro.run (init-compiler [])) + (case> (#e.Success valueT) ( (:! Frac valueT)) _ false)))] - ["lux frac min" (f.= real/bottom)] - ["lux frac max" (f.= real/top)] - ["lux frac not-a-number" number;not-a-number?] - ["lux frac positive-infinity" (f.= number;positive-infinity)] - ["lux frac negative-infinity" (f.= number;negative-infinity)] - ["lux frac smallest" (f.= ("lux frac smallest-value"))] + ["lux frac min" (f/= real/bottom)] + ["lux frac max" (f/= real/top)] + ["lux frac not-a-number" number.not-a-number?] + ["lux frac positive-infinity" (f/= number.positive-infinity)] + ["lux frac negative-infinity" (f/= number.negative-infinity)] + ["lux frac smallest" (f/= ("lux frac smallest"))] ) (do-template [ ] [(test - (|> (do macro;Monad - [runtime-bytecode @runtime;translate - sampleI (expressionT;translate (` ( (~ (code;frac subject)))))] - (@eval;eval sampleI)) - (macro;run (init-compiler [])) - (case> (#e;Success valueT) + (|> (do macro.Monad + [runtime-bytecode @runtime.translate + sampleI (expressionT.translate (` ( (~ (code.frac subject)))))] + (@eval.eval sampleI)) + (macro.run (init-compiler [])) + (case> (#e.Success valueT) ( ( subject) (:! valueT)) _ false)))] - ["lux frac to-int" Int frac-to-int i.=] - ["lux frac to-deg" Deg frac-to-deg d.=] + ["lux frac to-int" Int frac-to-int i/=] + ["lux frac to-deg" Deg frac-to-deg d/=] )] ($_ seq (test "frac encode|decode" - (|> (do macro;Monad - [runtime-bytecode @runtime;translate - sampleI (expressionT;translate (` ("lux frac decode" ("lux frac encode" (~ (code;frac subject))))))] - (@eval;eval sampleI)) - (macro;run (init-compiler [])) - (case> (^multi (#e;Success valueT) - [(:! (Maybe Frac) valueT) (#;Some value)]) - (f.= subject value) + (|> (do macro.Monad + [runtime-bytecode @runtime.translate + sampleI (expressionT.translate (` ("lux frac decode" ("lux frac encode" (~ (code.frac subject))))))] + (@eval.eval sampleI)) + (macro.run (init-compiler [])) + (case> (^multi (#e.Success valueT) + [(:! (Maybe Frac) valueT) (#.Some value)]) + (f/= subject value) _ false))) @@ -286,25 +286,25 @@ (def: (above-threshold value) (-> Deg Deg) (let [threshold .000000001 #( 1/(2^30) )#] - (if (d.< threshold value) - (d.+ threshold value) + (if (d/< threshold value) + (d/+ threshold value) value))) (context: "Deg procedures" (<| (times +100) (do @ - [param (|> r;deg (:: @ map above-threshold)) - special r;nat - subject (|> r;deg (:: @ map above-threshold))] + [param (|> r.deg (:: @ map above-threshold)) + special r.nat + subject (|> r.deg (:: @ map above-threshold))] (`` ($_ seq (~~ (do-template [ ] [(test - (|> (do macro;Monad - [sampleI (expressionT;translate (` ()))] - (@eval;eval sampleI)) - (macro;run (init-compiler [])) - (case> (#e;Success valueT) - (d.= (:! Deg valueT)) + (|> (do macro.Monad + [sampleI (expressionT.translate (` ()))] + (@eval.eval sampleI)) + (macro.run (init-compiler [])) + (case> (#e.Success valueT) + (d/= (:! Deg valueT)) _ false)))] @@ -314,54 +314,54 @@ )) (~~ (do-template [ ] [(test - (|> (do macro;Monad - [runtime-bytecode @runtime;translate - sampleI (expressionT;translate (` ( (~ (code;deg subject)))))] - (@eval;eval sampleI)) - (macro;run (init-compiler [])) - (case> (#e;Success valueT) + (|> (do macro.Monad + [runtime-bytecode @runtime.translate + sampleI (expressionT.translate (` ( (~ (code.deg subject)))))] + (@eval.eval sampleI)) + (macro.run (init-compiler [])) + (case> (#e.Success valueT) ( ( subject) (:! valueT)) _ false)))] - ["lux deg to-frac" Frac deg-to-frac f.=] + ["lux deg to-frac" Frac deg-to-frac f/=] )) (~~ (do-template [ ] [(test - (|> (do macro;Monad - [runtime-bytecode @runtime;translate - sampleI (expressionT;translate (` ( (~ (code;deg subject)) (~ (code;deg param)))))] - (@eval;eval sampleI)) - (macro;run (init-compiler [])) - (case> (#e;Success valueT) + (|> (do macro.Monad + [runtime-bytecode @runtime.translate + sampleI (expressionT.translate (` ( (~ (code.deg subject)) (~ (code.deg param)))))] + (@eval.eval sampleI)) + (macro.run (init-compiler [])) + (case> (#e.Success valueT) ( ( param subject) (:! valueT)) _ false)))] - ["lux deg +" d.+ Deg d.=] - ["lux deg -" d.- Deg d.=] - ["lux deg *" d.* Deg d.=] - ["lux deg /" d./ Deg d.=] - ["lux deg %" d.% Deg d.=] - ["lux deg =" d.= Bool bool/=] - ["lux deg <" d.< Bool bool/=] + ["lux deg +" d/+ Deg d/=] + ["lux deg -" d/- Deg d/=] + ["lux deg *" d/* Deg d/=] + ["lux deg /" d// Deg d/=] + ["lux deg %" d/% Deg d/=] + ["lux deg =" d/= Bool bool/=] + ["lux deg <" d/< Bool bool/=] )) (~~ (do-template [ ] [(test - (|> (do macro;Monad - [runtime-bytecode @runtime;translate - sampleI (expressionT;translate (` ( (~ (code;deg subject)) (~ (code;nat special)))))] - (@eval;eval sampleI)) - (macro;run (init-compiler [])) - (case> (#e;Success valueT) + (|> (do macro.Monad + [runtime-bytecode @runtime.translate + sampleI (expressionT.translate (` ( (~ (code.deg subject)) (~ (code.nat special)))))] + (@eval.eval sampleI)) + (macro.run (init-compiler [])) + (case> (#e.Success valueT) ( ( special subject) (:! valueT)) _ false)))] - ["lux deg scale" d.scale Deg d.=] - ["lux deg reciprocal" d.reciprocal Deg d.=] + ["lux deg scale" d/scale Deg d/=] + ["lux deg reciprocal" d/reciprocal Deg d/=] )) ))))) diff --git a/new-luxc/test/test/luxc/lang/translation/procedure/host.jvm.lux b/new-luxc/test/test/luxc/lang/translation/procedure/host.jvm.lux index f5b1e97df..5c188da45 100644 --- a/new-luxc/test/test/luxc/lang/translation/procedure/host.jvm.lux +++ b/new-luxc/test/test/luxc/lang/translation/procedure/host.jvm.lux @@ -1,4 +1,4 @@ -(;module: +(.module: lux (lux [io] (control [monad #+ do] @@ -16,39 +16,39 @@ (macro [code]) [host] test) - (luxc (lang [";L" host] + (luxc (lang [".L" host] ["ls" synthesis] - (translation [";T" expression] - ["@;" eval] - ["@;" runtime] - ["@;" common]))) + (translation [".T" expression] + ["@." eval] + ["@." runtime] + ["@." common]))) (test/luxc common)) (context: "Conversions [Part 1]" (<| (times +100) (do @ - [int-sample (|> r;int (:: @ map (i.% 128))) + [int-sample (|> r.int (:: @ map (i/% 128))) #let [frac-sample (int-to-frac int-sample)]] (with-expansions [<2step> (do-template [ ] [(test (format " / " ) - (|> (do macro;Monad - [sampleI (expressionT;translate (|> (~ ( )) (`)))] - (@eval;eval sampleI)) - (macro;run (init-compiler [])) - (case> (#e;Success valueT) + (|> (do macro.Monad + [sampleI (expressionT.translate (|> (~ ( )) (`)))] + (@eval.eval sampleI)) + (macro.run (init-compiler [])) + (case> (#e.Success valueT) ( (:! valueT)) - (#e;Error error) + (#e.Error error) false)))] - ["jvm convert double-to-float" "jvm convert float-to-double" code;frac frac-sample Frac f.=] - ["jvm convert double-to-int" "jvm convert int-to-double" code;frac frac-sample Frac f.=] - ["jvm convert double-to-long" "jvm convert long-to-double" code;frac frac-sample Frac f.=] + ["jvm convert double-to-float" "jvm convert float-to-double" code.frac frac-sample Frac f/=] + ["jvm convert double-to-int" "jvm convert int-to-double" code.frac frac-sample Frac f/=] + ["jvm convert double-to-long" "jvm convert long-to-double" code.frac frac-sample Frac f/=] - ["jvm convert long-to-float" "jvm convert float-to-long" code;int int-sample Int i.=] - ["jvm convert long-to-int" "jvm convert int-to-long" code;int int-sample Int i.=] - ["jvm convert long-to-short" "jvm convert short-to-long" code;int int-sample Int i.=] - ["jvm convert long-to-byte" "jvm convert byte-to-long" code;int int-sample Int i.=] + ["jvm convert long-to-float" "jvm convert float-to-long" code.int int-sample Int i/=] + ["jvm convert long-to-int" "jvm convert int-to-long" code.int int-sample Int i/=] + ["jvm convert long-to-short" "jvm convert short-to-long" code.int int-sample Int i/=] + ["jvm convert long-to-byte" "jvm convert byte-to-long" code.int int-sample Int i/=] )] ($_ seq <2step> @@ -57,65 +57,65 @@ (context: "Conversions [Part 2]" (<| (times +100) (do @ - [int-sample (|> r;int (:: @ map (|>. (i.% 128) int/abs))) + [int-sample (|> r.int (:: @ map (|>> (i/% 128) int/abs))) #let [frac-sample (int-to-frac int-sample)]] (`` ($_ seq (~~ (do-template [ ] [(test (format " / " " / " ) - (|> (do macro;Monad - [sampleI (expressionT;translate (|> (~ ( )) (`)))] - (@eval;eval sampleI)) - (macro;run (init-compiler [])) - (case> (#e;Success valueT) + (|> (do macro.Monad + [sampleI (expressionT.translate (|> (~ ( )) (`)))] + (@eval.eval sampleI)) + (macro.run (init-compiler [])) + (case> (#e.Success valueT) ( (:! valueT)) - (#e;Error error) + (#e.Error error) false)))] - ["jvm convert long-to-int" "jvm convert int-to-char" "jvm convert char-to-long" code;int int-sample Int i.=] - ["jvm convert long-to-int" "jvm convert int-to-byte" "jvm convert byte-to-long" code;int int-sample Int i.=] - ["jvm convert long-to-int" "jvm convert int-to-short" "jvm convert short-to-long" code;int int-sample Int i.=] - ["jvm convert long-to-float" "jvm convert float-to-int" "jvm convert int-to-long" code;int int-sample Int i.=] - ["jvm convert long-to-int" "jvm convert int-to-float" "jvm convert float-to-long" code;int int-sample Int i.=] + ["jvm convert long-to-int" "jvm convert int-to-char" "jvm convert char-to-long" code.int int-sample Int i/=] + ["jvm convert long-to-int" "jvm convert int-to-byte" "jvm convert byte-to-long" code.int int-sample Int i/=] + ["jvm convert long-to-int" "jvm convert int-to-short" "jvm convert short-to-long" code.int int-sample Int i/=] + ["jvm convert long-to-float" "jvm convert float-to-int" "jvm convert int-to-long" code.int int-sample Int i/=] + ["jvm convert long-to-int" "jvm convert int-to-float" "jvm convert float-to-long" code.int int-sample Int i/=] )) ))))) (context: "Conversions [Part 3]" (<| (times +100) (do @ - [int-sample (|> r;int (:: @ map (|>. (i.% 128) int/abs))) + [int-sample (|> r.int (:: @ map (|>> (i/% 128) int/abs))) #let [frac-sample (int-to-frac int-sample)]] (`` ($_ seq (~~ (do-template [ ] [(test (format " / " " / " ) - (|> (do macro;Monad - [sampleI (expressionT;translate (|> (~ ( )) (`)))] - (@eval;eval sampleI)) - (macro;run (init-compiler [])) - (case> (#e;Success valueT) + (|> (do macro.Monad + [sampleI (expressionT.translate (|> (~ ( )) (`)))] + (@eval.eval sampleI)) + (macro.run (init-compiler [])) + (case> (#e.Success valueT) ( (:! valueT)) - (#e;Error error) + (#e.Error error) false)))] - ["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.=] - ["jvm convert long-to-int" "jvm convert int-to-char" "jvm convert char-to-short" "jvm convert short-to-long" code;int int-sample Int i.=] - ["jvm convert long-to-int" "jvm convert int-to-char" "jvm convert char-to-int" "jvm convert int-to-long" code;int int-sample Int i.=] + ["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/=] + ["jvm convert long-to-int" "jvm convert int-to-char" "jvm convert char-to-short" "jvm convert short-to-long" code.int int-sample Int i/=] + ["jvm convert long-to-int" "jvm convert int-to-char" "jvm convert char-to-int" "jvm convert int-to-long" code.int int-sample Int i/=] )) ))))) (def: gen-nat - (r;Random Nat) - (|> r;nat - (r/map (n.% +128)) - (r;filter (|>. (n.= +0) not)))) + (r.Random Nat) + (|> r.nat + (r/map (n/% +128)) + (r.filter (|>> (n/= +0) not)))) (def: gen-int - (r;Random Int) + (r.Random Int) (|> gen-nat (r/map nat-to-int))) (def: gen-frac - (r;Random Frac) + (r.Random Frac) (|> gen-int (r/map int-to-frac))) (do-template [ <+> <-> <*> <%> 
 ]
@@ -126,17 +126,17 @@
             #let [subject ( param)]]
            (with-expansions [ (do-template [ ]
                                        [(test 
-                                              (|> (do macro;Monad
-                                                    [sampleI (expressionT;translate (` ( ((~ (code;text ))
+                                              (|> (do macro.Monad
+                                                    [sampleI (expressionT.translate (` ( ((~ (code.text ))
                                                                                                 (
 (~ ( subject)))
                                                                                                 (
 (~ ( param)))))))]
-                                                    (@eval;eval sampleI))
-                                                  (macro;run (init-compiler []))
-                                                  (case> (#e;Success valueT)
+                                                    (@eval.eval sampleI))
+                                                  (macro.run (init-compiler []))
+                                                  (case> (#e.Success valueT)
                                                          ( ( param subject)
                                                                  (:!  valueT))
 
-                                                         (#e;Error error)
+                                                         (#e.Error error)
                                                          false)))]
 
                                        [(format "jvm "  " +") <+>]
@@ -149,10 +149,10 @@
                  
                  )))))]
 
-  ["int" gen-int code;int Int i.= (i.* 10) i.+ i.- i.* i./ i.% "jvm convert long-to-int" "jvm convert int-to-long"]
-  ["long" gen-int code;int Int i.= (i.* 10) i.+ i.- i.* i./ i.% "lux noop" "lux noop"]
-  ["float" gen-frac code;frac Frac f.= (f.* 10.0) f.+ f.- f.* f./ f.% "jvm convert double-to-float" "jvm convert float-to-double"]
-  ["double" gen-frac code;frac Frac f.= (f.* 10.0) f.+ f.- f.* f./ f.% "lux noop" "lux noop"]
+  ["int" gen-int code.int Int i/= (i/* 10) i/+ i/- i/* i// i/% "jvm convert long-to-int" "jvm convert int-to-long"]
+  ["long" gen-int code.int Int i/= (i/* 10) i/+ i/- i/* i// i/% "lux noop" "lux noop"]
+  ["float" gen-frac code.frac Frac f/= (f/* 10.0) f/+ f/- f/* f// f/% "jvm convert double-to-float" "jvm convert float-to-double"]
+  ["double" gen-frac code.frac Frac f/= (f/* 10.0) f/+ f/- f/* f// f/% "lux noop" "lux noop"]
   )
 
 (do-template [  ]
@@ -164,22 +164,22 @@
            (`` ($_ seq
                    (~~ (do-template [ ]
                          [(test 
-                                (|> (do macro;Monad
-                                      [sampleI (expressionT;translate (` ( ((~ (code;text ))
-                                                                                  ( (~ (code;nat subject)))
-                                                                                  ( (~ (code;nat param)))))))]
-                                      (@eval;eval sampleI))
-                                    (macro;run (init-compiler []))
-                                    (case> (#e;Success valueT)
-                                           (n.= ( param subject)
+                                (|> (do macro.Monad
+                                      [sampleI (expressionT.translate (` ( ((~ (code.text ))
+                                                                                  ( (~ (code.nat subject)))
+                                                                                  ( (~ (code.nat param)))))))]
+                                      (@eval.eval sampleI))
+                                    (macro.run (init-compiler []))
+                                    (case> (#e.Success valueT)
+                                           (n/= ( param subject)
                                                 (:! Nat valueT))
 
-                                           (#e;Error error)
+                                           (#e.Error error)
                                            false)))]
 
-                         [(format "jvm "  " and") bit;and]
-                         [(format "jvm "  " or") bit;or]
-                         [(format "jvm "  " xor") bit;xor]
+                         [(format "jvm "  " and") bit.and]
+                         [(format "jvm "  " or") bit.or]
+                         [(format "jvm "  " xor") bit.xor]
                          ))
                    )))))]
 
@@ -193,26 +193,26 @@
          (do @
            [param gen-nat
             subject gen-nat
-            #let [shift (n.% +10 param)]]
+            #let [shift (n/% +10 param)]]
            (`` ($_ seq
                    (~~ (do-template [     
]
                          [(test 
-                                (|> (do macro;Monad
-                                      [sampleI (expressionT;translate (` ( ((~ (code;text ))
+                                (|> (do macro.Monad
+                                      [sampleI (expressionT.translate (` ( ((~ (code.text ))
                                                                                   ( (~ (
 subject)))
-                                                                                  ("jvm convert long-to-int" (~ (code;nat shift)))))))]
-                                      (@eval;eval sampleI))
-                                    (macro;run (init-compiler []))
-                                    (case> (#e;Success valueT)
+                                                                                  ("jvm convert long-to-int" (~ (code.nat shift)))))))]
+                                      (@eval.eval sampleI))
+                                    (macro.run (init-compiler []))
+                                    (case> (#e.Success valueT)
                                            ( ( shift ( subject))
                                                    (:!  valueT))
 
-                                           (#e;Error error)
+                                           (#e.Error error)
                                            false)))]
 
-                         [(format "jvm "  " shl") bit;shift-left Nat n.= id code;nat]
-                         [(format "jvm "  " shr") bit;signed-shift-right Int i.= nat-to-int (|>. nat-to-int code;int)]
-                         [(format "jvm "  " ushr") bit;shift-right Nat n.= id code;nat]
+                         [(format "jvm "  " shl") bit.shift-left Nat n/= id code.nat]
+                         [(format "jvm "  " shr") bit.signed-shift-right Int i/= nat-to-int (|>> nat-to-int code.int)]
+                         [(format "jvm "  " ushr") bit.shift-right Nat n/= id code.nat]
                          ))
                    )))))]
 
@@ -228,17 +228,17 @@
             subject ]
            (with-expansions [ (do-template [ ]
                                        [(test 
-                                              (|> (do macro;Monad
-                                                    [sampleI (expressionT;translate (` ((~ (code;text ))
+                                              (|> (do macro.Monad
+                                                    [sampleI (expressionT.translate (` ((~ (code.text ))
                                                                                         (
 (~ ( subject)))
                                                                                         (
 (~ ( param))))))]
-                                                    (@eval;eval sampleI))
-                                                  (macro;run (init-compiler []))
-                                                  (case> (#e;Success valueT)
+                                                    (@eval.eval sampleI))
+                                                  (macro.run (init-compiler []))
+                                                  (case> (#e.Success valueT)
                                                          (bool/= ( param subject)
                                                                  (:! Bool valueT))
 
-                                                         (#e;Error error)
+                                                         (#e.Error error)
                                                          false)))]
 
                                        [(format "jvm "  " =") <=>]
@@ -248,68 +248,68 @@
                  
                  )))))]
 
-  ["int" gen-int code;int i.= i.< "jvm convert long-to-int"]
-  ["long" gen-int code;int i.= i.< "lux noop"]
-  ["float" gen-frac code;frac f.= f.< "jvm convert double-to-float"]
-  ["double" gen-frac code;frac f.= f.< "lux noop"]
-  ["char" gen-int code;int i.= i.< "jvm convert long-to-char"]
+  ["int" gen-int code.int i/= i/< "jvm convert long-to-int"]
+  ["long" gen-int code.int i/= i/< "lux noop"]
+  ["float" gen-frac code.frac f/= f/< "jvm convert double-to-float"]
+  ["double" gen-frac code.frac f/= f/< "lux noop"]
+  ["char" gen-int code.int i/= i/< "jvm convert long-to-char"]
   )
 
 (def: (jvm//array//new dimension class size)
-  (-> Nat Text Nat ls;Synthesis)
-  (` ("jvm array new" (~ (code;nat dimension)) (~ (code;text class)) (~ (code;nat size)))))
+  (-> Nat Text Nat ls.Synthesis)
+  (` ("jvm array new" (~ (code.nat dimension)) (~ (code.text class)) (~ (code.nat size)))))
 
 (def: (jvm//array//write class idx inputS arrayS)
-  (-> Text Nat ls;Synthesis ls;Synthesis ls;Synthesis)
-  (` ("jvm array write" (~ (code;text class)) (~ (code;nat idx)) (~ inputS) (~ arrayS))))
+  (-> Text Nat ls.Synthesis ls.Synthesis ls.Synthesis)
+  (` ("jvm array write" (~ (code.text class)) (~ (code.nat idx)) (~ inputS) (~ arrayS))))
 
 (def: (jvm//array//read class idx arrayS)
-  (-> Text Nat ls;Synthesis ls;Synthesis)
-  (` ("jvm array read" (~ (code;text class)) (~ (code;nat idx)) (~ arrayS))))
+  (-> Text Nat ls.Synthesis ls.Synthesis)
+  (` ("jvm array read" (~ (code.text class)) (~ (code.nat idx)) (~ arrayS))))
 
 (context: "Array [Part 1]"
   (<| (times +100)
       (do @
-        [size (|> r;nat (:: @ map (|>. (n.% +10) (n.max +1))))
-         idx (|> r;nat (:: @ map (n.% size)))
-         valueZ r;bool
+        [size (|> r.nat (:: @ map (|>> (n/% +10) (n/max +1))))
+         idx (|> r.nat (:: @ map (n/% size)))
+         valueZ r.bool
          valueB gen-int
          valueS gen-int
          valueI gen-int
-         valueL r;int
+         valueL r.int
          valueF gen-frac
-         valueD r;frac
+         valueD r.frac
          valueC gen-int]
         (with-expansions [ (do-template [     ]
                                     [(test 
-                                           (|> (do macro;Monad
-                                                 [sampleI (expressionT;translate (|> (jvm//array//new +0  size)
+                                           (|> (do macro.Monad
+                                                 [sampleI (expressionT.translate (|> (jvm//array//new +0  size)
                                                                                      (jvm//array//write  idx )
                                                                                      (jvm//array//read  idx)
                                                                                      (~)
                                                                                      
                                                                                      (`)))]
-                                                 (@eval;eval sampleI))
-                                               (macro;run (init-compiler []))
-                                               (case> (#e;Success outputZ)
+                                                 (@eval.eval sampleI))
+                                               (macro.run (init-compiler []))
+                                               (case> (#e.Success outputZ)
                                                       (  (:!  outputZ))
 
-                                                      (#e;Error error)
+                                                      (#e.Error error)
                                                       false)))]
 
-                                    ["boolean" Bool valueZ bool/= (code;bool valueZ)
+                                    ["boolean" Bool valueZ bool/= (code.bool valueZ)
                                      "lux noop"]
-                                    ["byte" Int valueB i.= (|> (code;int valueB) (~) "jvm convert long-to-byte" (`))
+                                    ["byte" Int valueB i/= (|> (code.int valueB) (~) "jvm convert long-to-byte" (`))
                                      "jvm convert byte-to-long"]
-                                    ["short" Int valueS i.= (|> (code;int valueS) (~) "jvm convert long-to-short" (`))
+                                    ["short" Int valueS i/= (|> (code.int valueS) (~) "jvm convert long-to-short" (`))
                                      "jvm convert short-to-long"]
-                                    ["int" Int valueI i.= (|> (code;int valueI) (~) "jvm convert long-to-int" (`))
+                                    ["int" Int valueI i/= (|> (code.int valueI) (~) "jvm convert long-to-int" (`))
                                      "jvm convert int-to-long"]
-                                    ["long" Int valueL i.= (code;int valueL)
+                                    ["long" Int valueL i/= (code.int valueL)
                                      "lux noop"]
-                                    ["float" Frac valueF f.= (|> (code;frac valueF) (~) "jvm convert double-to-float" (`))
+                                    ["float" Frac valueF f/= (|> (code.frac valueF) (~) "jvm convert double-to-float" (`))
                                      "jvm convert float-to-double"]
-                                    ["double" Frac valueD f.= (code;frac valueD)
+                                    ["double" Frac valueD f/= (code.frac valueD)
                                      "lux noop"]
                                     )]
           ($_ seq
@@ -319,72 +319,72 @@
 (context: "Array [Part 2]"
   (<| (times +100)
       (do @
-        [size (|> r;nat (:: @ map (|>. (n.% +10) (n.max +1))))
-         idx (|> r;nat (:: @ map (n.% size)))
-         valueZ r;bool
+        [size (|> r.nat (:: @ map (|>> (n/% +10) (n/max +1))))
+         idx (|> r.nat (:: @ map (n/% size)))
+         valueZ r.bool
          valueB gen-int
          valueS gen-int
          valueI gen-int
-         valueL r;int
+         valueL r.int
          valueF gen-frac
-         valueD r;frac
+         valueD r.frac
          valueC gen-int]
         (with-expansions [ (do-template [     ]
                                     [(test 
-                                           (|> (do macro;Monad
-                                                 [sampleI (expressionT;translate (|> (jvm//array//new +0  size)
+                                           (|> (do macro.Monad
+                                                 [sampleI (expressionT.translate (|> (jvm//array//new +0  size)
                                                                                      (jvm//array//write  idx )
                                                                                      (jvm//array//read  idx)
                                                                                      (~)
                                                                                      
                                                                                      (`)))]
-                                                 (@eval;eval sampleI))
-                                               (macro;run (init-compiler []))
-                                               (case> (#e;Success outputT)
+                                                 (@eval.eval sampleI))
+                                               (macro.run (init-compiler []))
+                                               (case> (#e.Success outputT)
                                                       (  (:!  outputT))
 
-                                                      (#e;Error error)
+                                                      (#e.Error error)
                                                       false)))]
 
-                                    ["char" Int valueC i.=
-                                     (|> (code;int valueC) (~) "jvm convert long-to-int" "jvm convert int-to-char" (`))
+                                    ["char" Int valueC i/=
+                                     (|> (code.int valueC) (~) "jvm convert long-to-int" "jvm convert int-to-char" (`))
                                      "jvm convert char-to-long"]
-                                    ["java.lang.Long" Int valueL i.=
-                                     (code;int valueL)
+                                    ["java.lang.Long" Int valueL i/=
+                                     (code.int valueL)
                                      "lux noop"]
                                     )]
           ($_ seq
               
               (test "java.lang.Double (level 1)"
-                    (|> (do macro;Monad
-                          [#let [inner (|> ("jvm array new" +0 "java.lang.Double" (~ (code;nat size)))
-                                           ("jvm array write" "java.lang.Double" (~ (code;nat idx)) (~ (code;frac valueD)))
+                    (|> (do macro.Monad
+                          [#let [inner (|> ("jvm array new" +0 "java.lang.Double" (~ (code.nat size)))
+                                           ("jvm array write" "java.lang.Double" (~ (code.nat idx)) (~ (code.frac valueD)))
                                            (`))]
-                           sampleI (expressionT;translate (|> ("jvm array new" +1 "java.lang.Double" (~ (code;nat size)))
-                                                              ("jvm array write" "#Array" (~ (code;nat idx)) (~ inner))
-                                                              ("jvm array read" "#Array" (~ (code;nat idx)))
-                                                              ("jvm array read" "java.lang.Double" (~ (code;nat idx)))
+                           sampleI (expressionT.translate (|> ("jvm array new" +1 "java.lang.Double" (~ (code.nat size)))
+                                                              ("jvm array write" "#Array" (~ (code.nat idx)) (~ inner))
+                                                              ("jvm array read" "#Array" (~ (code.nat idx)))
+                                                              ("jvm array read" "java.lang.Double" (~ (code.nat idx)))
                                                               (`)))]
-                          (@eval;eval sampleI))
-                        (macro;run (init-compiler []))
-                        (case> (#e;Success outputT)
-                               (f.= valueD (:! Frac outputT))
+                          (@eval.eval sampleI))
+                        (macro.run (init-compiler []))
+                        (case> (#e.Success outputT)
+                               (f/= valueD (:! Frac outputT))
 
-                               (#e;Error error)
+                               (#e.Error error)
                                false)))
               (test "jvm array length"
-                    (|> (do macro;Monad
-                          [sampleI (expressionT;translate (` ("jvm array length" ("jvm array new" +0 "java.lang.Object" (~ (code;nat size))))))]
-                          (@eval;eval sampleI))
-                        (macro;run (init-compiler []))
-                        (case> (#e;Success outputT)
-                               (n.= size (:! Nat outputT))
-
-                               (#e;Error error)
+                    (|> (do macro.Monad
+                          [sampleI (expressionT.translate (` ("jvm array length" ("jvm array new" +0 "java.lang.Object" (~ (code.nat size))))))]
+                          (@eval.eval sampleI))
+                        (macro.run (init-compiler []))
+                        (case> (#e.Success outputT)
+                               (n/= size (:! Nat outputT))
+
+                               (#e.Error error)
                                false)))
               )))))
 
-(host;import java.lang.Class
+(host.import java/lang/Class
   (getName [] String))
 
 (def: classes
@@ -393,117 +393,117 @@
         "java.lang.String" "java.lang.Number"))
 
 (def: instances
-  (List [Text (r;Random ls;Synthesis)])
-  (let [gen-boolean (|> r;bool (:: r;Functor map code;bool))
-        gen-integer (|> r;int (:: r;Functor map code;int))
-        gen-double (|> r;frac (:: r;Functor map code;frac))
-        gen-string (|> (r;text +5) (:: r;Functor map code;text))]
+  (List [Text (r.Random ls.Synthesis)])
+  (let [gen-boolean (|> r.bool (:: r.Functor map code.bool))
+        gen-integer (|> r.int (:: r.Functor map code.int))
+        gen-double (|> r.frac (:: r.Functor map code.frac))
+        gen-string (|> (r.text +5) (:: r.Functor map code.text))]
     (list ["java.lang.Boolean" gen-boolean]
           ["java.lang.Long" gen-integer]
           ["java.lang.Double" gen-double]
           ["java.lang.String" gen-string]
-          ["java.lang.Object" (r;either (r;either gen-boolean
+          ["java.lang.Object" (r.either (r.either gen-boolean
                                                   gen-integer)
-                                        (r;either gen-double
+                                        (r.either gen-double
                                                   gen-string))])))
 
 (context: "Object."
   (<| (times +100)
       (do @
-        [#let [num-classes (list;size classes)]
-         #let [num-instances (list;size instances)]
-         class-idx (|> r;nat (:: @ map (n.% num-classes)))
-         instance-idx (|> r;nat (:: @ map (n.% num-instances)))
-         exception-message (r;text +5)
-         #let [class (maybe;assume (list;nth class-idx classes))
-               [instance-class instance-gen] (maybe;assume (list;nth instance-idx instances))
-               exception-message$ (` ["java.lang.String" (~ (code;text exception-message))])]
-         sample r;int
-         monitor r;int
+        [#let [num-classes (list.size classes)]
+         #let [num-instances (list.size instances)]
+         class-idx (|> r.nat (:: @ map (n/% num-classes)))
+         instance-idx (|> r.nat (:: @ map (n/% num-instances)))
+         exception-message (r.text +5)
+         #let [class (maybe.assume (list.nth class-idx classes))
+               [instance-class instance-gen] (maybe.assume (list.nth instance-idx instances))
+               exception-message$ (` ["java.lang.String" (~ (code.text exception-message))])]
+         sample r.int
+         monitor r.int
          instance instance-gen]
         ($_ seq
             (test "jvm object null"
-                  (|> (do macro;Monad
-                        [sampleI (expressionT;translate (` ("jvm object null?" ("jvm object null"))))]
-                        (@eval;eval sampleI))
-                      (macro;run (init-compiler []))
-                      (case> (#e;Success outputT)
+                  (|> (do macro.Monad
+                        [sampleI (expressionT.translate (` ("jvm object null?" ("jvm object null"))))]
+                        (@eval.eval sampleI))
+                      (macro.run (init-compiler []))
+                      (case> (#e.Success outputT)
                              (:! Bool outputT)
 
-                             (#e;Error error)
+                             (#e.Error error)
                              false)))
             (test "jvm object null?"
-                  (|> (do macro;Monad
-                        [sampleI (expressionT;translate (` ("jvm object null?" (~ (code;int sample)))))]
-                        (@eval;eval sampleI))
-                      (macro;run (init-compiler []))
-                      (case> (#e;Success outputT)
+                  (|> (do macro.Monad
+                        [sampleI (expressionT.translate (` ("jvm object null?" (~ (code.int sample)))))]
+                        (@eval.eval sampleI))
+                      (macro.run (init-compiler []))
+                      (case> (#e.Success outputT)
                              (not (:! Bool outputT))
 
-                             (#e;Error error)
+                             (#e.Error error)
                              false)))
             (test "jvm object synchronized"
-                  (|> (do macro;Monad
-                        [sampleI (expressionT;translate (` ("jvm object synchronized" (~ (code;int monitor)) (~ (code;int sample)))))]
-                        (@eval;eval sampleI))
-                      (macro;run (init-compiler []))
-                      (case> (#e;Success outputT)
-                             (i.= sample (:! Int outputT))
-
-                             (#e;Error error)
+                  (|> (do macro.Monad
+                        [sampleI (expressionT.translate (` ("jvm object synchronized" (~ (code.int monitor)) (~ (code.int sample)))))]
+                        (@eval.eval sampleI))
+                      (macro.run (init-compiler []))
+                      (case> (#e.Success outputT)
+                             (i/= sample (:! Int outputT))
+
+                             (#e.Error error)
                              false)))
             (test "jvm object throw"
-                  (|> (do macro;Monad
-                        [_ @runtime;translate
-                         sampleI (expressionT;translate (` ("lux try" ("lux function" +1 []
+                  (|> (do macro.Monad
+                        [_ @runtime.translate
+                         sampleI (expressionT.translate (` ("lux try" ("lux function" +1 []
                                                                        ("jvm object throw" ("jvm member invoke constructor"
                                                                                             "java.lang.Throwable"
                                                                                             (~ exception-message$)))))))]
-                        (@eval;eval sampleI))
-                      (macro;run (init-compiler []))
-                      (case> (#e;Success outputT)
-                             (case (:! (e;Error Top) outputT)
-                               (#e;Error error)
-                               (text;contains? exception-message error)
-
-                               (#e;Success outputT)
+                        (@eval.eval sampleI))
+                      (macro.run (init-compiler []))
+                      (case> (#e.Success outputT)
+                             (case (:! (e.Error Top) outputT)
+                               (#e.Error error)
+                               (text.contains? exception-message error)
+
+                               (#e.Success outputT)
                                false)
 
-                             (#e;Error error)
+                             (#e.Error error)
                              false)))
             (test "jvm object class"
-                  (|> (do macro;Monad
-                        [sampleI (expressionT;translate (` ("jvm object class" (~ (code;text class)))))]
-                        (@eval;eval sampleI))
-                      (macro;run (init-compiler []))
-                      (case> (#e;Success outputT)
-                             (|> outputT (:! Class) (Class.getName []) (text/= class))
-
-                             (#e;Error error)
+                  (|> (do macro.Monad
+                        [sampleI (expressionT.translate (` ("jvm object class" (~ (code.text class)))))]
+                        (@eval.eval sampleI))
+                      (macro.run (init-compiler []))
+                      (case> (#e.Success outputT)
+                             (|> outputT (:! Class) (Class::getName []) (text/= class))
+
+                             (#e.Error error)
                              false)))
             (test "jvm object instance?"
-                  (|> (do macro;Monad
-                        [sampleI (expressionT;translate (` ("jvm object instance?" (~ (code;text instance-class)) (~ instance))))]
-                        (@eval;eval sampleI))
-                      (macro;run (init-compiler []))
-                      (case> (#e;Success outputT)
+                  (|> (do macro.Monad
+                        [sampleI (expressionT.translate (` ("jvm object instance?" (~ (code.text instance-class)) (~ instance))))]
+                        (@eval.eval sampleI))
+                      (macro.run (init-compiler []))
+                      (case> (#e.Success outputT)
                              (:! Bool outputT)
 
-                             (#e;Error error)
+                             (#e.Error error)
                              false)))
             ))))
 
-(host;import java.util.GregorianCalendar
+(host.import java/util/GregorianCalendar
   (#static AD int))
 
 (context: "Member [Field]"
   (<| (times +100)
       (do @
-        [sample-short (|> r;int (:: @ map (|>. int/abs (i.% 100))))
-         sample-string (r;text +5)
-         other-sample-string (r;text +5)
-         #let [shortS (` ["short" ("jvm convert long-to-short" (~ (code;int sample-short)))])
-               stringS (` ["java.lang.String" (~ (code;text sample-string))])
+        [sample-short (|> r.int (:: @ map (|>> int/abs (i/% 100))))
+         sample-string (r.text +5)
+         other-sample-string (r.text +5)
+         #let [shortS (` ["short" ("jvm convert long-to-short" (~ (code.int sample-short)))])
+               stringS (` ["java.lang.String" (~ (code.text sample-string))])
                type-codeS (` ["org.omg.CORBA.TypeCode" ("jvm object null")])
                idl-typeS (` ["org.omg.CORBA.IDLType" ("jvm object null")])
                value-memberS (` ("jvm member invoke constructor"
@@ -512,103 +512,103 @@
                                  (~ type-codeS) (~ idl-typeS) (~ shortS)))]]
         ($_ seq
             (test "jvm member static get"
-                  (|> (do macro;Monad
-                        [sampleI (expressionT;translate (` ("jvm convert int-to-long" ("jvm member static get" "java.util.GregorianCalendar" "AD" "int"))))]
-                        (@eval;eval sampleI))
-                      (macro;run (init-compiler []))
-                      (case> (#e;Success outputT)
-                             (i.= GregorianCalendar.AD (:! Int outputT))
-
-                             (#e;Error error)
+                  (|> (do macro.Monad
+                        [sampleI (expressionT.translate (` ("jvm convert int-to-long" ("jvm member static get" "java.util.GregorianCalendar" "AD" "int"))))]
+                        (@eval.eval sampleI))
+                      (macro.run (init-compiler []))
+                      (case> (#e.Success outputT)
+                             (i/= GregorianCalendar::AD (:! Int outputT))
+
+                             (#e.Error error)
                              false)))
             (test "jvm member static put"
-                  (|> (do macro;Monad
-                        [sampleI (expressionT;translate (` ("jvm member static put" "java.awt.datatransfer.DataFlavor" "allHtmlFlavor" "java.awt.datatransfer.DataFlavor"
+                  (|> (do macro.Monad
+                        [sampleI (expressionT.translate (` ("jvm member static put" "java.awt.datatransfer.DataFlavor" "allHtmlFlavor" "java.awt.datatransfer.DataFlavor"
                                                             ("jvm member static get" "java.awt.datatransfer.DataFlavor" "allHtmlFlavor" "java.awt.datatransfer.DataFlavor"))))]
-                        (@eval;eval sampleI))
-                      (macro;run (init-compiler []))
-                      (case> (#e;Success outputT)
-                             (is hostL;unit (:! Text outputT))
+                        (@eval.eval sampleI))
+                      (macro.run (init-compiler []))
+                      (case> (#e.Success outputT)
+                             (is hostL.unit (:! Text outputT))
 
-                             (#e;Error error)
+                             (#e.Error error)
                              false)))
             (test "jvm member virtual get"
-                  (|> (do macro;Monad
-                        [sampleI (expressionT;translate (` ("jvm member virtual get" "org.omg.CORBA.ValueMember" "name" "java.lang.String" (~ value-memberS))))]
-                        (@eval;eval sampleI))
-                      (macro;run (init-compiler []))
-                      (case> (#e;Success outputT)
+                  (|> (do macro.Monad
+                        [sampleI (expressionT.translate (` ("jvm member virtual get" "org.omg.CORBA.ValueMember" "name" "java.lang.String" (~ value-memberS))))]
+                        (@eval.eval sampleI))
+                      (macro.run (init-compiler []))
+                      (case> (#e.Success outputT)
                              (text/= sample-string (:! Text outputT))
 
-                             (#e;Error error)
+                             (#e.Error error)
                              false)))
             (test "jvm member virtual put"
-                  (|> (do macro;Monad
-                        [sampleI (expressionT;translate (` ("jvm member virtual get" "org.omg.CORBA.ValueMember" "name" "java.lang.String"
+                  (|> (do macro.Monad
+                        [sampleI (expressionT.translate (` ("jvm member virtual get" "org.omg.CORBA.ValueMember" "name" "java.lang.String"
                                                             ("jvm member virtual put" "org.omg.CORBA.ValueMember" "name" "java.lang.String"
-                                                             (~ (code;text other-sample-string)) (~ value-memberS)))))]
-                        (@eval;eval sampleI))
-                      (macro;run (init-compiler []))
-                      (case> (#e;Success outputT)
+                                                             (~ (code.text other-sample-string)) (~ value-memberS)))))]
+                        (@eval.eval sampleI))
+                      (macro.run (init-compiler []))
+                      (case> (#e.Success outputT)
                              (text/= other-sample-string (:! Text outputT))
 
-                             (#e;Error error)
+                             (#e.Error error)
                              false)))
             ))))
 
-(host;import java.lang.Object)
+(host.import java/lang/Object)
 
-(host;import (java.util.ArrayList a))
+(host.import (java/util/ArrayList a))
 
 (context: "Member [Method]"
   (<| (times +100)
       (do @
-        [sample (|> r;int (:: @ map (|>. int/abs (i.% 100))))
-         #let [object-longS (` ["java.lang.Object" (~ (code;int sample))])
-               intS (` ["int" ("jvm convert long-to-int" (~ (code;int sample)))])
-               coded-intS (` ["java.lang.String" (~ (code;text (int/encode sample)))])
+        [sample (|> r.int (:: @ map (|>> int/abs (i/% 100))))
+         #let [object-longS (` ["java.lang.Object" (~ (code.int sample))])
+               intS (` ["int" ("jvm convert long-to-int" (~ (code.int sample)))])
+               coded-intS (` ["java.lang.String" (~ (code.text (int/encode sample)))])
                array-listS (` ("jvm member invoke constructor" "java.util.ArrayList" (~ intS)))]]
         ($_ seq
             (test "jvm member invoke static"
-                  (|> (do macro;Monad
-                        [sampleI (expressionT;translate (` ("jvm member invoke static" "java.lang.Long" "decode" "java.lang.Long" (~ coded-intS))))]
-                        (@eval;eval sampleI))
-                      (macro;run (init-compiler []))
-                      (case> (#e;Success outputT)
-                             (i.= sample (:! Int outputT))
-
-                             (#e;Error error)
+                  (|> (do macro.Monad
+                        [sampleI (expressionT.translate (` ("jvm member invoke static" "java.lang.Long" "decode" "java.lang.Long" (~ coded-intS))))]
+                        (@eval.eval sampleI))
+                      (macro.run (init-compiler []))
+                      (case> (#e.Success outputT)
+                             (i/= sample (:! Int outputT))
+
+                             (#e.Error error)
                              false)))
             (test "jvm member invoke virtual"
-                  (|> (do macro;Monad
-                        [sampleI (expressionT;translate (` ("jvm member invoke virtual" "java.lang.Object" "equals" "boolean"
-                                                            (~ (code;int sample)) (~ object-longS))))]
-                        (@eval;eval sampleI))
-                      (macro;run (init-compiler []))
-                      (case> (#e;Success outputT)
+                  (|> (do macro.Monad
+                        [sampleI (expressionT.translate (` ("jvm member invoke virtual" "java.lang.Object" "equals" "boolean"
+                                                            (~ (code.int sample)) (~ object-longS))))]
+                        (@eval.eval sampleI))
+                      (macro.run (init-compiler []))
+                      (case> (#e.Success outputT)
                              (:! Bool outputT)
 
-                             (#e;Error error)
+                             (#e.Error error)
                              false)))
             (test "jvm member invoke interface"
-                  (|> (do macro;Monad
-                        [sampleI (expressionT;translate (` ("jvm member invoke interface" "java.util.Collection" "add" "boolean"
+                  (|> (do macro.Monad
+                        [sampleI (expressionT.translate (` ("jvm member invoke interface" "java.util.Collection" "add" "boolean"
                                                             (~ array-listS) (~ object-longS))))]
-                        (@eval;eval sampleI))
-                      (macro;run (init-compiler []))
-                      (case> (#e;Success outputT)
+                        (@eval.eval sampleI))
+                      (macro.run (init-compiler []))
+                      (case> (#e.Success outputT)
                              (:! Bool outputT)
 
-                             (#e;Error error)
+                             (#e.Error error)
                              false)))
             (test "jvm member invoke constructor"
-                  (|> (do macro;Monad
-                        [sampleI (expressionT;translate array-listS)]
-                        (@eval;eval sampleI))
-                      (macro;run (init-compiler []))
-                      (case> (#e;Success outputT)
-                             (host;instance? ArrayList (:! Object outputT))
-
-                             (#e;Error error)
+                  (|> (do macro.Monad
+                        [sampleI (expressionT.translate array-listS)]
+                        (@eval.eval sampleI))
+                      (macro.run (init-compiler []))
+                      (case> (#e.Success outputT)
+                             (host.instance? ArrayList (:! Object outputT))
+
+                             (#e.Error error)
                              false)))
             ))))
diff --git a/new-luxc/test/test/luxc/lang/translation/reference.lux b/new-luxc/test/test/luxc/lang/translation/reference.lux
index 1ad68263d..488000e14 100644
--- a/new-luxc/test/test/luxc/lang/translation/reference.lux
+++ b/new-luxc/test/test/luxc/lang/translation/reference.lux
@@ -1,4 +1,4 @@
-(;module:
+(.module:
   lux
   (lux [io]
        (control [monad #+ do]
@@ -9,72 +9,72 @@
        [macro]
        (macro [code])
        test)
-  (luxc (lang ["_;" module]
+  (luxc (lang ["_." module]
               (host ["$" jvm]
                     (jvm ["$i" inst]))
               ["ls" synthesis]
-              (translation [";T" statement]
-                           [";T" eval]
-                           [";T" expression]
-                           [";T" case]
-                           [";T" runtime])))
+              (translation [".T" statement]
+                           [".T" eval]
+                           [".T" expression]
+                           [".T" case]
+                           [".T" runtime])))
   (test/luxc common))
 
-(def: nilI $;Inst runtimeT;noneI)
+(def: nilI $.Inst runtimeT.noneI)
 
 (def: cursorI
-  $;Inst
-  (|>. ($i;int 3)
-       ($i;array runtimeT;$Tuple)
-       $i;DUP ($i;int 0) ($i;string "") $i;AASTORE
-       $i;DUP ($i;int 1) ($i;long 0) ($i;wrap #$;Long) $i;AASTORE
-       $i;DUP ($i;int 2) ($i;long 0) ($i;wrap #$;Long) $i;AASTORE))
+  $.Inst
+  (|>> ($i.int 3)
+       ($i.array runtimeT.$Tuple)
+       $i.DUP ($i.int 0) ($i.string "") $i.AASTORE
+       $i.DUP ($i.int 1) ($i.long 0) ($i.wrap #$.Long) $i.AASTORE
+       $i.DUP ($i.int 2) ($i.long 0) ($i.wrap #$.Long) $i.AASTORE))
 
 (def: empty-metaI
-  (|>. ($i;int 2)
-       ($i;array runtimeT;$Tuple)
-       $i;DUP ($i;int 0) cursorI $i;AASTORE
-       $i;DUP ($i;int 1) nilI $i;AASTORE))
+  (|>> ($i.int 2)
+       ($i.array runtimeT.$Tuple)
+       $i.DUP ($i.int 0) cursorI $i.AASTORE
+       $i.DUP ($i.int 1) nilI $i.AASTORE))
 
 (context: "Definitions."
   (<| (times +100)
       (do @
-        [module-name (|> (r;text +5) (r;filter (|>. (text;contains? "/") not)))
-         def-name (r;text +5)
-         def-value r;int
-         #let [valueI (|>. ($i;long def-value) ($i;wrap #$;Long))]]
+        [module-name (|> (r.text +5) (r.filter (|>> (text.contains? "/") not)))
+         def-name (r.text +5)
+         def-value r.int
+         #let [valueI (|>> ($i.long def-value) ($i.wrap #$.Long))]]
         ($_ seq
             (test "Can refer to definitions."
-                  (|> (do macro;Monad
-                        [_ (_module;with-module +0 module-name
-                             (statementT;translate-def def-name Int valueI empty-metaI (' {})))
-                         sampleI (expressionT;translate (code;symbol [module-name def-name]))]
-                        (evalT;eval sampleI))
-                      (macro;run (init-compiler []))
-                      (case> (#e;Success valueT)
-                             (i.= def-value (:! Int valueT))
+                  (|> (do macro.Monad
+                        [_ (_module.with-module +0 module-name
+                             (statementT.translate-def def-name Int valueI empty-metaI (' {})))
+                         sampleI (expressionT.translate (code.symbol [module-name def-name]))]
+                        (evalT.eval sampleI))
+                      (macro.run (init-compiler []))
+                      (case> (#e.Success valueT)
+                             (i/= def-value (:! Int valueT))
 
-                             (#e;Error error)
+                             (#e.Error error)
                              false)))
             ))))
 
 (context: "Variables."
   (<| (times +100)
       (do @
-        [register (|> r;nat (:: @ map (n.% +100)))
-         value r;int]
+        [register (|> r.nat (:: @ map (n/% +100)))
+         value r.int]
         ($_ seq
             (test "Can refer to local variables/registers."
-                  (|> (do macro;Monad
-                        [sampleI (caseT;translate-let expressionT;translate
+                  (|> (do macro.Monad
+                        [sampleI (caseT.translate-let expressionT.translate
                                                       register
-                                                      (code;int value)
-                                                      (` ((~ (code;int (nat-to-int register))))))]
-                        (evalT;eval sampleI))
-                      (macro;run (init-compiler []))
-                      (case> (#e;Success outputT)
-                             (i.= value (:! Int outputT))
+                                                      (code.int value)
+                                                      (` ((~ (code.int (nat-to-int register))))))]
+                        (evalT.eval sampleI))
+                      (macro.run (init-compiler []))
+                      (case> (#e.Success outputT)
+                             (i/= value (:! Int outputT))
 
-                             (#e;Error error)
+                             (#e.Error error)
                              false)))
             ))))
diff --git a/new-luxc/test/test/luxc/lang/translation/structure.lux b/new-luxc/test/test/luxc/lang/translation/structure.lux
index 68a394261..d61ec185f 100644
--- a/new-luxc/test/test/luxc/lang/translation/structure.lux
+++ b/new-luxc/test/test/luxc/lang/translation/structure.lux
@@ -1,4 +1,4 @@
-(;module:
+(.module:
   lux
   (lux [io]
        (control [monad #+ do]
@@ -15,46 +15,46 @@
        (macro [code])
        [host]
        test)
-  (luxc (lang [";L" host]
+  (luxc (lang [".L" host]
               ["ls" synthesis]
-              (translation [";T" expression]
-                           ["@;" eval]
-                           ["@;" runtime]
-                           ["@;" common])))
+              (translation [".T" expression]
+                           ["@." eval]
+                           ["@." runtime]
+                           ["@." common])))
   (test/luxc common))
 
-(host;import java.lang.Integer)
+(host.import java/lang/Integer)
 
 (def: gen-primitive
-  (r;Random ls;Synthesis)
-  (r;either (r;either (r;either (r/wrap (' []))
-                                (r/map code;bool r;bool))
-                      (r;either (r/map code;nat r;nat)
-                                (r/map code;int r;int)))
-            (r;either (r;either (r/map code;deg r;deg)
-                                (r/map code;frac r;frac))
-                      (r/map code;text (r;text +5)))))
+  (r.Random ls.Synthesis)
+  (r.either (r.either (r.either (r/wrap (' []))
+                                (r/map code.bool r.bool))
+                      (r.either (r/map code.nat r.nat)
+                                (r/map code.int r.int)))
+            (r.either (r.either (r/map code.deg r.deg)
+                                (r/map code.frac r.frac))
+                      (r/map code.text (r.text +5)))))
 
 (def: (corresponds? [prediction sample])
-  (-> [ls;Synthesis Top] Bool)
+  (-> [ls.Synthesis Top] Bool)
   (case prediction
-    [_ (#;Tuple #;Nil)]
-    (is hostL;unit (:! Text sample))
+    [_ (#.Tuple #.Nil)]
+    (is hostL.unit (:! Text sample))
 
     (^template [  ]
       [_ ( prediction')]
-      (case (host;try ( prediction' (:!  sample)))
-        (#e;Success result)
+      (case (host.try ( prediction' (:!  sample)))
+        (#e.Success result)
         result
 
-        (#e;Error error)
+        (#e.Error error)
         false))
-    ([#;Bool Bool bool/=]
-     [#;Nat  Nat n.=]
-     [#;Int  Int i.=]
-     [#;Deg  Deg d.=]
-     [#;Frac Frac f.=]
-     [#;Text Text text/=])
+    ([#.Bool Bool bool/=]
+     [#.Nat  Nat n/=]
+     [#.Int  Int i/=]
+     [#.Deg  Deg d/=]
+     [#.Frac Frac f/=]
+     [#.Text Text text/=])
 
     _
     false
@@ -63,17 +63,17 @@
 (context: "Tuples."
   (<| (times +100)
       (do @
-        [size (|> r;nat (:: @ map (|>. (n.% +10) (n.max +2))))
-         members (r;list size gen-primitive)]
+        [size (|> r.nat (:: @ map (|>> (n/% +10) (n/max +2))))
+         members (r.list size gen-primitive)]
         (test "Can translate tuple."
-              (|> (do macro;Monad
-                    [sampleI (expressionT;translate (code;tuple members))]
-                    (@eval;eval sampleI))
-                  (macro;run (init-compiler []))
-                  (case> (#e;Success valueT)
+              (|> (do macro.Monad
+                    [sampleI (expressionT.translate (code.tuple members))]
+                    (@eval.eval sampleI))
+                  (macro.run (init-compiler []))
+                  (case> (#e.Success valueT)
                          (let [valueT (:! (Array Top) valueT)]
-                           (and (n.= size (array;size valueT))
-                                (list;every? corresponds? (list;zip2 members (array;to-list valueT)))))
+                           (and (n/= size (array.size valueT))
+                                (list.every? corresponds? (list.zip2 members (array.to-list valueT)))))
 
                          _
                          false))))))
@@ -81,28 +81,28 @@
 (context: "Variants."
   (<| (times +100)
       (do @
-        [num-tags (|> r;nat (:: @ map (|>. (n.% +10) (n.max +2))))
-         tag (|> r;nat (:: @ map (n.% num-tags)))
-         #let [last? (n.= (n.dec num-tags) tag)]
+        [num-tags (|> r.nat (:: @ map (|>> (n/% +10) (n/max +2))))
+         tag (|> r.nat (:: @ map (n/% num-tags)))
+         #let [last? (n/= (n/dec num-tags) tag)]
          member gen-primitive]
         (test "Can translate variant."
-              (|> (do macro;Monad
-                    [runtime-bytecode @runtime;translate
-                     sampleI (expressionT;translate (` ((~ (code;nat tag)) (~ (code;bool last?)) (~ member))))]
-                    (@eval;eval sampleI))
-                  (macro;run (init-compiler []))
-                  (case> (#e;Success valueT)
+              (|> (do macro.Monad
+                    [runtime-bytecode @runtime.translate
+                     sampleI (expressionT.translate (` ((~ (code.nat tag)) (~ (code.bool last?)) (~ member))))]
+                    (@eval.eval sampleI))
+                  (macro.run (init-compiler []))
+                  (case> (#e.Success valueT)
                          (let [valueT (:! (Array Top) valueT)]
-                           (and (n.= +3 (array;size valueT))
-                                (let [_tag (:! Integer (maybe;assume (array;read +0 valueT)))
-                                      _last? (array;read +1 valueT)
-                                      _value (:! Top (maybe;assume (array;read +2 valueT)))]
-                                  (and (n.= tag (|> _tag host;i2l int-to-nat))
+                           (and (n/= +3 (array.size valueT))
+                                (let [_tag (:! Integer (maybe.assume (array.read +0 valueT)))
+                                      _last? (array.read +1 valueT)
+                                      _value (:! Top (maybe.assume (array.read +2 valueT)))]
+                                  (and (n/= tag (|> _tag host.i2l int-to-nat))
                                        (case _last?
-                                         (#;Some _last?')
+                                         (#.Some _last?')
                                          (and last? (text/= "" (:! Text _last?')))
 
-                                         #;None
+                                         #.None
                                          (not last?))
                                        (corresponds? [member _value])))))
 
diff --git a/new-luxc/test/tests.lux b/new-luxc/test/tests.lux
index b36782517..98043260b 100644
--- a/new-luxc/test/tests.lux
+++ b/new-luxc/test/tests.lux
@@ -1,32 +1,32 @@
-(;module:
+(.module:
   lux
   (lux (control monad)
        [io]
        (concurrency [promise])
        [cli #+ program:]
        [test])
-  (test (luxc (lang (analysis ["_;A" primitive]
-                              ["_;A" structure]
-                              ["_;A" reference]
-                              ["_;A" case]
-                              ["_;A" function]
-                              ["_;A" type]
-                              (procedure ["_;A" common]
-                                         ["_;A" host]))
-                    (synthesis ["_;S" primitive]
-                               ["_;S" structure]
-                               (case ["_;S" special])
-                               ["_;S" function]
-                               ["_;S" procedure]
-                               ["_;S" loop])
-                    (translation ["_;T" primitive]
-                                 ["_;T" structure]
-                                 ["_;T" case]
-                                 ["_;T" function]
-                                 ["_;T" reference]
-                                 (procedure ["_;T" common]
-                                            ["_;T" host])))
+  (test (luxc (lang (analysis ["_.A" primitive]
+                              ["_.A" structure]
+                              ["_.A" reference]
+                              ["_.A" case]
+                              ["_.A" function]
+                              ["_.A" type]
+                              (procedure ["_.A" common]
+                                         ["_.A" host]))
+                    (synthesis ["_.S" primitive]
+                               ["_.S" structure]
+                               (case ["_.S" special])
+                               ["_.S" function]
+                               ["_.S" procedure]
+                               ["_.S" loop])
+                    (translation ["_.T" primitive]
+                                 ["_.T" structure]
+                                 ["_.T" case]
+                                 ["_.T" function]
+                                 ["_.T" reference]
+                                 (procedure ["_.T" common]
+                                            ["_.T" host])))
               )))
 
 (program: args
-  (test;run))
+  (test.run))
-- 
cgit v1.2.3