diff options
Diffstat (limited to 'new-luxc/test')
25 files changed, 1636 insertions, 1636 deletions
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<List> + (#.Cons head+ tail++) + (do list.Monad<List> [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 [<tag> <gen> <wrapper>] [_ (<tag> _)] (if allow-literals? - (do r;Monad<Random> - [?sample (r;maybe <gen>)] + (do r.Monad<Random> + [?sample (r.maybe <gen>)] (case ?sample - (#;Some sample) + (#.Some sample) (do @ [else (exhaustive-branches allow-literals? variantTC inputC)] (wrap (list& (<wrapper> 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<Random> - [member-wise-patterns (monad;map @ (exhaustive-branches allow-literals? variantTC) members)] + [_ (#.Tuple members)] + (do r.Monad<Random> + [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<Random> - [#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<Random> + [#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<Random> - [bundles (monad;map @ + (^ [_ (#.Form (list [_ (#.Tag _)] _))]) + (do r.Monad<Random> + [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<Random> - [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<Random> + [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<Random> - [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<Random> + [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<Text> size (r;text +5)) (:: @ map S;to-list)) - record-tags (|> (r;set text;Hash<Text> 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<Text> size (r.text +5)) (:: @ map S.to-list)) + record-tags (|> (r.set text.Hash<Text> 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<Meta> - [_ (@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<Meta> - [_ (@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<Meta> - [_ (@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<Meta> - [_ (@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<Random>] @@ -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 [<generators> (do-template [<type> <code-wrapper> <value-gen>] - [(r;seq (r/wrap <type>) (r/map <code-wrapper> <value-gen>))] + [(r.seq (r/wrap <type>) (r/map <code-wrapper> <value-gen>))] - [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 <generators> ))) (def: #export analyse - &;Analyser - (expressionA;analyser eval;eval)) + &.Analyser + (expressionA.analyser eval.eval)) (do-template [<name> <on-success> <on-failure>] [(def: #export (<name> analysis) (All [a] (-> (Meta a) Bool)) (|> analysis - (macro;run (init-compiler [])) - (case> (#e;Success _) + (macro.run (init-compiler [])) + (case> (#e.Success _) <on-success> - (#e;Error error) + (#e.Error error) <on-failure>)))] [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<Type>]) 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<Type>]) 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 [<desc> <type> <tag> <value> <analyser>] [(test (format "Can analyse " <desc> ".") - (|> (@common;with-unknown-type + (|> (@common.with-unknown-type (<analyser> <value>)) - (macro;run (init-compiler [])) - (case> (#e;Success [_type [_ (<tag> value)]]) + (macro.run (init-compiler [])) + (case> (#e.Success [_type [_ (<tag> value)]]) (and (type/= <type> _type) (is <value> 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<Type>]) 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 [<name> <success> <failure>] [(def: (<name> 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 _) <success> - (#e;Error error) + (#e.Error error) <failure>)))] [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 [<unary> (do-template [<proc> <desc>] [(test (format "Can calculate " <desc> ".") (check-success+ <proc> (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 [<name> <success> <failure>] [(def: (<name> procedure params output-type) (-> Text (List Code) Type Bool) (|> (do Monad<Meta> - [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 _) <success> - (#e;Error error) + (#e.Error error) <failure>)))] [success true false] @@ -56,12 +56,12 @@ (test (format <procedure> " FAILURE") (failure <procedure> (list (' [])) <to>))] - ["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 <conversions> @@ -74,12 +74,12 @@ (test (format <procedure> " FAILURE") (failure <procedure> (list (' [])) <to>))] - ["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 <conversions> @@ -92,11 +92,11 @@ (test (format <procedure> " FAILURE") (failure <procedure> (list (' [])) <to>))] - ["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 <conversions> @@ -109,12 +109,12 @@ (test (format <procedure> " FAILURE") (failure <procedure> (list (' [])) <to>))] - ["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 <conversions> @@ -147,8 +147,8 @@ (' ("lux coerce" (+0 <param> (+0)) []))) <output>))] - [(format "jvm " <domain> " =") <boxed> <boxed> @host;Boolean] - [(format "jvm " <domain> " <") <boxed> <boxed> @host;Boolean] + [(format "jvm " <domain> " =") <boxed> <boxed> @host.Boolean] + [(format "jvm " <domain> " <") <boxed> <boxed> @host.Boolean] )] ($_ seq <instructions> @@ -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 [<domain> <boxed> <type>] @@ -205,16 +205,16 @@ (' ("lux coerce" (+0 <param> (+0)) []))) <output>))] - [(format "jvm " <domain> " =") <boxed> <boxed> @host;Boolean] - [(format "jvm " <domain> " <") <boxed> <boxed> @host;Boolean] + [(format "jvm " <domain> " =") <boxed> <boxed> @host.Boolean] + [(format "jvm " <domain> " <") <boxed> <boxed> @host.Boolean] )] ($_ seq <instructions> )))] - ["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 [<domain> <boxed> <type>] @@ -226,59 +226,59 @@ (' ("lux coerce" (+0 <param> (+0)) []))) <output>))] - [(format "jvm " <domain> " =") <boxed> <boxed> @host;Boolean] - [(format "jvm " <domain> " <") <boxed> <boxed> @host;Boolean] + [(format "jvm " <domain> " =") <boxed> <boxed> @host.Boolean] + [(format "jvm " <domain> " <") <boxed> <boxed> @host.Boolean] )] ($_ seq <instructions> )))] - ["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<Random> - [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<Random> + [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<Meta>] (lang [type "type/" Eq<Type>]) 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<Meta> - [_ (&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<Meta> - [[_ 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<Meta> + [[_ 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<Meta> - [[_ 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<Meta> + [[_ 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<Meta> - [[_ 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<Meta> + [[_ 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<Text> 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<Text> 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<Meta> - [_ (@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<Meta> + [_ (@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<Meta> - [_ (@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<Meta> + [_ (@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<Meta> - [_ (@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<Meta> + [_ (@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<Meta> - [_ (@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<Meta> + [_ (@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<Text> 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<Text> 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<Meta> - [_ (@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<Meta> + [_ (@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<Meta> - [_ (@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<Meta> + [_ (@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<Meta> - [_ (@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<Meta> + [_ (@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<Type>]) 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 [<triples> (do-template [<random> <type> <code>] - [(do r;Monad<Random> + [(do r.Monad<Random> [value <random>] (wrap [(` <type>) <type> (<code> 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 <triples>))) (context: "Type checking/coercion." @@ -53,39 +53,39 @@ ($_ seq (test (format "Can analyse type-checking.") (|> (do Monad<Meta> - [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 [<tag> <test>] [[_ (<tag> expected)] [_ (<tag> actual)]] (<test> 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<Meta> - [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<Bool>] [text "text/" Eq<Text>]) @@ -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 [<tag> <test>] [[_ (<tag> valueA)] [_ (<tag> valueS)]] (<test> 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<Random> - [function? r;bool] + (do r.Monad<Random> + [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<Random> map (n.% scope-size)))) + (-> Nat (r.Random Nat)) + (|> r.nat (:: r.Monad<Random> map (n/% scope-size)))) (def: gen-function//captured - (r;Random [Nat Int la;Analysis]) - (do r;Monad<Random> - [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<Random> + [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<Nat>)) - (list;zip2 (list;n.range +0 (n.dec env-size)) + (dict.new number.Hash<Nat>)) + (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<Nat> 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<Nat> 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<Random> - [nest?' r;bool - [total-args prediction bodyA] (recur (n.inc num-args) nest?')] + (do r.Monad<Random> + [nest?' r.bool + [total-args prediction bodyA] (recur (n/inc num-args) nest?')] (wrap [total-args prediction (` ("lux function" [] (~ bodyA)))])) - (do r;Monad<Random> - [chosen (|> r;nat (:: @ map (|>. (n.% +100) (n.max +2))))] + (do r.Monad<Random> + [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<Random> - [inputA (|> r;nat (:: @ map code;nat)) - num-cases (|> r;nat (:: @ map (|>. (n.% +10) (n.max +1)))) - tests (|> (r;set number;Hash<Nat> 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<Random> + [inputA (|> r.nat (:: @ map code.nat)) + num-cases (|> r.nat (:: @ map (|>> (n/% +10) (n/max +1)))) + tests (|> (r.set number.Hash<Nat> 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<Random> - [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<Random> - [valueS r;bool - then|else r;bool + (~ (code.record (list.zip2 tests bodies)))))))) + (r.either (do r.Monad<Random> + [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<Random> + [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<Random> - [arity (|> r;nat (:: @ map (|>. (n.% +10) (n.max +1)))) - recur? r;bool + (r.Random [Bool Nat la.Analysis]) + (do r.Monad<Random> + [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<Random> - [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<Random> + [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 [<desc> <analysis> <synthesis> <sample>] [(test (format "Can synthesize " <desc> ".") - (|> (expressionS;synthesize (<analysis> <sample>)) + (|> (expressionS.synthesize (<analysis> <sample>)) (case> [_ (<synthesis> value)] (is <sample> 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 [<gen> <synth>] - [(do r;Monad<Random> + [(do r.Monad<Random> [value <gen>] (wrap [(<synth> value) (<synth> 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<Random> - [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<Random> + [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<Random> - [size (|> r;nat (:: @ map (|>. (n.% struct-limit) (n.max +2)))) - idx (|> r;nat (:: @ map (n.% size))) + (do r.Monad<Random> + [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<Meta> - [runtime-bytecode @runtime;translate - sampleI (@;translate-case expressionT;translate + (|> (do macro.Monad<Meta> + [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<Meta> - [runtime-bytecode @runtime;translate - sampleI (@;translate-case expressionT;translate - (code;nat to-bind) + (|> (do macro.Monad<Meta> + [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<Random> + (r.Random [ls.Arity Nat ls.Synthesis]) + (do r.Monad<Random> [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<Meta> - [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<Meta> + [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<Meta> - [#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<Meta> + [#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<Meta> - [#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<Meta> + [#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 [<tests> (do-template [<desc> <type> <synthesis> <sample> <test>] [(test (format "Can translate " <desc> ".") - (|> (do macro;Monad<Meta> - [sampleI (expressionT;translate (<synthesis> <sample>))] - (@eval;eval sampleI)) - (macro;run (init-compiler [])) - (case> (#e;Success valueT) + (|> (do macro.Monad<Meta> + [sampleI (expressionT.translate (<synthesis> <sample>))] + (@eval.eval sampleI)) + (macro.run (init-compiler [])) + (case> (#e.Success valueT) (<test> <sample> (:! <type> 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<Meta> - [sampleI (expressionT;translate (' []))] - (@eval;eval sampleI)) - (macro;run (init-compiler [])) - (case> (#e;Success valueT) - (is hostL;unit (:! Text valueT)) + (|> (do macro.Monad<Meta> + [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 [<binary> (do-template [<name> <reference>] [(test <name> - (|> (do macro;Monad<Meta> - [sampleI (expressionT;translate (` (<name> (~ (code;nat subject)) - (~ (code;nat param)))))] - (@eval;eval sampleI)) - (macro;run (init-compiler [])) - (case> (#e;Success valueT) - (n.= (<reference> param subject) (:! Nat valueT)) + (|> (do macro.Monad<Meta> + [sampleI (expressionT.translate (` (<name> (~ (code.nat subject)) + (~ (code.nat param)))))] + (@eval.eval sampleI)) + (macro.run (init-compiler [])) + (case> (#e.Success valueT) + (n/= (<reference> 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<Meta> - [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<Meta> + [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))) <binary> (test "bit shift-right" - (|> (do macro;Monad<Meta> - [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<Meta> + [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 [<name> <reference>] [(test <name> - (|> (do macro;Monad<Meta> - [sampleI (expressionT;translate (` (<name>)))] - (@eval;eval sampleI)) - (macro;run (init-compiler [])) - (case> (#e;Success valueT) - (n.= <reference> (:! Nat valueT)) + (|> (do macro.Monad<Meta> + [sampleI (expressionT.translate (` (<name>)))] + (@eval.eval sampleI)) + (macro.run (init-compiler [])) + (case> (#e.Success valueT) + (n/= <reference> (:! Nat valueT)) _ false)))] @@ -98,55 +98,55 @@ )) (~~ (do-template [<name> <type> <prepare> <comp>] [(test <name> - (|> (do macro;Monad<Meta> - [sampleI (expressionT;translate (` (<name> (~ (code;nat subject)))))] - (@eval;eval sampleI)) - (macro;run (init-compiler [])) - (case> (#e;Success valueT) + (|> (do macro.Monad<Meta> + [sampleI (expressionT.translate (` (<name> (~ (code.nat subject)))))] + (@eval.eval sampleI)) + (macro.run (init-compiler [])) + (case> (#e.Success valueT) (<comp> (<prepare> subject) (:! <type> 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 [<name> <reference> <outputT> <comp>] [(test <name> - (|> (do macro;Monad<Meta> - [runtime-bytecode @runtime;translate - sampleI (expressionT;translate (` (<name> (~ (code;nat subject)) (~ (code;nat param)))))] - (@eval;eval sampleI)) - (macro;run (init-compiler [])) - (case> (#e;Success valueT) + (|> (do macro.Monad<Meta> + [runtime-bytecode @runtime.translate + sampleI (expressionT.translate (` (<name> (~ (code.nat subject)) (~ (code.nat param)))))] + (@eval.eval sampleI)) + (macro.run (init-compiler [])) + (case> (#e.Success valueT) (<comp> (<reference> param subject) (:! <outputT> 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 [<nullary> (do-template [<name> <reference>] [(test <name> - (|> (do macro;Monad<Meta> - [sampleI (expressionT;translate (` (<name>)))] - (@eval;eval sampleI)) - (macro;run (init-compiler [])) - (case> (#e;Success valueT) - (i.= <reference> (:! Int valueT)) + (|> (do macro.Monad<Meta> + [sampleI (expressionT.translate (` (<name>)))] + (@eval.eval sampleI)) + (macro.run (init-compiler [])) + (case> (#e.Success valueT) + (i/= <reference> (:! Int valueT)) _ false)))] @@ -156,39 +156,39 @@ ) <unary> (do-template [<name> <type> <prepare> <comp>] [(test <name> - (|> (do macro;Monad<Meta> - [sampleI (expressionT;translate (` (<name> (~ (code;int subject)))))] - (@eval;eval sampleI)) - (macro;run (init-compiler [])) - (case> (#e;Success valueT) + (|> (do macro.Monad<Meta> + [sampleI (expressionT.translate (` (<name> (~ (code.int subject)))))] + (@eval.eval sampleI)) + (macro.run (init-compiler [])) + (case> (#e.Success valueT) (<comp> (<prepare> subject) (:! <type> 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/=] ) <binary> (do-template [<name> <reference> <outputT> <comp>] [(test <name> - (|> (do macro;Monad<Meta> - [runtime-bytecode @runtime;translate - sampleI (expressionT;translate (` (<name> (~ (code;int subject)) (~ (code;int param)))))] - (@eval;eval sampleI)) - (macro;run (init-compiler [])) - (case> (#e;Success valueT) + (|> (do macro.Monad<Meta> + [runtime-bytecode @runtime.translate + sampleI (expressionT.translate (` (<name> (~ (code.int subject)) (~ (code.int param)))))] + (@eval.eval sampleI)) + (macro.run (init-compiler [])) + (case> (#e.Success valueT) (<comp> (<reference> param subject) (:! <outputT> 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 <nullary> @@ -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 [<binary> (do-template [<name> <reference> <outputT> <comp>] [(test <name> - (|> (do macro;Monad<Meta> - [runtime-bytecode @runtime;translate - sampleI (expressionT;translate (` (<name> (~ (code;frac subject)) (~ (code;frac param)))))] - (@eval;eval sampleI)) - (macro;run (init-compiler [])) - (case> (#e;Success valueT) + (|> (do macro.Monad<Meta> + [runtime-bytecode @runtime.translate + sampleI (expressionT.translate (` (<name> (~ (code.frac subject)) (~ (code.frac param)))))] + (@eval.eval sampleI)) + (macro.run (init-compiler [])) + (case> (#e.Success valueT) (<comp> (<reference> param subject) (:! <outputT> 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 <binary> @@ -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 [<nullary> (do-template [<name> <test>] [(test <name> - (|> (do macro;Monad<Meta> - [sampleI (expressionT;translate (` (<name>)))] - (@eval;eval sampleI)) - (macro;run (init-compiler [])) - (case> (#e;Success valueT) + (|> (do macro.Monad<Meta> + [sampleI (expressionT.translate (` (<name>)))] + (@eval.eval sampleI)) + (macro.run (init-compiler [])) + (case> (#e.Success valueT) (<test> (:! 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"))] ) <unary> (do-template [<name> <type> <prepare> <comp>] [(test <name> - (|> (do macro;Monad<Meta> - [runtime-bytecode @runtime;translate - sampleI (expressionT;translate (` (<name> (~ (code;frac subject)))))] - (@eval;eval sampleI)) - (macro;run (init-compiler [])) - (case> (#e;Success valueT) + (|> (do macro.Monad<Meta> + [runtime-bytecode @runtime.translate + sampleI (expressionT.translate (` (<name> (~ (code.frac subject)))))] + (@eval.eval sampleI)) + (macro.run (init-compiler [])) + (case> (#e.Success valueT) (<comp> (<prepare> subject) (:! <type> 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 <nullary> <unary> (test "frac encode|decode" - (|> (do macro;Monad<Meta> - [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<Meta> + [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 [<name> <reference>] [(test <name> - (|> (do macro;Monad<Meta> - [sampleI (expressionT;translate (` (<name>)))] - (@eval;eval sampleI)) - (macro;run (init-compiler [])) - (case> (#e;Success valueT) - (d.= <reference> (:! Deg valueT)) + (|> (do macro.Monad<Meta> + [sampleI (expressionT.translate (` (<name>)))] + (@eval.eval sampleI)) + (macro.run (init-compiler [])) + (case> (#e.Success valueT) + (d/= <reference> (:! Deg valueT)) _ false)))] @@ -314,54 +314,54 @@ )) (~~ (do-template [<name> <type> <prepare> <comp>] [(test <name> - (|> (do macro;Monad<Meta> - [runtime-bytecode @runtime;translate - sampleI (expressionT;translate (` (<name> (~ (code;deg subject)))))] - (@eval;eval sampleI)) - (macro;run (init-compiler [])) - (case> (#e;Success valueT) + (|> (do macro.Monad<Meta> + [runtime-bytecode @runtime.translate + sampleI (expressionT.translate (` (<name> (~ (code.deg subject)))))] + (@eval.eval sampleI)) + (macro.run (init-compiler [])) + (case> (#e.Success valueT) (<comp> (<prepare> subject) (:! <type> valueT)) _ false)))] - ["lux deg to-frac" Frac deg-to-frac f.=] + ["lux deg to-frac" Frac deg-to-frac f/=] )) (~~ (do-template [<name> <reference> <outputT> <comp>] [(test <name> - (|> (do macro;Monad<Meta> - [runtime-bytecode @runtime;translate - sampleI (expressionT;translate (` (<name> (~ (code;deg subject)) (~ (code;deg param)))))] - (@eval;eval sampleI)) - (macro;run (init-compiler [])) - (case> (#e;Success valueT) + (|> (do macro.Monad<Meta> + [runtime-bytecode @runtime.translate + sampleI (expressionT.translate (` (<name> (~ (code.deg subject)) (~ (code.deg param)))))] + (@eval.eval sampleI)) + (macro.run (init-compiler [])) + (case> (#e.Success valueT) (<comp> (<reference> param subject) (:! <outputT> 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 [<name> <reference> <outputT> <comp>] [(test <name> - (|> (do macro;Monad<Meta> - [runtime-bytecode @runtime;translate - sampleI (expressionT;translate (` (<name> (~ (code;deg subject)) (~ (code;nat special)))))] - (@eval;eval sampleI)) - (macro;run (init-compiler [])) - (case> (#e;Success valueT) + (|> (do macro.Monad<Meta> + [runtime-bytecode @runtime.translate + sampleI (expressionT.translate (` (<name> (~ (code.deg subject)) (~ (code.nat special)))))] + (@eval.eval sampleI)) + (macro.run (init-compiler [])) + (case> (#e.Success valueT) (<comp> (<reference> special subject) (:! <outputT> 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 [<step1> <step2> <tag> <sample> <cast> <test>] [(test (format <step1> " / " <step2>) - (|> (do macro;Monad<Meta> - [sampleI (expressionT;translate (|> (~ (<tag> <sample>)) <step1> <step2> (`)))] - (@eval;eval sampleI)) - (macro;run (init-compiler [])) - (case> (#e;Success valueT) + (|> (do macro.Monad<Meta> + [sampleI (expressionT.translate (|> (~ (<tag> <sample>)) <step1> <step2> (`)))] + (@eval.eval sampleI)) + (macro.run (init-compiler [])) + (case> (#e.Success valueT) (<test> <sample> (:! <cast> 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 [<step1> <step2> <step3> <tag> <sample> <cast> <test>] [(test (format <step1> " / " <step2> " / " <step3>) - (|> (do macro;Monad<Meta> - [sampleI (expressionT;translate (|> (~ (<tag> <sample>)) <step1> <step2> <step3> (`)))] - (@eval;eval sampleI)) - (macro;run (init-compiler [])) - (case> (#e;Success valueT) + (|> (do macro.Monad<Meta> + [sampleI (expressionT.translate (|> (~ (<tag> <sample>)) <step1> <step2> <step3> (`)))] + (@eval.eval sampleI)) + (macro.run (init-compiler [])) + (case> (#e.Success valueT) (<test> <sample> (:! <cast> 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 [<step1> <step2> <step3> <step4> <tag> <sample> <cast> <test>] [(test (format <step1> " / " <step2> " / " <step3>) - (|> (do macro;Monad<Meta> - [sampleI (expressionT;translate (|> (~ (<tag> <sample>)) <step1> <step2> <step3> <step4> (`)))] - (@eval;eval sampleI)) - (macro;run (init-compiler [])) - (case> (#e;Success valueT) + (|> (do macro.Monad<Meta> + [sampleI (expressionT.translate (|> (~ (<tag> <sample>)) <step1> <step2> <step3> <step4> (`)))] + (@eval.eval sampleI)) + (macro.run (init-compiler [])) + (case> (#e.Success valueT) (<test> <sample> (:! <cast> 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 [<domain> <generator> <tag> <type> <test> <augmentation> <+> <-> <*> </> <%> <pre> <post>] @@ -126,17 +126,17 @@ #let [subject (<augmentation> param)]] (with-expansions [<tests> (do-template [<procedure> <reference>] [(test <procedure> - (|> (do macro;Monad<Meta> - [sampleI (expressionT;translate (` (<post> ((~ (code;text <procedure>)) + (|> (do macro.Monad<Meta> + [sampleI (expressionT.translate (` (<post> ((~ (code.text <procedure>)) (<pre> (~ (<tag> subject))) (<pre> (~ (<tag> param)))))))] - (@eval;eval sampleI)) - (macro;run (init-compiler [])) - (case> (#e;Success valueT) + (@eval.eval sampleI)) + (macro.run (init-compiler [])) + (case> (#e.Success valueT) (<test> (<reference> param subject) (:! <type> valueT)) - (#e;Error error) + (#e.Error error) false)))] [(format "jvm " <domain> " +") <+>] @@ -149,10 +149,10 @@ <tests> )))))] - ["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 [<domain> <post> <convert>] @@ -164,22 +164,22 @@ (`` ($_ seq (~~ (do-template [<procedure> <reference>] [(test <procedure> - (|> (do macro;Monad<Meta> - [sampleI (expressionT;translate (` (<post> ((~ (code;text <procedure>)) - (<convert> (~ (code;nat subject))) - (<convert> (~ (code;nat param)))))))] - (@eval;eval sampleI)) - (macro;run (init-compiler [])) - (case> (#e;Success valueT) - (n.= (<reference> param subject) + (|> (do macro.Monad<Meta> + [sampleI (expressionT.translate (` (<post> ((~ (code.text <procedure>)) + (<convert> (~ (code.nat subject))) + (<convert> (~ (code.nat param)))))))] + (@eval.eval sampleI)) + (macro.run (init-compiler [])) + (case> (#e.Success valueT) + (n/= (<reference> param subject) (:! Nat valueT)) - (#e;Error error) + (#e.Error error) false)))] - [(format "jvm " <domain> " and") bit;and] - [(format "jvm " <domain> " or") bit;or] - [(format "jvm " <domain> " xor") bit;xor] + [(format "jvm " <domain> " and") bit.and] + [(format "jvm " <domain> " or") bit.or] + [(format "jvm " <domain> " 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 [<procedure> <reference> <type> <test> <pre-subject> <pre>] [(test <procedure> - (|> (do macro;Monad<Meta> - [sampleI (expressionT;translate (` (<post> ((~ (code;text <procedure>)) + (|> (do macro.Monad<Meta> + [sampleI (expressionT.translate (` (<post> ((~ (code.text <procedure>)) (<convert> (~ (<pre> 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) (<test> (<reference> shift (<pre-subject> subject)) (:! <type> valueT)) - (#e;Error error) + (#e.Error error) false)))] - [(format "jvm " <domain> " shl") bit;shift-left Nat n.= id code;nat] - [(format "jvm " <domain> " shr") bit;signed-shift-right Int i.= nat-to-int (|>. nat-to-int code;int)] - [(format "jvm " <domain> " ushr") bit;shift-right Nat n.= id code;nat] + [(format "jvm " <domain> " shl") bit.shift-left Nat n/= id code.nat] + [(format "jvm " <domain> " shr") bit.signed-shift-right Int i/= nat-to-int (|>> nat-to-int code.int)] + [(format "jvm " <domain> " ushr") bit.shift-right Nat n/= id code.nat] )) )))))] @@ -228,17 +228,17 @@ subject <generator>] (with-expansions [<tests> (do-template [<procedure> <reference>] [(test <procedure> - (|> (do macro;Monad<Meta> - [sampleI (expressionT;translate (` ((~ (code;text <procedure>)) + (|> (do macro.Monad<Meta> + [sampleI (expressionT.translate (` ((~ (code.text <procedure>)) (<pre> (~ (<tag> subject))) (<pre> (~ (<tag> param))))))] - (@eval;eval sampleI)) - (macro;run (init-compiler [])) - (case> (#e;Success valueT) + (@eval.eval sampleI)) + (macro.run (init-compiler [])) + (case> (#e.Success valueT) (bool/= (<reference> param subject) (:! Bool valueT)) - (#e;Error error) + (#e.Error error) false)))] [(format "jvm " <domain> " =") <=>] @@ -248,68 +248,68 @@ <tests> )))))] - ["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 [<array> (do-template [<class> <type> <value> <test> <input> <post>] [(test <class> - (|> (do macro;Monad<Meta> - [sampleI (expressionT;translate (|> (jvm//array//new +0 <class> size) + (|> (do macro.Monad<Meta> + [sampleI (expressionT.translate (|> (jvm//array//new +0 <class> size) (jvm//array//write <class> idx <input>) (jvm//array//read <class> idx) (~) <post> (`)))] - (@eval;eval sampleI)) - (macro;run (init-compiler [])) - (case> (#e;Success outputZ) + (@eval.eval sampleI)) + (macro.run (init-compiler [])) + (case> (#e.Success outputZ) (<test> <value> (:! <type> 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 [<array> (do-template [<class> <type> <value> <test> <input> <post>] [(test <class> - (|> (do macro;Monad<Meta> - [sampleI (expressionT;translate (|> (jvm//array//new +0 <class> size) + (|> (do macro.Monad<Meta> + [sampleI (expressionT.translate (|> (jvm//array//new +0 <class> size) (jvm//array//write <class> idx <input>) (jvm//array//read <class> idx) (~) <post> (`)))] - (@eval;eval sampleI)) - (macro;run (init-compiler [])) - (case> (#e;Success outputT) + (@eval.eval sampleI)) + (macro.run (init-compiler [])) + (case> (#e.Success outputT) (<test> <value> (:! <type> 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 <array> (test "java.lang.Double (level 1)" - (|> (do macro;Monad<Meta> - [#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<Meta> + [#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<Meta> - [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<Meta> + [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<Random> map code;bool)) - gen-integer (|> r;int (:: r;Functor<Random> map code;int)) - gen-double (|> r;frac (:: r;Functor<Random> map code;frac)) - gen-string (|> (r;text +5) (:: r;Functor<Random> map code;text))] + (List [Text (r.Random ls.Synthesis)]) + (let [gen-boolean (|> r.bool (:: r.Functor<Random> map code.bool)) + gen-integer (|> r.int (:: r.Functor<Random> map code.int)) + gen-double (|> r.frac (:: r.Functor<Random> map code.frac)) + gen-string (|> (r.text +5) (:: r.Functor<Random> 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<Meta> - [sampleI (expressionT;translate (` ("jvm object null?" ("jvm object null"))))] - (@eval;eval sampleI)) - (macro;run (init-compiler [])) - (case> (#e;Success outputT) + (|> (do macro.Monad<Meta> + [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<Meta> - [sampleI (expressionT;translate (` ("jvm object null?" (~ (code;int sample)))))] - (@eval;eval sampleI)) - (macro;run (init-compiler [])) - (case> (#e;Success outputT) + (|> (do macro.Monad<Meta> + [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<Meta> - [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<Meta> + [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<Meta> - [_ @runtime;translate - sampleI (expressionT;translate (` ("lux try" ("lux function" +1 [] + (|> (do macro.Monad<Meta> + [_ @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<Meta> - [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<Meta> + [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<Meta> - [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<Meta> + [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<Meta> - [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<Meta> + [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<Meta> - [sampleI (expressionT;translate (` ("jvm member static put" "java.awt.datatransfer.DataFlavor" "allHtmlFlavor" "java.awt.datatransfer.DataFlavor" + (|> (do macro.Monad<Meta> + [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<Meta> - [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<Meta> + [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<Meta> - [sampleI (expressionT;translate (` ("jvm member virtual get" "org.omg.CORBA.ValueMember" "name" "java.lang.String" + (|> (do macro.Monad<Meta> + [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<Meta> - [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<Meta> + [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<Meta> - [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<Meta> + [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<Meta> - [sampleI (expressionT;translate (` ("jvm member invoke interface" "java.util.Collection" "add" "boolean" + (|> (do macro.Monad<Meta> + [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<Meta> - [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<Meta> + [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<Meta> - [_ (_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<Meta> + [_ (_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<Meta> - [sampleI (caseT;translate-let expressionT;translate + (|> (do macro.Monad<Meta> + [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 [<tag> <type> <test>] [_ (<tag> prediction')] - (case (host;try (<test> prediction' (:! <type> sample))) - (#e;Success result) + (case (host.try (<test> prediction' (:! <type> 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<Meta> - [sampleI (expressionT;translate (code;tuple members))] - (@eval;eval sampleI)) - (macro;run (init-compiler [])) - (case> (#e;Success valueT) + (|> (do macro.Monad<Meta> + [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<Meta> - [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<Meta> + [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)) |