diff options
Diffstat (limited to '')
13 files changed, 210 insertions, 210 deletions
diff --git a/stdlib/source/specification/compositor.lux b/stdlib/source/specification/compositor.lux index 162dcbec8..5645b0164 100644 --- a/stdlib/source/specification/compositor.lux +++ b/stdlib/source/specification/compositor.lux @@ -58,9 +58,9 @@ expander program))]] (case ?state,runner,definer - (#try.Success [[directive-bundle directive-state] runner definer]) + (#try.Success [[directive_bundle directive_state] runner definer]) (..test runner definer - (get@ [#directive.analysis #directive.state] directive-state) + (get@ [#directive.analysis #directive.state] directive_state) expander) (#try.Failure error) diff --git a/stdlib/source/specification/compositor/analysis/type.lux b/stdlib/source/specification/compositor/analysis/type.lux index 4db867513..5a34eae36 100644 --- a/stdlib/source/specification/compositor/analysis/type.lux +++ b/stdlib/source/specification/compositor/analysis/type.lux @@ -20,10 +20,10 @@ ["#/." scope] ["#/." type]]]]]]) -(def: (check-success+ expander state extension params output-type) +(def: (check_success+ expander state extension params output_type) (-> Expander State+ Text (List Code) Type Bit) - (|> (analysis/scope.with-scope "" - (analysis/type.with-type output-type + (|> (analysis/scope.with_scope "" + (analysis/type.with_type output_type (analysis.phase expander (` ((~ (code.text extension)) (~+ params)))))) (phase.run state) (case> (#try.Success _) @@ -46,18 +46,18 @@ [r.nat (0 #0 "#I64" (0 #1 (0 #0 "#Nat" (0 #0)) (0 #0))) code.nat] [r.int (0 #0 "#I64" (0 #1 (0 #0 "#Int" (0 #0)) (0 #0))) code.int] [r.rev (0 #0 "#I64" (0 #1 (0 #0 "#Rev" (0 #0)) (0 #0))) code.rev] - [r.safe-frac (0 #0 "#Frac" (0 #0)) code.frac] - [(r.ascii/upper-alpha 5) (0 #0 "#Text" (0 #0)) code.text] + [r.safe_frac (0 #0 "#Frac" (0 #0)) code.frac] + [(r.ascii/upper_alpha 5) (0 #0 "#Text" (0 #0)) code.text] ))))) (def: #export (spec expander state) (-> Expander State+ Test) (do r.monad [[typeC exprT exprC] ..check - [other-typeC other-exprT other-exprC] ..check] + [other_typeC other_exprT other_exprC] ..check] ($_ _.and (_.test "lux check" - (check-success+ expander state "lux check" (list typeC exprC) exprT)) + (check_success+ expander state "lux check" (list typeC exprC) exprT)) (_.test "lux coerce" - (check-success+ expander state "lux coerce" (list typeC other-exprC) exprT)) + (check_success+ expander state "lux coerce" (list typeC other_exprC) exprT)) ))) diff --git a/stdlib/source/specification/compositor/common.lux b/stdlib/source/specification/compositor/common.lux index 33268ecde..0b7c7979a 100644 --- a/stdlib/source/specification/compositor/common.lux +++ b/stdlib/source/specification/compositor/common.lux @@ -33,32 +33,32 @@ (def: (runner (^slots [#platform.runtime #platform.phase #platform.host]) state) (Instancer Runner) - (function (_ evaluation-name expressionS) + (function (_ evaluation_name expressionS) (do try.monad [expressionG (<| (phase.run state) - generation.with-buffer + generation.with_buffer (do phase.monad [_ runtime] (phase expressionS)))] - (\ host evaluate! evaluation-name expressionG)))) + (\ host evaluate! evaluation_name expressionG)))) (def: (definer (^slots [#platform.runtime #platform.phase #platform.host]) state) (Instancer Definer) - (function (_ lux-name expressionS) + (function (_ lux_name expressionS) (do try.monad [definitionG (<| (phase.run state) - generation.with-buffer + generation.with_buffer (do phase.monad [_ runtime expressionG (phase expressionS) - [host-name host-value host-directive] (generation.define! lux-name expressionG) - _ (generation.learn lux-name host-name)] - (phase (synthesis.constant lux-name))))] + [host_name host_value host_directive] (generation.define! lux_name expressionG) + _ (generation.learn lux_name host_name)] + (phase (synthesis.constant lux_name))))] (\ host evaluate! "definer" definitionG)))) (def: #export (executors target expander platform - analysis-bundle generation-bundle directive-bundle + analysis_bundle generation_bundle directive_bundle program extender) (All [anchor expression directive] (-> Text Expander (Platform IO anchor expression directive) @@ -70,12 +70,12 @@ Runner Definer])))) (do io.monad - [?state (platform.initialize target expander analysis-bundle platform generation-bundle directive-bundle program extender)] + [?state (platform.initialize target expander analysis_bundle platform generation_bundle directive_bundle program extender)] (in (do try.monad - [[directive-bundle directive-state] ?state - #let [generation-state (get@ [#directive.generation + [[directive_bundle directive_state] ?state + #let [generation_state (get@ [#directive.generation #directive.state] - directive-state)]] - (in [[directive-bundle directive-state] - (..runner platform generation-state) - (..definer platform generation-state)]))))) + directive_state)]] + (in [[directive_bundle directive_state] + (..runner platform generation_state) + (..definer platform generation_state)]))))) diff --git a/stdlib/source/specification/compositor/generation/case.lux b/stdlib/source/specification/compositor/generation/case.lux index d18d6b461..3ca5440bf 100644 --- a/stdlib/source/specification/compositor/generation/case.lux +++ b/stdlib/source/specification/compositor/generation/case.lux @@ -96,48 +96,48 @@ (in [caseS caseP])) )))) -(def: (let-spec run) +(def: (let_spec run) (-> Runner Test) (do r.monad - [value r.safe-frac] - (_.test (%.name (name-of synthesis.branch/let)) + [value r.safe_frac] + (_.test (%.name (name_of synthesis.branch/let)) (|> (synthesis.branch/let [(synthesis.f64 value) 0 (synthesis.variable/local 0)]) - (run "let-spec") + (run "let_spec") (verify value))))) -(def: (if-spec run) +(def: (if_spec run) (-> Runner Test) (do r.monad - [on-true r.safe-frac - on-false (|> r.safe-frac (r.only (|>> (f.= on-true) not))) + [on_true r.safe_frac + on_false (|> r.safe_frac (r.only (|>> (f.= on_true) not))) verdict r.bit] - (_.test (%.name (name-of synthesis.branch/if)) + (_.test (%.name (name_of synthesis.branch/if)) (|> (synthesis.branch/if [(synthesis.bit verdict) - (synthesis.f64 on-true) - (synthesis.f64 on-false)]) - (run "if-spec") - (verify (if verdict on-true on-false)))))) + (synthesis.f64 on_true) + (synthesis.f64 on_false)]) + (run "if_spec") + (verify (if verdict on_true on_false)))))) -(def: (case-spec run) +(def: (case_spec run) (-> Runner Test) (do r.monad [[inputS pathS] ..case - on-success r.safe-frac - on-failure (|> r.safe-frac (r.only (|>> (f.= on-success) not)))] - (_.test (%.name (name-of synthesis.branch/case)) + on_success r.safe_frac + on_failure (|> r.safe_frac (r.only (|>> (f.= on_success) not)))] + (_.test (%.name (name_of synthesis.branch/case)) (|> (synthesis.branch/case [inputS ($_ synthesis.path/alt ($_ synthesis.path/seq pathS - (synthesis.path/then (synthesis.f64 on-success))) - (synthesis.path/then (synthesis.f64 on-failure)))]) - (run "case-spec") - (verify on-success))))) + (synthesis.path/then (synthesis.f64 on_success))) + (synthesis.path/then (synthesis.f64 on_failure)))]) + (run "case_spec") + (verify on_success))))) -(def: special-input +(def: special_input Synthesis (let [_cursor_ (: Synthesis (synthesis.tuple (list (synthesis.text .prelude_module) @@ -146,13 +146,13 @@ _code_ (: (-> Synthesis Synthesis) (function (_ content) (synthesis.tuple (list _cursor_ content)))) - _nil_ (: Synthesis + _end_ (: Synthesis (synthesis.variant [0 #0 (synthesis.text "")])) - _cons_ (: (-> Synthesis Synthesis Synthesis) + _item_ (: (-> Synthesis Synthesis Synthesis) (function (_ head tail) (synthesis.variant [0 #1 (synthesis.tuple (list head tail))]))) _list_ (: (-> (List Synthesis) Synthesis) - (list\fold _cons_ _nil_))] + (list\fold _item_ _end_))] (let [__tuple__ (: (-> (List Synthesis) Synthesis) (|>> list.reverse _list_ [9 #0] synthesis.variant _code_)) __form__ (: (-> (List Synthesis) Synthesis) @@ -170,40 +170,40 @@ (synthesis.text short)))])))) __list__ (: (-> (List Synthesis) Synthesis) (list\fold (function (_ head tail) - (__form__ (list (__tag__ ["" "Cons"]) head tail))) - (__tag__ ["" "Nil"]))) + (__form__ (list (__tag__ ["" "Item"]) head tail))) + (__tag__ ["" "End"]))) __apply__ (: (-> Synthesis Synthesis Synthesis) (function (_ func arg) (__form__ (list func arg))))] - (|> _nil_ - (_cons_ (__apply__ (__identifier__ ["" "form$"]) + (|> _end_ + (_item_ (__apply__ (__identifier__ ["" "form$"]) (__list__ (list (__apply__ (__identifier__ ["" "tag$"]) (__tuple__ (list (__text__ .prelude_module) - (__text__ "Cons")))) + (__text__ "Item")))) (__identifier__ ["" "export?-meta"]) (__identifier__ ["" "tail"]))))) - (_cons_ (__tuple__ (list (__identifier__ ["" "tail"])))) + (_item_ (__tuple__ (list (__identifier__ ["" "tail"])))) )))) -(def: special-path +(def: special_path Path - (let [_nil_ (synthesis.path/side (#.Left 0)) - _cons_ (synthesis.path/side (#.Right 0)) + (let [_end_ (synthesis.path/side (#.Left 0)) + _item_ (synthesis.path/side (#.Right 0)) _head_ (synthesis.path/member (#.Left 0)) _tail_ (synthesis.path/member (#.Right 0)) _tuple_ (synthesis.path/side (#.Left 9))] ($_ synthesis.path/alt ($_ synthesis.path/seq - _cons_ + _item_ _head_ _head_ (synthesis.path/bind 2) synthesis.path/pop - _tail_ _tuple_ _cons_ + _tail_ _tuple_ _item_ _head_ (synthesis.path/bind 3) synthesis.path/pop _tail_ (synthesis.path/bind 4) synthesis.path/pop synthesis.path/pop synthesis.path/pop synthesis.path/pop synthesis.path/pop - _tail_ _cons_ + _tail_ _item_ _head_ (synthesis.path/bind 5) synthesis.path/pop - _tail_ _nil_ + _tail_ _end_ ## THEN (synthesis.path/then (synthesis.bit #1))) ($_ synthesis.path/seq @@ -211,31 +211,31 @@ ## THEN (synthesis.path/then (synthesis.bit #0)))))) -(def: special-pattern +(def: special_pattern analysis.Pattern - (let [## [_ (#Tuple (#Cons arg args'))] + (let [## [_ (#Tuple (#Item arg args'))] head (<| analysis.pattern/tuple (list (analysis.pattern/bind 2)) analysis.pattern/variant [9 #0] analysis.pattern/variant [0 #1] analysis.pattern/tuple (list (analysis.pattern/bind 3) (analysis.pattern/bind 4))) - ## (#Cons body #Nil) + ## (#Item body #End) tail (<| analysis.pattern/variant [0 #1] analysis.pattern/tuple (list (analysis.pattern/bind 5)) analysis.pattern/variant [0 #0] (analysis.pattern/unit))] - ## (#Cons <head> <tail>) + ## (#Item <head> <tail>) (<| analysis.pattern/variant [0 #1] (analysis.pattern/tuple (list head tail))))) -(def: special-pattern-path +(def: special_pattern_path Path ($_ synthesis.path/alt (<| try.assumed (phase.run [extension/synthesis.bundle synthesis.init]) (case.path phase/synthesis.phase - special-pattern) + special_pattern) (analysis.bit #1)) ($_ synthesis.path/seq (synthesis.path/bind 2) @@ -243,34 +243,34 @@ (synthesis.path/then (synthesis.bit #0))))) ## TODO: Get rid of this ASAP -(def: (special-spec run) +(def: (special_spec run) (-> Runner Test) ($_ _.and (_.test "===" - (and (text\= (synthesis.%path special-path) - (synthesis.%path special-pattern-path)) - (\ synthesis.path-equivalence = special-path special-pattern-path))) + (and (text\= (synthesis.%path special_path) + (synthesis.%path special_pattern_path)) + (\ synthesis.path_equivalence = special_path special_pattern_path))) (_.test "CODE" - (|> special-input - (run "special-input") + (|> special_input + (run "special_input") (case> (#try.Success output) true (#try.Failure _) false))) - (_.test "PATTERN-MATCHING 0" - (|> (synthesis.branch/case [special-input - special-path]) - (run "special-path") + (_.test "PATTERN_MATCHING 0" + (|> (synthesis.branch/case [special_input + special_path]) + (run "special_path") (case> (#try.Success output) true (#try.Failure _) false))) - (_.test "PATTERN-MATCHING 1" - (|> (synthesis.branch/case [special-input - special-pattern-path]) - (run "special-pattern-path") + (_.test "PATTERN_MATCHING 1" + (|> (synthesis.branch/case [special_input + special_pattern_path]) + (run "special_pattern_path") (case> (#try.Success output) true @@ -281,8 +281,8 @@ (def: #export (spec run) (-> Runner Test) ($_ _.and - (..special-spec run) - (..let-spec run) - (..if-spec run) - (..case-spec run) + (..special_spec run) + (..let_spec run) + (..if_spec run) + (..case_spec run) )) diff --git a/stdlib/source/specification/compositor/generation/common.lux b/stdlib/source/specification/compositor/generation/common.lux index bea185b99..1ef9f780b 100644 --- a/stdlib/source/specification/compositor/generation/common.lux +++ b/stdlib/source/specification/compositor/generation/common.lux @@ -30,14 +30,14 @@ (def: safe (-> Text Text) - (text.replace-all " " "_")) + (text.replace_all " " "_")) (def: (bit run) (-> Runner Test) (do r.monad [param r.i64 subject r.i64] - (with-expansions [<binary> (template [<extension> <reference> <param-expr>] + (with_expansions [<binary> (template [<extension> <reference> <param_expr>] [(_.test <extension> (|> (#synthesis.Extension <extension> (list (synthesis.i64 param) (synthesis.i64 subject))) @@ -47,30 +47,30 @@ (#try.Failure _) false) - (let [param <param-expr>])))] + (let [param <param_expr>])))] ["lux i64 and" i64.and param] ["lux i64 or" i64.or param] ["lux i64 xor" i64.xor param] - ["lux i64 left-shift" i64.left-shift (n.% 64 param)] - ["lux i64 logical-right-shift" i64.logic-right-shift (n.% 64 param)] + ["lux i64 left-shift" i64.left_shift (n.% 64 param)] + ["lux i64 logical-right-shift" i64.logic_right_shift (n.% 64 param)] )] - ($_ _.and - <binary> - (_.test "lux i64 arithmetic-right-shift" - (|> (#synthesis.Extension "lux i64 arithmetic-right-shift" - (list (synthesis.i64 subject) - (synthesis.i64 param))) - (run (..safe "lux i64 arithmetic-right-shift")) - (case> (#try.Success valueT) - ("lux i64 =" - (i64.arithmetic-right-shift param subject) - (:as I64 valueT)) - - (#try.Failure _) - false) - (let [param (n.% 64 param)]))) - )))) + ($_ _.and + <binary> + (_.test "lux i64 arithmetic-right-shift" + (|> (#synthesis.Extension "lux i64 arithmetic-right-shift" + (list (synthesis.i64 subject) + (synthesis.i64 param))) + (run (..safe "lux i64 arithmetic-right-shift")) + (case> (#try.Success valueT) + ("lux i64 =" + (i64.arithmetic_right_shift param subject) + (:as I64 valueT)) + + (#try.Failure _) + false) + (let [param (n.% 64 param)]))) + )))) (def: (i64 run) (-> Runner Test) @@ -78,7 +78,7 @@ [param (|> r.i64 (r.only (|>> ("lux i64 =" 0) not))) subject r.i64] (`` ($_ _.and - (~~ (template [<extension> <type> <prepare> <comp> <subject-expr>] + (~~ (template [<extension> <type> <prepare> <comp> <subject_expr>] [(_.test <extension> (|> (#synthesis.Extension <extension> (list (synthesis.i64 subject))) (run (..safe <extension>)) @@ -87,12 +87,12 @@ (#try.Failure _) false) - (let [subject <subject-expr>])))] + (let [subject <subject_expr>])))] ["lux i64 f64" Frac i.frac f.= subject] - ["lux i64 char" Text (|>> (:as Nat) text.from-code) text\= (|> subject + ["lux i64 char" Text (|>> (:as Nat) text.from_code) text\= (|> subject (:as Nat) - (n.% (i64.left-shift 8 1)) + (n.% (i64.left_shift 8 1)) (:as Int))] )) (~~ (template [<extension> <reference> <outputT> <comp>] @@ -116,15 +116,15 @@ )) )))) -(def: simple-frac +(def: simple_frac (Random Frac) (|> r.nat (\ r.monad map (|>> (n.% 1000) .int i.frac)))) (def: (f64 run) (-> Runner Test) (do r.monad - [param (|> ..simple-frac (r.only (|>> (f.= +0.0) not))) - subject ..simple-frac] + [param (|> ..simple_frac (r.only (|>> (f.= +0.0) not))) + subject ..simple_frac] (`` ($_ _.and (~~ (template [<extension> <reference> <comp>] [(_.test <extension> @@ -175,30 +175,30 @@ (def: (text run) (-> Runner Test) (do {! r.monad} - [sample-size (|> r.nat (\ ! map (|>> (n.% 10) (n.max 1)))) - sample-lower (r.ascii/lower-alpha sample-size) - sample-upper (r.ascii/upper-alpha sample-size) - sample-alpha (|> (r.ascii/alpha sample-size) - (r.only (|>> (text\= sample-upper) not))) - char-idx (|> r.nat (\ ! map (n.% sample-size))) - #let [sample-lowerS (synthesis.text sample-lower) - sample-upperS (synthesis.text sample-upper) - sample-alphaS (synthesis.text sample-alpha) - concatenatedS (#synthesis.Extension "lux text concat" (list sample-lowerS sample-upperS)) - pre-rep-once (format sample-lower sample-upper) - post-rep-once (format sample-lower sample-alpha) - pre-rep-all (|> (list.repeat sample-size sample-lower) (text.join-with sample-upper)) - post-rep-all (|> (list.repeat sample-size sample-lower) (text.join-with sample-alpha))]] + [sample_size (|> r.nat (\ ! map (|>> (n.% 10) (n.max 1)))) + sample_lower (r.ascii/lower_alpha sample_size) + sample_upper (r.ascii/upper_alpha sample_size) + sample_alpha (|> (r.ascii/alpha sample_size) + (r.only (|>> (text\= sample_upper) not))) + char_idx (|> r.nat (\ ! map (n.% sample_size))) + #let [sample_lowerS (synthesis.text sample_lower) + sample_upperS (synthesis.text sample_upper) + sample_alphaS (synthesis.text sample_alpha) + concatenatedS (#synthesis.Extension "lux text concat" (list sample_lowerS sample_upperS)) + pre_rep_once (format sample_lower sample_upper) + post_rep_once (format sample_lower sample_alpha) + pre_rep_all (|> (list.repeat sample_size sample_lower) (text.join_with sample_upper)) + post_rep_all (|> (list.repeat sample_size sample_lower) (text.join_with sample_alpha))]] ($_ _.and (_.test "Can compare texts for equality." - (and (|> (#synthesis.Extension "lux text =" (list sample-lowerS sample-lowerS)) + (and (|> (#synthesis.Extension "lux text =" (list sample_lowerS sample_lowerS)) (run (..safe "lux text =")) (case> (#try.Success valueV) (:as Bit valueV) _ false)) - (|> (#synthesis.Extension "lux text =" (list sample-upperS sample-lowerS)) + (|> (#synthesis.Extension "lux text =" (list sample_upperS sample_lowerS)) (run (..safe "lux text =")) (case> (#try.Success valueV) (not (:as Bit valueV)) @@ -206,7 +206,7 @@ _ false)))) (_.test "Can compare texts for order." - (|> (#synthesis.Extension "lux text <" (list sample-lowerS sample-upperS)) + (|> (#synthesis.Extension "lux text <" (list sample_lowerS sample_upperS)) (run (..safe "lux text <")) (case> (#try.Success valueV) (:as Bit valueV) @@ -214,10 +214,10 @@ (#try.Failure _) false))) (_.test "Can get length of text." - (|> (#synthesis.Extension "lux text size" (list sample-lowerS)) + (|> (#synthesis.Extension "lux text size" (list sample_lowerS)) (run (..safe "lux text size")) (case> (#try.Success valueV) - (n.= sample-size (:as Nat valueV)) + (n.= sample_size (:as Nat valueV)) _ false))) @@ -225,13 +225,13 @@ (|> (#synthesis.Extension "lux text size" (list concatenatedS)) (run (..safe "lux text size")) (case> (#try.Success valueV) - (n.= (n.* 2 sample-size) (:as Nat valueV)) + (n.= (n.* 2 sample_size) (:as Nat valueV)) _ false))) (_.test "Can find index of sub-text." (and (|> (#synthesis.Extension "lux text index" - (list concatenatedS sample-lowerS + (list concatenatedS sample_lowerS (synthesis.i64 +0))) (run (..safe "lux text index")) (case> (^multi (#try.Success valueV) @@ -241,16 +241,16 @@ _ false)) (|> (#synthesis.Extension "lux text index" - (list concatenatedS sample-upperS + (list concatenatedS sample_upperS (synthesis.i64 +0))) (run (..safe "lux text index")) (case> (^multi (#try.Success valueV) {(:as (Maybe Nat) valueV) (#.Some valueV)}) - (n.= sample-size valueV) + (n.= sample_size valueV) _ false)))) - (let [test-clip (: (-> (I64 Any) (I64 Any) Text Bit) + (let [test_clip (: (-> (I64 Any) (I64 Any) Text Bit) (function (_ offset length expected) (|> (#synthesis.Extension "lux text clip" (list concatenatedS @@ -264,17 +264,17 @@ _ false))))] (_.test "Can clip text to extract sub-text." - (and (test-clip 0 sample-size sample-lower) - (test-clip sample-size sample-size sample-upper)))) + (and (test_clip 0 sample_size sample_lower) + (test_clip sample_size sample_size sample_upper)))) (_.test "Can extract individual characters from text." (|> (#synthesis.Extension "lux text char" - (list sample-lowerS - (synthesis.i64 char-idx))) + (list sample_lowerS + (synthesis.i64 char_idx))) (run (..safe "lux text char")) (case> (^multi (#try.Success valueV) {(:as (Maybe Int) valueV) (#.Some valueV)}) (text.contains? ("lux i64 char" valueV) - sample-lower) + sample_lower) _ false))) diff --git a/stdlib/source/specification/compositor/generation/function.lux b/stdlib/source/specification/compositor/generation/function.lux index 61f6d6656..5a5891088 100644 --- a/stdlib/source/specification/compositor/generation/function.lux +++ b/stdlib/source/specification/compositor/generation/function.lux @@ -24,13 +24,13 @@ [// [common (#+ Runner)]]]) -(def: max-arity +(def: max_arity Arity 10) (def: arity (Random Arity) - (|> r.nat (r\map (|>> (n.% max-arity) (n.max 1))))) + (|> r.nat (r\map (|>> (n.% max_arity) (n.max 1))))) (def: (local arity) (-> Arity (Random Register)) @@ -51,45 +51,45 @@ (-> Runner Test) (do {! r.monad} [[arity local functionS] ..function - partial-arity (|> r.nat (\ ! map (|>> (n.% arity) (n.max 1)))) - inputs (r.list arity r.safe-frac) + partial_arity (|> r.nat (\ ! map (|>> (n.% arity) (n.max 1)))) + inputs (r.list arity r.safe_frac) #let [expectation (maybe.assume (list.nth (dec local) inputs)) inputsS (list\map (|>> synthesis.f64) inputs)]] ($_ _.and (_.test "Can read arguments." (|> (synthesis.function/apply {#synthesis.function functionS #synthesis.arguments inputsS}) - (run "with-local") + (run "with_local") (//case.verify expectation))) (_.test "Can partially apply functions." (or (n.= 1 arity) - (let [preS (list.take partial-arity inputsS) - postS (list.drop partial-arity inputsS) + (let [preS (list.take partial_arity inputsS) + postS (list.drop partial_arity inputsS) partialS (synthesis.function/apply {#synthesis.function functionS #synthesis.arguments preS})] (|> (synthesis.function/apply {#synthesis.function partialS #synthesis.arguments postS}) - (run "partial-application") + (run "partial_application") (//case.verify expectation))))) (_.test "Can read environment." (or (n.= 1 arity) - (let [environment (|> partial-arity + (let [environment (|> partial_arity (enum.range n.enum 1) (list\map (|>> #reference.Local))) - variableS (if (n.<= partial-arity local) + variableS (if (n.<= partial_arity local) (synthesis.variable/foreign (dec local)) - (synthesis.variable/local (|> local (n.- partial-arity)))) - inner-arity (n.- partial-arity arity) + (synthesis.variable/local (|> local (n.- partial_arity)))) + inner_arity (n.- partial_arity arity) innerS (synthesis.function/abstraction {#synthesis.environment environment - #synthesis.arity inner-arity + #synthesis.arity inner_arity #synthesis.body variableS}) outerS (synthesis.function/abstraction {#synthesis.environment (list) - #synthesis.arity partial-arity + #synthesis.arity partial_arity #synthesis.body innerS})] (|> (synthesis.function/apply {#synthesis.function outerS #synthesis.arguments inputsS}) - (run "with-foreign") + (run "with_foreign") (//case.verify expectation))))) ))) diff --git a/stdlib/source/specification/compositor/generation/primitive.lux b/stdlib/source/specification/compositor/generation/primitive.lux index 3b6dd657b..2ddb9a02e 100644 --- a/stdlib/source/specification/compositor/generation/primitive.lux +++ b/stdlib/source/specification/compositor/generation/primitive.lux @@ -23,17 +23,17 @@ (def: (f/=' reference subject) (-> Frac Frac Bit) (or (f.= reference subject) - (and (f.not-a-number? reference) - (f.not-a-number? subject)))) + (and (f.not_a_number? reference) + (f.not_a_number? subject)))) (def: #export (spec run) (-> Runner Test) (`` ($_ _.and - (~~ (template [<evaluation-name> <synthesis> <gen> <test>] + (~~ (template [<evaluation_name> <synthesis> <gen> <test>] [(do r.monad [expected <gen>] - (_.test (%.name (name-of <synthesis>)) - (|> (run <evaluation-name> (<synthesis> expected)) + (_.test (%.name (name_of <synthesis>)) + (|> (run <evaluation_name> (<synthesis> expected)) (case> (#try.Success actual) (<test> expected (:assume actual)) diff --git a/stdlib/source/specification/compositor/generation/reference.lux b/stdlib/source/specification/compositor/generation/reference.lux index 665175ab4..d5c3cfd34 100644 --- a/stdlib/source/specification/compositor/generation/reference.lux +++ b/stdlib/source/specification/compositor/generation/reference.lux @@ -21,14 +21,14 @@ (def: name (Random Name) - (let [name-part (r.ascii/upper-alpha 5)] - [(r.and name-part name-part)])) + (let [name_part (r.ascii/upper_alpha 5)] + [(r.and name_part name_part)])) (def: (definition define) (-> Definer Test) (do r.monad [name ..name - expected r.safe-frac] + expected r.safe_frac] (_.test "Definitions." (|> (define name (synthesis.f64 expected)) (case> (#try.Success actual) @@ -41,7 +41,7 @@ (-> Runner Test) (do {! r.monad} [register (|> r.nat (\ ! map (n.% 100))) - expected r.safe-frac] + expected r.safe_frac] (_.test "Local variables." (|> (synthesis.branch/let [(synthesis.f64 expected) register diff --git a/stdlib/source/specification/compositor/generation/structure.lux b/stdlib/source/specification/compositor/generation/structure.lux index 355b98409..4cc4f0676 100644 --- a/stdlib/source/specification/compositor/generation/structure.lux +++ b/stdlib/source/specification/compositor/generation/structure.lux @@ -31,34 +31,34 @@ (def: (variant run) (-> Runner Test) (do {! r.monad} - [num-tags (|> r.nat (\ ! map (|>> (n.% 10) (n.max 2)))) - tag-in (|> r.nat (\ ! map (n.% num-tags))) - #let [last?-in (|> num-tags dec (n.= tag-in))] - value-in r.i64] - (_.test (%.name (name-of synthesis.variant)) - (|> (synthesis.variant {#analysis.lefts (if last?-in - (dec tag-in) - tag-in) - #analysis.right? last?-in - #analysis.value (synthesis.i64 value-in)}) + [num_tags (|> r.nat (\ ! map (|>> (n.% 10) (n.max 2)))) + tag_in (|> r.nat (\ ! map (n.% num_tags))) + #let [last?_in (|> num_tags dec (n.= tag_in))] + value_in r.i64] + (_.test (%.name (name_of synthesis.variant)) + (|> (synthesis.variant {#analysis.lefts (if last?_in + (dec tag_in) + tag_in) + #analysis.right? last?_in + #analysis.value (synthesis.i64 value_in)}) (run "variant") (case> (#try.Success valueT) (let [valueT (:as (Array Any) valueT)] (and (n.= 3 (array.size valueT)) - (let [tag-out (:as java/lang/Integer (maybe.assume (array.read 0 valueT))) - last?-out (array.read 1 valueT) - value-out (:as Any (maybe.assume (array.read 2 valueT))) - same-tag? (|> tag-out ffi.int-to-long (:as Nat) (n.= tag-in)) - same-flag? (case last?-out - (#.Some last?-out') - (and last?-in (text\= "" (:as Text last?-out'))) + (let [tag_out (:as java/lang/Integer (maybe.assume (array.read 0 valueT))) + last?_out (array.read 1 valueT) + value_out (:as Any (maybe.assume (array.read 2 valueT))) + same_tag? (|> tag_out ffi.int_to_long (:as Nat) (n.= tag_in)) + same_flag? (case last?_out + (#.Some last?_out') + (and last?_in (text\= "" (:as Text last?_out'))) #.None - (not last?-in)) - same-value? (|> value-out (:as Int) (i.= value-in))] - (and same-tag? - same-flag? - same-value?)))) + (not last?_in)) + same_value? (|> value_out (:as Int) (i.= value_in))] + (and same_tag? + same_flag? + same_value?)))) (#try.Failure _) false))))) @@ -67,16 +67,16 @@ (-> Runner Test) (do {! r.monad} [size (|> r.nat (\ ! map (|>> (n.% 10) (n.max 2)))) - tuple-in (r.list size r.i64)] - (_.test (%.name (name-of synthesis.tuple)) - (|> (synthesis.tuple (list\map (|>> synthesis.i64) tuple-in)) + tuple_in (r.list size r.i64)] + (_.test (%.name (name_of synthesis.tuple)) + (|> (synthesis.tuple (list\map (|>> synthesis.i64) tuple_in)) (run "tuple") - (case> (#try.Success tuple-out) - (let [tuple-out (:as (Array Any) tuple-out)] - (and (n.= size (array.size tuple-out)) + (case> (#try.Success tuple_out) + (let [tuple_out (:as (Array Any) tuple_out)] + (and (n.= size (array.size tuple_out)) (list.every? (function (_ [left right]) (i.= left (:as Int right))) - (list.zipped/2 tuple-in (array.to_list tuple-out))))) + (list.zipped/2 tuple_in (array.to_list tuple_out))))) (#try.Failure _) false))))) diff --git a/stdlib/source/specification/lux/abstract/enum.lux b/stdlib/source/specification/lux/abstract/enum.lux index ddb2a80f1..6375b4829 100644 --- a/stdlib/source/specification/lux/abstract/enum.lux +++ b/stdlib/source/specification/lux/abstract/enum.lux @@ -9,10 +9,10 @@ [\\library ["." /]]) -(def: #export (spec (^open "\.") gen-sample) +(def: #export (spec (^open "\.") gen_sample) (All [a] (-> (/.Enum a) (Random a) Test)) (do random.monad - [sample gen-sample] + [sample gen_sample] (<| (_.for [/.Enum]) ($_ _.and (_.test "Successor and predecessor are inverse functions." diff --git a/stdlib/source/specification/lux/abstract/interval.lux b/stdlib/source/specification/lux/abstract/interval.lux index 5b74bc34d..c5d89aab3 100644 --- a/stdlib/source/specification/lux/abstract/interval.lux +++ b/stdlib/source/specification/lux/abstract/interval.lux @@ -10,11 +10,11 @@ [\\library ["." /]]) -(def: #export (spec (^open "@//.") gen-sample) +(def: #export (spec (^open "@//.") gen_sample) (All [a] (-> (/.Interval a) (Random a) Test)) (<| (_.for [/.Interval]) (do random.monad - [sample gen-sample] + [sample gen_sample] ($_ _.and (_.test "No value is bigger than the top." (@//< @//top sample)) diff --git a/stdlib/source/specification/lux/abstract/monoid.lux b/stdlib/source/specification/lux/abstract/monoid.lux index f8626fe74..592b98bb4 100644 --- a/stdlib/source/specification/lux/abstract/monoid.lux +++ b/stdlib/source/specification/lux/abstract/monoid.lux @@ -11,13 +11,13 @@ [// [equivalence (#+ Equivalence)]]]]) -(def: #export (spec (^open "\.") (^open "\.") gen-sample) +(def: #export (spec (^open "\.") (^open "\.") gen_sample) (All [a] (-> (Equivalence a) (/.Monoid a) (Random a) Test)) (do random.monad - [sample gen-sample - left gen-sample - mid gen-sample - right gen-sample] + [sample gen_sample + left gen_sample + mid gen_sample + right gen_sample] (<| (_.for [/.Monoid]) ($_ _.and (_.test "Left identity." diff --git a/stdlib/source/specification/lux/abstract/order.lux b/stdlib/source/specification/lux/abstract/order.lux index e620fd520..8d4844b2a 100644 --- a/stdlib/source/specification/lux/abstract/order.lux +++ b/stdlib/source/specification/lux/abstract/order.lux @@ -40,19 +40,19 @@ (@//< parameter extra)) lesser? (and (@//< extra parameter) (@//< extra subject)) - in-between? (and (@//< parameter extra) + in_between? (and (@//< parameter extra) (@//< extra subject))] (or greater? lesser? - in-between?)) + in_between?)) ## (@//< subject parameter) (let [greater? (and (@//< extra subject) (@//< extra parameter)) lesser? (and (@//< parameter extra) (@//< subject extra)) - in-between? (and (@//< subject extra) + in_between? (and (@//< subject extra) (@//< extra parameter))] (or greater? lesser? - in-between?))))) + in_between?))))) ))) |