diff options
Diffstat (limited to 'stdlib/source/specification/compositor')
8 files changed, 0 insertions, 1089 deletions
diff --git a/stdlib/source/specification/compositor/analysis/type.lux b/stdlib/source/specification/compositor/analysis/type.lux deleted file mode 100644 index 726e438c9..000000000 --- a/stdlib/source/specification/compositor/analysis/type.lux +++ /dev/null @@ -1,65 +0,0 @@ -(.require - [library - [lux (.except) - [abstract - [monad (.only do)]] - [control - ["[0]" pipe] - ["[0]" io] - ["[0]" try]] - [math - ["r" random (.only Random)]] - [meta - ["[0]" code] - [compiler - [analysis (.only State)] - ["[0]" phase - [macro (.only Expander)] - ["[0]" analysis - ["[1]/[0]" scope] - ["[1]/[0]" type]]]]] - [test - ["_" property (.only Test)]]]]) - -(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.phase expander (` ((, (code.text extension)) (,* params)))))) - (phase.result state) - (pipe.when - {try.#Success _} - true - - {try.#Failure _} - false))) - -(def check - (Random [Code Type Code]) - (`` (all r.either - (,, (with_template [<random> <type> <code>] - [(do r.monad - [value <random>] - (in [(` <type>) - <type> - (<code> value)]))] - - [r.bit {0 #0 "#Bit" {0 #0}} code.bit] - [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.upper_case_alpha 5) {0 #0 "#Text" {0 #0}} code.text] - ))))) - -(def .public (spec expander state) - (-> Expander State Test) - (do r.monad - [[typeC exprT exprC] ..check - [other_typeC other_exprT other_exprC] ..check] - (all _.and - (_.test "lux check" - (check_success+ expander state "lux check" (list typeC exprC) exprT)) - (_.test "lux coerce" - (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 deleted file mode 100644 index 6045d8db1..000000000 --- a/stdlib/source/specification/compositor/common.lux +++ /dev/null @@ -1,80 +0,0 @@ -(.require - [lux (.except) - [abstract - [monad (.only do)]] - [control - ["[0]" io (.only IO)] - ["[0]" try (.only Try)]] - [meta - [compiler - ["[0]" reference] - ["[0]" analysis] - ["[0]" synthesis (.only Synthesis)] - ["[0]" declaration] - ["[0]" phase - ["[0]" macro (.only Expander)] - ["[0]" translation (.only Operation)] - [extension (.only Extender) - ["[0]" bundle]]] - [default - ["[0]" platform (.only Platform)]]]]]) - -(type .public Runner - (-> Text Synthesis (Try Any))) - -(type .public Definer - (-> Symbol Synthesis (Try Any))) - -(type .public (Instancer what) - (All (_ anchor expression declaration) - (-> (Platform IO anchor expression declaration) - (translation.State anchor expression declaration) - what))) - -(def (runner (open "[0]") state) - (Instancer Runner) - (function (_ evaluation_name expressionS) - (do try.monad - [expressionG (<| (phase.result state) - translation.with_buffer - (do phase.monad - [_ runtime] - (phase expressionS)))] - (of host evaluate! evaluation_name expressionG)))) - -(def (definer (open "[0]") state) - (Instancer Definer) - (function (_ lux_name expressionS) - (do try.monad - [definitionG (<| (phase.result state) - translation.with_buffer - (do phase.monad - [_ runtime - expressionG (phase expressionS) - [host_name host_value host_declaration] (translation.define! lux_name expressionG) - _ (translation.learn lux_name host_name)] - (phase (synthesis.constant lux_name))))] - (of host evaluate! "definer" definitionG)))) - -(def .public (executors target expander platform - analysis_bundle translation_bundle declaration_bundle - program extender) - (All (_ anchor expression declaration) - (-> Text Expander (Platform IO anchor expression declaration) - analysis.Bundle - (translation.Bundle anchor expression declaration) - (declaration.Bundle anchor expression declaration) - (-> expression declaration) Extender - (IO (Try [(declaration.State anchor expression declaration) - Runner - Definer])))) - (do io.monad - [?state (platform.initialize target expander analysis_bundle platform translation_bundle declaration_bundle program extender)] - (in (do try.monad - [[declaration_bundle declaration_state] ?state - .let [translation_state (the [declaration.#translation - declaration.#state] - declaration_state)]] - (in [[declaration_bundle declaration_state] - (..runner platform translation_state) - (..definer platform translation_state)]))))) diff --git a/stdlib/source/specification/compositor/generation/case.lux b/stdlib/source/specification/compositor/generation/case.lux deleted file mode 100644 index 5b36db339..000000000 --- a/stdlib/source/specification/compositor/generation/case.lux +++ /dev/null @@ -1,290 +0,0 @@ -(.require - [library - [lux (.except when) - [abstract - [monad (.only do)]] - [control - ["[0]" pipe] - ["[0]" try (.only Try)]] - [data - ["[0]" text (.use "[1]#[0]" equivalence) - ["%" \\format (.only format)]] - [number - ["n" nat] - ["f" frac]] - [collection - ["[0]" list (.use "[1]#[0]" mix)]]] - [math - ["r" random (.only Random)]] - [meta - [compiler - ["[0]" reference] - ["[0]" analysis] - ["[0]" synthesis (.only Path Synthesis)] - ["[0]" phase - ["[1]/[0]" synthesis - ["[0]" when]] - ["[0]" extension/synthesis]]]] - [test - ["_" property (.only Test)]]]] - [/// - [common (.only Runner)]]) - -(def limit Nat 10) - -(def size - (Random Nat) - (|> r.nat (of r.monad each (|>> (n.% ..limit) (n.max 2))))) - -(def (tail? size idx) - (-> Nat Nat Bit) - (n.= (-- size) idx)) - -(def .public (verify expected) - (-> Frac (Try Any) Bit) - (|>> (pipe.when - {try.#Success actual} - (f.= expected (as Frac actual)) - - {try.#Failure _} - false))) - -(def when - (Random [Synthesis Path]) - (<| r.rec (function (_ when)) - (`` (all r.either - (do r.monad - [value r.i64] - (in [(synthesis.i64 value) - synthesis.path/pop])) - (,, (with_template [<gen> <synth> <path>] - [(do r.monad - [value <gen>] - (in [(<synth> value) - (<path> value)]))] - - [r.bit synthesis.bit synthesis.path/bit] - [r.i64 synthesis.i64 synthesis.path/i64] - [r.frac synthesis.f64 synthesis.path/f64] - [(r.unicode 5) synthesis.text synthesis.path/text])) - (do [! r.monad] - [size ..size - idx (|> r.nat (of ! each (n.% size))) - [subS subP] when - .let [unitS (synthesis.text synthesis.unit) - whenS (synthesis.tuple - (list.together (list (list.repeated idx unitS) - (list subS) - (list.repeated (|> size -- (n.- idx)) unitS)))) - whenP (all synthesis.path/seq - (if (tail? size idx) - (synthesis.member/right idx) - (synthesis.member/left idx)) - subP)]] - (in [whenS whenP])) - (do [! r.monad] - [size ..size - idx (|> r.nat (of ! each (n.% size))) - [subS subP] when - .let [right? (tail? size idx) - whenS (synthesis.variant - [analysis.#lefts idx - analysis.#right? right? - analysis.#value subS]) - whenP (all synthesis.path/seq - (if right? - (synthesis.side/right idx) - (synthesis.side/left idx)) - subP)]] - (in [whenS whenP])) - )))) - -(def (let_spec run) - (-> Runner Test) - (do r.monad - [value r.safe_frac] - (_.test (%.symbol (symbol synthesis.branch/let)) - (|> (synthesis.branch/let [(synthesis.f64 value) - 0 - (synthesis.variable/local 0)]) - (run "let_spec") - (verify value))))) - -(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))) - verdict r.bit] - (_.test (%.symbol (symbol 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)))))) - -(def (when_spec run) - (-> Runner Test) - (do r.monad - [[inputS pathS] ..when - on_success r.safe_frac - on_failure (|> r.safe_frac (r.only (|>> (f.= on_success) not)))] - (_.test (%.symbol (symbol synthesis.branch/when)) - (|> (synthesis.branch/when - [inputS - (all synthesis.path/alt - (all synthesis.path/seq - pathS - (synthesis.path/then (synthesis.f64 on_success))) - (synthesis.path/then (synthesis.f64 on_failure)))]) - (run "when_spec") - (verify on_success))))) - -(def special_input - Synthesis - (let [_cursor_ (is Synthesis - (synthesis.tuple (list (synthesis.text .prelude) - (synthesis.i64 +901) - (synthesis.i64 +13)))) - _code_ (is (-> Synthesis Synthesis) - (function (_ content) - (synthesis.tuple (list _cursor_ content)))) - _end_ (is Synthesis - (synthesis.variant [0 #0 (synthesis.text "")])) - _item_ (is (-> Synthesis Synthesis Synthesis) - (function (_ head tail) - (synthesis.variant [0 #1 (synthesis.tuple (list head tail))]))) - _list_ (is (-> (List Synthesis) Synthesis) - (list#mix _item_ _end_))] - (let [__tuple__ (is (-> (List Synthesis) Synthesis) - (|>> list.reversed _list_ [9 #0] synthesis.variant _code_)) - __form__ (is (-> (List Synthesis) Synthesis) - (|>> list.reversed _list_ [7 #0] synthesis.variant _code_)) - __text__ (is (-> Text Synthesis) - (function (_ value) - (_code_ (synthesis.variant [5 #0 (synthesis.text value)])))) - __symbol__ (is (-> Symbol Synthesis) - (function (_ [module short]) - (_code_ (synthesis.variant [6 #0 (synthesis.tuple (list (synthesis.text module) - (synthesis.text short)))])))) - __list__ (is (-> (List Synthesis) Synthesis) - (list#mix (function (_ head tail) - (__form__ (list (__tag__ ["" "Item"]) head tail))) - (__tag__ ["" "End"]))) - __apply__ (is (-> Synthesis Synthesis Synthesis) - (function (_ func arg) - (__form__ (list func arg))))] - (|> _end_ - (_item_ (__apply__ (__symbol__ ["" "form$"]) - (__list__ (list (__apply__ (__symbol__ ["" "tag$"]) - (__tuple__ (list (__text__ .prelude) - (__text__ "Item")))) - (__symbol__ ["" "export?-meta"]) - (__symbol__ ["" "tail"]))))) - (_item_ (__tuple__ (list (__symbol__ ["" "tail"])))) - )))) - -(def special_path - Path - (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})] - (all synthesis.path/alt - (all synthesis.path/seq - _item_ - _head_ - _head_ (synthesis.path/bind 2) synthesis.path/pop - _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_ _item_ - _head_ (synthesis.path/bind 5) synthesis.path/pop - _tail_ _end_ - ... THEN - (synthesis.path/then (synthesis.bit #1))) - (all synthesis.path/seq - (synthesis.path/bind 2) - ... THEN - (synthesis.path/then (synthesis.bit #0)))))) - -(def special_pattern - analysis.Pattern - (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))) - ... {#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))] - ... {#Item <head> <tail>} - (<| analysis.pattern/variant [0 #1] - (analysis.pattern/tuple (list head tail))))) - -(def special_pattern_path - Path - (all synthesis.path/alt - (<| try.trusted - (phase.result [extension/synthesis.bundle - synthesis.init]) - (when.path phase/synthesis.phase - special_pattern) - (analysis.bit #1)) - (all synthesis.path/seq - (synthesis.path/bind 2) - ... THEN - (synthesis.path/then (synthesis.bit #0))))) - -... TODO: Get rid of this ASAP -(def (special_spec run) - (-> Runner Test) - (all _.and - (_.test "===" - (and (text#= (synthesis.%path special_path) - (synthesis.%path special_pattern_path)) - (of synthesis.path_equivalence = special_path special_pattern_path))) - (_.test "CODE" - (|> special_input - (run "special_input") - (pipe.when - {try.#Success output} - true - - {try.#Failure _} - false))) - (_.test "PATTERN_MATCHING 0" - (|> (synthesis.branch/when [special_input - special_path]) - (run "special_path") - (pipe.when - {try.#Success output} - true - - {try.#Failure _} - false))) - (_.test "PATTERN_MATCHING 1" - (|> (synthesis.branch/when [special_input - special_pattern_path]) - (run "special_pattern_path") - (pipe.when - {try.#Success output} - true - - {try.#Failure _} - false))) - )) - -(def .public (spec run) - (-> Runner Test) - (all _.and - (..special_spec run) - (..let_spec run) - (..if_spec run) - (..when_spec run) - )) diff --git a/stdlib/source/specification/compositor/generation/common.lux b/stdlib/source/specification/compositor/generation/common.lux deleted file mode 100644 index acb782c1f..000000000 --- a/stdlib/source/specification/compositor/generation/common.lux +++ /dev/null @@ -1,350 +0,0 @@ -(.require - [library - [lux (.except i64) - [abstract - [monad (.only do)]] - [control - ["[0]" pipe] - ["[0]" try (.only Try)]] - [data - ["[0]" bit (.use "[1]#[0]" equivalence)] - [number - ["[0]" i64] - ["n" nat] - ["i" int] - ["f" frac]] - ["[0]" text (.use "[1]#[0]" equivalence) - ["%" \\format (.only format)]] - [collection - ["[0]" list]]] - [math - ["r" random (.only Random)]] - [meta - [macro - ["^" pattern]] - [compiler - ["[0]" reference] - ["[0]" synthesis]]] - [test - ["_" property (.only Test)]]]] - ["[0]" // - ["[1][0]" when] - [// - [common (.only Runner)]]]) - -(def safe - (-> Text Text) - (text.replaced " " "_")) - -(def (bit run) - (-> Runner Test) - (do r.monad - [param r.i64 - subject r.i64] - (with_expansions [<binary> (with_template [<extension> <reference> <param_expr>] - [(_.test <extension> - (|> {synthesis.#Extension (symbol <extension>) (list (synthesis.i64 param) - (synthesis.i64 subject))} - (run (..safe <extension>)) - (pipe.when - {try.#Success valueT} - (n.= (<reference> param subject) (as Nat valueT)) - - {try.#Failure _} - false) - (let [param <param_expr>])))] - - [.i64_and# i64.and param] - [.i64_or# i64.or param] - [.i64_xor# i64.xor param] - [.i64_left# i64.left_shifted (n.% 64 param)] - ["lux i64 logical-right-shift" i64.logic_right_shifted (n.% 64 param)] - )] - (all _.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")) - (pipe.when - {try.#Success valueT} - (.i64_=# (i64.arithmetic_right_shifted param subject) - (as I64 valueT)) - - {try.#Failure _} - false) - (let [param (n.% 64 param)]))) - )))) - -(def (i64 run) - (-> Runner Test) - (do r.monad - [param (|> r.i64 (r.only (|>> (.i64_=# 0) not))) - subject r.i64] - (`` (all _.and - (,, (with_template [<extension> <type> <prepare> <comp> <subject_expr>] - [(_.test <extension> - (|> {synthesis.#Extension (symbol <extension>) (list (synthesis.i64 subject))} - (run (..safe <extension>)) - (pipe.when - {try.#Success valueT} - (<comp> (<prepare> subject) (as <type> valueT)) - - {try.#Failure _} - false) - (let [subject <subject_expr>])))] - - [.int_f64# Frac i.frac f.= subject] - [.int_char# Text (|>> (as Nat) text.from_code) text#= (|> subject - (as Nat) - (n.% (i64.left_shifted 8 1)) - (as Int))] - )) - (,, (with_template [<extension> <reference> <outputT> <comp>] - [(_.test <extension> - (|> {synthesis.#Extension (symbol <extension>) (list (synthesis.i64 param) - (synthesis.i64 subject))} - (run (..safe <extension>)) - (pipe.when - {try.#Success valueT} - (<comp> (<reference> param subject) (as <outputT> valueT)) - - {try.#Failure _} - false)))] - - [.i64_+# i.+ Int i.=] - [.i64_-# i.- Int i.=] - [.i64_=# i.= Bit bit#=] - - [.int_<# i.< Bit bit#=] - [.int_*# i.* Int i.=] - [.int_/# i./ Int i.=] - [.int_%# i.% Int i.=] - )) - )))) - -(def simple_frac - (Random Frac) - (|> r.nat (of r.monad each (|>> (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] - (`` (all _.and - (,, (with_template [<extension> <reference> <comp>] - [(_.test <extension> - (|> {synthesis.#Extension (symbol <extension>) (list (synthesis.f64 param) - (synthesis.f64 subject))} - (run (..safe <extension>)) - (//when.verify (<reference> param subject))))] - - [.f64_+# f.+ f.=] - [.f64_-# f.- f.=] - [.f64_*# f.* f.=] - [.f64_/# f./ f.=] - [.f64_%# f.% f.=] - )) - (,, (with_template [<extension> <text>] - [(_.test <extension> - (|> {synthesis.#Extension (symbol <extension>) (list (synthesis.f64 param) - (synthesis.f64 subject))} - (run (..safe <extension>)) - (pipe.when - {try.#Success valueV} - (bit#= (<text> param subject) - (as Bit valueV)) - - _ - false)))] - - [.f64_=# f.=] - [.f64_<# f.<] - )) - (_.test ".f64_int# && .int_f64#" - (|> (run (..safe .f64_int#) - (|> subject synthesis.f64 - (list) {synthesis.#Extension (symbol .f64_int#)} - (list) {synthesis.#Extension (symbol .int_f64#)})) - (//when.verify subject))) - )))) - -(def (text run) - (-> Runner Test) - (do [! r.monad] - [sample_size (|> r.nat (of ! each (|>> (n.% 10) (n.max 1)))) - sample_lower (r.lower_case_alpha sample_size) - sample_upper (r.upper_case_alpha sample_size) - sample_alpha (|> (r.alphabetic sample_size) - (r.only (|>> (text#= sample_upper) not))) - char_idx (|> r.nat (of ! each (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 (symbol .text_composite#) (list sample_lowerS sample_upperS)} - pre_rep_once (format sample_lower sample_upper) - post_rep_once (format sample_lower sample_alpha) - pre_rep_all (|> sample_lower (list.repeated sample_size) (text.interposed sample_upper)) - post_rep_all (|> sample_lower (list.repeated sample_size) (text.interposed sample_alpha))]] - (all _.and - (_.test "Can compare texts for equality." - (and (|> {synthesis.#Extension (symbol .text_=#) (list sample_lowerS sample_lowerS)} - (run (..safe .text_=#)) - (pipe.when - {try.#Success valueV} - (as Bit valueV) - - _ - false)) - (|> {synthesis.#Extension (symbol .text_=#) (list sample_upperS sample_lowerS)} - (run (..safe .text_=#)) - (pipe.when - {try.#Success valueV} - (not (as Bit valueV)) - - _ - false)))) - (_.test "Can compare texts for order." - (|> {synthesis.#Extension (symbol .text_<#) (list sample_lowerS sample_upperS)} - (run (..safe .text_<#)) - (pipe.when - {try.#Success valueV} - (as Bit valueV) - - {try.#Failure _} - false))) - (_.test "Can get length of text." - (|> {synthesis.#Extension (symbol .text_size#) (list sample_lowerS)} - (run (..safe .text_size#)) - (pipe.when - {try.#Success valueV} - (n.= sample_size (as Nat valueV)) - - _ - false))) - (_.test "Can concatenate text." - (|> {synthesis.#Extension (symbol .text_size#) (list concatenatedS)} - (run (..safe .text_size#)) - (pipe.when - {try.#Success valueV} - (n.= (n.* 2 sample_size) (as Nat valueV)) - - _ - false))) - (_.test "Can find index of sub-text." - (and (|> {synthesis.#Extension (symbol .text_index#) - (list concatenatedS sample_lowerS - (synthesis.i64 +0))} - (run (..safe .text_index#)) - (pipe.when - (^.multi {try.#Success valueV} - [(as (Maybe Nat) valueV) - {.#Some valueV}]) - (n.= 0 valueV) - - _ - false)) - (|> {synthesis.#Extension (symbol .text_index#) - (list concatenatedS sample_upperS - (synthesis.i64 +0))} - (run (..safe .text_index#)) - (pipe.when - (^.multi {try.#Success valueV} - [(as (Maybe Nat) valueV) - {.#Some valueV}]) - (n.= sample_size valueV) - - _ - false)))) - (let [test_clip (is (-> (I64 Any) (I64 Any) Text Bit) - (function (_ offset length expected) - (|> {synthesis.#Extension (symbol .text_clip#) - (list concatenatedS - (synthesis.i64 offset) - (synthesis.i64 length))} - (run (..safe .text_clip#)) - (pipe.when - (^.multi {try.#Success valueV} - [(as (Maybe Text) valueV) - {.#Some valueV}]) - (text#= expected valueV) - - _ - 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)))) - (_.test "Can extract individual characters from text." - (|> {synthesis.#Extension (symbol .text_char#) - (list sample_lowerS - (synthesis.i64 char_idx))} - (run (..safe .text_char#)) - (pipe.when - (^.multi {try.#Success valueV} - [(as (Maybe Int) valueV) - {.#Some valueV}]) - (text.contains? (.int_char# valueV) - sample_lower) - - _ - false))) - ))) - -(def (io run) - (-> Runner Test) - (do r.monad - [message (r.alphabetic 5)] - (all _.and - (_.test "Can log messages." - (|> {synthesis.#Extension .log!# - (list (synthesis.text (format "LOG: " message)))} - (run (..safe .log!#)) - (pipe.when - {try.#Success valueV} - true - - {try.#Failure _} - false))) - (_.test "Can throw runtime errors." - (and (|> {synthesis.#Extension .try# - (list (synthesis.function/abstraction - [synthesis.#environment (list) - synthesis.#arity 1 - synthesis.#body {synthesis.#Extension (symbol .error#) - (list (synthesis.text message))}]))} - (run (..safe .try#)) - (pipe.when - (^.multi {try.#Success valueV} - [(as (Try Text) valueV) - {try.#Failure error}]) - (text.contains? message error) - - _ - false)) - (|> {synthesis.#Extension .try# - (list (synthesis.function/abstraction - [synthesis.#environment (list) - synthesis.#arity 1 - synthesis.#body (synthesis.text message)]))} - (run (..safe .try#)) - (pipe.when - (^.multi {try.#Success valueV} - [(as (Try Text) valueV) - {try.#Success valueV}]) - (text#= message valueV) - - _ - false)))) - ))) - -(def .public (spec runner) - (-> Runner Test) - (all _.and - (..bit runner) - (..i64 runner) - (..f64 runner) - (..text runner) - (..io runner) - )) diff --git a/stdlib/source/specification/compositor/generation/function.lux b/stdlib/source/specification/compositor/generation/function.lux deleted file mode 100644 index 63b025065..000000000 --- a/stdlib/source/specification/compositor/generation/function.lux +++ /dev/null @@ -1,96 +0,0 @@ -(.require - [library - [lux (.except function) - [abstract - [monad (.only do)] - ["[0]" enum]] - [control - ["[0]" maybe]] - [data - [number - ["n" nat]] - [collection - ["[0]" list (.use "[1]#[0]" functor)]]] - [math - ["r" random (.only Random) (.use "[1]#[0]" monad)]] - [meta - [compiler - [analysis (.only Arity)] - ["[0]" reference (.only Register)] - ["[0]" synthesis (.only Synthesis)]]]] - [test - ["_" property (.only Test)]]] - ["[0]" // - ["[1][0]" case] - [// - [common (.only Runner)]]]) - -(def max_arity - Arity - 10) - -(def arity - (Random Arity) - (|> r.nat (r#each (|>> (n.% max_arity) (n.max 1))))) - -(def (local arity) - (-> Arity (Random Register)) - (|> r.nat (r#each (|>> (n.% arity) ++)))) - -(def function - (Random [Arity Register Synthesis]) - (do r.monad - [arity ..arity - local (..local arity)] - (in [arity local - (synthesis.function/abstraction - [synthesis.#environment (list) - synthesis.#arity arity - synthesis.#body (synthesis.variable/local local)])]))) - -(def .public (spec run) - (-> Runner Test) - (do [! r.monad] - [[arity local functionS] ..function - partial_arity (|> r.nat (of ! each (|>> (n.% arity) (n.max 1)))) - inputs (r.list arity r.safe_frac) - .let [expectation (maybe.trusted (list.item (-- local) inputs)) - inputsS (list#each (|>> synthesis.f64) inputs)]] - (all _.and - (_.test "Can read arguments." - (|> (synthesis.function/apply [synthesis.#function functionS - synthesis.#arguments inputsS]) - (run "with_local") - (//case.verify expectation))) - (_.test "Can partially apply functions." - (or (n.= 1 arity) - (let [preS (list.first partial_arity inputsS) - postS (list.after 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") - (//case.verify expectation))))) - (_.test "Can read environment." - (or (n.= 1 arity) - (let [environment (|> partial_arity - (enum.range n.enum 1) - (list#each (|>> {reference.#Local}))) - variableS (if (n.<= partial_arity local) - (synthesis.variable/foreign (-- local)) - (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.#body variableS]) - outerS (synthesis.function/abstraction - [synthesis.#environment (list) - synthesis.#arity partial_arity - synthesis.#body innerS])] - (|> (synthesis.function/apply [synthesis.#function outerS - synthesis.#arguments inputsS]) - (run "with_foreign") - (//case.verify expectation))))) - ))) diff --git a/stdlib/source/specification/compositor/generation/primitive.lux b/stdlib/source/specification/compositor/generation/primitive.lux deleted file mode 100644 index 167f219e8..000000000 --- a/stdlib/source/specification/compositor/generation/primitive.lux +++ /dev/null @@ -1,51 +0,0 @@ -(.require - [library - [lux (.except) - [abstract - [monad (.only do)]] - [control - ["[0]" pipe] - ["[0]" try]] - [data - ["[0]" bit (.use "[1]#[0]" equivalence)] - [number - ["f" frac]] - ["[0]" text (.use "[1]#[0]" equivalence) - ["%" \\format (.only format)]]] - [math - ["r" random]] - [meta - [compiler - ["[0]" synthesis]]] - [test - ["_" property (.only Test)]]]] - [/// - [common (.only Runner)]]) - -(def (f/=' reference subject) - (-> Frac Frac Bit) - (or (f.= reference subject) - (and (f.not_a_number? reference) - (f.not_a_number? subject)))) - -(def .public (spec run) - (-> Runner Test) - (`` (all _.and - (,, (with_template [<evaluation_name> <synthesis> <gen> <test>] - [(do r.monad - [expected <gen>] - (_.test (%.symbol (symbol <synthesis>)) - (|> (run <evaluation_name> (<synthesis> expected)) - (pipe.when - {try.#Success actual} - (<test> expected (as_expected actual)) - - {try.#Failure _} - false))))] - - ["bit" synthesis.bit r.bit bit#=] - ["i64" synthesis.i64 r.i64 .i64_=#] - ["f64" synthesis.f64 r.frac f.='] - ["text" synthesis.text (r.ascii 5) text#=] - )) - ))) diff --git a/stdlib/source/specification/compositor/generation/reference.lux b/stdlib/source/specification/compositor/generation/reference.lux deleted file mode 100644 index 74c556d80..000000000 --- a/stdlib/source/specification/compositor/generation/reference.lux +++ /dev/null @@ -1,64 +0,0 @@ -(.require - [library - [lux (.except symbol) - [abstract - [monad (.only do)]] - [control - ["[0]" pipe] - ["[0]" try]] - [data - [number - ["n" nat] - ["f" frac]]] - [meta - [compiler - ["[0]" reference] - ["[0]" synthesis]]] - [math - ["r" random (.only Random)]] - [test - ["_" property (.only Test)]]]] - [/// - [common (.only Runner Definer)]]) - -(def symbol - (Random Symbol) - (let [symbol_part (r.upper_case_alpha 5)] - [(r.and symbol_part symbol_part)])) - -(def (definition define) - (-> Definer Test) - (do r.monad - [name ..symbol - expected r.safe_frac] - (_.test "Definitions." - (|> (define name (synthesis.f64 expected)) - (pipe.when - {try.#Success actual} - (f.= expected (as Frac actual)) - - {try.#Failure _} - false))))) - -(def (variable run) - (-> Runner Test) - (do [! r.monad] - [register (|> r.nat (of ! each (n.% 100))) - expected r.safe_frac] - (_.test "Local variables." - (|> (synthesis.branch/let [(synthesis.f64 expected) - register - (synthesis.variable/local register)]) - (run "variable") - (pipe.when - {try.#Success actual} - (f.= expected (as Frac actual)) - - {try.#Failure _} - false))))) - -(def .public (spec runner definer) - (-> Runner Definer Test) - (all _.and - (..definition definer) - (..variable runner))) diff --git a/stdlib/source/specification/compositor/generation/structure.lux b/stdlib/source/specification/compositor/generation/structure.lux deleted file mode 100644 index b28648520..000000000 --- a/stdlib/source/specification/compositor/generation/structure.lux +++ /dev/null @@ -1,93 +0,0 @@ -(.require - [library - [lux (.except) - ["[0]" ffi (.only import)] - [abstract - [monad (.only do)]] - [control - ["[0]" pipe] - ["[0]" maybe] - ["[0]" try]] - [data - [number - ["n" nat] - ["i" int]] - ["[0]" text (.use "[1]#[0]" equivalence) - ["%" \\format (.only format)]] - [collection - ["[0]" array (.only Array)] - ["[0]" list (.use "[1]#[0]" functor)]]] - [math - ["r" random]] - [meta - [compiler - ["[0]" analysis] - ["[0]" synthesis]]] - [test - ["_" property (.only Test)]]]] - [/// - [common (.only Runner)]]) - -(import java/lang/Integer) - -(def (variant run) - (-> Runner Test) - (do [! r.monad] - [num_tags (|> r.nat (of ! each (|>> (n.% 10) (n.max 2)))) - tag_in (|> r.nat (of ! each (n.% num_tags))) - .let [last?_in (|> num_tags -- (n.= tag_in))] - value_in r.i64] - (_.test (%.symbol (symbol synthesis.variant)) - (|> (synthesis.variant [analysis.#lefts (if last?_in - (-- tag_in) - tag_in) - analysis.#right? last?_in - analysis.#value (synthesis.i64 value_in)]) - (run "variant") - (pipe.when - {try.#Success valueT} - (let [valueT (as (Array Any) valueT)] - (and (n.= 3 (array.size valueT)) - (let [tag_out (as java/lang/Integer (maybe.trusted (array.read! 0 valueT))) - last?_out (array.read! 1 valueT) - value_out (as Any (maybe.trusted (array.read! 2 valueT))) - same_tag? (|> tag_out ffi.int_to_long (as Nat) (n.= tag_in)) - same_flag? (when 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?)))) - - {try.#Failure _} - false))))) - -(def (tuple run) - (-> Runner Test) - (do [! r.monad] - [size (|> r.nat (of ! each (|>> (n.% 10) (n.max 2)))) - tuple_in (r.list size r.i64)] - (_.test (%.symbol (symbol synthesis.tuple)) - (|> (synthesis.tuple (list#each (|>> synthesis.i64) tuple_in)) - (run "tuple") - (pipe.when - {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.list tuple_out))))) - - {try.#Failure _} - false))))) - -(def .public (spec runner) - (-> Runner Test) - (all _.and - (..variant runner) - (..tuple runner) - )) |