aboutsummaryrefslogtreecommitdiff
path: root/stdlib/source/specification/compositor
diff options
context:
space:
mode:
Diffstat (limited to 'stdlib/source/specification/compositor')
-rw-r--r--stdlib/source/specification/compositor/analysis/type.lux16
-rw-r--r--stdlib/source/specification/compositor/common.lux32
-rw-r--r--stdlib/source/specification/compositor/generation/case.lux122
-rw-r--r--stdlib/source/specification/compositor/generation/common.lux114
-rw-r--r--stdlib/source/specification/compositor/generation/function.lux30
-rw-r--r--stdlib/source/specification/compositor/generation/primitive.lux10
-rw-r--r--stdlib/source/specification/compositor/generation/reference.lux8
-rw-r--r--stdlib/source/specification/compositor/generation/structure.lux58
8 files changed, 195 insertions, 195 deletions
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)))))