diff options
Diffstat (limited to 'stdlib/source/test')
21 files changed, 435 insertions, 417 deletions
diff --git a/stdlib/source/test/aedifex/command/build.lux b/stdlib/source/test/aedifex/command/build.lux index 141573f6f..b38b61340 100644 --- a/stdlib/source/test/aedifex/command/build.lux +++ b/stdlib/source/test/aedifex/command/build.lux @@ -84,18 +84,18 @@ (if error? (exception.except shell.no_more_output []) (case state - (#.Cons head tail) + (#.Item head tail) (#try.Success [tail head]) - #.Nil + #.End (exception.except shell.no_more_output [])))) (def: (on_error state) (if error? (case state - (#.Cons head tail) + (#.Item head tail) (#try.Success [tail head]) - #.Nil + #.End (exception.except shell.no_more_output [])) (exception.except shell.no_more_output []))) (def: (on_write input state) diff --git a/stdlib/source/test/lux.lux b/stdlib/source/test/lux.lux index de99ee775..bfdc93f30 100644 --- a/stdlib/source/test/lux.lux +++ b/stdlib/source/test/lux.lux @@ -972,6 +972,23 @@ (is? post (io.run (atom.read box))))))) )) +(def: identity/constant + (All [a] (-> a a)) + (function (_ value) + value)) + +(def: (identity/function value) + (All [a] (-> a a)) + value) + +(def: for_def: + Test + (do random.monad + [expected random.nat] + (_.cover [/.def:] + (and (is? expected (identity/constant expected)) + (is? expected (identity/function expected)))))) + (def: test Test (<| (_.covering /._) @@ -995,6 +1012,7 @@ ..for_value ..for_case ..for_control_flow + ..for_def: ..sub_tests ))) diff --git a/stdlib/source/test/lux/abstract/enum.lux b/stdlib/source/test/lux/abstract/enum.lux index b5c39ad75..8e472db22 100644 --- a/stdlib/source/test/lux/abstract/enum.lux +++ b/stdlib/source/test/lux/abstract/enum.lux @@ -37,7 +37,7 @@ (/.range n.enum start end) (list.reverse (/.range n.enum end start))) every_element_is_a_successor? (case range - (#.Cons head tail) + (#.Item head tail) (|> (list\fold (function (_ next [verdict prev]) [(and verdict (n.= next (\ n.enum succ prev))) @@ -46,7 +46,7 @@ tail) product.left) - #.Nil + #.End false)] (and (n.= expected_size (list.size range)) expected_start? diff --git a/stdlib/source/test/lux/abstract/equivalence.lux b/stdlib/source/test/lux/abstract/equivalence.lux index 007382e60..10af6891d 100644 --- a/stdlib/source/test/lux/abstract/equivalence.lux +++ b/stdlib/source/test/lux/abstract/equivalence.lux @@ -45,10 +45,10 @@ (implementation (def: (= left right) (case [left right] - [#.Nil #.Nil] + [#.End #.End] true - [(#.Cons leftH lefT) (#.Cons rightH rightT)] + [(#.Item leftH lefT) (#.Item rightH rightT)] (and (n.= leftH rightH) (\ equivalence = lefT rightT)) diff --git a/stdlib/source/test/lux/abstract/predicate.lux b/stdlib/source/test/lux/abstract/predicate.lux index 0e902fb40..b821865de 100644 --- a/stdlib/source/test/lux/abstract/predicate.lux +++ b/stdlib/source/test/lux/abstract/predicate.lux @@ -80,10 +80,10 @@ (/.rec (function (_ recur) (function (_ values) (case values - #.Nil + #.End false - (#.Cons head tail) + (#.Item head tail) (or (even? head) (recur tail)))))))] (bit\= (list.any? even? samples) diff --git a/stdlib/source/test/lux/control/concatenative.lux b/stdlib/source/test/lux/control/concatenative.lux index 678a8aa99..fe7773eea 100644 --- a/stdlib/source/test/lux/control/concatenative.lux +++ b/stdlib/source/test/lux/control/concatenative.lux @@ -266,12 +266,12 @@ (/.push |inc|) /.compose /.call))) - (_.cover [/.curry] + (_.cover [/.partial] (n.= (n.+ sample sample) (||> (/.push sample) (/.push sample) (/.push (/.apply/2 n.+)) - /.curry + /.partial /.call))) (_.cover [/.when] (n.= (if choice diff --git a/stdlib/source/test/lux/control/concurrency/frp.lux b/stdlib/source/test/lux/control/concurrency/frp.lux index 5c555ebfc..6d60c750f 100644 --- a/stdlib/source/test/lux/control/concurrency/frp.lux +++ b/stdlib/source/test/lux/control/concurrency/frp.lux @@ -51,15 +51,15 @@ (case amount_of_polls 0 (do async.monad [_ (async.future (\ sink close))] - (in #.Nil)) + (in #.End)) _ (do {! async.monad} [event channel] (case event #.None - (in #.Nil) + (in #.End) (#.Some [head tail]) - (\ ! map (|>> (#.Cons head)) + (\ ! map (|>> (#.Item head)) (take_amount (dec amount_of_polls) [channel sink])))))) (def: #export test diff --git a/stdlib/source/test/lux/control/continuation.lux b/stdlib/source/test/lux/control/continuation.lux index 24944c49e..4103d1a1f 100644 --- a/stdlib/source/test/lux/control/continuation.lux +++ b/stdlib/source/test/lux/control/continuation.lux @@ -72,15 +72,15 @@ (/.Cont (List Nat) (List Nat))) (function (visit xs) (case xs - #.Nil - (_\in #.Nil) + #.End + (_\in #.End) - (#.Cons x xs') + (#.Item x xs') (do {! /.monad} [output (/.shift (function (_ k) (do ! [tail (k xs')] - (in (#.Cons x tail)))))] + (in (#.Item x tail)))))] (visit output)))))] (list\= elems (/.run (/.reset (visit elems)))))) diff --git a/stdlib/source/test/lux/control/parser.lux b/stdlib/source/test/lux/control/parser.lux index 382d17063..b71ab1256 100644 --- a/stdlib/source/test/lux/control/parser.lux +++ b/stdlib/source/test/lux/control/parser.lux @@ -110,7 +110,7 @@ (\ (list.equivalence n.equivalence) = expected+ actual))) (|> (list\map (|>> .int code.int) expected+) (/.run (/.some <code>.nat)) - (match #.Nil + (match #.End #1)))) (_.cover [/.many] (and (|> (list\map code.nat expected+) diff --git a/stdlib/source/test/lux/data/binary.lux b/stdlib/source/test/lux/data/binary.lux index b8775be48..a9e977c0a 100644 --- a/stdlib/source/test/lux/data/binary.lux +++ b/stdlib/source/test/lux/data/binary.lux @@ -72,7 +72,7 @@ (def: as_list (-> /.Binary (List Nat)) (/.fold (function (_ head tail) - (#.Cons head tail)) + (#.Item head tail)) (list))) (def: #export test @@ -138,10 +138,10 @@ (and (\ /.equivalence = sample (/.drop 0 sample)) (\ /.equivalence = (/.create 0) (/.drop size sample)) (case (list.reverse (..as_list sample)) - #.Nil + #.End false - (#.Cons head tail) + (#.Item head tail) (n.= (list.fold n.+ 0 tail) (/.fold n.+ 0 (/.drop 1 sample)))))) (_.cover [/.copy] diff --git a/stdlib/source/test/lux/data/collection/list.lux b/stdlib/source/test/lux/data/collection/list.lux index 207ba73d9..2374b2f21 100644 --- a/stdlib/source/test/lux/data/collection/list.lux +++ b/stdlib/source/test/lux/data/collection/list.lux @@ -238,20 +238,20 @@ [($_ _.and (_.cover [<head>] (case [(<pre> sample) (<head> sample)] - [(#.Cons expected _) (#.Some actual)] + [(#.Item expected _) (#.Some actual)] (n.= expected actual) - [#.Nil #.None] + [#.End #.None] true _ false)) (_.cover [<tail>] (case [(<pre> sample) (<tail> sample)] - [(#.Cons _ expected) (#.Some actual)] + [(#.Item _ expected) (#.Some actual)] (/\= (<pre> expected) actual) - [#.Nil #.None] + [#.End #.None] true _ diff --git a/stdlib/source/test/lux/data/collection/queue.lux b/stdlib/source/test/lux/data/collection/queue.lux index 3bc695aca..b394220ef 100644 --- a/stdlib/source/test/lux/data/collection/queue.lux +++ b/stdlib/source/test/lux/data/collection/queue.lux @@ -60,10 +60,10 @@ all_empty_queues_look_the_same!))) (_.cover [/.peek] (case [members (/.peek sample)] - [(#.Cons head tail) (#.Some first)] + [(#.Item head tail) (#.Some first)] (n.= head first) - [#.Nil #.None] + [#.End #.None] true _ @@ -95,7 +95,7 @@ has_expected_order!))) (_.cover [/.pop] (case members - (#.Cons target expected) + (#.Item target expected) (let [popped (/.pop sample) size_decreases! @@ -113,7 +113,7 @@ popped_member_is_not_identified! has_expected_order!)) - #.Nil + #.End (and (/.empty? sample) (/.empty? (/.pop sample))))) )))) diff --git a/stdlib/source/test/lux/target/jvm.lux b/stdlib/source/test/lux/target/jvm.lux index fbbcc2414..1f52753d1 100644 --- a/stdlib/source/test/lux/target/jvm.lux +++ b/stdlib/source/test/lux/target/jvm.lux @@ -1030,7 +1030,7 @@ (..bytecode (|>> (:as Nat) (n.= sizesH))) (do {! /.monad} [_ (monad.map ! (|>> (:as java/lang/Long) ffi.long_to_int ..$Integer::literal) - (#.Cons sizesH sizesT)) + (#.Item sizesH sizesT)) _ (/.multianewarray type (|> dimensions /unsigned.u1 try.assumed)) _ ?length] $Long::wrap)))) diff --git a/stdlib/source/test/lux/tool/compiler/language/lux/phase/analysis/case.lux b/stdlib/source/test/lux/tool/compiler/language/lux/phase/analysis/case.lux index 0c1d1a712..4afc28a2d 100644 --- a/stdlib/source/test/lux/tool/compiler/language/lux/phase/analysis/case.lux +++ b/stdlib/source/test/lux/tool/compiler/language/lux/phase/analysis/case.lux @@ -40,17 +40,17 @@ (def: (exhaustive_weaving branchings) (-> (List (List Code)) (List (List Code))) (case branchings - #.Nil - #.Nil + #.End + #.End - (#.Cons head+ #.Nil) + (#.Item head+ #.End) (list\map (|>> list) head+) - (#.Cons head+ tail++) + (#.Item head+ tail++) (do list.monad [tail+ (exhaustive_weaving tail++) head head+] - (in (#.Cons head tail+))))) + (in (#.Item head tail+))))) (def: #export (exhaustive_branches allow_literals? variantTC inputC) (-> Bit (List [Code Code]) Code (Random (List Code))) diff --git a/stdlib/source/test/lux/tool/compiler/language/lux/phase/analysis/function.lux b/stdlib/source/test/lux/tool/compiler/language/lux/phase/analysis/function.lux index b8a692f07..1cf61d839 100644 --- a/stdlib/source/test/lux/tool/compiler/language/lux/phase/analysis/function.lux +++ b/stdlib/source/test/lux/tool/compiler/language/lux/phase/analysis/function.lux @@ -101,7 +101,7 @@ partial_polyT1 (<| (type.function partial_poly_inputsT) poly_inputT) partial_polyT2 (<| (type.univ_q 1) - (type.function (#.Cons varT partial_poly_inputsT)) + (type.function (#.Item varT partial_poly_inputsT)) varT) dummy_function (#////analysis.Function (list) (#////analysis.Reference (////reference.local 1)))]] (<| (_.context (%.name (name_of /.apply))) diff --git a/stdlib/source/test/lux/tool/compiler/language/lux/phase/synthesis/case.lux b/stdlib/source/test/lux/tool/compiler/language/lux/phase/synthesis/case.lux index 8eed2d440..e24fac097 100644 --- a/stdlib/source/test/lux/tool/compiler/language/lux/phase/synthesis/case.lux +++ b/stdlib/source/test/lux/tool/compiler/language/lux/phase/synthesis/case.lux @@ -39,7 +39,7 @@ [meta ["." archive]]]]]]]]) -(def: masking-test +(def: masking_test Test (do {! random.monad} [maskedA //primitive.primitive @@ -49,14 +49,14 @@ [[(#analysis.Bind temp) (#analysis.Reference (////reference.local temp))] (list)]])]] - (_.cover [/.synthesize-masking] + (_.cover [/.synthesize_masking] (|> maskA (//.phase archive.empty) (phase.run [///bundle.empty synthesis.init]) (try\map (//primitive.corresponds? maskedA)) (try.default false))))) -(def: let-test +(def: let_test Test (do random.monad [registerA random.nat @@ -67,7 +67,7 @@ [[(#analysis.Bind registerA) outputA] (list)]])]] - (_.cover [/.synthesize-let] + (_.cover [/.synthesize_let] (|> letA (//.phase archive.empty) (phase.run [///bundle.empty synthesis.init]) @@ -79,7 +79,7 @@ _ false))))) -(def: if-test +(def: if_test Test (do random.monad [then|else random.bit @@ -95,7 +95,7 @@ ifA (if then|else (analysis.control/case [inputA [thenB (list elseB)]]) (analysis.control/case [inputA [elseB (list thenB)]]))]] - (_.cover [/.synthesize-if] + (_.cover [/.synthesize_if] (|> ifA (//.phase archive.empty) (phase.run [///bundle.empty synthesis.init]) @@ -107,7 +107,7 @@ _ false))))) -(def: random-member +(def: random_member (Random synthesis.Member) (do {! random.monad} [lefts (|> random.nat (\ ! map (n.% 10))) @@ -116,13 +116,13 @@ (#.Right lefts) (#.Left lefts))))) -(def: random-path +(def: random_path (Random (analysis.Tuple synthesis.Member)) (do {! random.monad} - [size-1 (|> random.nat (\ ! map (|>> (n.% 10) inc)))] - (random.list size-1 ..random-member))) + [size_1 (|> random.nat (\ ! map (|>> (n.% 10) inc)))] + (random.list size_1 ..random_member))) -(def: (get-pattern path) +(def: (get_pattern path) (-> (analysis.Tuple synthesis.Member) (Random [analysis.Pattern Register])) (do random.monad @@ -142,19 +142,19 @@ (list.reverse path)) @member]))) -(def: get-test +(def: get_test Test (do {! random.monad} [recordA (|> random.nat (\ ! map (|>> analysis.nat)) (random.list 10) (\ ! map (|>> analysis.tuple))) - pathA ..random-path - [pattern @member] (get-pattern pathA) + pathA ..random_path + [pattern @member] (get_pattern pathA) #let [getA (analysis.control/case [recordA [[pattern (#analysis.Reference (////reference.local @member))] (list)]])]] - (_.cover [/.synthesize-get] + (_.cover [/.synthesize_get] (|> getA (//.phase archive.empty) (phase.run [///bundle.empty synthesis.init]) @@ -165,7 +165,7 @@ _ false))))) -(def: random-bit +(def: random_bit (Random [Path Match]) (do {! random.monad} [test random.bit @@ -180,9 +180,9 @@ (list {#analysis.when (analysis.pattern/bit (not test)) #analysis.then (analysis.nat else)})]]))) -(def: (random-five hash random-element) +(def: (random_five hash random_element) (All [a] (-> (Hash a) (Random a) (Random [a a a a a]))) - (|> random-element + (|> random_element (random.set hash 5) (\ random.monad map (|>> set.to_list (case> (^ (list s0 s1 s2 s3 s4)) @@ -195,8 +195,8 @@ [(def: <name> (Random [Path Match]) (do {! random.monad} - [[test/0 test/1 test/2 test/3 test/4] (random-five <hash> <random>) - [body/0 body/1 body/2 body/3 body/4] (random-five <hash> <random>)] + [[test/0 test/1 test/2 test/3 test/4] (random_five <hash> <random>) + [body/0 body/1 body/2 body/3 body/4] (random_five <hash> <random>)] (in [($_ #synthesis.Alt (#synthesis.Seq (<path> test/0) (#synthesis.Then (<synthesis> body/0))) (#synthesis.Seq (<path> test/1) (#synthesis.Then (<synthesis> body/1))) @@ -209,30 +209,30 @@ {#analysis.when (<pattern> test/3) #analysis.then (<analysis> body/3)} {#analysis.when (<pattern> test/4) #analysis.then (<analysis> body/4)})]])))] - [random-nat n.hash random.nat (|>> .i64 synthesis.path/i64) (|>> .i64 synthesis.i64) analysis.pattern/nat analysis.nat] - [random-int int.hash random.int (|>> .i64 synthesis.path/i64) (|>> .i64 synthesis.i64) analysis.pattern/int analysis.int] - [random-rev rev.hash random.rev (|>> .i64 synthesis.path/i64) (|>> .i64 synthesis.i64) analysis.pattern/rev analysis.rev] - [random-frac frac.hash random.frac synthesis.path/f64 synthesis.f64 analysis.pattern/frac analysis.frac] - [random-text text.hash (random.unicode 1) synthesis.path/text synthesis.text analysis.pattern/text analysis.text] + [random_nat n.hash random.nat (|>> .i64 synthesis.path/i64) (|>> .i64 synthesis.i64) analysis.pattern/nat analysis.nat] + [random_int int.hash random.int (|>> .i64 synthesis.path/i64) (|>> .i64 synthesis.i64) analysis.pattern/int analysis.int] + [random_rev rev.hash random.rev (|>> .i64 synthesis.path/i64) (|>> .i64 synthesis.i64) analysis.pattern/rev analysis.rev] + [random_frac frac.hash random.frac synthesis.path/f64 synthesis.f64 analysis.pattern/frac analysis.frac] + [random_text text.hash (random.unicode 1) synthesis.path/text synthesis.text analysis.pattern/text analysis.text] ) -(def: random-simple +(def: random_simple ($_ random.either - ..random-bit - ..random-nat - ..random-int - ..random-rev - ..random-frac - ..random-text + ..random_bit + ..random_nat + ..random_int + ..random_rev + ..random_frac + ..random_text )) -(def: random-variant +(def: random_variant (Random [Path Match]) (do {! random.monad} - [[lefts/0 lefts/1 lefts/2 lefts/3 lefts/4] (random-five n.hash random.nat) - [value/0 value/1 value/2 value/3 value/4] (random-five text.hash (random.unicode 1)) - last-is-right? random.bit - [body/0 body/1 body/2 body/3 body/4] (random-five frac.hash random.frac) + [[lefts/0 lefts/1 lefts/2 lefts/3 lefts/4] (random_five n.hash random.nat) + [value/0 value/1 value/2 value/3 value/4] (random_five text.hash (random.unicode 1)) + last_is_right? random.bit + [body/0 body/1 body/2 body/3 body/4] (random_five frac.hash random.frac) #let [path (: (-> Nat Bit Text Frac Path) (function (_ lefts right? value body) ($_ #synthesis.Seq @@ -252,24 +252,24 @@ (path lefts/1 false value/1 body/1) (path lefts/2 false value/2 body/2) (path lefts/3 false value/3 body/3) - (path lefts/4 last-is-right? value/4 body/4)) + (path lefts/4 last_is_right? value/4 body/4)) [(branch lefts/0 false value/0 body/0) (list (branch lefts/1 false value/1 body/1) (branch lefts/2 false value/2 body/2) (branch lefts/3 false value/3 body/3) - (branch lefts/4 last-is-right? value/4 body/4))]]))) + (branch lefts/4 last_is_right? value/4 body/4))]]))) -(def: random-tuple +(def: random_tuple (Random [Path Match]) (do {! random.monad} - [mid-size (\ ! map (n.% 4) random.nat) + [mid_size (\ ! map (n.% 4) random.nat) value/first (random.unicode 1) - value/mid (random.list mid-size (random.unicode 1)) + value/mid (random.list mid_size (random.unicode 1)) value/last (random.unicode 1) body/first random.frac - body/mid (random.list mid-size random.frac) + body/mid (random.list mid_size random.frac) body/last random.frac #let [path (: (-> Nat Bit Text Frac Path) (function (_ lefts right? value body) @@ -299,9 +299,9 @@ #analysis.then (analysis.frac body)}))]] (in [(list\fold (function (_ left right) (#synthesis.Alt left right)) - (path (inc mid-size) true value/last body/last) + (path (inc mid_size) true value/last body/last) (|> (list.zipped/2 value/mid body/mid) - (#.Cons [value/first body/first]) + (#.Item [value/first body/first]) list.enumeration (list\map (function (_ [lefts' [value body]]) (path lefts' false value body))) @@ -311,31 +311,31 @@ list.enumeration (list\map (function (_ [lefts' [value body]]) (branch (inc lefts') false value body)))) - (list (branch (inc mid-size) true value/last body/last)))]]))) + (list (branch (inc mid_size) true value/last body/last)))]]))) -(def: random-complex +(def: random_complex ($_ random.either - ..random-variant - ..random-tuple + ..random_variant + ..random_tuple )) -(def: random-case +(def: random_case ($_ random.either - ..random-simple - ..random-complex + ..random_simple + ..random_complex )) -(def: case-test +(def: case_test Test (do {! random.monad} - [expected-input (\ ! map (|>> .i64 synthesis.i64) random.nat) - [expected-path match] ..random-case] - (_.cover [/.synthesize-case] - (|> (/.synthesize-case //.phase archive.empty expected-input match) + [expected_input (\ ! map (|>> .i64 synthesis.i64) random.nat) + [expected_path match] ..random_case] + (_.cover [/.synthesize_case] + (|> (/.synthesize_case //.phase archive.empty expected_input match) (phase.run [///bundle.empty synthesis.init]) - (case> (^ (#try.Success (synthesis.branch/case [actual-input actual-path]))) - (and (\ synthesis.equivalence = expected-input actual-input) - (\ synthesis.path-equivalence = expected-path actual-path)) + (case> (^ (#try.Success (synthesis.branch/case [actual_input actual_path]))) + (and (\ synthesis.equivalence = expected_input actual_input) + (\ synthesis.path_equivalence = expected_path actual_path)) _ false))))) @@ -345,9 +345,9 @@ (<| (_.covering /._) (_.for [/.synthesize]) ($_ _.and - ..masking-test - ..let-test - ..if-test - ..get-test - ..case-test + ..masking_test + ..let_test + ..if_test + ..get_test + ..case_test ))) diff --git a/stdlib/source/test/lux/tool/compiler/language/lux/phase/synthesis/function.lux b/stdlib/source/test/lux/tool/compiler/language/lux/phase/synthesis/function.lux index 63d9d9d20..4b9b9a9f3 100644 --- a/stdlib/source/test/lux/tool/compiler/language/lux/phase/synthesis/function.lux +++ b/stdlib/source/test/lux/tool/compiler/language/lux/phase/synthesis/function.lux @@ -37,7 +37,7 @@ [meta ["." archive]]]]]]]]) -(def: (n-function loop? arity body) +(def: (n_function loop? arity body) (-> Bit Arity Synthesis Synthesis) (synthesis.function/abstraction {#synthesis.environment (list) @@ -49,14 +49,14 @@ #synthesis.iteration body}) body)})) -(def: (n-abstraction arity body) +(def: (n_abstraction arity body) (-> Arity Analysis Analysis) - (list\fold (function (_ arity-1 body) - (case arity-1 + (list\fold (function (_ arity_1 body) + (case arity_1 0 (#analysis.Function (list) body) _ (#analysis.Function ($_ list\compose (list\map (|>> #variable.Foreign) - (list.indices arity-1)) + (list.indices arity_1)) (list (#variable.Local 1))) body))) body @@ -78,7 +78,7 @@ (type: Scenario (-> Bit (Random Circumstance))) -(def: (random-unit output?) +(def: (random_unit output?) Scenario (\ random.monad in [true @@ -94,57 +94,57 @@ (<synthesis> value) (<analysis> value)])))] - [random-bit random.bit synthesis.bit analysis.bit] - [random-nat random.nat (|>> .i64 synthesis.i64) analysis.nat] - [random-int random.int (|>> .i64 synthesis.i64) analysis.int] - [random-rev random.rev (|>> .i64 synthesis.i64) analysis.rev] - [random-frac random.frac synthesis.f64 analysis.frac] - [random-text (random.unicode 1) synthesis.text analysis.text] + [random_bit random.bit synthesis.bit analysis.bit] + [random_nat random.nat (|>> .i64 synthesis.i64) analysis.nat] + [random_int random.int (|>> .i64 synthesis.i64) analysis.int] + [random_rev random.rev (|>> .i64 synthesis.i64) analysis.rev] + [random_frac random.frac synthesis.f64 analysis.frac] + [random_text (random.unicode 1) synthesis.text analysis.text] ) -(def: (random-primitive output?) +(def: (random_primitive output?) Scenario - (random.either (random.either (..random-unit output?) - (random.either (..random-bit output?) - (..random-nat output?))) - (random.either (random.either (..random-int output?) - (..random-rev output?)) - (random.either (..random-frac output?) - (..random-text output?))))) - -(def: (random-variant random-value output?) + (random.either (random.either (..random_unit output?) + (random.either (..random_bit output?) + (..random_nat output?))) + (random.either (random.either (..random_int output?) + (..random_rev output?)) + (random.either (..random_frac output?) + (..random_text output?))))) + +(def: (random_variant random_value output?) (-> Scenario Scenario) (do {! random.monad} [lefts random.nat right? random.bit - [loop? expected-value actual-value] (random-value false)] + [loop? expected_value actual_value] (random_value false)] (in [loop? (synthesis.variant {#analysis.lefts lefts #analysis.right? right? - #analysis.value expected-value}) + #analysis.value expected_value}) (analysis.variant {#analysis.lefts lefts #analysis.right? right? - #analysis.value actual-value})]))) + #analysis.value actual_value})]))) -(def: (random-tuple random-value output?) +(def: (random_tuple random_value output?) (-> Scenario Scenario) (do {! random.monad} - [[loop?-left expected-left actual-left] (random-value false) - [loop?-right expected-right actual-right] (random-value false)] - (in [(and loop?-left - loop?-right) - (synthesis.tuple (list expected-left expected-right)) - (analysis.tuple (list actual-left actual-right))]))) - -(def: (random-structure random-value output?) + [[loop?_left expected_left actual_left] (random_value false) + [loop?_right expected_right actual_right] (random_value false)] + (in [(and loop?_left + loop?_right) + (synthesis.tuple (list expected_left expected_right)) + (analysis.tuple (list actual_left actual_right))]))) + +(def: (random_structure random_value output?) (-> Scenario Scenario) ($_ random.either - (..random-variant random-value output?) - (..random-tuple random-value output?))) + (..random_variant random_value output?) + (..random_tuple random_value output?))) -(def: (random-variable arity output?) +(def: (random_variable arity output?) (-> Arity Scenario) (do {! random.monad} [register (\ ! map (|>> (n.% arity) inc) random.nat)] @@ -154,7 +154,7 @@ (#analysis.Reference (reference.local 1)) (#analysis.Reference (reference.foreign register)))]))) -(def: (random-constant output?) +(def: (random_constant output?) Scenario (do {! random.monad} [module (random.unicode 1) @@ -163,131 +163,131 @@ (synthesis.constant [module short]) (#analysis.Reference (reference.constant [module short]))]))) -(def: (random-reference arity output?) +(def: (random_reference arity output?) (-> Arity Scenario) - (random.either (..random-variable arity output?) - (..random-constant output?))) + (random.either (..random_variable arity output?) + (..random_constant output?))) -(def: (random-case arity random-value output?) +(def: (random_case arity random_value output?) (-> Arity Scenario Scenario) (do {! random.monad} - [bit-test random.bit - i64-test random.nat - f64-test random.frac - text-test (random.unicode 1) - [loop?-input expected-input actual-input] (random-value false) - [loop?-output expected-output actual-output] (random-value output?) + [bit_test random.bit + i64_test random.nat + f64_test random.frac + text_test (random.unicode 1) + [loop?_input expected_input actual_input] (random_value false) + [loop?_output expected_output actual_output] (random_value output?) lefts (|> random.nat (\ ! map (n.% 10))) right? random.bit #let [side|member (if right? (#.Right lefts) (#.Left lefts))]] - (in [(and loop?-input - loop?-output) - (synthesis.branch/case [expected-input + (in [(and loop?_input + loop?_output) + (synthesis.branch/case [expected_input ($_ synthesis.path/alt - (synthesis.path/then expected-output) - (synthesis.path/seq (synthesis.path/bit bit-test) - (synthesis.path/then expected-output)) - (synthesis.path/seq (synthesis.path/i64 (.i64 i64-test)) - (synthesis.path/then expected-output)) - (synthesis.path/seq (synthesis.path/f64 f64-test) - (synthesis.path/then expected-output)) - (synthesis.path/seq (synthesis.path/text text-test) - (synthesis.path/then expected-output)) + (synthesis.path/then expected_output) + (synthesis.path/seq (synthesis.path/bit bit_test) + (synthesis.path/then expected_output)) + (synthesis.path/seq (synthesis.path/i64 (.i64 i64_test)) + (synthesis.path/then expected_output)) + (synthesis.path/seq (synthesis.path/f64 f64_test) + (synthesis.path/then expected_output)) + (synthesis.path/seq (synthesis.path/text text_test) + (synthesis.path/then expected_output)) (synthesis.path/seq (synthesis.path/bind (inc arity)) - (synthesis.path/then expected-output)) + (synthesis.path/then expected_output)) ($_ synthesis.path/seq (synthesis.path/side side|member) (synthesis.path/bind (inc arity)) - (synthesis.path/then expected-output)) + (synthesis.path/then expected_output)) (if right? ($_ synthesis.path/seq (synthesis.path/member side|member) (synthesis.path/bind (inc arity)) - (synthesis.path/then expected-output)) + (synthesis.path/then expected_output)) ($_ synthesis.path/seq (synthesis.path/member side|member) (synthesis.path/bind (inc arity)) synthesis.path/pop - (synthesis.path/then expected-output))))]) - (#analysis.Case actual-input + (synthesis.path/then expected_output))))]) + (#analysis.Case actual_input [{#analysis.when (analysis.pattern/unit) - #analysis.then actual-output} - (list {#analysis.when (analysis.pattern/bit bit-test) - #analysis.then actual-output} - {#analysis.when (analysis.pattern/nat (.nat i64-test)) - #analysis.then actual-output} - {#analysis.when (analysis.pattern/frac f64-test) - #analysis.then actual-output} - {#analysis.when (analysis.pattern/text text-test) - #analysis.then actual-output} + #analysis.then actual_output} + (list {#analysis.when (analysis.pattern/bit bit_test) + #analysis.then actual_output} + {#analysis.when (analysis.pattern/nat (.nat i64_test)) + #analysis.then actual_output} + {#analysis.when (analysis.pattern/frac f64_test) + #analysis.then actual_output} + {#analysis.when (analysis.pattern/text text_test) + #analysis.then actual_output} {#analysis.when (#analysis.Bind 2) - #analysis.then actual-output} + #analysis.then actual_output} {#analysis.when (analysis.pattern/variant {#analysis.lefts lefts #analysis.right? right? #analysis.value (#analysis.Bind 2)}) - #analysis.then actual-output} + #analysis.then actual_output} {#analysis.when (analysis.pattern/tuple (list\compose (list.repeat lefts (analysis.pattern/unit)) (if right? (list (analysis.pattern/unit) (#analysis.Bind 2)) (list (#analysis.Bind 2) (analysis.pattern/unit))))) - #analysis.then actual-output})])]))) + #analysis.then actual_output})])]))) -(def: (random-let arity random-value output?) +(def: (random_let arity random_value output?) (-> Arity Scenario Scenario) (do {! random.monad} - [[loop?-input expected-input actual-input] (random-value false) - [loop?-output expected-output actual-output] (random-value output?)] - (in [(and loop?-input - loop?-output) - (synthesis.branch/let [expected-input + [[loop?_input expected_input actual_input] (random_value false) + [loop?_output expected_output actual_output] (random_value output?)] + (in [(and loop?_input + loop?_output) + (synthesis.branch/let [expected_input (inc arity) - expected-output]) - (#analysis.Case actual-input + expected_output]) + (#analysis.Case actual_input [{#analysis.when (#analysis.Bind 2) - #analysis.then actual-output} + #analysis.then actual_output} (list)])]))) -(def: (random-if random-value output?) +(def: (random_if random_value output?) (-> Scenario Scenario) (do {! random.monad} - [[loop?-test expected-test actual-test] (random-value false) - [loop?-then expected-then actual-then] (random-value output?) - [loop?-else expected-else actual-else] (random-value output?) + [[loop?_test expected_test actual_test] (random_value false) + [loop?_then expected_then actual_then] (random_value output?) + [loop?_else expected_else actual_else] (random_value output?) flip? random.bit] - (in [(and loop?-test - loop?-then - loop?-else) - (synthesis.branch/if [expected-test - expected-then - expected-else]) + (in [(and loop?_test + loop?_then + loop?_else) + (synthesis.branch/if [expected_test + expected_then + expected_else]) (if flip? - (#analysis.Case actual-test + (#analysis.Case actual_test [{#analysis.when (analysis.pattern/bit false) - #analysis.then actual-else} + #analysis.then actual_else} (list {#analysis.when (analysis.pattern/bit true) - #analysis.then actual-then})]) - (#analysis.Case actual-test + #analysis.then actual_then})]) + (#analysis.Case actual_test [{#analysis.when (analysis.pattern/bit true) - #analysis.then actual-then} + #analysis.then actual_then} (list {#analysis.when (analysis.pattern/bit false) - #analysis.then actual-else})]))]))) + #analysis.then actual_else})]))]))) -(def: (random-get random-value output?) +(def: (random_get random_value output?) (-> Scenario Scenario) (do {! random.monad} [lefts (|> random.nat (\ ! map (n.% 10))) right? random.bit - [loop?-record expected-record actual-record] (random-value false)] - (in [loop?-record + [loop?_record expected_record actual_record] (random_value false)] + (in [loop?_record (synthesis.branch/get [(list (if right? (#.Right lefts) (#.Left lefts))) - expected-record]) - (#analysis.Case actual-record + expected_record]) + (#analysis.Case actual_record [{#analysis.when (analysis.pattern/tuple (list\compose (list.repeat lefts (analysis.pattern/unit)) (if right? @@ -296,17 +296,17 @@ #analysis.then (#analysis.Reference (reference.local 2))} (list)])]))) -(def: (random-branch arity random-value output?) +(def: (random_branch arity random_value output?) (-> Arity Scenario Scenario) - (random.either (random.either (..random-case arity random-value output?) - (..random-let arity random-value output?)) - (random.either (..random-if random-value output?) - (..random-get random-value output?)))) + (random.either (random.either (..random_case arity random_value output?) + (..random_let arity random_value output?)) + (random.either (..random_if random_value output?) + (..random_get random_value output?)))) -(def: (random-recur arity random-value output?) +(def: (random_recur arity random_value output?) (-> Arity Scenario Scenario) (do {! random.monad} - [resets (random.list arity (random-value false))] + [resets (random.list arity (random_value false))] (in [true (synthesis.loop/recur (list\map (|>> product.right product.left) resets)) (analysis.apply [(#analysis.Reference (case arity @@ -314,11 +314,11 @@ _ (reference.foreign 0))) (list\map (|>> product.right product.right) resets)])]))) -(def: (random-scope arity output?) +(def: (random_scope arity output?) (-> Arity Scenario) (do {! random.monad} - [resets (random.list arity (..random-variable arity output?)) - [_ expected-output actual-output] (..random-nat output?)] + [resets (random.list arity (..random_variable arity output?)) + [_ expected_output actual_output] (..random_nat output?)] (in [(list\fold (function (_ new old) (and new old)) true @@ -326,23 +326,23 @@ (synthesis.loop/scope {#synthesis.start (inc arity) #synthesis.inits (list\map (|>> product.right product.left) resets) - #synthesis.iteration expected-output}) - (analysis.apply [(..n-abstraction arity actual-output) + #synthesis.iteration expected_output}) + (analysis.apply [(..n_abstraction arity actual_output) (list\map (|>> product.right product.right) resets)])]))) -(def: (random-loop arity random-value output?) +(def: (random_loop arity random_value output?) (-> Arity Scenario Scenario) (if output? ($_ random.either - (..random-recur arity random-value output?) - (..random-scope arity output?) + (..random_recur arity random_value output?) + (..random_scope arity output?) ) - (..random-scope arity output?))) + (..random_scope arity output?))) -(def: (random-abstraction' output?) +(def: (random_abstraction' output?) Scenario (do {! random.monad} - [[loop?-output expected-output actual-output] (..random-nat output?) + [[loop?_output expected_output actual_output] (..random_nat output?) arity (|> random.nat (\ ! map (|>> (n.% 5) inc))) #let [environment ($_ list\compose (list\map (|>> #variable.Foreign) @@ -355,79 +355,79 @@ #synthesis.body (synthesis.loop/scope {#synthesis.start 1 #synthesis.inits (list) - #synthesis.iteration expected-output})}) + #synthesis.iteration expected_output})}) (#analysis.Function environment - actual-output)]))) + actual_output)]))) -(def: (random-apply random-value output?) +(def: (random_apply random_value output?) (-> Scenario Scenario) (do {! random.monad} - [[loop?-abstraction expected-abstraction actual-abstraction] (..random-nat output?) + [[loop?_abstraction expected_abstraction actual_abstraction] (..random_nat output?) arity (|> random.nat (\ ! map (|>> (n.% 5) inc))) - inputs (random.list arity (random-value false))] + inputs (random.list arity (random_value false))] (in [(list\fold (function (_ new old) (and new old)) - loop?-abstraction + loop?_abstraction (list\map product.left inputs)) - (synthesis.function/apply [expected-abstraction + (synthesis.function/apply [expected_abstraction (list\map (|>> product.right product.left) inputs)]) - (analysis.apply [actual-abstraction + (analysis.apply [actual_abstraction (list\map (|>> product.right product.right) inputs)])]))) -(def: (random-function random-value output?) +(def: (random_function random_value output?) (-> Scenario Scenario) (if output? - (..random-apply random-value output?) + (..random_apply random_value output?) ($_ random.either - (..random-abstraction' output?) - (..random-apply random-value output?) + (..random_abstraction' output?) + (..random_apply random_value output?) ))) -(def: (random-control arity random-value output?) +(def: (random_control arity random_value output?) (-> Arity Scenario Scenario) ($_ random.either - (..random-branch arity random-value output?) - (..random-loop arity random-value output?) - (..random-function random-value output?) + (..random_branch arity random_value output?) + (..random_loop arity random_value output?) + (..random_function random_value output?) )) -(def: (random-extension random-value output?) +(def: (random_extension random_value output?) (-> Scenario Scenario) (do {! random.monad} [name (random.unicode 1) - [loop?-first expected-first actual-first] (random-value false) - [loop?-second expected-second actual-second] (random-value false) - [loop?-third expected-third actual-third] (random-value false)] - (in [(and loop?-first - loop?-second - loop?-third) - (#synthesis.Extension name (list expected-first expected-second expected-third)) - (#analysis.Extension name (list actual-first actual-second actual-third))]))) - -(def: (random-body arity) + [loop?_first expected_first actual_first] (random_value false) + [loop?_second expected_second actual_second] (random_value false) + [loop?_third expected_third actual_third] (random_value false)] + (in [(and loop?_first + loop?_second + loop?_third) + (#synthesis.Extension name (list expected_first expected_second expected_third)) + (#analysis.Extension name (list actual_first actual_second actual_third))]))) + +(def: (random_body arity) (-> Arity Scenario) - (function (random-value output?) + (function (random_value output?) (random.rec (function (_ _) ($_ random.either - (..random-primitive output?) - (..random-structure random-value output?) - (..random-reference arity output?) - (..random-control arity random-value output?) - (..random-extension random-value output?)))))) + (..random_primitive output?) + (..random_structure random_value output?) + (..random_reference arity output?) + (..random_control arity random_value output?) + (..random_extension random_value output?)))))) -(def: random-abstraction +(def: random_abstraction (Random [Synthesis Analysis]) (do {! random.monad} [arity (|> random.nat (\ ! map (|>> (n.% 5) inc))) - [loop? expected-body actual-body] (random-body arity true)] - (in [(..n-function loop? arity expected-body) - (..n-abstraction arity actual-body)]))) + [loop? expected_body actual_body] (random_body arity true)] + (in [(..n_function loop? arity expected_body) + (..n_abstraction arity actual_body)]))) (def: abstraction Test (do random.monad - [[expected input] ..random-abstraction] + [[expected input] ..random_abstraction] (_.cover [/.abstraction] (|> input (//.phase archive.empty) diff --git a/stdlib/source/test/lux/tool/compiler/language/lux/phase/synthesis/primitive.lux b/stdlib/source/test/lux/tool/compiler/language/lux/phase/synthesis/primitive.lux index e46960793..e4ccec535 100644 --- a/stdlib/source/test/lux/tool/compiler/language/lux/phase/synthesis/primitive.lux +++ b/stdlib/source/test/lux/tool/compiler/language/lux/phase/synthesis/primitive.lux @@ -44,11 +44,11 @@ (def: #export (corresponds? analysis synthesis) (-> Analysis Synthesis Bit) (`` (case [analysis synthesis] - (~~ (template [<analysis> <post-analysis> <synthesis> <post-synthesis>] + (~~ (template [<analysis> <post_analysis> <synthesis> <post_synthesis>] [[(#////analysis.Primitive (<analysis> expected)) (#////synthesis.Primitive (<synthesis> actual))] - (is? (|> expected <post-analysis>) - (|> actual <post-synthesis>))] + (is? (|> expected <post_analysis>) + (|> actual <post_synthesis>))] [#////analysis.Unit (:as Text) #////synthesis.Text (|>)] [#////analysis.Bit (|>) #////synthesis.Bit (|>)] @@ -72,12 +72,12 @@ (def: #export test Test - (<| (_.context (%.name (name-of #////synthesis.Primitive))) + (<| (_.context (%.name (name_of #////synthesis.Primitive))) (`` ($_ _.and (~~ (template [<analysis> <synthesis> <generator>] [(do r.monad [expected <generator>] - (_.test (%.name (name-of <synthesis>)) + (_.test (%.name (name_of <synthesis>)) (|> (#////analysis.Primitive (<analysis> expected)) (//.phase archive.empty) (phase.run [///bundle.empty ////synthesis.init]) diff --git a/stdlib/source/test/lux/tool/compiler/language/lux/phase/synthesis/structure.lux b/stdlib/source/test/lux/tool/compiler/language/lux/phase/synthesis/structure.lux index af665dd7a..36d59cfd9 100644 --- a/stdlib/source/test/lux/tool/compiler/language/lux/phase/synthesis/structure.lux +++ b/stdlib/source/test/lux/tool/compiler/language/lux/phase/synthesis/structure.lux @@ -74,7 +74,7 @@ (def: #export test Test - (<| (_.context (%.name (name-of #////synthesis.Structure))) + (<| (_.context (%.name (name_of #////synthesis.Structure))) ($_ _.and ..variant ..tuple diff --git a/stdlib/source/test/lux/tool/compiler/language/lux/phase/synthesis/variable.lux b/stdlib/source/test/lux/tool/compiler/language/lux/phase/synthesis/variable.lux index 8fa9ad158..e9f9268ac 100644 --- a/stdlib/source/test/lux/tool/compiler/language/lux/phase/synthesis/variable.lux +++ b/stdlib/source/test/lux/tool/compiler/language/lux/phase/synthesis/variable.lux @@ -49,42 +49,42 @@ (in [(<synthesis> value) (<synthesis> value)])))] - [bit-scenario synthesis.bit random.bit] - [i64-scenario synthesis.i64 (\ ! map .i64 random.nat)] - [f64-scenario synthesis.f64 random.frac] - [text-scenario synthesis.text (random.unicode 1)] + [bit_scenario synthesis.bit random.bit] + [i64_scenario synthesis.i64 (\ ! map .i64 random.nat)] + [f64_scenario synthesis.f64 random.frac] + [text_scenario synthesis.text (random.unicode 1)] ) -(def: (primitive-scenario context) +(def: (primitive_scenario context) (Scenario Synthesis) - (random.either (random.either (..bit-scenario context) - (..i64-scenario context)) - (random.either (..f64-scenario context) - (..text-scenario context)))) + (random.either (random.either (..bit_scenario context) + (..i64_scenario context)) + (random.either (..f64_scenario context) + (..text_scenario context)))) -(def: (with-redundancy scenario context) +(def: (with_redundancy scenario context) (-> (Scenario Synthesis) (Scenario Synthesis)) (do {! random.monad} [redundant? random.bit] (if redundant? (do ! [let? random.bit - [expected-input actual-input] (..primitive-scenario context) - #let [fake-register (n.+ (get@ #redundants context) + [expected_input actual_input] (..primitive_scenario context) + #let [fake_register (n.+ (get@ #redundants context) (dictionary.size (get@ #necessary context)))] - [expected-output actual-output] (scenario (update@ #redundants inc context))] - (in [(synthesis.branch/case [expected-input + [expected_output actual_output] (scenario (update@ #redundants inc context))] + (in [(synthesis.branch/case [expected_input (#synthesis.Seq #synthesis.Pop - (#synthesis.Then expected-output))]) + (#synthesis.Then expected_output))]) (if let? - (synthesis.branch/let [actual-input fake-register actual-output]) - (synthesis.branch/case [actual-input - (#synthesis.Seq (#synthesis.Bind fake-register) + (synthesis.branch/let [actual_input fake_register actual_output]) + (synthesis.branch/case [actual_input + (#synthesis.Seq (#synthesis.Bind fake_register) (#synthesis.Seq #synthesis.Pop - (#synthesis.Then actual-output)))]))])) + (#synthesis.Then actual_output)))]))])) (scenario context)))) -(def: (variant-scenario scenario context) +(def: (variant_scenario scenario context) (-> (Scenario Synthesis) (Scenario Synthesis)) (do {! random.monad} [lefts random.nat @@ -93,45 +93,45 @@ (in [(synthesis.variant [lefts right? expected]) (synthesis.variant [lefts right? input])]))) -(def: (tuple-scenario context) +(def: (tuple_scenario context) (Scenario Synthesis) (let [registers (dictionary.entries (get@ #necessary context))] (\ random.monad in [(synthesis.tuple (list\map (|>> product.left synthesis.variable/local) registers)) (synthesis.tuple (list\map (|>> product.right synthesis.variable/local) registers))]))) -(def: (structure-scenario context) +(def: (structure_scenario context) (Scenario Synthesis) - (random.either (..variant-scenario (..with-redundancy ..tuple-scenario) context) - (..tuple-scenario context))) + (random.either (..variant_scenario (..with_redundancy ..tuple_scenario) context) + (..tuple_scenario context))) -(def: (let-scenario scenario context) +(def: (let_scenario scenario context) (-> (Scenario Synthesis) (Scenario Synthesis)) (do random.monad [_ (in []) - [expected-input actual-input] (scenario context) - #let [real-register (dictionary.size (get@ #necessary context)) - fake-register (n.+ (get@ #redundants context) + [expected_input actual_input] (scenario context) + #let [real_register (dictionary.size (get@ #necessary context)) + fake_register (n.+ (get@ #redundants context) (dictionary.size (get@ #necessary context)))] - [expected-output actual-output] (scenario (update@ #necessary (dictionary.put real-register fake-register) context))] - (in [(synthesis.branch/let [expected-input real-register expected-output]) - (synthesis.branch/let [actual-input fake-register actual-output])]))) + [expected_output actual_output] (scenario (update@ #necessary (dictionary.put real_register fake_register) context))] + (in [(synthesis.branch/let [expected_input real_register expected_output]) + (synthesis.branch/let [actual_input fake_register actual_output])]))) -(def: (if-scenario scenario context) +(def: (if_scenario scenario context) (-> (Scenario Synthesis) (Scenario Synthesis)) (do random.monad [_ (in []) - [expected-test actual-test] (scenario context) - [expected-then actual-then] (scenario context) - [expected-else actual-else] (scenario context)] - (in [(synthesis.branch/if [expected-test - expected-then - expected-else]) - (synthesis.branch/if [actual-test - actual-then - actual-else])]))) + [expected_test actual_test] (scenario context) + [expected_then actual_then] (scenario context) + [expected_else actual_else] (scenario context)] + (in [(synthesis.branch/if [expected_test + expected_then + expected_else]) + (synthesis.branch/if [actual_test + actual_then + actual_else])]))) -(def: random-member +(def: random_member (Random Member) (do random.monad [lefts random.nat @@ -140,51 +140,51 @@ (#.Right lefts) (#.Left lefts))))) -(def: (get-scenario scenario context) +(def: (get_scenario scenario context) (-> (Scenario Synthesis) (Scenario Synthesis)) (do {! random.monad} [length (\ ! map (|>> (n.% 5) inc) random.nat) - path (random.list length ..random-member) - [expected-record actual-record] (scenario context)] - (in [(synthesis.branch/get [path expected-record]) - (synthesis.branch/get [path actual-record])]))) + path (random.list length ..random_member) + [expected_record actual_record] (scenario context)] + (in [(synthesis.branch/get [path expected_record]) + (synthesis.branch/get [path actual_record])]))) -(def: random-side +(def: random_side (Random Side) - ..random-member) + ..random_member) -(def: (path-scenario scenario context) +(def: (path_scenario scenario context) (-> (Scenario Synthesis) (Scenario Path)) (`` ($_ random.either ($_ random.either (do {! random.monad} [_ (in []) - [expected-then actual-then] (scenario context)] + [expected_then actual_then] (scenario context)] (in [(#synthesis.Seq #synthesis.Pop - (#synthesis.Then expected-then)) + (#synthesis.Then expected_then)) (#synthesis.Seq #synthesis.Pop - (#synthesis.Then actual-then))])) + (#synthesis.Then actual_then))])) (do {! random.monad} [_ (in []) - #let [real-register (dictionary.size (get@ #necessary context)) - fake-register (n.+ (get@ #redundants context) + #let [real_register (dictionary.size (get@ #necessary context)) + fake_register (n.+ (get@ #redundants context) (dictionary.size (get@ #necessary context)))] - [expected-then actual-then] (scenario (update@ #necessary (dictionary.put real-register fake-register) context))] - (in [(#synthesis.Seq (#synthesis.Bind real-register) + [expected_then actual_then] (scenario (update@ #necessary (dictionary.put real_register fake_register) context))] + (in [(#synthesis.Seq (#synthesis.Bind real_register) (#synthesis.Seq #synthesis.Pop - (#synthesis.Then expected-then))) - (#synthesis.Seq (#synthesis.Bind fake-register) + (#synthesis.Then expected_then))) + (#synthesis.Seq (#synthesis.Bind fake_register) (#synthesis.Seq #synthesis.Pop - (#synthesis.Then actual-then)))]))) + (#synthesis.Then actual_then)))]))) ($_ random.either (~~ (template [<tag> <random>] [(do {! random.monad} [test <random> - [expected-then actual-then] (scenario context)] + [expected_then actual_then] (scenario context)] (in [(#synthesis.Seq (#synthesis.Test (<tag> test)) - (#synthesis.Then expected-then)) + (#synthesis.Then expected_then)) (#synthesis.Seq (#synthesis.Test (<tag> test)) - (#synthesis.Then actual-then))]))] + (#synthesis.Then actual_then))]))] [#synthesis.Bit random.bit] [#synthesis.I64 (\ ! map .i64 random.nat)] @@ -193,127 +193,127 @@ ))) ($_ random.either (do {! random.monad} - [side ..random-side - [expected-next actual-next] (path-scenario scenario context)] + [side ..random_side + [expected_next actual_next] (path_scenario scenario context)] (in [(#synthesis.Seq (#synthesis.Access (#synthesis.Side side)) - expected-next) + expected_next) (#synthesis.Seq (#synthesis.Access (#synthesis.Side side)) - actual-next)])) + actual_next)])) (do {! random.monad} - [member ..random-member - [expected-next actual-next] (path-scenario scenario context)] + [member ..random_member + [expected_next actual_next] (path_scenario scenario context)] (in [(#synthesis.Seq (#synthesis.Access (#synthesis.Member member)) - expected-next) + expected_next) (#synthesis.Seq (#synthesis.Access (#synthesis.Member member)) - actual-next)]))) + actual_next)]))) (do {! random.monad} [_ (in []) - [expected-left actual-left] (path-scenario scenario context) - [expected-right actual-right] (path-scenario scenario context)] - (in [(#synthesis.Alt expected-left expected-right) - (#synthesis.Alt actual-left actual-right)])) + [expected_left actual_left] (path_scenario scenario context) + [expected_right actual_right] (path_scenario scenario context)] + (in [(#synthesis.Alt expected_left expected_right) + (#synthesis.Alt actual_left actual_right)])) ))) -(def: (case-scenario scenario context) +(def: (case_scenario scenario context) (-> (Scenario Synthesis) (Scenario Synthesis)) (do {! random.monad} [_ (in []) - [expected-input actual-input] (scenario context) - [expected-path actual-path] (..path-scenario scenario context)] - (in [(synthesis.branch/case [expected-input expected-path]) - (synthesis.branch/case [actual-input actual-path])]))) + [expected_input actual_input] (scenario context) + [expected_path actual_path] (..path_scenario scenario context)] + (in [(synthesis.branch/case [expected_input expected_path]) + (synthesis.branch/case [actual_input actual_path])]))) -(def: (branch-scenario scenario context) +(def: (branch_scenario scenario context) (-> (Scenario Synthesis) (Scenario Synthesis)) ($_ random.either - (..let-scenario scenario context) - (..if-scenario scenario context) - (..get-scenario scenario context) - (..case-scenario scenario context) + (..let_scenario scenario context) + (..if_scenario scenario context) + (..get_scenario scenario context) + (..case_scenario scenario context) )) -(def: scope-arity 5) +(def: scope_arity 5) -(def: (scope-scenario scenario context) +(def: (scope_scenario scenario context) (-> (Scenario Synthesis) (Scenario Synthesis)) (do {! random.monad} [_ (in []) - #let [real-start (dictionary.size (get@ #necessary context)) - fake-start (n.+ (get@ #redundants context) - real-start)] - inits (random.list ..scope-arity (scenario context)) - [expected-iteration actual-iteration] (scenario (update@ #necessary + #let [real_start (dictionary.size (get@ #necessary context)) + fake_start (n.+ (get@ #redundants context) + real_start)] + inits (random.list ..scope_arity (scenario context)) + [expected_iteration actual_iteration] (scenario (update@ #necessary (function (_ necessary) (list\fold (function (_ [idx _] context) - (dictionary.put (n.+ real-start idx) - (n.+ fake-start idx) + (dictionary.put (n.+ real_start idx) + (n.+ fake_start idx) context)) necessary (list.enumeration inits))) context))] - (in [(synthesis.loop/scope [real-start (list\map product.left inits) expected-iteration]) - (synthesis.loop/scope [fake-start (list\map product.right inits) actual-iteration])]))) + (in [(synthesis.loop/scope [real_start (list\map product.left inits) expected_iteration]) + (synthesis.loop/scope [fake_start (list\map product.right inits) actual_iteration])]))) -(def: (recur-scenario scenario context) +(def: (recur_scenario scenario context) (-> (Scenario Synthesis) (Scenario Synthesis)) (do {! random.monad} [_ (in []) - resets (random.list ..scope-arity (scenario context))] + resets (random.list ..scope_arity (scenario context))] (in [(synthesis.loop/recur (list\map product.left resets)) (synthesis.loop/recur (list\map product.right resets))]))) -(def: (loop-scenario scenario context) +(def: (loop_scenario scenario context) (-> (Scenario Synthesis) (Scenario Synthesis)) ($_ random.either - (..scope-scenario scenario context) - (..recur-scenario scenario context) + (..scope_scenario scenario context) + (..recur_scenario scenario context) )) -(def: (abstraction-scenario scenario context) +(def: (abstraction_scenario scenario context) (-> (Scenario Synthesis) (Scenario Synthesis)) (do {! random.monad} [_ (in []) #let [registers (dictionary.entries (get@ #necessary context)) - expected-environment (list\map (|>> product.left #variable.Local) registers) - actual-environment (list\map (|>> product.right #variable.Local) registers)] - [expected-body actual-body] (..primitive-scenario context)] - (in [(synthesis.function/abstraction [expected-environment 1 expected-body]) - (synthesis.function/abstraction [actual-environment 1 actual-body])]))) + expected_environment (list\map (|>> product.left #variable.Local) registers) + actual_environment (list\map (|>> product.right #variable.Local) registers)] + [expected_body actual_body] (..primitive_scenario context)] + (in [(synthesis.function/abstraction [expected_environment 1 expected_body]) + (synthesis.function/abstraction [actual_environment 1 actual_body])]))) -(def: (apply-scenario scenario context) +(def: (apply_scenario scenario context) (-> (Scenario Synthesis) (Scenario Synthesis)) (do {! random.monad} [abstraction (\ ! map (|>> synthesis.constant) (random.and (random.unicode 1) (random.unicode 1))) - inputs (random.list ..scope-arity (scenario context))] + inputs (random.list ..scope_arity (scenario context))] (in [(synthesis.function/apply [abstraction (list\map product.left inputs)]) (synthesis.function/apply [abstraction (list\map product.right inputs)])]))) -(def: (function-scenario scenario context) +(def: (function_scenario scenario context) (-> (Scenario Synthesis) (Scenario Synthesis)) ($_ random.either - (..abstraction-scenario scenario context) - (..apply-scenario scenario context) + (..abstraction_scenario scenario context) + (..apply_scenario scenario context) )) -(def: (control-scenario scenario context) +(def: (control_scenario scenario context) (-> (Scenario Synthesis) (Scenario Synthesis)) ($_ random.either - (..branch-scenario scenario context) - (..loop-scenario scenario context) - (..function-scenario scenario context) + (..branch_scenario scenario context) + (..loop_scenario scenario context) + (..function_scenario scenario context) )) (def: (scenario context) (Scenario Synthesis) ($_ random.either - (..primitive-scenario context) - (..structure-scenario context) - (..control-scenario (..with-redundancy - (..control-scenario - (..with-redundancy - ..structure-scenario))) + (..primitive_scenario context) + (..structure_scenario context) + (..control_scenario (..with_redundancy + (..control_scenario + (..with_redundancy + ..structure_scenario))) context) )) diff --git a/stdlib/source/test/lux/tool/compiler/language/lux/syntax.lux b/stdlib/source/test/lux/tool/compiler/language/lux/syntax.lux index 4e4968462..48f1f9817 100644 --- a/stdlib/source/test/lux/tool/compiler/language/lux/syntax.lux +++ b/stdlib/source/test/lux/tool/compiler/language/lux/syntax.lux @@ -24,15 +24,15 @@ [\\ ["." /]]) -(def: name-part^ +(def: name_part^ (Random Text) (do {! r.monad} [size (|> r.nat (\ ! map (|>> (n.% 20) (n.max 1))))] - (r.ascii/lower-alpha size))) + (r.ascii/lower_alpha size))) (def: name^ (Random Name) - (r.and name-part^ name-part^)) + (r.and name_part^ name_part^)) (def: code^ (Random Code) @@ -42,12 +42,12 @@ (|> r.nat (r\map code.nat)) (|> r.int (r\map code.int)) (|> r.rev (r\map code.rev)) - (|> r.safe-frac (r\map code.frac)))) + (|> r.safe_frac (r\map code.frac)))) textual^ (: (Random Code) ($_ r.either (do r.monad [size (|> r.nat (r\map (n.% 20)))] - (|> (r.ascii/upper-alpha size) (r\map code.text))) + (|> (r.ascii/upper_alpha size) (r\map code.text))) (|> name^ (r\map code.identifier)) (|> name^ (r\map code.tag)))) simple^ (: (Random Code) @@ -77,9 +77,9 @@ [sample code^] ($_ _.and (_.test "Can parse Lux code." - (case (let [source-code (%.code sample)] - (/.parse "" (dictionary.new text.hash) (text.size source-code) - [location.dummy 0 source-code])) + (case (let [source_code (%.code sample)] + (/.parse "" (dictionary.new text.hash) (text.size source_code) + [location.dummy 0 source_code])) (#.Left error) false @@ -88,15 +88,15 @@ (do ! [other code^] (_.test "Can parse multiple Lux code nodes." - (let [source-code (format (%.code sample) " " (%.code other)) - source-code//size (text.size source-code)] - (case (/.parse "" (dictionary.new text.hash) source-code//size - [location.dummy 0 source-code]) + (let [source_code (format (%.code sample) " " (%.code other)) + source_code//size (text.size source_code)] + (case (/.parse "" (dictionary.new text.hash) source_code//size + [location.dummy 0 source_code]) (#.Left error) false (#.Right [remaining =sample]) - (case (/.parse "" (dictionary.new text.hash) source-code//size + (case (/.parse "" (dictionary.new text.hash) source_code//size remaining) (#.Left error) false @@ -106,18 +106,18 @@ (\ code.equivalence = other =other))))))) ))) -(def: comment-text^ +(def: comment_text^ (Random Text) - (let [char-gen (|> r.nat (r.only (|>> (n.= (`` (char (~~ (static text.new-line))))) not)))] + (let [char_gen (|> r.nat (r.only (|>> (n.= (`` (char (~~ (static text.new_line))))) not)))] (do r.monad [size (|> r.nat (r\map (n.% 20)))] - (r.text char-gen size)))) + (r.text char_gen size)))) (def: comment^ (Random Text) (do r.monad - [comment comment-text^] - (in (format "## " comment text.new-line)))) + [comment comment_text^] + (in (format "## " comment text.new_line)))) (def: comments Test @@ -126,10 +126,10 @@ comment comment^] ($_ _.and (_.test "Can handle comments." - (case (let [source-code (format comment (%.code sample)) - source-code//size (text.size source-code)] - (/.parse "" (dictionary.new text.hash) source-code//size - [location.dummy 0 source-code])) + (case (let [source_code (format comment (%.code sample)) + source_code//size (text.size source_code)] + (/.parse "" (dictionary.new text.hash) source_code//size + [location.dummy 0 source_code])) (#.Left error) false @@ -139,7 +139,7 @@ (def: #export test Test - (<| (_.context (name.module (name-of /._))) + (<| (_.context (name.module (name_of /._))) ($_ _.and ..code ..comments |