diff options
31 files changed, 879 insertions, 608 deletions
diff --git a/lux-jvm/source/luxc/lang/translation/jvm/extension/host.lux b/lux-jvm/source/luxc/lang/translation/jvm/extension/host.lux index 45bbce9f9..7048bdd25 100644 --- a/lux-jvm/source/luxc/lang/translation/jvm/extension/host.lux +++ b/lux-jvm/source/luxc/lang/translation/jvm/extension/host.lux @@ -905,11 +905,11 @@ (-> (Dictionary Synthesis Variable) Synthesis Synthesis) (function (again body) (case body - (^ {synthesis.#Primitive value}) - body - - (^ (synthesis.constant value)) - body + (^template [<tag>] + [(^ <tag>) + body]) + ([{//////synthesis.#Primitive _}] + [(//////synthesis.constant _)]) (^ (synthesis.variant [lefts right? sub])) (synthesis.variant [lefts right? (again sub)]) @@ -926,6 +926,9 @@ (^ (synthesis.branch/case [inputS pathS])) (synthesis.branch/case [(again inputS) (normalize_path again pathS)]) + (^ (synthesis.branch/exec [this that])) + (synthesis.branch/exec [(again this) (again that)]) + (^ (synthesis.branch/let [inputS register outputS])) (synthesis.branch/let [(again inputS) register (again outputS)]) diff --git a/stdlib/source/library/lux.lux b/stdlib/source/library/lux.lux index 4aed1937b..d65fa7bcb 100644 --- a/stdlib/source/library/lux.lux +++ b/stdlib/source/library/lux.lux @@ -895,11 +895,8 @@ {#None} {#Item [k v] environment'} - ({#1 - {#Some v} - - #0 - (replacement for environment')} + ({[#1] {#Some v} + [#0] (replacement for environment')} (text#= k for))} environment)) @@ -999,8 +996,8 @@ ({... Jackpot! {#Parameter id} ({id' - ({#0 {#Parameter id'} - #1 {#Parameter ("lux i64 -" 2 id')}} + ({[#0] {#Parameter id'} + [#1] {#Parameter ("lux i64 -" 2 id')}} (self_id? id))} ("lux i64 -" ("lux i64 -" depth id) 0)) @@ -1072,18 +1069,19 @@ ..#seed _ ..#expected _ ..#location _ ..#extensions _ ..#scope_type_vars _ ..#eval _] (list#mix (function'' [scope verdict] - ({#1 #1 - _ ({[..#name _ ..#inner _ ..#captured _ - ..#locals [..#counter _ - ..#mappings locals]] - (list#mix (function'' [local verdict] - ({[local _] - ({#1 #1 _ ("lux text =" ..quantification_level local)} - verdict)} - local)) - #0 - locals)} - scope)} + ({[#1] #1 + _ ({[..#name _ ..#inner _ ..#captured _ + ..#locals [..#counter _ + ..#mappings locals]] + (list#mix (function'' [local verdict] + ({[local _] + ({[#1] #1 + _ ("lux text =" ..quantification_level local)} + verdict)} + local)) + #0 + locals)} + scope)} verdict)) #0 scopes)} @@ -1094,8 +1092,8 @@ {#Item body {#End}}} {#Right [lux {#Item ({raw - ({#1 raw - #0 (..quantified raw)} + ({[#1] raw + [#0] (..quantified raw)} (initialized_quantification? lux))} ({{#End} body @@ -1126,8 +1124,8 @@ {#Item body {#End}}} {#Right [lux {#Item ({raw - ({#1 raw - #0 (..quantified raw)} + ({[#1] raw + [#0] (..quantified raw)} (initialized_quantification? lux))} ({{#End} body @@ -1301,8 +1299,8 @@ #0 {#Item x xs'} - ({#1 #1 - #0 (any? p xs')} + ({[#1] #1 + [#0] (any? p xs')} (p x))} xs)) @@ -1561,40 +1559,38 @@ (def:''' .private (spliced replace? untemplated elems) (-> Bit (-> Code ($' Meta Code)) ($' List Code) ($' Meta Code)) - ({#1 - ({{#End} - (in_meta |#End|) - - {#Item lastI inits} - (do meta_monad - [lastO ({[_ {#Form {#Item [[_ {#Symbol ["" "~+"]}] {#Item [spliced {#End}]}]}}] - (in (:List<Code> spliced)) + ({[#1] ({{#End} + (in_meta |#End|) + + {#Item lastI inits} + (do meta_monad + [lastO ({[_ {#Form {#Item [[_ {#Symbol ["" "~+"]}] {#Item [spliced {#End}]}]}}] + (in (:List<Code> spliced)) - _ - (do meta_monad - [lastO (untemplated lastI)] - (in (:List<Code> (|#Item| lastO |#End|))))} - lastI)] - (monad#mix meta_monad - (function' [leftI rightO] - ({[_ {#Form {#Item [[_ {#Symbol ["" "~+"]}] {#Item [spliced {#End}]}]}}] - (let' [g!in-module (form$ (list (text$ "lux in-module") - (text$ ..prelude_module) - (symbol$ [..prelude_module "list#composite"])))] - (in (form$ (list g!in-module (:List<Code> spliced) rightO)))) - - _ - (do meta_monad - [leftO (untemplated leftI)] - (in (|#Item| leftO rightO)))} - leftI)) - lastO - inits))} - (list#reversed elems)) - #0 - (do meta_monad - [=elems (monad#each meta_monad untemplated elems)] - (in (untemplated_list =elems)))} + _ + (do meta_monad + [lastO (untemplated lastI)] + (in (:List<Code> (|#Item| lastO |#End|))))} + lastI)] + (monad#mix meta_monad + (function' [leftI rightO] + ({[_ {#Form {#Item [[_ {#Symbol ["" "~+"]}] {#Item [spliced {#End}]}]}}] + (let' [g!in-module (form$ (list (text$ "lux in-module") + (text$ ..prelude_module) + (symbol$ [..prelude_module "list#composite"])))] + (in (form$ (list g!in-module (:List<Code> spliced) rightO)))) + + _ + (do meta_monad + [leftO (untemplated leftI)] + (in (|#Item| leftO rightO)))} + leftI)) + lastO + inits))} + (list#reversed elems)) + [#0] (do meta_monad + [=elems (monad#each meta_monad untemplated elems)] + (in (untemplated_list =elems)))} replace?)) (def:''' .private (untemplated_text value) @@ -1925,27 +1921,24 @@ (def:''' .private (digit::format digit) (-> Nat Text) - ({0 "0" - 1 "1" 2 "2" 3 "3" - 4 "4" 5 "5" 6 "6" - 7 "7" 8 "8" 9 "9" - _ ("lux io error" "@digit::format Undefined behavior.")} + ({[0] "0" + [1] "1" [2] "2" [3] "3" + [4] "4" [5] "5" [6] "6" + [7] "7" [8] "8" [9] "9" + _ ("lux io error" "@digit::format Undefined behavior.")} digit)) (def:''' .private (nat#encoded value) (-> Nat Text) - ({0 - "0" - - _ - (let' [loop ("lux type check" (-> Nat Text Text) - (function' again [input output] - (if ("lux i64 =" 0 input) - output - (again (n// 10 input) - (text#composite (|> input (n/% 10) digit::format) - output)))))] - (loop value ""))} + ({[0] "0" + _ (let' [loop ("lux type check" (-> Nat Text Text) + (function' again [input output] + (if ("lux i64 =" 0 input) + output + (again (n// 10 input) + (text#composite (|> input (n/% 10) digit::format) + output)))))] + (loop value ""))} value)) (def:''' .private (int#abs value) diff --git a/stdlib/source/library/lux/control/parser/analysis.lux b/stdlib/source/library/lux/control/parser/analysis.lux index a59bbfe13..73889de68 100644 --- a/stdlib/source/library/lux/control/parser/analysis.lux +++ b/stdlib/source/library/lux/control/parser/analysis.lux @@ -1,6 +1,6 @@ (.using [library - [lux {"-" Tuple Variant nat int rev local} + [lux {"-" nat int rev local} [abstract [monad {"+" do}]] [control @@ -30,7 +30,8 @@ [variable {"+" }]] [language [lux - ["/" analysis {"+" Variant Tuple Environment Analysis}]]]]]]] + ["/" analysis {"+" Environment Analysis} + ["[1][0]" composite]]]]]]]] ["[0]" //]) (def: (remaining_inputs asts) diff --git a/stdlib/source/library/lux/control/parser/synthesis.lux b/stdlib/source/library/lux/control/parser/synthesis.lux index 473d6371b..894f7da68 100644 --- a/stdlib/source/library/lux/control/parser/synthesis.lux +++ b/stdlib/source/library/lux/control/parser/synthesis.lux @@ -1,32 +1,32 @@ (.using - [library - [lux {"-" Tuple Variant function loop i64 local} - [abstract - [monad {"+" do}]] - [control - ["[0]" try {"+" Try}] - ["[0]" exception {"+" exception:}]] - [data - ["[0]" bit] - ["[0]" text - ["%" format {"+" format}]]] - [math - [number - ["n" nat] - ["[0]" i64] - ["[0]" frac]]] - [meta - ["[0]" symbol]] - [tool - [compiler - [reference {"+" } - [variable {"+" Register}]] - [arity {"+" Arity}] - [language - [lux - [analysis {"+" Variant Tuple Environment}] - ["/" synthesis {"+" Synthesis Abstraction}]]]]]]] - ["[0]" //]) + [library + [lux {"-" function loop i64 local} + [abstract + [monad {"+" do}]] + [control + ["[0]" try {"+" Try}] + ["[0]" exception {"+" exception:}]] + [data + ["[0]" bit] + ["[0]" text + ["%" format {"+" format}]]] + [math + [number + ["n" nat] + ["[0]" i64] + ["[0]" frac]]] + [meta + ["[0]" symbol]] + [tool + [compiler + [reference {"+" } + [variable {"+" Register}]] + [arity {"+" Arity}] + [language + [lux + [analysis {"+" Environment}] + ["/" synthesis {"+" Synthesis Abstraction}]]]]]]] + ["[0]" //]) (exception: .public (cannot_parse [input (List Synthesis)]) (exception.report diff --git a/stdlib/source/library/lux/target/ruby.lux b/stdlib/source/library/lux/target/ruby.lux index c2d0517c9..df112f23f 100644 --- a/stdlib/source/library/lux/target/ruby.lux +++ b/stdlib/source/library/lux/target/ruby.lux @@ -43,18 +43,12 @@ (abstract: .public (Code brand) Text - (implementation: .public code_equivalence + (implementation: .public equivalence (All (_ brand) (Equivalence (Code brand))) (def: (= reference subject) (# text.equivalence = (:representation reference) (:representation subject)))) - (implementation: .public code_hash - (All (_ brand) (Hash (Code brand))) - - (def: &equivalence ..code_equivalence) - (def: hash (|>> :representation (# text.hash hash)))) - (def: .public manual (-> Text Code) (|>> :abstraction)) @@ -223,8 +217,18 @@ \n+ "end" ..statement_suffix)) (type: .public Block - [(List LVar) - Statement]) + (Record + [#parameters (List Var) + #body Statement])) + + (def: (block it) + (-> Block Text) + (|> (format (|> (value@ #parameters it) + (list#each (|>> :representation)) + (text.interposed ..input_separator) + (text.enclosed' "|")) + (..nested (:representation (value@ #body it)))) + (text.enclosed ["{" "}"]))) (def: .public (apply/* arguments block func) (-> (List Expression) (Maybe Block) Expression Computation) @@ -336,19 +340,18 @@ (..nested (:representation rescue))))) (text.interposed \n+))))) - (def: .public (catch expectation body!) - (-> Expression Statement Statement) + (def: .public (catch expectation block) + (-> Expression Block Expression) (<| :abstraction - ..control_structure - (format "catch(" (:representation expectation) ") do" - (..nested (:representation body!))))) + (format "catch(" (:representation expectation) ") " + (..block block)))) (def: .public (return value) (-> Expression Statement) (:abstraction (format "return " (:representation value) ..statement_suffix))) (def: .public (raise message) - (-> Expression Computation) + (-> Expression Expression) (:abstraction (format "raise " (:representation message)))) (template [<name> <keyword>] @@ -374,15 +377,9 @@ (text.enclosed ["(" ")"])) (..nested (:representation body!))))) - (def: .public (lambda name args body!) - (-> (Maybe LVar) (List Var) Statement Computation) - (let [proc (|> (format (|> args - (list#each (|>> :representation)) - (text.interposed ..input_separator) - (text.enclosed' "|")) - (..nested (:representation body!))) - (text.enclosed ["{" "}"]) - (format "lambda "))] + (def: .public (lambda name block) + (-> (Maybe LVar) Block Literal) + (let [proc (format "lambda " (..block block))] (|> (case name {.#None} proc @@ -491,12 +488,13 @@ [2 [["print"] ["alias_method"]]] - - [3 - [["print"]]] ) (def: .public throw/1 (-> Expression Statement) (|>> (..apply/1 (..local "throw")) ..statement)) + +(def: .public (throw/2 tag value) + (-> Expression Expression Statement) + (..statement (..apply/2 (..local "throw") tag value))) diff --git a/stdlib/source/library/lux/tool/compiler/language/lux/analysis.lux b/stdlib/source/library/lux/tool/compiler/language/lux/analysis.lux index 1b3f70f05..0096a259a 100644 --- a/stdlib/source/library/lux/tool/compiler/language/lux/analysis.lux +++ b/stdlib/source/library/lux/tool/compiler/language/lux/analysis.lux @@ -27,6 +27,7 @@ ["[0]" location]]]] ["[0]" / "_" ["[1][0]" primitive {"+" Primitive}] + ["[1][0]" composite {"+" Tuple Variant Composite}] [// [phase ["[0]" extension {"+" Extension}]] @@ -37,41 +38,6 @@ ["[0]" reference {"+" Reference} ["[0]" variable {"+" Register Variable}]]]]]) -(type: .public Tag - Nat) - -(type: .public (Variant a) - (Record - [#lefts Nat - #right? Bit - #value a])) - -(def: .public (tag lefts right?) - (-> Nat Bit Nat) - (if right? - (++ lefts) - lefts)) - -(def: (lefts tag right?) - (-> Nat Bit Nat) - (if right? - (-- tag) - tag)) - -(def: .public (choice options pick) - (-> Nat Nat [Nat Bit]) - (let [right? (n.= (-- options) pick)] - [(..lefts pick right?) - right?])) - -(type: .public (Tuple a) - (List a)) - -(type: .public (Composite a) - (.Variant - {#Variant (Variant a)} - {#Tuple (Tuple a)})) - (type: .public Pattern (Rec Pattern (.Variant @@ -107,42 +73,6 @@ (type: .public Match (Match' Analysis)) -(implementation: .public (composite_equivalence (^open "/#[0]")) - (All (_ a) (-> (Equivalence a) (Equivalence (Composite a)))) - - (def: (= reference sample) - (case [reference sample] - [{#Variant [reference_lefts reference_right? reference_value]} - {#Variant [sample_lefts sample_right? sample_value]}] - (and (n.= reference_lefts sample_lefts) - (bit#= reference_right? sample_right?) - (/#= reference_value sample_value)) - - [{#Tuple reference} {#Tuple sample}] - (# (list.equivalence /#=) = reference sample) - - _ - false))) - -(implementation: .public (composite_hash super) - (All (_ a) (-> (Hash a) (Hash (Composite a)))) - - (def: &equivalence - (..composite_equivalence (# super &equivalence))) - - (def: (hash value) - (case value - {#Variant [lefts right? value]} - ($_ n.* 2 - (# n.hash hash lefts) - (# bit.hash hash right?) - (# super hash value)) - - {#Tuple members} - ($_ n.* 3 - (# (list.hash super) hash members)) - ))) - (implementation: pattern_equivalence (Equivalence Pattern) @@ -152,7 +82,7 @@ (# /primitive.equivalence = reference sample) [{#Complex reference} {#Complex sample}] - (# (composite_equivalence =) = reference sample) + (# (/composite.equivalence =) = reference sample) [{#Bind reference} {#Bind sample}] (n.= reference sample) @@ -176,7 +106,7 @@ (# /primitive.equivalence = reference sample) [{#Structure reference} {#Structure sample}] - (# (composite_equivalence =) = reference sample) + (# (/composite.equivalence =) = reference sample) [{#Reference reference} {#Reference sample}] (# reference.equivalence = reference sample) @@ -230,10 +160,6 @@ (type: .public (Application c) [c (List c)]) -(def: (last? size tag) - (-> Nat Tag Bit) - (n.= (-- size) tag)) - (template: .public (no_op value) [(|> 1 {variable.#Local} @@ -279,8 +205,8 @@ <tag> content)])] - [pattern/variant {..#Variant}] - [pattern/tuple {..#Tuple}] + [pattern/variant {/composite.#Variant}] + [pattern/tuple {/composite.#Tuple}] ) (template [<name> <tag>] @@ -289,8 +215,8 @@ {<tag>} content)])] - [variant ..#Variant] - [tuple ..#Tuple] + [variant /composite.#Variant] + [tuple /composite.#Tuple] ) (template: .public (pattern/unit) @@ -317,16 +243,8 @@ {#Primitive it} (/primitive.format it) - {#Structure structure} - (case structure - {#Variant [lefts right? value]} - (format "(" (%.nat lefts) " " (%.bit right?) " " (%analysis value) ")") - - {#Tuple members} - (|> members - (list#each %analysis) - (text.interposed " ") - (text.enclosed ["[" "]"]))) + {#Structure it} + (/composite.format %analysis it) {#Reference reference} (reference.format reference) diff --git a/stdlib/source/library/lux/tool/compiler/language/lux/analysis/composite.lux b/stdlib/source/library/lux/tool/compiler/language/lux/analysis/composite.lux new file mode 100644 index 000000000..c85f332f9 --- /dev/null +++ b/stdlib/source/library/lux/tool/compiler/language/lux/analysis/composite.lux @@ -0,0 +1,98 @@ +(.using + [library + [lux {"-" Tuple Variant} + [abstract + [equivalence {"+" Equivalence}] + [hash {"+" Hash}]] + [data + ["[0]" bit ("[1]#[0]" equivalence)] + ["[0]" text + ["%" format {"+" Format}]] + [collection + ["[0]" list ("[1]#[0]" functor)]]] + [math + [number + ["n" nat]]]]]) + +(type: .public (Variant a) + (Record + [#lefts Nat + #right? Bit + #value a])) + +(type: .public (Tuple a) + (List a)) + +(type: .public (Composite a) + (.Variant + {#Variant (Variant a)} + {#Tuple (Tuple a)})) + +(type: .public Tag + Nat) + +(def: .public (tag right? lefts) + (-> Bit Nat Tag) + (if right? + (++ lefts) + lefts)) + +(def: .public (lefts right? tag) + (-> Bit Tag Nat) + (if right? + (-- tag) + tag)) + +(def: .public (choice multiplicity pick) + (-> Nat Tag [Nat Bit]) + (let [right? (n.= (-- multiplicity) pick)] + [(..lefts right? pick) + right?])) + +(implementation: .public (equivalence (^open "/#[0]")) + (All (_ a) (-> (Equivalence a) (Equivalence (Composite a)))) + + (def: (= reference sample) + (case [reference sample] + [{#Variant [reference_lefts reference_right? reference_value]} + {#Variant [sample_lefts sample_right? sample_value]}] + (and (n.= reference_lefts sample_lefts) + (bit#= reference_right? sample_right?) + (/#= reference_value sample_value)) + + [{#Tuple reference} {#Tuple sample}] + (# (list.equivalence /#=) = reference sample) + + _ + false))) + +(implementation: .public (hash super) + (All (_ a) (-> (Hash a) (Hash (Composite a)))) + + (def: &equivalence + (..equivalence (# super &equivalence))) + + (def: (hash value) + (case value + {#Variant [lefts right? value]} + ($_ n.* 2 + (# n.hash hash lefts) + (# bit.hash hash right?) + (# super hash value)) + + {#Tuple members} + ($_ n.* 3 + (# (list.hash super) hash members)) + ))) + +(def: .public (format %it it) + (All (_ a) (-> (Format a) (Format (Composite a)))) + (case it + {#Variant [lefts right? it]} + (%.format "{" (%.nat lefts) " " (%.bit right?) " " (%it it) "}") + + {#Tuple it} + (|> it + (list#each %it) + (text.interposed " ") + (text.enclosed ["[" "]"])))) diff --git a/stdlib/source/library/lux/tool/compiler/language/lux/phase/analysis/case.lux b/stdlib/source/library/lux/tool/compiler/language/lux/phase/analysis/case.lux index c2ae6155d..c6e389f6a 100644 --- a/stdlib/source/library/lux/tool/compiler/language/lux/phase/analysis/case.lux +++ b/stdlib/source/library/lux/tool/compiler/language/lux/phase/analysis/case.lux @@ -31,7 +31,8 @@ ["[1][0]" extension] [// ["/" analysis {"+" Pattern Analysis Operation Phase} - ["[1][0]" primitive]] + ["[1][0]" primitive] + ["[1][0]" composite]] [/// ["[1]" phase]]]]]]) @@ -285,7 +286,7 @@ (let [flat_sum (type.flat_variant inputT') size_sum (list.size flat_sum) num_cases (maybe.else size_sum num_tags) - idx (/.tag lefts right?)] + idx (/composite.tag right? lefts)] (.case (list.item idx flat_sum) (^multi {.#Some caseT} (n.< num_cases idx)) @@ -322,7 +323,7 @@ [idx group variantT] (///extension.lifted (meta.tag tag)) _ (//type.with_env (check.check inputT variantT)) - .let [[lefts right?] (/.choice (list.size group) idx)]] + .let [[lefts right?] (/composite.choice (list.size group) idx)]] (analyse_pattern {.#Some (list.size group)} inputT (` {(~ (code.nat lefts)) (~ (code.bit right?)) (~+ values)}) next))) _ diff --git a/stdlib/source/library/lux/tool/compiler/language/lux/phase/analysis/case/coverage.lux b/stdlib/source/library/lux/tool/compiler/language/lux/phase/analysis/case/coverage.lux index fd07b53b5..9306b1c20 100644 --- a/stdlib/source/library/lux/tool/compiler/language/lux/phase/analysis/case/coverage.lux +++ b/stdlib/source/library/lux/tool/compiler/language/lux/phase/analysis/case/coverage.lux @@ -25,7 +25,8 @@ ["[0]" //// "_" [// ["/" analysis {"+" Pattern Operation} - ["[1][0]" primitive]] + ["[1][0]" primitive] + ["[1][0]" composite]] [/// ["[1]" phase ("[1]#[0]" monad)]]]]) @@ -138,7 +139,7 @@ ... Tuple patterns can be exhaustive if there is exhaustiveness for all of ... their sub-patterns. - {/.#Complex {/.#Tuple membersP+}} + {/.#Complex {/composite.#Tuple membersP+}} (case (list.reversed membersP+) (^or {.#End} {.#Item _ {.#End}}) (/.except ..invalid_tuple_pattern []) @@ -160,7 +161,7 @@ ... Variant patterns can be shown to be exhaustive if all the possible ... cases are handled exhaustively. - {/.#Complex {/.#Variant [lefts right? value]}} + {/.#Complex {/composite.#Variant [lefts right? value]}} (do ////.monad [value_coverage (determine value) .let [idx (if right? diff --git a/stdlib/source/library/lux/tool/compiler/language/lux/phase/analysis/inference.lux b/stdlib/source/library/lux/tool/compiler/language/lux/phase/analysis/inference.lux index d71ad7c71..6c94f14bd 100644 --- a/stdlib/source/library/lux/tool/compiler/language/lux/phase/analysis/inference.lux +++ b/stdlib/source/library/lux/tool/compiler/language/lux/phase/analysis/inference.lux @@ -22,7 +22,8 @@ ["/[1]" // "_" ["[1][0]" extension] [// - ["/" analysis {"+" Tag Analysis Operation Phase}] + ["/" analysis {"+" Analysis Operation Phase} + [composite {"+" Tag}]] [/// ["[1]" phase ("[1]#[0]" monad)] [meta @@ -248,7 +249,7 @@ ... Turns a variant type into the kind of function type suitable for inference. (def: .public (variant tag expected_size inferT) - (-> Nat Nat Type (Operation Type)) + (-> Tag Nat Type (Operation Type)) (loop [depth 0 currentT inferT] (case currentT diff --git a/stdlib/source/library/lux/tool/compiler/language/lux/phase/analysis/structure.lux b/stdlib/source/library/lux/tool/compiler/language/lux/phase/analysis/structure.lux index 3ba31d089..54eca8afb 100644 --- a/stdlib/source/library/lux/tool/compiler/language/lux/phase/analysis/structure.lux +++ b/stdlib/source/library/lux/tool/compiler/language/lux/phase/analysis/structure.lux @@ -32,7 +32,8 @@ ["/[1]" // "_" ["[1][0]" extension] [// - ["/" analysis {"+" Tag Analysis Operation Phase}] + ["/" analysis {"+" Analysis Operation Phase} + ["[1][0]" composite {"+" Tag}]] [/// ["[1]" phase] [meta @@ -108,7 +109,7 @@ (def: .public (sum analyse lefts right? archive) (-> Phase Nat Bit Phase) - (let [tag (/.tag lefts right?)] + (let [tag (/composite.tag right? lefts)] (function (again valueC) (do [! ///.monad] [expectedT (///extension.lifted meta.expected_type) @@ -289,7 +290,7 @@ [tag (///extension.lifted (meta.normal tag)) [idx group variantT] (///extension.lifted (meta.tag tag)) .let [case_size (list.size group) - [lefts right?] (/.choice case_size idx)] + [lefts right?] (/composite.choice case_size idx)] expectedT (///extension.lifted meta.expected_type)] (case expectedT {.#Var _} diff --git a/stdlib/source/library/lux/tool/compiler/language/lux/phase/extension/analysis/jvm.lux b/stdlib/source/library/lux/tool/compiler/language/lux/phase/extension/analysis/jvm.lux index cfee738e6..49a9758bd 100644 --- a/stdlib/source/library/lux/tool/compiler/language/lux/phase/extension/analysis/jvm.lux +++ b/stdlib/source/library/lux/tool/compiler/language/lux/phase/extension/analysis/jvm.lux @@ -1,62 +1,63 @@ (.using - [library - [lux {"-" Type Module Primitive type char int} - ["[0]" ffi {"+" import:}] - ["[0]" meta] - [abstract - ["[0]" monad {"+" do}]] - [control - pipe - ["[0]" maybe] - ["[0]" try {"+" Try} ("[1]#[0]" monad)] - ["[0]" exception {"+" exception:}] - ["<>" parser - ["<[0]>" code {"+" Parser}] - ["<[0]>" text]]] - [data - ["[0]" product] - ["[0]" text ("[1]#[0]" equivalence) - ["%" format {"+" format}]] - [collection - ["[0]" list ("[1]#[0]" mix monad monoid)] - ["[0]" array] - ["[0]" dictionary {"+" Dictionary}]]] - [math - [number - ["n" nat]]] - [target - ["[0]" jvm "_" - ["[0]!" reflection] - [encoding - [name {"+" External}]] - ["[1]" type {"+" Type Argument Typed} ("[1]#[0]" equivalence) - ["[0]" category {"+" Void Value' Value Return' Return Primitive Object Class Array Var Parameter Method}] - ["[0]" box] - ["[0]" reflection] - ["[0]" descriptor] - ["[0]" signature] - ["[1]_[0]" parser] - ["[1]_[0]" alias {"+" Aliasing}] - ["[0]T" lux {"+" Mapping}]]]] - ["[0]" type - ["[0]" check {"+" Check} ("[1]#[0]" monad)]]]] - ["[0]" // "_" - ["[1][0]" lux {"+" custom}] - ["/[1]" // - ["[1][0]" bundle] + [library + [lux {"-" Type Module Primitive type char int} + ["[0]" ffi {"+" import:}] + ["[0]" meta] + [abstract + ["[0]" monad {"+" do}]] + [control + pipe + ["[0]" maybe] + ["[0]" try {"+" Try} ("[1]#[0]" monad)] + ["[0]" exception {"+" exception:}] + ["<>" parser + ["<[0]>" code {"+" Parser}] + ["<[0]>" text]]] + [data + ["[0]" product] + ["[0]" text ("[1]#[0]" equivalence) + ["%" format {"+" format}]] + [collection + ["[0]" list ("[1]#[0]" mix monad monoid)] + ["[0]" array] + ["[0]" dictionary {"+" Dictionary}]]] + [math + [number + ["n" nat]]] + [target + ["[0]" jvm "_" + ["[0]!" reflection] + [encoding + [name {"+" External}]] + ["[1]" type {"+" Type Argument Typed} ("[1]#[0]" equivalence) + ["[0]" category {"+" Void Value' Value Return' Return Primitive Object Class Array Var Parameter Method}] + ["[0]" box] + ["[0]" reflection] + ["[0]" descriptor] + ["[0]" signature] + ["[1]_[0]" parser] + ["[1]_[0]" alias {"+" Aliasing}] + ["[0]T" lux {"+" Mapping}]]]] + ["[0]" type + ["[0]" check {"+" Check} ("[1]#[0]" monad)]]]] + ["[0]" // "_" + ["[1][0]" lux {"+" custom}] + ["/[1]" // + ["[1][0]" bundle] + ["/[1]" // "_" + [analysis + ["[0]A" type] + ["[0]A" inference] + ["[0]" scope]] ["/[1]" // "_" - [analysis - ["[0]A" type] - ["[0]A" inference] - ["[0]" scope]] - ["/[1]" // "_" - ["[1][0]" analysis {"+" Analysis Operation Phase Handler Bundle}] - ["[1][0]" synthesis] - [/// - ["[0]" phase ("[1]#[0]" monad)] - [meta - [archive {"+" Archive} - [descriptor {"+" Module}]]]]]]]]) + ["[1][0]" analysis {"+" Analysis Operation Phase Handler Bundle} + ["[1]/[0]" composite]] + ["[1][0]" synthesis] + [/// + ["[0]" phase ("[1]#[0]" monad)] + [meta + [archive {"+" Archive} + [descriptor {"+" Module}]]]]]]]]) (import: java/lang/ClassLoader) @@ -1980,9 +1981,10 @@ {/////analysis.#Case (/////analysis.unit) [[/////analysis.#when {/////analysis.#Complex - {/////analysis.#Tuple (|> arity - list.indices - (list#each (|>> (n.+ 2) {/////analysis.#Bind})))}} + {/////analysis/composite.#Tuple + (|> arity + list.indices + (list#each (|>> (n.+ 2) {/////analysis.#Bind})))}} /////analysis.#then bodyA] diff --git a/stdlib/source/library/lux/tool/compiler/language/lux/phase/extension/generation/jvm/host.lux b/stdlib/source/library/lux/tool/compiler/language/lux/phase/extension/generation/jvm/host.lux index 7c70c99ed..dd3816d77 100644 --- a/stdlib/source/library/lux/tool/compiler/language/lux/phase/extension/generation/jvm/host.lux +++ b/stdlib/source/library/lux/tool/compiler/language/lux/phase/extension/generation/jvm/host.lux @@ -7,20 +7,23 @@ ["[0]" maybe] ["[0]" exception {"+" exception:}] ["<>" parser - ["<t>" text] - ["<s>" synthesis {"+" Parser}]]] + ["<[0]>" text] + ["<[0]>" synthesis {"+" Parser}]]] [data ["[0]" product] ["[0]" text ("[1]#[0]" equivalence)] [collection - ["[0]" list ("[1]#[0]" monad monoid)] + ["[0]" list ("[1]#[0]" monad mix monoid)] ["[0]" dictionary {"+" Dictionary}] ["[0]" set {"+" Set}] ["[0]" sequence]] ["[0]" format "_" ["[1]" binary]]] + [macro + ["[0]" template]] [math [number + ["n" nat] ["[0]" i32]]] [target [jvm @@ -49,6 +52,7 @@ ["///" jvm ["[1][0]" runtime {"+" Operation Bundle Phase Handler}] ["[1][0]" reference] + ["[1][0]" value] [function [field [variable @@ -64,7 +68,7 @@ [/// ["[1]" phase] ["[1][0]" reference - ["[2][0]" variable {"+" Variable}]] + ["[2][0]" variable {"+" Variable Register}]] [meta ["[0]" archive {"+" Archive} ["[0]" artifact] @@ -322,7 +326,7 @@ (template [<name> <category> <parser>] [(def: .public <name> (Parser (Type <category>)) - (<t>.then <parser> <s>.text))] + (<text>.then <parser> <synthesis>.text))] [var Var parser.var] [class category.Class parser.class] @@ -338,7 +342,7 @@ (def: .public object_array (Parser (Type Object)) (do <>.monad - [arrayJT (<t>.then parser.array <s>.text)] + [arrayJT (<text>.then parser.array <synthesis>.text)] (case (parser.array? arrayJT) {.#Some elementJT} (case (parser.object? elementJT) @@ -354,7 +358,7 @@ (def: (primitive_array_length_handler jvm_primitive) (-> (Type Primitive) Handler) (..custom - [<s>.any + [<synthesis>.any (function (_ extension_name generate archive arrayS) (do //////.monad [arrayG (generate archive arrayS)] @@ -366,7 +370,7 @@ (def: array::length::object Handler (..custom - [($_ <>.and ..object_array <s>.any) + [($_ <>.and ..object_array <synthesis>.any) (function (_ extension_name generate archive [elementJT arrayS]) (do //////.monad [arrayG (generate archive arrayS)] @@ -378,7 +382,7 @@ (def: (new_primitive_array_handler jvm_primitive) (-> Primitive_Array_Type Handler) (..custom - [<s>.any + [<synthesis>.any (function (_ extension_name generate archive [lengthS]) (do //////.monad [lengthG (generate archive lengthS)] @@ -389,7 +393,7 @@ (def: array::new::object Handler (..custom - [($_ <>.and ..object <s>.any) + [($_ <>.and ..object <synthesis>.any) (function (_ extension_name generate archive [objectJT lengthS]) (do //////.monad [lengthG (generate archive lengthS)] @@ -400,7 +404,7 @@ (def: (read_primitive_array_handler jvm_primitive loadG) (-> (Type Primitive) (Bytecode Any) Handler) (..custom - [($_ <>.and <s>.any <s>.any) + [($_ <>.and <synthesis>.any <synthesis>.any) (function (_ extension_name generate archive [idxS arrayS]) (do //////.monad [arrayG (generate archive arrayS) @@ -414,7 +418,7 @@ (def: array::read::object Handler (..custom - [($_ <>.and ..object_array <s>.any <s>.any) + [($_ <>.and ..object_array <synthesis>.any <synthesis>.any) (function (_ extension_name generate archive [elementJT idxS arrayS]) (do //////.monad [arrayG (generate archive arrayS) @@ -428,7 +432,7 @@ (def: (write_primitive_array_handler jvm_primitive storeG) (-> (Type Primitive) (Bytecode Any) Handler) (..custom - [($_ <>.and <s>.any <s>.any <s>.any) + [($_ <>.and <synthesis>.any <synthesis>.any <synthesis>.any) (function (_ extension_name generate archive [idxS valueS arrayS]) (do //////.monad [arrayG (generate archive arrayS) @@ -445,7 +449,7 @@ (def: array::write::object Handler (..custom - [($_ <>.and ..object_array <s>.any <s>.any <s>.any) + [($_ <>.and ..object_array <synthesis>.any <synthesis>.any <synthesis>.any) (function (_ extension_name generate archive [elementJT idxS valueS arrayS]) (do //////.monad [arrayG (generate archive arrayS) @@ -549,7 +553,7 @@ (def: object::class Handler (..custom - [<s>.text + [<synthesis>.text (function (_ extension_name generate archive [class]) (do //////.monad [] @@ -560,7 +564,7 @@ (def: object::instance? Handler (..custom - [($_ <>.and <s>.text <s>.any) + [($_ <>.and <synthesis>.text <synthesis>.any) (function (_ extension_name generate archive [class objectS]) (do //////.monad [objectG (generate archive objectS)] @@ -577,7 +581,7 @@ (def: object::cast Handler (..custom - [($_ <>.and <s>.text <s>.text <s>.any) + [($_ <>.and <synthesis>.text <synthesis>.text <synthesis>.any) (function (_ extension_name generate archive [from to valueS]) (do //////.monad [valueG (generate archive valueS)] @@ -640,7 +644,7 @@ (def: get::static Handler (..custom - [($_ <>.and <s>.text <s>.text <s>.text) + [($_ <>.and <synthesis>.text <synthesis>.text <synthesis>.text) (function (_ extension_name generate archive [class field unboxed]) (do //////.monad [.let [$class (type.class class (list))]] @@ -656,7 +660,7 @@ (def: put::static Handler (..custom - [($_ <>.and <s>.text <s>.text <s>.text <s>.any) + [($_ <>.and <synthesis>.text <synthesis>.text <synthesis>.text <synthesis>.any) (function (_ extension_name generate archive [class field unboxed valueS]) (do //////.monad [valueG (generate archive valueS) @@ -678,7 +682,7 @@ (def: get::virtual Handler (..custom - [($_ <>.and <s>.text <s>.text <s>.text <s>.any) + [($_ <>.and <synthesis>.text <synthesis>.text <synthesis>.text <synthesis>.any) (function (_ extension_name generate archive [class field unboxed objectS]) (do //////.monad [objectG (generate archive objectS) @@ -697,7 +701,7 @@ (def: put::virtual Handler (..custom - [($_ <>.and <s>.text <s>.text <s>.text <s>.any <s>.any) + [($_ <>.and <synthesis>.text <synthesis>.text <synthesis>.text <synthesis>.any <synthesis>.any) (function (_ extension_name generate archive [class field unboxed valueS objectS]) (do //////.monad [valueG (generate archive valueS) @@ -724,7 +728,7 @@ (def: input (Parser Input) - (<s>.tuple (<>.and ..value <s>.any))) + (<synthesis>.tuple (<>.and ..value <synthesis>.any))) (def: (generate_input generate archive [valueT valueS]) (-> Phase Archive Input (Operation (Typed (Bytecode Any)))) @@ -751,7 +755,7 @@ (def: invoke::static Handler (..custom - [($_ <>.and ..class <s>.text ..return (<>.some ..input)) + [($_ <>.and ..class <synthesis>.text ..return (<>.some ..input)) (function (_ extension_name generate archive [class method outputT inputsTS]) (do [! //////.monad] [inputsTG (monad.each ! (generate_input generate archive) inputsTS)] @@ -764,7 +768,7 @@ [(def: <name> Handler (..custom - [($_ <>.and ..class <s>.text ..return <s>.any (<>.some ..input)) + [($_ <>.and ..class <synthesis>.text ..return <synthesis>.any (<>.some ..input)) (function (_ extension_name generate archive [class method outputT objectS inputsTS]) (do [! //////.monad] [objectG (generate archive objectS) @@ -817,36 +821,72 @@ (def: annotation_parameter (Parser (/.Annotation_Parameter Synthesis)) - (<s>.tuple (<>.and <s>.text <s>.any))) + (<synthesis>.tuple (<>.and <synthesis>.text <synthesis>.any))) (def: annotation (Parser (/.Annotation Synthesis)) - (<s>.tuple (<>.and <s>.text (<>.some ..annotation_parameter)))) + (<synthesis>.tuple (<>.and <synthesis>.text (<>.some ..annotation_parameter)))) (def: argument (Parser Argument) - (<s>.tuple (<>.and <s>.text ..value))) + (<synthesis>.tuple (<>.and <synthesis>.text ..value))) + +(def: .public (hidden_method_body arity body) + (-> Nat Synthesis Synthesis) + (case [arity body] + (^or [0 _] + [1 _]) + body + + (^or [2 {//////synthesis.#Control {//////synthesis.#Branch {//////synthesis.#Let _ 2 hidden}}}] + [2 {//////synthesis.#Control {//////synthesis.#Branch {//////synthesis.#Exec _ hidden}}}]) + hidden + + [_ {//////synthesis.#Control {//////synthesis.#Branch {//////synthesis.#Case _ path}}}] + (loop [path (: Path path)] + (case path + (^or {//////synthesis.#Pop} + {//////synthesis.#Access _} + {//////synthesis.#Bind _} + {//////synthesis.#Bit_Fork _} + {//////synthesis.#I64_Fork _} + {//////synthesis.#F64_Fork _} + {//////synthesis.#Text_Fork _} + {//////synthesis.#Alt _}) + body + + {//////synthesis.#Seq _ next} + (again next) + + {//////synthesis.#Then hidden} + hidden)) + + _ + body)) (def: overriden_method_definition (Parser [(Environment Synthesis) (/.Overriden_Method Synthesis)]) - (<s>.tuple (do <>.monad - [_ (<s>.text! /.overriden_tag) - ownerT ..class - name <s>.text - strict_fp? <s>.bit - annotations (<s>.tuple (<>.some ..annotation)) - vars (<s>.tuple (<>.some ..var)) - self_name <s>.text - arguments (<s>.tuple (<>.some ..argument)) - returnT ..return - exceptionsT (<s>.tuple (<>.some ..class)) - [environment body] (<s>.function 1 - (<s>.tuple <s>.any))] - (in [environment - [ownerT name - strict_fp? annotations vars - self_name arguments returnT exceptionsT - body]])))) + (<synthesis>.tuple (do <>.monad + [_ (<synthesis>.text! /.overriden_tag) + ownerT ..class + name <synthesis>.text + strict_fp? <synthesis>.bit + annotations (<synthesis>.tuple (<>.some ..annotation)) + vars (<synthesis>.tuple (<>.some ..var)) + self_name <synthesis>.text + arguments (<synthesis>.tuple (<>.some ..argument)) + returnT ..return + exceptionsT (<synthesis>.tuple (<>.some ..class)) + [environment _ _ body] (<| (<synthesis>.function 1) + (<synthesis>.loop (<>.exactly 0 <synthesis>.any)) + <synthesis>.tuple + (<>.after <synthesis>.any) + <synthesis>.any)] + (in [environment + [ownerT name + strict_fp? annotations vars + self_name arguments returnT exceptionsT + (..hidden_method_body (list.size arguments) body)]])))) (def: (normalize_path normalize) (-> (-> Synthesis Synthesis) @@ -872,8 +912,11 @@ _ (undefined)))) +(type: Mapping + (Dictionary Synthesis Variable)) + (def: (normalize_method_body mapping) - (-> (Dictionary Variable Variable) Synthesis Synthesis) + (-> Mapping Synthesis Synthesis) (function (again body) (case body (^template [<tag>] @@ -890,7 +933,7 @@ (^ (//////synthesis.variable var)) (|> mapping - (dictionary.value var) + (dictionary.value body) (maybe.else var) //////synthesis.variable) @@ -916,16 +959,16 @@ (//////synthesis.loop/again (list#each again updatesS+)) (^ (//////synthesis.function/abstraction [environment arity bodyS])) - (//////synthesis.function/abstraction [(list#each (function (_ local) - (case local - (^ (//////synthesis.variable local)) + (//////synthesis.function/abstraction [(list#each (function (_ captured) + (case captured + (^ (//////synthesis.variable var)) (|> mapping - (dictionary.value local) - (maybe.else local) + (dictionary.value captured) + (maybe.else var) //////synthesis.variable) _ - local)) + captured)) environment) arity bodyS]) @@ -984,26 +1027,34 @@ {.#Left returnT} (case (type.primitive? returnT) {.#Left returnT} - ($_ _.composite - (_.checkcast returnT) - _.areturn) + (case (type.class? returnT) + {.#Some class_name} + ($_ _.composite + (_.checkcast returnT) + _.areturn) + + {.#None} + _.areturn) {.#Right returnT} - (cond (or (# type.equivalence = type.boolean returnT) - (# type.equivalence = type.byte returnT) - (# type.equivalence = type.short returnT) - (# type.equivalence = type.int returnT) - (# type.equivalence = type.char returnT)) - _.ireturn - - (# type.equivalence = type.long returnT) - _.lreturn - - (# type.equivalence = type.float returnT) - _.freturn - - ... (# type.equivalence = type.double returnT) - _.dreturn)))) + (template.let [(unwrap_primitive <return> <type>) + [($_ _.composite + (///value.unwrap <type>) + <return>)]] + (`` (cond (~~ (template [<return> <type>] + [(# type.equivalence = <type> returnT) + (unwrap_primitive <return> <type>)] + + [_.ireturn type.boolean] + [_.ireturn type.byte] + [_.ireturn type.short] + [_.ireturn type.int] + [_.ireturn type.char] + [_.freturn type.float] + [_.lreturn type.long])) + + ... (# type.equivalence = type.double returnT) + (unwrap_primitive _.dreturn type.double))))))) (def: (method_dependencies archive method) (-> Archive (/.Overriden_Method Synthesis) (Operation (Set artifact.Dependency))) @@ -1027,15 +1078,124 @@ all_closure_dependencies all_method_dependencies))))) +(def: (prepare_argument lux_register argumentT jvm_register) + (-> Register (Type Value) Register [Register (Bytecode Any)]) + (case (type.primitive? argumentT) + {.#Left argumentT} + [(n.+ 1 jvm_register) + (if (n.= lux_register jvm_register) + (_#in []) + ($_ _.composite + (_.aload jvm_register) + (_.astore lux_register)))] + + {.#Right argumentT} + (template.let [(wrap_primitive <shift> <load> <type>) + [[(n.+ <shift> jvm_register) + ($_ _.composite + (<load> jvm_register) + (///value.wrap <type>) + (_.astore lux_register))]]] + (`` (cond (~~ (template [<shift> <load> <type>] + [(# type.equivalence = <type> argumentT) + (wrap_primitive <shift> <load> <type>)] + + [1 _.iload type.boolean] + [1 _.iload type.byte] + [1 _.iload type.short] + [1 _.iload type.int] + [1 _.iload type.char] + [1 _.fload type.float] + [2 _.lload type.long])) + + ... (# type.equivalence = type.double argumentT) + (wrap_primitive 2 _.dload type.double)))))) + +(def: .public (prepare_arguments offset types) + (-> Nat (List (Type Value)) (Bytecode Any)) + (|> types + list.enumeration + (list#mix (function (_ [lux_register type] [jvm_register before]) + (let [[jvm_register' after] (prepare_argument (n.+ offset lux_register) type jvm_register)] + [jvm_register' + ($_ _.composite + before + after)])) + (: [Register (Bytecode Any)] + [offset + (_#in [])])) + product.right)) + +(def: (normalized_method global_mapping [environment method]) + (-> Mapping [(Environment Synthesis) (/.Overriden_Method Synthesis)] + (/.Overriden_Method Synthesis)) + (let [[ownerT name strict_fp? annotations vars self_name arguments returnT exceptionsT body] method + local_mapping (|> environment + list.enumeration + (list#each (function (_ [foreign_id capture]) + [(//////synthesis.variable/foreign foreign_id) + (|> global_mapping + (dictionary.value capture) + maybe.trusted)])) + (dictionary.of_list //////synthesis.hash))] + [ownerT name + strict_fp? annotations vars + self_name arguments returnT exceptionsT + (normalize_method_body local_mapping body)])) + +(def: (total_environment overriden_methods) + (-> (List [(Environment Synthesis) (/.Overriden_Method Synthesis)]) + (List Synthesis)) + (|> overriden_methods + ... Get all the environments. + (list#each product.left) + ... Combine them. + list#conjoint + ... Remove duplicates. + (set.of_list //////synthesis.hash) + set.list)) + +(def: (global_mapping total_environment) + (-> (List Synthesis) Mapping) + (|> total_environment + ... Give them names as "foreign" variables. + list.enumeration + (list#each (function (_ [id capture]) + [capture {//////variable.#Foreign id}])) + (dictionary.of_list //////synthesis.hash))) + +(def: (method_definition phase archive artifact_id method) + (-> Phase Archive artifact.ID (/.Overriden_Method Synthesis) (Operation (Resource Method))) + (let [[ownerT name strict_fp? annotations vars self_name arguments returnT exceptionsT bodyS] method] + (do //////.monad + [bodyG (//////generation.with_context artifact_id + (phase archive bodyS)) + .let [argumentsT (list#each product.right arguments) + methodT (type.method [vars argumentsT returnT exceptionsT])]] + (in (method.method ($_ modifier#composite + method.public + method.final + (if strict_fp? + method.strict + modifier#identity)) + name + methodT + (list) + {.#Some ($_ _.composite + (prepare_arguments 1 argumentsT) + bodyG + (returnG returnT))}))))) + (def: class::anonymous Handler (..custom [($_ <>.and ..class - (<s>.tuple (<>.some ..class)) - (<s>.tuple (<>.some ..input)) - (<s>.tuple (<>.some ..overriden_method_definition))) - (function (_ extension_name generate archive [super_class super_interfaces + (<synthesis>.tuple (<>.some ..class)) + (<synthesis>.tuple (<>.some ..input)) + (<synthesis>.tuple (<>.some ..overriden_method_definition))) + (function (_ extension_name generate archive [super_class + super_interfaces inputsTS overriden_methods]) (do [! //////.monad] @@ -1044,62 +1204,12 @@ .let [[module_id artifact_id] context anonymous_class_name (///runtime.class_name context) class (type.class anonymous_class_name (list)) - total_environment (|> overriden_methods - ... Get all the environments. - (list#each product.left) - ... Combine them. - list#conjoint - ... Remove duplicates. - (set.of_list //////synthesis.hash) - set.list) - global_mapping (|> total_environment - ... Give them names as "foreign" variables. - list.enumeration - (list#each (function (_ [id capture]) - [capture {//////variable.#Foreign id}])) - (dictionary.of_list //////synthesis.hash)) - normalized_methods (list#each (function (_ [environment - [ownerT name - strict_fp? annotations vars - self_name arguments returnT exceptionsT - body]]) - (let [local_mapping (|> environment - list.enumeration - (list#each (function (_ [foreign_id capture]) - [{//////variable.#Foreign foreign_id} - (|> global_mapping - (dictionary.value capture) - maybe.trusted)])) - (dictionary.of_list //////variable.hash))] - [ownerT name - strict_fp? annotations vars - self_name arguments returnT exceptionsT - (normalize_method_body local_mapping body)])) - overriden_methods)] + total_environment (..total_environment overriden_methods) + global_mapping (..global_mapping total_environment)] inputsTI (monad.each ! (generate_input generate archive) inputsTS) - method_definitions (monad.each ! (function (_ [ownerT name - strict_fp? annotations vars - self_name arguments returnT exceptionsT - bodyS]) - (do ! - [bodyG (//////generation.with_context artifact_id - (generate archive bodyS))] - (in (method.method ($_ modifier#composite - method.public - method.final - (if strict_fp? - method.strict - modifier#identity)) - name - (type.method [(list) - (list#each product.right arguments) - returnT - exceptionsT]) - (list) - {.#Some ($_ _.composite - bodyG - (returnG returnT))})))) - normalized_methods) + methods! (|> overriden_methods + (list#each (normalized_method global_mapping)) + (monad.each ! (method_definition generate archive artifact_id))) bytecode (<| (# ! each (format.result class.writer)) //////.lifted (class.class version.v6_0 ($_ modifier#composite class.public class.final) @@ -1108,10 +1218,11 @@ (list#each (|>> ..reflection name.internal) super_interfaces) (foreign.variables total_environment) (list& (..with_anonymous_init class total_environment super_class inputsTI) - method_definitions) + methods!) (sequence.sequence))) - _ (//////generation.execute! [anonymous_class_name bytecode]) - _ (//////generation.save! artifact_id {.#None} [anonymous_class_name bytecode])] + .let [artifact [anonymous_class_name bytecode]] + _ (//////generation.execute! artifact) + _ (//////generation.save! artifact_id {.#None} artifact)] (anonymous_instance generate archive class total_environment)))])) (def: bundle::class diff --git a/stdlib/source/library/lux/tool/compiler/language/lux/phase/extension/generation/ruby/common.lux b/stdlib/source/library/lux/tool/compiler/language/lux/phase/extension/generation/ruby/common.lux index a65557eeb..2328c2f2a 100644 --- a/stdlib/source/library/lux/tool/compiler/language/lux/phase/extension/generation/ruby/common.lux +++ b/stdlib/source/library/lux/tool/compiler/language/lux/phase/extension/generation/ruby/common.lux @@ -88,7 +88,8 @@ (^template [<tag> <generator>] [(^ (<tag> value)) (<generator> statement expression archive value)]) - ([synthesis.branch/let //case.let!] + ([synthesis.branch/exec //case.exec!] + [synthesis.branch/let //case.let!] [synthesis.branch/if //case.if!] [synthesis.loop/scope //loop.scope!] [synthesis.loop/again //loop.again!]) diff --git a/stdlib/source/library/lux/tool/compiler/language/lux/phase/generation/jvm/structure.lux b/stdlib/source/library/lux/tool/compiler/language/lux/phase/generation/jvm/structure.lux index 5a1ec9ea6..7827fee86 100644 --- a/stdlib/source/library/lux/tool/compiler/language/lux/phase/generation/jvm/structure.lux +++ b/stdlib/source/library/lux/tool/compiler/language/lux/phase/generation/jvm/structure.lux @@ -21,8 +21,9 @@ ["[1][0]" runtime {"+" Operation Phase Generator}] ["[1][0]" primitive] ["///[1]" //// "_" - [analysis {"+" Variant Tuple}] ["[1][0]" synthesis {"+" Synthesis}] + [analysis + [composite {"+" Variant Tuple}]] [/// ["[0]" phase]]]]) diff --git a/stdlib/source/library/lux/tool/compiler/language/lux/phase/generation/ruby.lux b/stdlib/source/library/lux/tool/compiler/language/lux/phase/generation/ruby.lux index 02170332c..ca563e3e1 100644 --- a/stdlib/source/library/lux/tool/compiler/language/lux/phase/generation/ruby.lux +++ b/stdlib/source/library/lux/tool/compiler/language/lux/phase/generation/ruby.lux @@ -49,6 +49,7 @@ ([////synthesis.variant /structure.variant] [////synthesis.tuple /structure.tuple] + [////synthesis.branch/exec /case.exec] [////synthesis.branch/let /case.let] [////synthesis.branch/if /case.if] [////synthesis.branch/get /case.get] diff --git a/stdlib/source/library/lux/tool/compiler/language/lux/phase/generation/ruby/case.lux b/stdlib/source/library/lux/tool/compiler/language/lux/phase/generation/ruby/case.lux index 766b4fa43..400e47cfb 100644 --- a/stdlib/source/library/lux/tool/compiler/language/lux/phase/generation/ruby/case.lux +++ b/stdlib/source/library/lux/tool/compiler/language/lux/phase/generation/ruby/case.lux @@ -1,6 +1,6 @@ (.using [library - [lux {"-" case let if symbol} + [lux {"-" case exec let if symbol} [abstract ["[0]" monad {"+" do}]] [control @@ -48,6 +48,24 @@ (-> Register LVar) (|>> (///reference.foreign //reference.system) :expected)) +(def: .public (exec expression archive [this that]) + (Generator [Synthesis Synthesis]) + (do ///////phase.monad + [this (expression archive this) + that (expression archive that)] + (in (|> (_.array (list this that)) + (_.item (_.int +1)))))) + +(def: .public (exec! statement expression archive [this that]) + (Generator! [Synthesis Synthesis]) + (do ///////phase.monad + [this (expression archive this) + that (statement expression archive that)] + (in ($_ _.then + (_.statement this) + that + )))) + (def: .public (let expression archive [valueS register bodyS]) (Generator [Synthesis Register Synthesis]) (do ///////phase.monad @@ -56,7 +74,7 @@ ... TODO: Find some way to do 'let' without paying the price of the closure. (in (|> bodyO _.return - (_.lambda {.#None} (list (..register register))) + [(list (..register register))] (_.lambda {.#None}) (_.apply_lambda/* (list valueO)))))) (def: .public (let! statement expression archive [valueS register bodyS]) @@ -217,8 +235,10 @@ ..peek)]) (again then))) {.#Item item})] - (in {.#Some (_.cond clauses - ..fail!)}))]) + (in {.#Some (list#mix (function (_ [when then] else) + (_.if when then else)) + ..fail! + clauses)}))]) ([/////synthesis.#I64_Fork (<| //primitive.i64 .int)] [/////synthesis.#F64_Fork (<| //primitive.f64)] [/////synthesis.#Text_Fork (<| //primitive.text)]) @@ -272,8 +292,10 @@ ..peek)]) (again then))) {.#Item item})] - (in (_.cond clauses - ..fail!)))]) + (in (list#mix (function (_ [when then] else) + (_.if when then else)) + ..fail! + clauses)))]) ([/////synthesis.#I64_Fork (<| //primitive.i64 .int)] [/////synthesis.#F64_Fork (<| //primitive.f64)] [/////synthesis.#Text_Fork (<| //primitive.text)]) @@ -356,5 +378,5 @@ (|> case (case! true statement expression archive) (# ///////phase.monad each - (|>> (_.lambda {.#None} (list)) + (|>> [(list)] (_.lambda {.#None}) (_.apply_lambda/* (list)))))) diff --git a/stdlib/source/library/lux/tool/compiler/language/lux/phase/generation/ruby/function.lux b/stdlib/source/library/lux/tool/compiler/language/lux/phase/generation/ruby/function.lux index ccad8ba2a..16dab0814 100644 --- a/stdlib/source/library/lux/tool/compiler/language/lux/phase/generation/ruby/function.lux +++ b/stdlib/source/library/lux/tool/compiler/language/lux/phase/generation/ruby/function.lux @@ -1,6 +1,6 @@ (.using [library - [lux {"-" Variant Tuple function} + [lux {"-" function} [abstract ["[0]" monad {"+" do}]] [data @@ -19,7 +19,7 @@ ["/[1]" // "_" ["[1][0]" reference] ["//[1]" /// "_" - [analysis {"+" Variant Tuple Environment Abstraction Application Analysis}] + [analysis {"+" Environment Abstraction Application Analysis}] [synthesis {"+" Synthesis}] ["[1][0]" generation {"+" Context}] ["//[1]" /// "_" @@ -52,12 +52,12 @@ _ [(_.set (list @self) (_.lambda {.#None} - (|> (list.enumeration inits) - (list#each (|>> product.left ..capture))) - (let [@self (_.local self)] - ($_ _.then - (_.set (list @self) function_definition) - (_.return @self))))) + [(|> (list.enumeration inits) + (list#each (|>> product.left ..capture))) + (let [@self (_.local self)] + ($_ _.then + (_.set (list @self) function_definition) + (_.return @self)))])) (_.apply_lambda/* inits @self)]))) (def: input @@ -91,29 +91,31 @@ initialize_self! (list.indices arity)) [declaration instatiation] (with_closure closureO+ function_name - (_.lambda {.#None} (list (_.variadic @curried)) - ($_ _.then - (_.set (list @num_args) (_.the "length" @curried)) - (_.cond (list [(|> @num_args (_.= arityO)) - (<| (_.then initialize!) - //loop.with_scope - body!)] - [(|> @num_args (_.> arityO)) - (let [slice (.function (_ from to) - (_.array_range from to @curried)) - arity_args (_.splat (slice (_.int +0) limitO)) - output_func_args (_.splat (slice arityO @num_args))] - (_.return (|> @self - (_.apply_lambda/* (list arity_args)) - (_.apply_lambda/* (list output_func_args)))))]) - ... (|> @num_args (_.< arityO)) - (let [@missing (_.local "missing")] - (_.return (_.lambda {.#None} (list (_.variadic @missing)) - (_.return (|> @self - (_.apply_lambda/* (list (_.splat (|> (_.array (list)) - (_.do "concat" (list @curried) {.#None}) - (_.do "concat" (list @missing) {.#None}))))))))))) - )))] + (_.lambda {.#None} + [(list (_.variadic @curried)) + ($_ _.then + (_.set (list @num_args) (_.the "length" @curried)) + (<| (_.if (|> @num_args (_.= arityO)) + (<| (_.then initialize!) + //loop.with_scope + body!)) + (_.if (|> @num_args (_.> arityO)) + (let [slice (.function (_ from to) + (_.array_range from to @curried)) + arity_args (_.splat (slice (_.int +0) limitO)) + output_func_args (_.splat (slice arityO @num_args))] + (_.return (|> @self + (_.apply_lambda/* (list arity_args)) + (_.apply_lambda/* (list output_func_args)))))) + ... (|> @num_args (_.< arityO)) + (let [@missing (_.local "missing")] + (_.return (_.lambda {.#None} + [(list (_.variadic @missing)) + (_.return (|> @self + (_.apply_lambda/* (list (_.splat (|> (_.array (list)) + (_.do "concat" (list @curried) {.#None}) + (_.do "concat" (list @missing) {.#None})))))))])))) + )]))] _ (/////generation.execute! declaration) _ (/////generation.save! function_artifact {.#None} declaration)] (in instatiation))) diff --git a/stdlib/source/library/lux/tool/compiler/language/lux/phase/generation/ruby/loop.lux b/stdlib/source/library/lux/tool/compiler/language/lux/phase/generation/ruby/loop.lux index b4dbf8248..9ccd0151e 100644 --- a/stdlib/source/library/lux/tool/compiler/language/lux/phase/generation/ruby/loop.lux +++ b/stdlib/source/library/lux/tool/compiler/language/lux/phase/generation/ruby/loop.lux @@ -77,7 +77,7 @@ (do [! ///////phase.monad] [body! (scope! statement expression archive [start initsS+ bodyS])] (in (|> body! - (_.lambda {.#None} (list)) + [(list)] (_.lambda {.#None}) (_.apply_lambda/* (list))))))) (def: .public (again! statement expression archive argsS+) diff --git a/stdlib/source/library/lux/tool/compiler/language/lux/phase/generation/ruby/runtime.lux b/stdlib/source/library/lux/tool/compiler/language/lux/phase/generation/ruby/runtime.lux index af0f3338c..d82d5e7ba 100644 --- a/stdlib/source/library/lux/tool/compiler/language/lux/phase/generation/ruby/runtime.lux +++ b/stdlib/source/library/lux/tool/compiler/language/lux/phase/generation/ruby/runtime.lux @@ -171,12 +171,12 @@ ($_ _.then (_.set (list last_index_right) (..last_index tuple)) (_.set (list right_index) (_.+ (_.int +1) lefts)) - (_.cond (list [(_.= last_index_right right_index) - (_.return (_.item right_index tuple))] - [(_.> last_index_right right_index) - ... Needs recursion. - <recur>]) - (_.return (_.array_range right_index (..tuple_size tuple) tuple))) + (<| (_.if (_.= last_index_right right_index) + (_.return (_.item right_index tuple))) + (_.if (_.> last_index_right right_index) + ... Needs recursion. + <recur>) + (_.return (_.array_range right_index (..tuple_size tuple) tuple))) ))))) (def: .public variant_tag_field "_lux_tag") @@ -219,24 +219,21 @@ (_.- (_.int +1)))) (_.set (list sum) actual##value))] (<| (_.while (_.bool true)) - (_.cond (list [(_.= expected##lefts actual##lefts) - (_.if (_.= expected##right? actual##right?) - (_.return actual##value) - mismatch!)] - - [(_.< expected##lefts actual##lefts) - (_.if (_.= ..unit actual##right?) - recur! - mismatch!)] - - [(_.= ..unit expected##right?) - (_.return (sum//make (|> actual##lefts - (_.- expected##lefts) - (_.- (_.int +1))) - actual##right? - actual##value))]) - - mismatch!)))) + (_.if (_.= expected##lefts actual##lefts) + (_.if (_.= expected##right? actual##right?) + (_.return actual##value) + mismatch!)) + (_.if (_.< expected##lefts actual##lefts) + (_.if (_.= ..unit actual##right?) + recur! + mismatch!)) + (_.if (_.= ..unit expected##right?) + (_.return (sum//make (|> actual##lefts + (_.- expected##lefts) + (_.- (_.int +1))) + actual##right? + actual##value))) + mismatch!))) (def: runtime//adt Statement diff --git a/stdlib/source/library/lux/tool/compiler/language/lux/phase/generation/ruby/structure.lux b/stdlib/source/library/lux/tool/compiler/language/lux/phase/generation/ruby/structure.lux index 72c620827..27361d558 100644 --- a/stdlib/source/library/lux/tool/compiler/language/lux/phase/generation/ruby/structure.lux +++ b/stdlib/source/library/lux/tool/compiler/language/lux/phase/generation/ruby/structure.lux @@ -9,7 +9,8 @@ ["[1][0]" runtime {"+" Operation Phase Generator}] ["[1][0]" primitive] ["///[1]" //// "_" - [analysis {"+" Variant Tuple}] + [analysis + [composite {"+" Variant Tuple}]] ["[1][0]" synthesis {"+" Synthesis}] ["//[1]" /// "_" ["[1][0]" phase ("[1]#[0]" monad)]]]]) diff --git a/stdlib/source/library/lux/tool/compiler/language/lux/phase/synthesis.lux b/stdlib/source/library/lux/tool/compiler/language/lux/phase/synthesis.lux index 68f3c22d4..e8aec1a83 100644 --- a/stdlib/source/library/lux/tool/compiler/language/lux/phase/synthesis.lux +++ b/stdlib/source/library/lux/tool/compiler/language/lux/phase/synthesis.lux @@ -19,7 +19,8 @@ ["/[1]" // "_" ["/" synthesis {"+" Synthesis Phase}] ["[1][0]" analysis {"+" Analysis} - ["[2][0]" primitive]] + ["[2][0]" primitive] + ["[2][0]" composite]] [/// ["[0]" phase ("[1]#[0]" monad)] [reference {"+"} @@ -58,12 +59,12 @@ {///analysis.#Structure structure} (/.with_currying? false (case structure - {///analysis.#Variant variant} + {///composite.#Variant variant} (do phase.monad - [valueS (optimization' (value@ ///analysis.#value variant))] - (in (/.variant (with@ ///analysis.#value valueS variant)))) + [valueS (optimization' (value@ ///composite.#value variant))] + (in (/.variant (with@ ///composite.#value valueS variant)))) - {///analysis.#Tuple tuple} + {///composite.#Tuple tuple} (|> tuple (monad.each phase.monad optimization') (phase#each (|>> /.tuple))))) diff --git a/stdlib/source/library/lux/tool/compiler/language/lux/phase/synthesis/case.lux b/stdlib/source/library/lux/tool/compiler/language/lux/phase/synthesis/case.lux index 29d478d0b..10d71f730 100644 --- a/stdlib/source/library/lux/tool/compiler/language/lux/phase/synthesis/case.lux +++ b/stdlib/source/library/lux/tool/compiler/language/lux/phase/synthesis/case.lux @@ -22,7 +22,8 @@ [// ["/" synthesis {"+" Path Synthesis Operation Phase}] ["[1][0]" analysis {"+" Pattern Match Analysis} - ["[2][0]" primitive]] + ["[2][0]" primitive] + ["[2][0]" composite]] [/// ["[1]" phase ("[1]#[0]" monad)] ["[1][0]" reference @@ -63,7 +64,7 @@ /.with_new_local thenC) - {///analysis.#Complex {///analysis.#Variant [lefts right? value_pattern]}} + {///analysis.#Complex {///composite.#Variant [lefts right? value_pattern]}} (<| (///#each (|>> {/.#Seq {/.#Access {/.#Side (if right? {.#Right lefts} {.#Left lefts})}}})) @@ -71,7 +72,7 @@ (when> [(new> (not end?) [])] [(///#each ..clean_up)]) thenC) - {///analysis.#Complex {///analysis.#Tuple tuple}} + {///analysis.#Complex {///composite.#Tuple tuple}} (let [tuple::last (-- (list.size tuple))] (list#mix (function (_ [tuple::lefts tuple::member] nextC) (.case tuple::member @@ -192,7 +193,7 @@ <default>))) (def: (get patterns @selection) - (-> (///analysis.Tuple ///analysis.Pattern) Register (List /.Member)) + (-> (///composite.Tuple ///analysis.Pattern) Register (List /.Member)) (loop [lefts 0 patterns patterns] (with_expansions [<failure> (as_is (list)) @@ -215,7 +216,7 @@ (list <member>) <continue>) - {///analysis.#Complex {///analysis.#Tuple sub_patterns}} + {///analysis.#Complex {///composite.#Tuple sub_patterns}} (case (get sub_patterns @selection) {.#End} <continue> @@ -264,7 +265,7 @@ (.list)]]) (def: .public (synthesize_get synthesize archive input patterns @member) - (-> Phase Archive Synthesis (///analysis.Tuple ///analysis.Pattern) Register (Operation Synthesis)) + (-> Phase Archive Synthesis (///composite.Tuple ///analysis.Pattern) Register (Operation Synthesis)) (case (..get patterns @member) {.#End} (..synthesize_case synthesize archive input (!get patterns @member)) diff --git a/stdlib/source/library/lux/tool/compiler/language/lux/phase/synthesis/function.lux b/stdlib/source/library/lux/tool/compiler/language/lux/phase/synthesis/function.lux index e2380b282..5e171165e 100644 --- a/stdlib/source/library/lux/tool/compiler/language/lux/phase/synthesis/function.lux +++ b/stdlib/source/library/lux/tool/compiler/language/lux/phase/synthesis/function.lux @@ -19,7 +19,8 @@ ["[0]" // "_" ["[1][0]" loop {"+" Transform}] ["//[1]" /// "_" - ["[1][0]" analysis {"+" Environment Analysis}] + ["[1][0]" analysis {"+" Environment Analysis} + ["[1]/[0]" composite]] ["/" synthesis {"+" Path Abstraction Synthesis Operation Phase}] [/// [arity {"+" Arity}] @@ -143,12 +144,12 @@ (case expression {/.#Structure structure} (case structure - {////analysis.#Variant [lefts right? subS]} + {////analysis/composite.#Variant [lefts right? subS]} (|> subS (grow environment) (phase#each (|>> [lefts right?] /.variant))) - {////analysis.#Tuple membersS+} + {////analysis/composite.#Tuple membersS+} (|> membersS+ (monad.each phase.monad (grow environment)) (phase#each (|>> /.tuple)))) diff --git a/stdlib/source/library/lux/tool/compiler/language/lux/phase/synthesis/loop.lux b/stdlib/source/library/lux/tool/compiler/language/lux/phase/synthesis/loop.lux index 8b9273084..eea8ea951 100644 --- a/stdlib/source/library/lux/tool/compiler/language/lux/phase/synthesis/loop.lux +++ b/stdlib/source/library/lux/tool/compiler/language/lux/phase/synthesis/loop.lux @@ -12,7 +12,8 @@ [number ["n" nat]]]]] [//// - ["[0]" analysis {"+" Environment}] + ["[0]" analysis {"+" Environment} + ["[1]/[0]" composite]] ["/" synthesis {"+" Path Abstraction Synthesis}] [/// [arity {"+" Arity}] @@ -84,14 +85,14 @@ {/.#Structure structure} (case structure - {analysis.#Variant variant} + {analysis/composite.#Variant variant} (do maybe.monad - [value' (|> variant (value@ analysis.#value) (again false))] + [value' (|> variant (value@ analysis/composite.#value) (again false))] (in (|> variant - (with@ analysis.#value value') + (with@ analysis/composite.#value value') /.variant))) - {analysis.#Tuple tuple} + {analysis/composite.#Tuple tuple} (|> tuple (monad.each maybe.monad (again false)) (maybe#each (|>> /.tuple)))) @@ -190,11 +191,11 @@ matches (monad.each ! (function (_ match) (case match - (^ {/.#Structure {analysis.#Tuple (list when then)}}) + (^ {/.#Structure {analysis/composite.#Tuple (list when then)}}) (do ! [when (again false when) then (again return? then)] - (in {/.#Structure {analysis.#Tuple (list when then)}})) + (in {/.#Structure {analysis/composite.#Tuple (list when then)}})) _ (again false match))) diff --git a/stdlib/source/library/lux/tool/compiler/language/lux/phase/synthesis/variable.lux b/stdlib/source/library/lux/tool/compiler/language/lux/phase/synthesis/variable.lux index 375919eca..79321ad28 100644 --- a/stdlib/source/library/lux/tool/compiler/language/lux/phase/synthesis/variable.lux +++ b/stdlib/source/library/lux/tool/compiler/language/lux/phase/synthesis/variable.lux @@ -20,7 +20,8 @@ ["n" nat]]]]] [//// ["/" synthesis {"+" Path Synthesis}] - ["[0]" analysis] + ["[0]" analysis + ["[1]/[0]" composite]] [/// [arity {"+" Arity}] ["[0]" reference @@ -112,11 +113,11 @@ {/.#Structure structure} {/.#Structure (case structure - {analysis.#Variant [lefts right value]} - {analysis.#Variant [lefts right (again value)]} + {analysis/composite.#Variant [lefts right value]} + {analysis/composite.#Variant [lefts right (again value)]} - {analysis.#Tuple tuple} - {analysis.#Tuple (list#each again tuple)})} + {analysis/composite.#Tuple tuple} + {analysis/composite.#Tuple (list#each again tuple)})} {/.#Reference reference} (case reference @@ -335,17 +336,17 @@ {/.#Structure structure} (case structure - {analysis.#Variant [lefts right value]} + {analysis/composite.#Variant [lefts right value]} (do try.monad [[redundancy value] (optimization' [redundancy value])] (in [redundancy - {/.#Structure {analysis.#Variant [lefts right value]}}])) + {/.#Structure {analysis/composite.#Variant [lefts right value]}}])) - {analysis.#Tuple tuple} + {analysis/composite.#Tuple tuple} (do try.monad [[redundancy tuple] (..list_optimization optimization' [redundancy tuple])] (in [redundancy - {/.#Structure {analysis.#Tuple tuple}}]))) + {/.#Structure {analysis/composite.#Tuple tuple}}]))) {/.#Reference reference} (case reference diff --git a/stdlib/source/library/lux/tool/compiler/language/lux/synthesis.lux b/stdlib/source/library/lux/tool/compiler/language/lux/synthesis.lux index c27fa9a81..2bd2bd22e 100644 --- a/stdlib/source/library/lux/tool/compiler/language/lux/synthesis.lux +++ b/stdlib/source/library/lux/tool/compiler/language/lux/synthesis.lux @@ -1,38 +1,39 @@ (.using - [library - [lux {"-" Primitive Scope i64} - [abstract - [monad {"+" do}] - [equivalence {"+" Equivalence}] - [hash {"+" Hash}]] - [control - [pipe {"+" case>}] - ["[0]" maybe] - ["[0]" exception {"+" exception:}]] - [data - ["[0]" sum] - ["[0]" product] - ["[0]" bit ("[1]#[0]" equivalence)] - ["[0]" text ("[1]#[0]" equivalence) - ["%" format {"+" Format format}]] - [collection - ["[0]" list ("[1]#[0]" functor)] - ["[0]" dictionary {"+" Dictionary}]]] - [math - [number - ["[0]" i64] - ["n" nat] - ["i" int] - ["f" frac]]]]] - [// - ["[0]" analysis {"+" Environment Composite Analysis}] - [phase - ["[0]" extension {"+" Extension}]] - [/// - [arity {"+" Arity}] - ["[0]" phase] - ["[0]" reference {"+" Reference} - ["[0]" variable {"+" Register Variable}]]]]) + [library + [lux {"-" Primitive Scope i64} + [abstract + [monad {"+" do}] + [equivalence {"+" Equivalence}] + [hash {"+" Hash}]] + [control + [pipe {"+" case>}] + ["[0]" maybe] + ["[0]" exception {"+" exception:}]] + [data + ["[0]" sum] + ["[0]" product] + ["[0]" bit ("[1]#[0]" equivalence)] + ["[0]" text ("[1]#[0]" equivalence) + ["%" format {"+" Format format}]] + [collection + ["[0]" list ("[1]#[0]" functor)] + ["[0]" dictionary {"+" Dictionary}]]] + [math + [number + ["[0]" i64] + ["n" nat] + ["i" int] + ["f" frac]]]]] + [// + ["[0]" analysis {"+" Environment Analysis} + ["[1]/[0]" composite {"+" Composite}]] + [phase + ["[0]" extension {"+" Extension}]] + [/// + [arity {"+" Arity}] + ["[0]" phase] + ["[0]" reference {"+" Reference} + ["[0]" variable {"+" Register Variable}]]]]) (type: .public Resolver (Dictionary Variable Variable)) @@ -238,8 +239,8 @@ {<tag>} content)])] - [variant analysis.#Variant] - [tuple analysis.#Tuple] + [variant analysis/composite.#Variant] + [tuple analysis/composite.#Tuple] ) (template [<name> <tag>] @@ -350,12 +351,12 @@ {#Structure structure} (case structure - {analysis.#Variant [lefts right? content]} + {analysis/composite.#Variant [lefts right? content]} (|> (%synthesis content) (format (%.nat lefts) " " (%.bit right?) " ") (text.enclosed ["{" "}"])) - {analysis.#Tuple members} + {analysis/composite.#Tuple members} (|> members (list#each %synthesis) (text.interposed " ") @@ -775,7 +776,7 @@ [[{<tag> reference'} {<tag> sample'}] (# <equivalence> = reference' sample')]) ([#Primitive ..primitive_equivalence] - [#Structure (analysis.composite_equivalence =)] + [#Structure (analysis/composite.equivalence =)] [#Reference reference.equivalence] [#Control (control_equivalence =)] [#Extension (extension.equivalence =)]) @@ -799,7 +800,7 @@ [{<tag> value} (# <hash> hash value)]) ([#Primitive ..primitive_hash] - [#Structure (analysis.composite_hash again_hash)] + [#Structure (analysis/composite.hash again_hash)] [#Reference reference.hash] [#Control (..control_hash again_hash)] [#Extension (extension.hash again_hash)]))))) diff --git a/stdlib/source/library/lux/tool/compiler/meta/archive/dependency.lux b/stdlib/source/library/lux/tool/compiler/meta/archive/dependency.lux index f3e1c6d83..7b0065dc4 100644 --- a/stdlib/source/library/lux/tool/compiler/meta/archive/dependency.lux +++ b/stdlib/source/library/lux/tool/compiler/meta/archive/dependency.lux @@ -23,7 +23,8 @@ ["[0]" reference {"+" Constant}] [language [lux - ["[0]" analysis] + ["[0]" analysis + ["[1]/[0]" composite]] ["[0]" synthesis {"+" Synthesis Path}] ["[0]" generation {"+" Context Operation}]]] [meta @@ -79,12 +80,12 @@ {synthesis.#Structure value} (case value - {analysis.#Variant value} + {analysis/composite.#Variant value} (|> value - (value@ analysis.#value) + (value@ analysis/composite.#value) references) - {analysis.#Tuple value} + {analysis/composite.#Tuple value} (|> value (list#each references) list#conjoint)) diff --git a/stdlib/source/test/lux/target/ruby.lux b/stdlib/source/test/lux/target/ruby.lux index 86a817703..7723cd776 100644 --- a/stdlib/source/test/lux/target/ruby.lux +++ b/stdlib/source/test/lux/target/ruby.lux @@ -5,7 +5,9 @@ ["[0]" ffi] [abstract [monad {"+" do}] - ["[0]" predicate]] + ["[0]" predicate] + [\\specification + ["$[0]" equivalence]]] [control ["[0]" maybe ("[1]#[0]" functor)] ["[0]" try {"+" Try} ("[1]#[0]" functor)]] @@ -306,7 +308,7 @@ (|> ($_ /.then (/.set (list $foreign) (/.+ $foreign $foreign)) (/.return $foreign)) - (/.lambda {.#None} (list $foreign)) + [(list $foreign)] (/.lambda {.#None}) (/.apply_lambda/* (list (/.float float/0)))))) )) (_.cover [/.Access] @@ -316,7 +318,7 @@ (/.set (list $foreign) (/.array (list $foreign))) (/.set (list @) (/.+ @ @)) (/.return @)) - (/.lambda {.#None} (list $foreign)) + [(list $foreign)] (/.lambda {.#None}) (/.apply_lambda/* (list (/.float float/0)))))) (expression (|>> (:as Frac) (f.= (f.+ float/0 float/0))) (let [@ (/.item field $foreign)] @@ -324,7 +326,7 @@ (/.set (list $foreign) (/.hash (list [field $foreign]))) (/.set (list @) (/.+ @ @)) (/.return @)) - (/.lambda {.#None} (list $foreign)) + [(list $foreign)] (/.lambda {.#None}) (/.apply_lambda/* (list (/.float float/0)))))) )) ))) @@ -359,7 +361,7 @@ (/.set (list $inner_index) (/.+ (/.int +1) $inner_index)) )) (/.return $output)) - (/.lambda {.#None} (list $input)) + [(list $input)] (/.lambda {.#None}) (/.apply_lambda/* (list (/.int input))))))) (_.cover [/.next] (let [expected (i.* (.int (n.- expected_inner_iterations full_inner_iterations)) input)] @@ -375,7 +377,7 @@ (/.set (list $output) (/.+ $input $output)) )) (/.return $output)) - (/.lambda {.#None} (list $input)) + [(list $input)] (/.lambda {.#None}) (/.apply_lambda/* (list (/.int input))))))) ))) @@ -400,7 +402,7 @@ (/.set (list $index) (/.+ (/.int +1) $index)) )) (/.return $output)) - (/.lambda {.#None} (list $input)) + [(list $input)] (/.lambda {.#None}) (/.apply_lambda/* (list (/.int input)))))) (_.cover [/.for_in] (expression (|>> (:as Int) (i.= expected)) @@ -409,7 +411,7 @@ (/.for_in $index (/.array (list.repeated iterations (/.int input))) (/.set (list $output) (/.+ $index $output))) (/.return $output)) - (/.lambda {.#None} (list $input)) + [(list $input)] (/.lambda {.#None}) (/.apply_lambda/* (list (/.int input)))))) ..test|label ))) @@ -420,13 +422,19 @@ [expected random.safe_frac dummy (random.only (|>> (f.= expected) not) random.safe_frac) - $ex (# ! each /.local (random.ascii/lower 10))] + $ex (# ! each /.local (random.ascii/lower 10)) + + expected_tag random.int + dummy_tag (random.only (|>> (i.= expected_tag) not) + random.int) + .let [expected_tag (/.int expected_tag) + dummy_tag (/.int dummy_tag)]] ($_ _.and (_.cover [/.begin] (expression (|>> (:as Frac) (f.= expected)) (|> (/.begin (/.return (/.float expected)) (list [(list) $ex (/.return (/.float dummy))])) - (/.lambda {.#None} (list)) + [(list)] (/.lambda {.#None}) (/.apply_lambda/* (list))))) (_.cover [/.Rescue /.throw/1] (expression (|>> (:as Frac) (f.= expected)) @@ -434,8 +442,37 @@ (/.throw/1 (/.string "")) (/.return (/.float dummy))) (list [(list) $ex (/.return (/.float expected))])) - (/.lambda {.#None} (list)) + [(list)] (/.lambda {.#None}) + (/.apply_lambda/* (list))))) + (_.cover [/.raise] + (expression (|>> (:as Frac) (f.= expected)) + (|> (/.begin ($_ /.then + (/.statement (/.raise (/.string ""))) + (/.return (/.float dummy))) + (list [(list) $ex (/.return (/.float expected))])) + [(list)] (/.lambda {.#None}) (/.apply_lambda/* (list))))) + (_.cover [/.catch /.throw/2] + (and (expression (|>> (:as Frac) (f.= expected)) + (<| (/.apply_lambda/* (list)) + (/.lambda {.#None}) [(list)] + /.return + (/.catch expected_tag) [(list)] + (/.throw/2 expected_tag (/.float expected)))) + (expression (|>> (:as Frac) (f.= expected)) + (<| (/.apply_lambda/* (list)) + (/.lambda {.#None}) [(list)] + /.return + (/.catch expected_tag) [(list)] + /.statement (/.catch dummy_tag) [(list)] + (/.throw/2 expected_tag (/.float expected)))) + (expression (|>> (:as Frac) (f.= expected)) + (<| (/.apply_lambda/* (list)) + (/.lambda {.#None}) [(list)] + /.return + (/.catch dummy_tag) [(list)] + /.statement (/.catch expected_tag) [(list)] + (/.throw/2 expected_tag (/.float expected)))))) ))) (def: test|function @@ -456,18 +493,18 @@ (_.cover [/.lambda /.return] (and (expression (|>> (:as Frac) (f.= float/0)) (|> (/.return (/.float float/0)) - (/.lambda {.#None} (list)) + [(list)] (/.lambda {.#None}) (/.apply_lambda/* (list)))) (expression (|>> (:as Frac) f.nat (n.= iterations)) - (|> (/.lambda {.#Some $self} (list $arg/0) - (/.return (/.? (/.< (/.int (.int iterations)) $arg/0) - (/.apply_lambda/* (list (/.+ (/.int +1) $arg/0)) $self) - $arg/0))) + (|> (/.return (/.? (/.< (/.int (.int iterations)) $arg/0) + (/.apply_lambda/* (list (/.+ (/.int +1) $arg/0)) $self) + $arg/0)) + [(list $arg/0)] (/.lambda {.#Some $self}) (/.apply_lambda/* (list (/.int +0))))))) (_.cover [/.apply_lambda/*] (expression (|>> (:as Frac) (f.= ($_ f.+ float/0 float/1 float/2))) (|> (/.return ($_ /.+ $arg/0 $arg/1 $arg/2)) - (/.lambda {.#None} (list $arg/0 $arg/1 $arg/2)) + [(list $arg/0 $arg/1 $arg/2)] (/.lambda {.#None}) (/.apply_lambda/* (list (/.float float/0) (/.float float/1) (/.float float/2)))))) (_.cover [/.function] (expression (|>> (:as Frac) f.nat (n.= iterations)) @@ -477,7 +514,7 @@ (/.apply/1 $self (/.+ (/.int +1) $arg/0)) $arg/0))) (/.return (/.apply/1 $self (/.int +0)))) - (/.lambda {.#None} (list)) + [(list)] (/.lambda {.#None}) (/.apply_lambda/* (list))))) (_.cover [/.apply/1] (expression (|>> (:as Frac) (f.= float/0)) @@ -485,7 +522,7 @@ (/.function $self (list $arg/0) (/.return $arg/0)) (/.return (/.apply/1 $self (/.float float/0)))) - (/.lambda {.#None} (list)) + [(list)] (/.lambda {.#None}) (/.apply_lambda/* (list))))) (_.cover [/.apply/2] (expression (|>> (:as Frac) (f.= ($_ f.+ float/0 float/1))) @@ -493,15 +530,7 @@ (/.function $self (list $arg/0 $arg/1) (/.return ($_ /.+ $arg/0 $arg/1))) (/.return (/.apply/2 $self (/.float float/0) (/.float float/1)))) - (/.lambda {.#None} (list)) - (/.apply_lambda/* (list))))) - (_.cover [/.apply/3] - (expression (|>> (:as Frac) (f.= ($_ f.+ float/0 float/1 float/2))) - (|> ($_ /.then - (/.function $self (list $arg/0 $arg/1 $arg/2) - (/.return ($_ /.+ $arg/0 $arg/1 $arg/2))) - (/.return (/.apply/3 $self (/.float float/0) (/.float float/1) (/.float float/2)))) - (/.lambda {.#None} (list)) + [(list)] (/.lambda {.#None}) (/.apply_lambda/* (list))))) (_.cover [/.apply/*] (expression (|>> (:as Frac) (f.= ($_ f.+ float/0 float/1 float/2))) @@ -509,7 +538,7 @@ (/.function $self (list $arg/0 $arg/1 $arg/2) (/.return ($_ /.+ $arg/0 $arg/1 $arg/2))) (/.return (/.apply/* (list (/.float float/0) (/.float float/1) (/.float float/2)) {.#None} $self))) - (/.lambda {.#None} (list)) + [(list)] (/.lambda {.#None}) (/.apply_lambda/* (list))))) ... (_.cover [/.new] ... (let [$this (/.local "this")] @@ -544,7 +573,7 @@ (|> (/.if (/.bool ???) (/.return (/.float float/0)) (/.return (/.float float/1))) - (/.lambda {.#None} (list)) + [(list)] (/.lambda {.#None}) (/.apply_lambda/* (list))))) (_.cover [/.when] (expression (|>> (:as Frac) (f.= (if ??? float/0 float/1))) @@ -552,7 +581,7 @@ (/.when (/.bool ???) (/.return (/.float float/0))) (/.return (/.float float/1))) - (/.lambda {.#None} (list)) + [(list)] (/.lambda {.#None}) (/.apply_lambda/* (list))))) ))) @@ -571,19 +600,20 @@ (|> ($_ /.then (/.statement (/.+ $arg/0 $arg/0)) (/.return $arg/0)) - (/.lambda {.#None} (list $arg/0)) + [(list $arg/0)] (/.lambda {.#None}) (/.apply_lambda/* (list (/.float float/0)))))) (_.cover [/.then] (expression (|>> (:as Frac) (f.= float/0)) (|> ($_ /.then (/.return $arg/0) (/.return $arg/1)) - (/.lambda {.#None} (list $arg/0 $arg/1)) + [(list $arg/0 $arg/1)] (/.lambda {.#None}) (/.apply_lambda/* (list (/.float float/0) (/.float float/1)))))) ..test|exception - ..test|function ..test|branching ..test|loop + (_.for [/.Block] + ..test|function) (_.for [/.Location] ..test/location) ))) @@ -632,10 +662,13 @@ (<| (_.covering /._) (_.for [/.Code]) ($_ _.and + (_.for [/.equivalence] + ($equivalence.spec /.equivalence ..random_expression)) + (_.cover [/.code /.manual] (|> (/.manual (/.code expected)) (: /.Expression) - (# /.code_equivalence = expected))) + (# /.equivalence = expected))) (_.for [/.Expression] ..test|expression) (_.for [/.Statement] diff --git a/stdlib/source/test/lux/tool.lux b/stdlib/source/test/lux/tool.lux index e2cbc50b6..4e3bad586 100644 --- a/stdlib/source/test/lux/tool.lux +++ b/stdlib/source/test/lux/tool.lux @@ -11,7 +11,8 @@ [lux ... ["[1][0]" syntax] ["[1][0]" analysis "_" - ["[1]/[0]" primitive]] + ["[1]/[0]" primitive] + ["[1]/[0]" composite]] ... [phase ... ["[1][0]" analysis] ... ["[1][0]" synthesis]] @@ -25,6 +26,7 @@ /version.test /reference.test /analysis/primitive.test + /analysis/composite.test ... /syntax.test ... /analysis.test ... /synthesis.test diff --git a/stdlib/source/test/lux/tool/compiler/language/lux/analysis/composite.lux b/stdlib/source/test/lux/tool/compiler/language/lux/analysis/composite.lux new file mode 100644 index 000000000..8c74718b8 --- /dev/null +++ b/stdlib/source/test/lux/tool/compiler/language/lux/analysis/composite.lux @@ -0,0 +1,76 @@ +(.using + [library + [lux "*" + ["_" test {"+" Test}] + [abstract + [monad {"+" do}] + [\\specification + ["$[0]" equivalence] + ["$[0]" hash]]] + [data + ["[0]" bit ("[1]#[0]" equivalence)] + ["[0]" text ("[1]#[0]" equivalence) + ["%" format {"+" format}]]] + [math + ["[0]" random {"+" Random} ("[1]#[0]" monad)] + [number + ["n" nat]]]]] + [\\library + ["[0]" /]]) + +(def: test|tag + Test + (do [! random.monad] + [multiplicity (# ! each (n.max 2) random.nat) + tag (# ! each (n.% multiplicity) random.nat) + lefts random.nat + right? random.bit] + ($_ _.and + (_.cover [/.tag /.lefts] + (and (|> lefts + (/.tag right?) + (/.lefts right?) + (n.= lefts)) + (|> tag + (/.lefts right?) + (/.tag right?) + (n.= tag)))) + (_.cover [/.choice] + (let [[lefts right?] (/.choice multiplicity tag)] + (if right? + (n.= (-- tag) lefts) + (n.= tag lefts)))) + ))) + +(def: .public (random multiplicity it) + (All (_ a) + (-> Nat (Random a) (Random (/.Composite a)))) + ($_ random.or + ($_ random.and + (random#each (n.% (-- multiplicity)) random.nat) + random.bit + it) + (random.list multiplicity it) + )) + +(def: .public test + Test + (let [random (..random 3 random.nat)] + (<| (_.covering /._) + (_.for [/.Composite /.Variant /.Tuple]) + ($_ _.and + (_.for [/.equivalence] + ($equivalence.spec (/.equivalence n.equivalence) random)) + (_.for [/.hash] + ($hash.spec (/.hash n.hash) random)) + + (_.for [/.Tag] + ..test|tag) + + (do random.monad + [left random + right random] + (_.cover [/.format] + (bit#= (# (/.equivalence n.equivalence) = left right) + (text#= (/.format %.nat left) (/.format %.nat right))))) + )))) |