aboutsummaryrefslogtreecommitdiff
path: root/stdlib
diff options
context:
space:
mode:
authorEduardo Julian2022-01-08 06:37:39 -0400
committerEduardo Julian2022-01-08 06:37:39 -0400
commit54e219ee24c1508713d07473cd8a3b04c7f8fe18 (patch)
tree704007cf63c49d54e4d642da028f12c59eea0047 /stdlib
parentef847d54cc6ac57bb2d470c1164ca7daeaa241b1 (diff)
Fixes for the pure-Lux JVM compiler machinery. [Part 4]
Diffstat (limited to '')
-rw-r--r--stdlib/source/library/lux.lux143
-rw-r--r--stdlib/source/library/lux/control/parser/analysis.lux5
-rw-r--r--stdlib/source/library/lux/control/parser/synthesis.lux56
-rw-r--r--stdlib/source/library/lux/target/ruby.lux52
-rw-r--r--stdlib/source/library/lux/tool/compiler/language/lux/analysis.lux100
-rw-r--r--stdlib/source/library/lux/tool/compiler/language/lux/analysis/composite.lux98
-rw-r--r--stdlib/source/library/lux/tool/compiler/language/lux/phase/analysis/case.lux7
-rw-r--r--stdlib/source/library/lux/tool/compiler/language/lux/phase/analysis/case/coverage.lux7
-rw-r--r--stdlib/source/library/lux/tool/compiler/language/lux/phase/analysis/inference.lux5
-rw-r--r--stdlib/source/library/lux/tool/compiler/language/lux/phase/analysis/structure.lux7
-rw-r--r--stdlib/source/library/lux/tool/compiler/language/lux/phase/extension/analysis/jvm.lux122
-rw-r--r--stdlib/source/library/lux/tool/compiler/language/lux/phase/extension/generation/jvm/host.lux377
-rw-r--r--stdlib/source/library/lux/tool/compiler/language/lux/phase/extension/generation/ruby/common.lux3
-rw-r--r--stdlib/source/library/lux/tool/compiler/language/lux/phase/generation/jvm/structure.lux3
-rw-r--r--stdlib/source/library/lux/tool/compiler/language/lux/phase/generation/ruby.lux1
-rw-r--r--stdlib/source/library/lux/tool/compiler/language/lux/phase/generation/ruby/case.lux36
-rw-r--r--stdlib/source/library/lux/tool/compiler/language/lux/phase/generation/ruby/function.lux64
-rw-r--r--stdlib/source/library/lux/tool/compiler/language/lux/phase/generation/ruby/loop.lux2
-rw-r--r--stdlib/source/library/lux/tool/compiler/language/lux/phase/generation/ruby/runtime.lux45
-rw-r--r--stdlib/source/library/lux/tool/compiler/language/lux/phase/generation/ruby/structure.lux3
-rw-r--r--stdlib/source/library/lux/tool/compiler/language/lux/phase/synthesis.lux11
-rw-r--r--stdlib/source/library/lux/tool/compiler/language/lux/phase/synthesis/case.lux13
-rw-r--r--stdlib/source/library/lux/tool/compiler/language/lux/phase/synthesis/function.lux7
-rw-r--r--stdlib/source/library/lux/tool/compiler/language/lux/phase/synthesis/loop.lux15
-rw-r--r--stdlib/source/library/lux/tool/compiler/language/lux/phase/synthesis/variable.lux19
-rw-r--r--stdlib/source/library/lux/tool/compiler/language/lux/synthesis.lux81
-rw-r--r--stdlib/source/library/lux/tool/compiler/meta/archive/dependency.lux9
-rw-r--r--stdlib/source/test/lux/target/ruby.lux103
-rw-r--r--stdlib/source/test/lux/tool.lux4
-rw-r--r--stdlib/source/test/lux/tool/compiler/language/lux/analysis/composite.lux76
30 files changed, 871 insertions, 603 deletions
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)))))
+ ))))