aboutsummaryrefslogtreecommitdiff
path: root/stdlib
diff options
context:
space:
mode:
Diffstat (limited to 'stdlib')
-rw-r--r--stdlib/source/library/lux/data/color/cmyk.lux2
-rw-r--r--stdlib/source/library/lux/data/color/hsb.lux52
-rw-r--r--stdlib/source/library/lux/data/color/hsl.lux2
-rw-r--r--stdlib/source/library/lux/ffi.lux484
-rw-r--r--stdlib/source/library/lux/meta/compiler/language/lux/phase/translation/c++/runtime.lux63
-rw-r--r--stdlib/source/library/lux/meta/compiler/language/lux/phase/translation/c++/type.lux26
-rw-r--r--stdlib/source/library/lux/meta/compiler/language/lux/phase/translation/js/runtime.lux4
-rw-r--r--stdlib/source/library/lux/meta/compiler/language/lux/phase/translation/jvm/debug.lux31
-rw-r--r--stdlib/source/library/lux/meta/compiler/language/lux/phase/translation/jvm/runtime.lux4
-rw-r--r--stdlib/source/library/lux/meta/compiler/language/lux/phase/translation/jvm/type.lux5
-rw-r--r--stdlib/source/library/lux/meta/target/c++.lux284
-rw-r--r--stdlib/source/library/lux/meta/target/jvm/type.lux47
-rw-r--r--stdlib/source/library/lux/meta/target/python.lux18
-rw-r--r--stdlib/source/specification/aedifex/repository.lux59
-rw-r--r--stdlib/source/specification/compositor.lux69
-rw-r--r--stdlib/source/specification/compositor/analysis/type.lux65
-rw-r--r--stdlib/source/specification/compositor/common.lux80
-rw-r--r--stdlib/source/specification/compositor/generation/case.lux290
-rw-r--r--stdlib/source/specification/compositor/generation/common.lux350
-rw-r--r--stdlib/source/specification/compositor/generation/function.lux96
-rw-r--r--stdlib/source/specification/compositor/generation/primitive.lux51
-rw-r--r--stdlib/source/specification/compositor/generation/reference.lux64
-rw-r--r--stdlib/source/specification/compositor/generation/structure.lux93
-rw-r--r--stdlib/source/test/aedifex.lux2
-rw-r--r--stdlib/source/test/aedifex/artifact.lux7
-rw-r--r--stdlib/source/test/aedifex/dependency/deployment.lux31
-rw-r--r--stdlib/source/test/aedifex/repository.lux64
-rw-r--r--stdlib/source/test/lux/meta/compiler/language/lux/phase.lux4
-rw-r--r--stdlib/source/test/lux/meta/compiler/language/lux/phase/translation/jvm/type.lux45
-rw-r--r--stdlib/source/test/lux/meta/compiler/meta/archive/artifact.lux5
30 files changed, 858 insertions, 1539 deletions
diff --git a/stdlib/source/library/lux/data/color/cmyk.lux b/stdlib/source/library/lux/data/color/cmyk.lux
index dc85a4a97..4f2b46238 100644
--- a/stdlib/source/library/lux/data/color/cmyk.lux
+++ b/stdlib/source/library/lux/data/color/cmyk.lux
@@ -68,7 +68,7 @@
(def up
(-> Frac
Nat)
- (|>> (f.* rgb_factor) f.int .nat))
+ (|>> (f.* rgb_factor) f.round f.int .nat))
(def (opposite it)
(-> Frac
diff --git a/stdlib/source/library/lux/data/color/hsb.lux b/stdlib/source/library/lux/data/color/hsb.lux
index ede1ffd08..5e7216de0 100644
--- a/stdlib/source/library/lux/data/color/hsb.lux
+++ b/stdlib/source/library/lux/data/color/hsb.lux
@@ -92,7 +92,7 @@
(def up
(-> Frac
Nat)
- (|>> (f.* rgb_factor) f.int .nat))
+ (|>> (f.* rgb_factor) f.round f.int .nat))
(def .public (of_rgb it)
(-> RGB
@@ -101,30 +101,36 @@
green (..down (the rgb.#green it))
blue (..down (the rgb.#blue it))
- max (all f.max red green blue)
- min (all f.min red green blue)
+ brightness (all f.max red green blue)
+ range (all f.min red green blue)
- brightness max
- diff (|> max (f.- min))
- saturation (if (f.= +0.0 max)
+ chroma (|> brightness (f.- range))
+ saturation (if (f.= +0.0 brightness)
+0.0
- (|> diff (f./ max)))]
+ (|> chroma (f./ brightness)))]
(nominal.abstraction
- [#hue (if (f.= max min)
- ... Achromatic
- +0.0
- ... Chromatic
- (cond (f.= max red)
- (|> green (f.- blue) (f./ diff)
- (f.+ (if (f.< blue green) +6.0 +0.0)))
-
- (f.= max green)
- (|> blue (f.- red) (f./ diff)
- (f.+ +2.0))
-
- ... (f.= max blue)
- (|> red (f.- green) (f./ diff)
- (f.+ +4.0))))
+ [#hue (cond (f.= +0.0 chroma)
+ ... Achromatic
+ +0.0
+ ... Chromatic
+ (and (f.= brightness red)
+ (not (f.= red blue)))
+ (|> green (f.- blue)
+ (f./ chroma)
+ (f.+ +0.0)
+ (f./ +6.0))
+
+ (f.= brightness green)
+ (|> blue (f.- red)
+ (f./ chroma)
+ (f.+ +2.0)
+ (f./ +6.0))
+
+ ... (f.= brightness blue)
+ (|> red (f.- green)
+ (f./ chroma)
+ (f.+ +4.0)
+ (f./ +6.0)))
#saturation saturation
#brightness brightness])))
@@ -140,7 +146,7 @@
t (|> +1.0 (f.- (|> +1.0 (f.- f) (f.* saturation))) (f.* brightness))
v brightness
mod (|> i (f.% +6.0) f.int .nat)
-
+
red (when mod 0 v 1 q 2 p 3 p 4 t 5 v _ (undefined))
green (when mod 0 t 1 v 2 v 3 q 4 p 5 p _ (undefined))
blue (when mod 0 p 1 p 2 t 3 v 4 v 5 q _ (undefined))]
diff --git a/stdlib/source/library/lux/data/color/hsl.lux b/stdlib/source/library/lux/data/color/hsl.lux
index df8fb8a82..ac0b637c8 100644
--- a/stdlib/source/library/lux/data/color/hsl.lux
+++ b/stdlib/source/library/lux/data/color/hsl.lux
@@ -28,7 +28,7 @@
(def up
(-> Frac
Nat)
- (|>> (f.* rgb_factor) f.int .nat))
+ (|>> (f.* rgb_factor) f.round f.int .nat))
(type .public Value
Frac)
diff --git a/stdlib/source/library/lux/ffi.lux b/stdlib/source/library/lux/ffi.lux
index 6d0f9d390..8afc76f04 100644
--- a/stdlib/source/library/lux/ffi.lux
+++ b/stdlib/source/library/lux/ffi.lux
@@ -1,13 +1,13 @@
(.require
[library
- [lux (.except Symbol Alias Global Declaration global function type_of undefined alias)
+ [lux (.except Symbol Alias Global Declaration Pattern global function type_of undefined alias)
[abstract
["[0]" monad (.only do)]]
[control
["<>" parser (.use "[1]#[0]" monad)]
["[0]" io]
["[0]" maybe (.use "[1]#[0]" functor)]
- ["[0]" try]]
+ ["[0]" try (.only Try)]]
[data
["[0]" product]
["[0]" text (.use "[1]#[0]" equivalence)
@@ -15,174 +15,324 @@
[collection
["[0]" list (.use "[1]#[0]" monoid monad mix)]]]
["[0]" meta (.only)
+ ["[0]" location]
["[0]" code (.only)
["<[1]>" \\parser (.only Parser)]]
["[0]" macro (.only with_symbols)
[syntax (.only syntax)]
["[0]" template]]
- [type
+ [type (.only sharing)
["[0]" nominal (.except #name def)]]
["@" target (.only)
- ["[0]" js]]]]])
-
-... These extensions must be defined this way because importing any of the modules
-... normally used when writing extensions would introduce a circular dependency
-... because the Archive type depends on Binary, and that module depends on this ffi module.
-(def extension_name
- (syntax (_ [])
- (do meta.monad
- [module meta.current_module_name
- unique_id meta.seed]
- (in (list (code.text (%.format module " " (%.nat unique_id))))))))
-
-(def extension_analysis
- (template (_ <name> <parameter>)
- [{5 #1 [<name> <parameter>]}]))
-
-(def text_analysis
- (template (_ <it>)
- [{0 #0 {5 #1 <it>}}]))
-
-(def analysis
- (template (_ <name> <bindings> <parser> <inputs> <body>)
- [("lux def analysis" <name>
- (.function (_ name phase archive inputs)
- (.function (_ state)
- (let [<bindings> [name phase archive state]]
- (when (<code>.result <parser> inputs)
- {try.#Failure error}
- {try.#Failure (%.format "Invalid inputs for extension: " (%.text name)
- text.\n error)}
-
- {try.#Success <inputs>}
- <body>)))))]))
-
-(def translation
- (template (_ <name> <bindings> <inputs> <body>)
- [("lux def translation" <name>
- (.function (_ name phase archive inputs)
- (.function (_ state)
- (let [<bindings> [name phase archive state]]
- (when inputs
- <inputs>
- <body>
-
- _
- {try.#Failure (%.format "Invalid inputs for extension: " (%.text name))})))))]))
-
-(for @.js (with_expansions [<undefined> (..extension_name)
- <undefined?> (..extension_name)
- <object> (..extension_name)
- <set> (..extension_name)]
- (these (analysis <undefined>
- [name phase archive state]
- <code>.end
- _
- {try.#Success [state (extension_analysis name (list))]})
-
- (translation <undefined>
- [name phase archive state]
+ ["[0]" js]
+ ["[0]" python]]
+ [compiler
+ [arity (.only Arity)]
+ [reference (.only Reference)
+ [variable (.only Register)]]
+ [language
+ [lux
+ ["[0]" analysis
+ ["[1]/[0]" simple]
+ [complex (.only Complex)]
+ [pattern (.only Pattern)]]
+ ["[0]" synthesis
+ ["[1]/[0]" simple]
+ [access (.only Access)
+ [side (.only Side)]
+ ["[1]/[0]" member]]]]]]]]])
+
+(for @.js (these (type (Analysis_Branch of)
+ [Pattern of])
+
+ (type (Analysis_Match of)
+ [(Analysis_Branch of) (List (Analysis_Branch of))])
+
+ (type (Environment of)
+ (List of))
+
+ (type (Extension of)
+ [.Symbol (List of)])
+
+ (with_expansions [@ ($ (Analysis~' $))]
+ (type (Analysis~' $)
+ (Or analysis/simple.Simple
+ (Complex @)
+ Reference
+ [@ (Analysis_Match @)]
+ [(Environment @) @]
+ [@ @]
+ (Extension @))))
+
+ (type Analysis~
+ (Ann Location
+ (Analysis~' (Ann Location))))
+
+ (def extension_analysis
+ (template (_ <name> <parameter>)
+ [(is Analysis~
+ [location.dummy {5 #1 [<name> <parameter>]}])]))
+
+ (def text_analysis
+ (template (_ <it>)
+ [(is Analysis~
+ [location.dummy {0 #0 {5 #1 <it>}}])]))
+
+ (def analysis
+ (template (_ <name> <bindings> <parser> <inputs> <body>)
+ [(def .public <name>
+ (<| (as .Analysis)
+ (.function (_ phase archive inputs))
+ (.function (_ state))
+ (let [<bindings> [phase archive state]]
+ (when (<code>.result <parser> inputs)
+ {try.#Success <inputs>}
+ <body>
+
+ {try.#Failure error}
+ {try.#Failure (%.format "Invalid inputs for extension..."
+ text.\n error)}))))]))
+
+ (type (Synthesis_Road value next)
+ [value next])
+
+ (type (Synthesis_Fork value next)
+ [(Synthesis_Road value next)
+ (List (Synthesis_Road value next))])
+
+ (type (Synthesis_Path s)
+ (Or Any
+ Register
+ Access
+ [Bit (Synthesis_Path s) (Maybe (Synthesis_Path s))]
+ (Synthesis_Fork I64 (Synthesis_Path s))
+ (Synthesis_Fork Frac (Synthesis_Path s))
+ (Synthesis_Fork Text (Synthesis_Path s))
+ [(Synthesis_Path s) (Synthesis_Path s)]
+ [(Synthesis_Path s) (Synthesis_Path s)]
+ s))
+
+ (type (Synthesis_Abstraction s)
+ [(Environment s) Arity s])
+
+ (type (Synthesis_Apply s)
+ [s (List s)])
+
+ (type (Synthesis_Function s)
+ (Or (Synthesis_Abstraction s)
+ (Synthesis_Apply s)))
+
+ (type (Synthesis_Branch s)
+ (Or [s s]
+ [s Register s]
+ [s s s]
+ [(List synthesis/member.Member) s]
+ [s (Synthesis_Path s)]))
+
+ (type (Synthesis_Scope s)
+ [Register (List s) s])
+
+ (type (Synthesis_Loop s)
+ (Or (Synthesis_Scope s)
+ (List s)))
+
+ (type (Synthesis_Control s)
+ (Or (Synthesis_Branch s)
+ (Synthesis_Loop s)
+ (Synthesis_Function s)))
+
+ (with_expansions [@ ($ (Synthesis~' $))]
+ (type (Synthesis~' $)
+ (Or synthesis/simple.Simple
+ (Complex @)
+ Reference
+ (Synthesis_Control @)
+ (Extension @))))
+
+ (type Synthesis~
+ (Ann Location
+ (Synthesis~' (Ann Location))))
+
+ (def text_synthesis
+ (template (_ <@> <it>)
+ [[<@> {0 #0 {2 #1 <it>}}]]))
+
+ (def translation
+ (syntax (_ [<name> <code>.any
+ <bindings> <code>.any
+ <inputs> (<>.or <code>.local
+ <code>.any)
+ <body> <code>.any])
+ (with_symbols ['_ 'phase 'archive 'inputs 'state]
+ (in (list (` (def .public (, <name>)
+ (<| (as .Translation)
+ (.function ((, '_) (, 'phase) (, 'archive) (, 'inputs)))
+ (.function ((, '_) (, 'state)))
+ (let [(, <bindings>) [(, 'phase) (, 'archive) (, 'state)]]
+ (, (when <inputs>
+ {.#Left <inputs>}
+ (` (when (is (List Synthesis~) (, 'inputs))
+ (, (code.local <inputs>))
+ (, <body>)))
+
+ {.#Right <inputs>}
+ (` (when (is (List Synthesis~) (, 'inputs))
+ (, <inputs>)
+ (, <body>)
+
+ (, '_)
+ {try.#Failure "Invalid inputs for extension."})))))))))))))
+
+ (translation undefined?|translation
+ [phase archive state]
+ (list it)
+ (do try.monad
+ [.let [phase (sharing [archive it state]
+ (is [archive it state]
+ [archive it state])
+ (is (-> archive it state
+ (Try [state js.Expression]))
+ (as_expected phase)))]
+ [state it] (phase archive it state)]
+ (in [state (js.= js.undefined it)])))
+
+ (analysis undefined?|analysis
+ [phase archive state]
+ <code>.any
+ it
+ (do try.monad
+ [.let [phase (sharing [archive state]
+ (is [archive state]
+ [archive state])
+ (is (-> archive Code state
+ (Try [state Analysis~]))
+ (as_expected phase)))]
+ [state it] (phase archive (` (.is .Any (, it))) state)]
+ (in [state (extension_analysis (symbol ..undefined?|translation)
+ (list it))])))
+
+ (def .public undefined?
+ (template (undefined? <it>)
+ [(.as .Bit (.is .Any (undefined?|analysis <it>)))]))
+
+ (translation undefined|translation
+ [phase archive state]
+ (list)
+ {try.#Success [state js.undefined]})
+
+ (analysis undefined|analysis
+ [phase archive state]
+ <code>.end
+ _
+ {try.#Success [state (extension_analysis (symbol ..undefined|translation)
+ (list))]})
+
+ (def .public undefined
+ (template (_)
+ [(.is ..Undefined (undefined|analysis))]))
+
+ (def (pairs it)
+ (All (_ a) (-> (List a) (List [a a])))
+ (when it
+ (list.partial left right tail)
+ (list.partial [left right] (pairs tail))
+
(list)
- {try.#Success [state js.undefined]})
-
- (def .public undefined
- (template (undefined)
- [(.is ..Undefined (<undefined>))]))
-
- (analysis <undefined?>
- [name phase archive state]
- <code>.any
- it
- (do try.monad
- [[state it] (phase archive (` (.is .Any (, it))) state)]
- (in [state (extension_analysis name (list it))])))
-
- (translation <undefined?>
- [name phase archive state]
- (list it)
- (do try.monad
- [[state it] (phase archive it state)]
- (in [state (js.= js.undefined it)])))
-
- (def .public undefined?
- (template (undefined? <it>)
- [(.as .Bit (.is .Any (<undefined?> <it>)))]))
-
- (analysis <object>
- [name phase archive state]
- (<>.some (<>.and <code>.text <code>.any))
- it
- (do [! try.monad]
- [[state output] (monad.mix ! (.function (_ [key value] [state output])
- (do !
- [[state value] (phase archive (` (.is .Any (, value))) state)]
- (in [state (list.partial value (text_analysis key) output)])))
- [state (list)]
- it)]
- (in [state (extension_analysis name (list.reversed output))])))
-
- (def text_synthesis
- (template (_ <it>)
- [{0 #0 {2 #1 <it>}}]))
-
- (def (pairs it)
- (All (_ a) (-> (List a) (List [a a])))
- (when it
- (list.partial left right tail)
- (list.partial [left right] (pairs tail))
-
- (list)
- (list)
-
- _
- (.undefined)))
-
- (translation <object>
- [name phase archive state]
- (list.partial head_key head_value tail)
- (do [! try.monad]
- [[state output] (monad.mix !
- (.function (_ [key value] [state output])
- (when key
- (text_synthesis key)
- (do try.monad
- [[state value] (phase archive value state)]
- (in [state (list.partial [key value] output)]))
-
- _
- (.undefined)))
- [state (list)]
- (pairs (list.partial head_key head_value tail)))]
- (in [state (js.object (list.reversed output))])))
-
- (def .public object
- (syntax (_ [it (<>.some <code>.any)])
- (in (list (` (.as (..Object .Any)
- (<object> (,* it))))))))
-
- (analysis <set>
- [name phase archive state]
- (all <>.and <code>.text <code>.any <code>.any)
- [field value object]
- (do try.monad
- [[state value] (phase archive (` (.is .Any (, value))) state)
- [state object] (phase archive (` (.is (..Object .Any) (, object))) state)]
- (in [state (extension_analysis name (list (text_analysis field) value object))])))
-
- (translation <set>
- [name phase archive state]
- (list (text_synthesis field) value object)
- (do try.monad
- [[state value] (phase archive value state)
- [state object] (phase archive object state)]
- (in [state (js.set (js.the field object) value)])))
-
- (def .public set
- (syntax (_ [field <code>.any
- value <code>.any
- object <code>.any])
- (in (list (` (.as .Any (<set> (, field) (, value) (, object))))))))
- ))
+ (list)
+
+ _
+ (.undefined)))
+
+ (translation object|translation
+ [phase archive state]
+ it
+ (do [! try.monad]
+ [.let [phase (sharing [archive state]
+ (is [archive state]
+ [archive state])
+ (is (-> archive Synthesis~ state
+ (Try [state js.Expression]))
+ (as_expected phase)))]
+ [state output] (monad.mix !
+ (sharing [state]
+ (is state
+ state)
+ (is (-> [Synthesis~ Synthesis~] [state (List [Text js.Expression])]
+ (Try [state (List [Text js.Expression])]))
+ (.function (_ [key value] [state output])
+ (when key
+ (text_synthesis @ key)
+ (do try.monad
+ [[state value] (phase archive value state)]
+ (in [state (list.partial [key value] output)]))
+
+ _
+ (.undefined)))))
+ [state (list)]
+ (pairs it))]
+ (in [state (js.object (list.reversed output))])))
+
+ (analysis object|analysis
+ [phase archive state]
+ (<>.some (<>.and <code>.text <code>.any))
+ it
+ (do [! try.monad]
+ [.let [phase (sharing [archive state]
+ (is [archive state]
+ [archive state])
+ (is (-> archive Code state
+ (Try [state Analysis~]))
+ (as_expected phase)))]
+ [state output] (monad.mix ! (.function (_ [key value] [state output])
+ (do !
+ [[state value] (phase archive (` (.is .Any (, value))) state)]
+ (in [state (list.partial value (text_analysis key) output)])))
+ [state (list)]
+ it)]
+ (in [state (extension_analysis (symbol ..object|translation)
+ (list.reversed output))])))
+
+ (def .public object
+ (syntax (_ [it (<>.some <code>.any)])
+ (in (list (` (.as (..Object .Any)
+ (object|analysis (,* it))))))))
+
+ (translation set|translation
+ [phase archive state]
+ (list (text_synthesis @ field) value object)
+ (do try.monad
+ [.let [phase (sharing [archive state]
+ (is [archive state]
+ [archive state])
+ (is (-> archive Synthesis~ state
+ (Try [state js.Expression]))
+ (as_expected phase)))]
+ [state value] (phase archive value state)
+ [state object] (phase archive object state)]
+ (in [state (js.set (js.the field object) value)])))
+
+ (analysis set|analysis
+ [phase archive state]
+ (all <>.and <code>.text <code>.any <code>.any)
+ [field value object]
+ (do try.monad
+ [.let [phase (sharing [archive state]
+ (is [archive state]
+ [archive state])
+ (is (-> archive Code state
+ (Try [state Analysis~]))
+ (as_expected phase)))]
+ [state value] (phase archive (` (.is .Any (, value))) state)
+ [state object] (phase archive (` (.is (..Object .Any) (, object))) state)]
+ (in [state (extension_analysis (symbol ..set|translation)
+ (list (text_analysis field) value object))])))
+
+ (def .public set
+ (syntax (_ [field <code>.any
+ value <code>.any
+ object <code>.any])
+ (in (list (` (.as .Any (set|analysis (, field) (, value) (, object))))))))
+ )
... else
(these))
@@ -217,7 +367,7 @@
@.python .python_function#
@.lua .lua_function#
(these))]
- (nominal.def .public (Object brand) Any)
+ (nominal.def .public (Object of) Any)
(with_expansions [<un_common> (for @.js (these [Symbol]
[Null]
@@ -229,12 +379,12 @@
@.ruby (these [Nil]))
<un_common> <un_common>]
(with_template [<name>]
- [(with_expansions [<brand> (template.symbol [<name> "'"])]
- (nominal.def <brand>
+ [(with_expansions [<of> (template.symbol [<name> "'"])]
+ (nominal.def <of>
Any
(type .public <name>
- (Object <brand>))))]
+ (Object <of>))))]
[Function]
<un_common>
@@ -510,7 +660,7 @@
(def (input_type input :it:)
(-> Input Code Code)
(let [:it: (if (the #try? input)
- (` (try.Try (, :it:)))
+ (` (Try (, :it:)))
:it:)]
(if (the #io? input)
(` (io.IO (, :it:)))
diff --git a/stdlib/source/library/lux/meta/compiler/language/lux/phase/translation/c++/runtime.lux b/stdlib/source/library/lux/meta/compiler/language/lux/phase/translation/c++/runtime.lux
new file mode 100644
index 000000000..7e29191ac
--- /dev/null
+++ b/stdlib/source/library/lux/meta/compiler/language/lux/phase/translation/c++/runtime.lux
@@ -0,0 +1,63 @@
+(.require
+ [library
+ [lux (.except)
+ [data
+ [text
+ ["%" \\format]]]
+ ["[0]" meta (.use "[1]#[0]" functor)
+ ["[0]" code]
+ [macro
+ [syntax (.only syntax)]]
+ [target
+ ["_" c++]]]]])
+
+(def .public (host_value of it)
+ (-> _.Type _.Expression
+ _.Expression)
+ (|> it
+ (_.do "get" (list) (list))
+ (_.as (_.* of))))
+
+(def .public namespace
+ _.Namespace
+ "lux")
+
+(def name
+ (syntax (_ [])
+ (|> meta.seed
+ (meta#each (|>> %.nat
+ (%.format ..namespace)
+ code.text
+ list)))))
+
+(with_expansions [<clean_up> (..name)]
+ (def .public declaration
+ _.Declaration
+ (let [clean_up (let [of (_.type_name "Of")
+ it (_.local "it")]
+ (_.function (_.local <clean_up>)
+ (list of)
+ (list [(_.* of) it])
+ _.void
+ (_.delete it)))]
+ (all _.then
+ (_.include "memory")
+
+ (<| (_.namespace ..namespace)
+ (all _.then
+ clean_up
+ )))))
+
+ (def .public clean_up
+ (-> _.Type
+ _.Expression)
+ (|>> (list)
+ (_.global [..namespace <clean_up>])))
+ )
+
+(def .public (lux_value of it)
+ (-> _.Type _.Expression
+ _.Expression)
+ (_.on (list (_.new of (list it))
+ (clean_up of))
+ (_.global [_.standard "shared_ptr"] (list _.void))))
diff --git a/stdlib/source/library/lux/meta/compiler/language/lux/phase/translation/c++/type.lux b/stdlib/source/library/lux/meta/compiler/language/lux/phase/translation/c++/type.lux
new file mode 100644
index 000000000..f091e288f
--- /dev/null
+++ b/stdlib/source/library/lux/meta/compiler/language/lux/phase/translation/c++/type.lux
@@ -0,0 +1,26 @@
+(.require
+ [library
+ [lux (.except i64)
+ [meta
+ [target
+ ["_" c++]]]]])
+
+(def .public bit
+ _.Type
+ (_.type ["" "bool"] (list)))
+
+(def .public i64
+ _.Type
+ (_.type ["" "int64_t"] (list)))
+
+(def .public f64
+ _.Type
+ (_.type ["" "double"] (list)))
+
+(def .public text
+ _.Type
+ (_.type [_.standard "u32string"] (list)))
+
+(def .public value
+ _.Type
+ (_.type [_.standard "shared_ptr"] (list (_.type ["" "void"] (list)))))
diff --git a/stdlib/source/library/lux/meta/compiler/language/lux/phase/translation/js/runtime.lux b/stdlib/source/library/lux/meta/compiler/language/lux/phase/translation/js/runtime.lux
index dbd9f5c45..13790c910 100644
--- a/stdlib/source/library/lux/meta/compiler/language/lux/phase/translation/js/runtime.lux
+++ b/stdlib/source/library/lux/meta/compiler/language/lux/phase/translation/js/runtime.lux
@@ -258,7 +258,7 @@
(lux//try op)
(with_vars [ex]
(_.try (_.return (..right (_.apply_1 op ..unit)))
- [ex (_.return (..left (|> ex (_.do "toString" (list)))))])))
+ [ex (_.return (..left (_.the "stack" ex)))])))
(runtime
(lux//program_args inputs)
@@ -751,7 +751,7 @@
(runtime
(io//error message)
- (_.throw message))
+ (_.throw (_.new (_.var "Error") (list message))))
(def runtime//io
Statement
diff --git a/stdlib/source/library/lux/meta/compiler/language/lux/phase/translation/jvm/debug.lux b/stdlib/source/library/lux/meta/compiler/language/lux/phase/translation/jvm/debug.lux
deleted file mode 100644
index 1d6adf5f6..000000000
--- a/stdlib/source/library/lux/meta/compiler/language/lux/phase/translation/jvm/debug.lux
+++ /dev/null
@@ -1,31 +0,0 @@
-(.require
- [library
- [lux (.except)
- [abstract
- [monad (.only do)]]
- [control
- ["[0]" io (.only IO)]
- ["[0]" try (.only Try)]]
- [data
- [binary (.only Binary)]
- [text
- ["%" \\format (.only format)]]]
- [world
- ["[0]" file (.only File)]]]])
-
-(def extension ".class")
-
-(def .public (write_class! name bytecode)
- (-> Text Binary (IO Text))
- (let [file_path (format name ..extension)]
- (do io.monad
- [outcome (do (try.with @)
- [file (is (IO (Try (File IO)))
- (file.get_file io.monad file.default file_path))]
- (of file over_write bytecode))]
- (in (when outcome
- {try.#Success definition}
- file_path
-
- {try.#Failure error}
- error)))))
diff --git a/stdlib/source/library/lux/meta/compiler/language/lux/phase/translation/jvm/runtime.lux b/stdlib/source/library/lux/meta/compiler/language/lux/phase/translation/jvm/runtime.lux
index 297504638..af848be72 100644
--- a/stdlib/source/library/lux/meta/compiler/language/lux/phase/translation/jvm/runtime.lux
+++ b/stdlib/source/library/lux/meta/compiler/language/lux/phase/translation/jvm/runtime.lux
@@ -375,7 +375,7 @@
_.areturn
))}))
-(def projection_type (type.method [(list) (list //type.tuple //type.offset) //type.value (list)]))
+(def projection_type (type.method [(list) (list //type.tuple //type.lefts) //type.value (list)]))
(def left_projection::name "left")
(def .public left_projection (..procedure ..left_projection::name ..projection_type))
@@ -452,7 +452,7 @@
$right
$tuple::size
(_.invokestatic (type.class "java.util.Arrays" (list)) "copyOfRange"
- (type.method [(list) (list //type.tuple //type.index //type.index) //type.tuple (list)])))]]
+ (type.method [(list) (list //type.tuple //type.lefts //type.lefts) //type.tuple (list)])))]]
(all _.composite
(_.set_label @loop)
$last_right $right
diff --git a/stdlib/source/library/lux/meta/compiler/language/lux/phase/translation/jvm/type.lux b/stdlib/source/library/lux/meta/compiler/language/lux/phase/translation/jvm/type.lux
index c178701b3..329c0a02f 100644
--- a/stdlib/source/library/lux/meta/compiler/language/lux/phase/translation/jvm/type.lux
+++ b/stdlib/source/library/lux/meta/compiler/language/lux/phase/translation/jvm/type.lux
@@ -8,17 +8,12 @@
(def .public frac (type.class "java.lang.Double" (list)))
(def .public text (type.class "java.lang.String" (list)))
-
(def .public value (type.class "java.lang.Object" (list)))
(def .public lefts type.int)
(def .public right? ..value)
(def .public variant (type.array ..value))
-
-(def .public offset type.int)
-(def .public index ..offset)
(def .public tuple (type.array ..value))
(def .public stack (type.array ..value))
-
(def .public error (type.class "java.lang.Throwable" (list)))
diff --git a/stdlib/source/library/lux/meta/target/c++.lux b/stdlib/source/library/lux/meta/target/c++.lux
index b8c2414f4..952cc0c0b 100644
--- a/stdlib/source/library/lux/meta/target/c++.lux
+++ b/stdlib/source/library/lux/meta/target/c++.lux
@@ -1,10 +1,12 @@
(.require
[library
- [lux (.except Code Type int)
+ [lux (.except Code Type Global Declaration int as function template local global type)
+ [abstract
+ [equivalence (.only Equivalence)]]
[control
["|" pipe]]
[data
- ["[0]" text (.only)
+ ["[0]" text (.only \n \t) (.use "[1]#[0]" equivalence)
["%" \\format]]
[collection
["[0]" list (.use "[1]#[0]" functor)]]]
@@ -17,32 +19,60 @@
[type
["[0]" nominal]]]]])
+(def parameter_separator ", ")
+(def term_delimiters ["(" ")"])
+(def type_delimiters ["<" ">"])
+
(nominal.def .public (Code of)
Text
+ (def .public equivalence
+ (All (_ of)
+ (Equivalence (Code of)))
+ (implementation
+ (def (= refererence it)
+ (text#= (nominal.representation refererence)
+ (nominal.representation it)))))
+
(def .public code
(-> (Code Any)
Text)
(|>> nominal.representation))
- (with_template [<type> <super>+]
- [(with_expansions [<of> (template.symbol [<type> "'"])]
- (nominal.def (<of> of)
- Any)
- (`` (type .public <type>
- (|> Any <of> (,, (template.spliced <super>+))))))]
+ (with_template [<super> <type>+]
+ [(`` (with_template [<type> <parameter>*']
+ [(with_expansions [<parameter>* (template.spliced <parameter>*')
+ <brand> (template.symbol [<type> "'"])]
+ (nominal.def (<brand> <parameter>*)
+ Any)
+
+ (.type .public <type>
+ (Ex (_ <parameter>*)
+ (<super> (<brand> <parameter>*)))))]
- [Type [Code]]
- [Expression [Code]]
- [Computation [Expression' Code]]
- )
+ (,, (template.spliced <type>+))))]
+
+ [Code
+ [[Type [of]]
+ [Expression [of]]
+ [Statement [of]]]]
+
+ [Expression
+ [[Computation [of]]
+ [Reference [of]]]]
+
+ [Type
+ [[Type_Name []]]]
- (with_template [<type> <super>+]
- [(with_expansions [<brand> (template.symbol [<type> "'"])]
- (nominal.def <brand> Any)
- (`` (type .public <type> (|> <brand> (,, (template.spliced <super>+))))))]
+ [Computation
+ [[Literal []]]]
- [Literal [Computation' Expression' Code]]
+ [Reference
+ [[Local []]
+ [Global []]]]
+
+ [Statement
+ [[Declaration []]]]
)
(def .public bool
@@ -69,7 +99,74 @@
[%.frac])
nominal.abstraction))
- (def .public (cast type term)
+ (.type .public Namespace
+ Text)
+
+ (def .public standard
+ Namespace
+ "std")
+
+ (def .public local
+ (-> Text
+ Local)
+ (|>> nominal.abstraction))
+
+ (def instantiation
+ (-> (List Type)
+ Text)
+ (|>> (|.when
+ (list)
+ ""
+
+ it
+ (|> it
+ (list#each ..code)
+ (text.interposed ..parameter_separator)
+ (text.enclosed ..type_delimiters)))))
+
+ (def .public (global [ns name] parameters)
+ (-> [Namespace Text] (List Type)
+ Global)
+ (nominal.abstraction
+ (let [instance (%.format name (instantiation parameters))]
+ (when ns
+ "" instance
+ _ (%.format ns "::" instance)))))
+
+ (def .public (type name parameters)
+ (-> [Namespace Text] (List Type)
+ Type)
+ (|> (..global name parameters)
+ nominal.transmutation))
+
+ (def .public type_name
+ (-> Text
+ Type_Name)
+ (|>> nominal.abstraction))
+
+ (with_template [<ns> <name>]
+ [(def .public <name>
+ Type
+ (..type [<ns> (template.text [<name>])] (list)))]
+
+ ["" void]
+ )
+
+ (def .public *
+ (-> Type
+ Type)
+ (|>> nominal.representation
+ (text.suffix "*")
+ nominal.abstraction))
+
+ (def .public deref
+ (-> Expression
+ Expression)
+ (|>> nominal.representation
+ (text.prefix "*")
+ nominal.abstraction))
+
+ (def .public (as type term)
(-> Type Expression
Computation)
(nominal.abstraction
@@ -82,16 +179,135 @@
(|>> %.int
nominal.abstraction))
+ (def application
+ (-> (List Expression)
+ Text)
+ (|>> (list#each ..code)
+ (text.interposed ..parameter_separator)
+ (text.enclosed ..term_delimiters)))
+
(def .public (on parameters function)
(-> (List Expression) Expression
Expression)
(nominal.abstraction
(%.format (nominal.representation function)
- "("
- (|> parameters
- (list#each (|>> nominal.representation))
- (text.interposed ", "))
- ")")))
+ (application parameters))))
+
+ (def .public (new of parameters)
+ (-> Type (List Expression)
+ Expression)
+ (nominal.abstraction
+ (%.format "new "
+ (nominal.representation of)
+ (application parameters))))
+
+ (def .public (do method types parameters object)
+ (-> Text (List Type) (List Expression) Expression
+ Expression)
+ (nominal.abstraction
+ (%.format (nominal.representation object)
+ "." method
+ (instantiation types)
+ (application parameters))))
+
+ (def .public (<< it to)
+ (-> Expression Expression
+ Expression)
+ (nominal.abstraction
+ (%.format (nominal.representation to)
+ " << "
+ (nominal.representation it))))
+
+ (def .public (include it)
+ (-> Text
+ Declaration)
+ (nominal.abstraction
+ (%.format "#include <" it ">")))
+
+ (def .public (then before after)
+ (All (_ of)
+ (-> (Statement of) (Statement of)
+ (Statement of)))
+ (nominal.abstraction
+ (%.format (nominal.representation before)
+ \n (nominal.representation after))))
+
+ (def statement
+ (-> Text
+ Statement)
+ (|>> (text.suffix ";")
+ nominal.abstraction))
+
+ (def .public ;
+ (-> Expression
+ Statement)
+ (|>> nominal.representation
+ ..statement))
+
+ (def .public delete
+ (-> Expression
+ Statement)
+ (|>> nominal.representation
+ (%.format "delete ")
+ ..statement))
+
+ (def template
+ (-> (List Type_Name)
+ Text)
+ (|>> (|.when
+ (list)
+ ""
+
+ it
+ (%.format "template"
+ " " (|> it
+ (list#each (|>> nominal.representation (%.format "typename ")))
+ (text.interposed ..parameter_separator)
+ (text.enclosed ..type_delimiters))
+ " "))))
+
+ (.type Argument
+ [Type Local])
+
+ (def (argument [type it])
+ (-> Argument
+ Text)
+ (%.format (nominal.representation type)
+ " " (nominal.representation it)))
+
+ (def arguments
+ (-> (List Argument)
+ Text)
+ (|>> (list#each ..argument)
+ (text.interposed ..parameter_separator)
+ (text.enclosed ..term_delimiters)))
+
+ (def block
+ (-> Statement
+ Text)
+ (let [\n\t (%.format \n \t)
+ <| (%.format "{" \n)
+ |> (%.format \n "}")]
+ (|>> nominal.representation
+ (text.replaced \n \n\t)
+ (text.enclosed [<| |>]))))
+
+ (def .public (function name types inputs output body)
+ (-> Local (List Type_Name) (List Argument) Type Statement
+ Declaration)
+ (nominal.abstraction
+ (%.format (..template types) (nominal.representation output)
+ " " (nominal.representation name)
+ (..arguments inputs)
+ " " (..block body))))
+
+ (def .public (namespace it body)
+ (-> Namespace Declaration
+ Declaration)
+ (nominal.abstraction
+ (%.format "namespace"
+ " " it
+ " " (..block body))))
... https://en.cppreference.com/w/cpp/types/integer
(with_template [<name>]
@@ -104,11 +320,31 @@
[int64_t]
)
+ (def safe
+ (-> Text
+ Text)
+ (let [\\'' (%.format "\" text.\'')]
+ (`` (|>> (,, (with_template [<find> <replace>]
+ [(text.replaced <find> <replace>)]
+
+ ["\" "\\"]
+ [text.\t "\t"]
+ [text.\v "\v"]
+ [text.\0 "\0"]
+ [text.\b "\b"]
+ [text.\f "\f"]
+ [text.\n "\n"]
+ [text.\r "\r"]
+ [text.\'' \\'']
+ ))
+ ))))
+
... https://en.cppreference.com/w/cpp/string/basic_string
(def .public u32string
(-> Text
Literal)
- (|>> %.text
+ (|>> ..safe
+ %.text
(%.format "U")
nominal.abstraction))
)
diff --git a/stdlib/source/library/lux/meta/target/jvm/type.lux b/stdlib/source/library/lux/meta/target/jvm/type.lux
index 0eff5b048..e1cbb4374 100644
--- a/stdlib/source/library/lux/meta/target/jvm/type.lux
+++ b/stdlib/source/library/lux/meta/target/jvm/type.lux
@@ -45,7 +45,9 @@
(with_template [<name> <style>]
[(def .public (<name> type)
- (All (_ category) (-> (Type category) (<style> category)))
+ (All (_ category)
+ (-> (Type category)
+ (<style> category)))
(let [[signature descriptor reflection] (representation type)]
<name>))]
@@ -77,28 +79,32 @@
)
(def .public (array type)
- (-> (Type Value) (Type Array))
+ (-> (Type Value)
+ (Type Array))
(abstraction
[(/signature.array (..signature type))
(/descriptor.array (..descriptor type))
(/reflection.array (..reflection type))]))
(def .public (class name parameters)
- (-> External (List (Type Parameter)) (Type Class))
+ (-> External (List (Type Parameter))
+ (Type Class))
(abstraction
[(/signature.class name (list#each ..signature parameters))
(/descriptor.class name)
(/reflection.class name)]))
(def .public (declaration name variables)
- (-> External (List (Type Var)) (Type Declaration))
+ (-> External (List (Type Var))
+ (Type Declaration))
(abstraction
[(/signature.declaration name (list#each ..signature variables))
(/descriptor.declaration name)
(/reflection.declaration name)]))
(def .public (as_class type)
- (-> (Type Declaration) (Type Class))
+ (-> (Type Declaration)
+ (Type Class))
(abstraction
(let [[signature descriptor reflection] (representation type)]
[(/signature.as_class signature)
@@ -113,14 +119,16 @@
/reflection.wildcard]))
(def .public (var name)
- (-> Text (Type Var))
+ (-> Text
+ (Type Var))
(abstraction
[(/signature.var name)
/descriptor.var
/reflection.var]))
(def .public (lower bound)
- (-> (Type Parameter) (Type Parameter))
+ (-> (Type Parameter)
+ (Type Parameter))
(abstraction
(let [[signature descriptor reflection] (representation bound)]
[(/signature.lower signature)
@@ -128,7 +136,8 @@
(/reflection.lower reflection)])))
(def .public (upper bound)
- (-> (Type Parameter) (Type Parameter))
+ (-> (Type Parameter)
+ (Type Parameter))
(abstraction
(let [[signature descriptor reflection] (representation bound)]
[(/signature.upper signature)
@@ -151,7 +160,8 @@
(as_expected ..void)]))
(def .public equivalence
- (All (_ category) (Equivalence (Type category)))
+ (All (_ category)
+ (Equivalence (Type category)))
(implementation
(def (= parameter subject)
(of /signature.equivalence =
@@ -159,14 +169,16 @@
(..signature subject)))))
(def .public hash
- (All (_ category) (Hash (Type category)))
+ (All (_ category)
+ (Hash (Type category)))
(implementation
(def equivalence ..equivalence)
(def hash (|>> ..signature (of /signature.hash hash)))))
(def .public (primitive? type)
- (-> (Type Value) (Either (Type Object)
- (Type Primitive)))
+ (-> (Type Value)
+ (Either (Type Object)
+ (Type Primitive)))
(if (`` (or (,, (with_template [<type>]
[(of ..equivalence = (is (Type Value) <type>) type)]
@@ -182,8 +194,9 @@
(|> type (as (Type Object)) {.#Left})))
(def .public (void? type)
- (-> (Type Return) (Either (Type Value)
- (Type Void)))
+ (-> (Type Return)
+ (Either (Type Value)
+ (Type Void)))
(if (`` (or (,, (with_template [<type>]
[(of ..equivalence = (is (Type Return) <type>) type)]
@@ -193,7 +206,8 @@
)
(def .public (class? type)
- (-> (Type Value) (Maybe External))
+ (-> (Type Value)
+ (Maybe External))
(let [repr (|> type ..descriptor /descriptor.descriptor)]
(if (and (text.starts_with? /descriptor.class_prefix repr)
(text.ends_with? /descriptor.class_suffix repr))
@@ -208,5 +222,6 @@
{.#None})))
(def .public format
- (All (_ a) (Format (Type a)))
+ (All (_ of)
+ (Format (Type of)))
(|>> ..signature /signature.signature))
diff --git a/stdlib/source/library/lux/meta/target/python.lux b/stdlib/source/library/lux/meta/target/python.lux
index a6d0968c5..c1c8fe105 100644
--- a/stdlib/source/library/lux/meta/target/python.lux
+++ b/stdlib/source/library/lux/meta/target/python.lux
@@ -1,7 +1,6 @@
(.require
[library
[lux (.except Location Code not or and list if int comment exec try the is def when)
- ["[0]" ffi]
[abstract
[equivalence (.only Equivalence)]
[hash (.only Hash)]
@@ -18,7 +17,6 @@
["n" nat]
["f" frac]]]
[meta
- ["@" target]
["[0]" code (.only)
["<[1]>" \\parser]]
[macro
@@ -34,14 +32,6 @@
(-> Text Text)
(text.enclosed ["(" ")"]))
-(for @.old (these (ffi.import java/lang/CharSequence
- "[1]::[0]")
-
- (ffi.import java/lang/String
- "[1]::[0]"
- (replace [java/lang/CharSequence java/lang/CharSequence] java/lang/String)))
- (these))
-
... Added the carriage return for better Windows compatibility.
(.def \n+
Text
@@ -50,12 +40,8 @@
(.def nested
(-> Text Text)
(.let [nested_new_line (format text.new_line text.tab)]
- (for @.old (|>> (format \n+)
- (as java/lang/String)
- (java/lang/String::replace (as java/lang/CharSequence text.new_line)
- (as java/lang/CharSequence nested_new_line)))
- (|>> (format \n+)
- (text.replaced text.new_line nested_new_line)))))
+ (|>> (format \n+)
+ (text.replaced text.new_line nested_new_line))))
(nominal.def .public (Code brand)
Text
diff --git a/stdlib/source/specification/aedifex/repository.lux b/stdlib/source/specification/aedifex/repository.lux
deleted file mode 100644
index 52a7e1bfe..000000000
--- a/stdlib/source/specification/aedifex/repository.lux
+++ /dev/null
@@ -1,59 +0,0 @@
-(.require
- [library
- [lux (.except)
- [abstract
- [monad (.only do)]]
- [control
- ["[0]" try (.only Try)]
- [concurrency
- ["[0]" async (.only Async)]]]
- [data
- ["[0]" binary (.only)
- ["_[1]" \\test]]]
- [math
- ["[0]" random]]
- [test
- ["[0]" unit]
- ["_" property (.only Test)]]]]
- [\\program
- ["[0]" / (.only)
- ["[1][0]" remote]
- ["/[1]" //
- ["[1][0]" artifact (.only Artifact)
- ["[1]/[0]" extension]]]]]
- [\\test
- ["_[0]" //
- ["[1][0]" artifact]]])
-
-(def .public (spec valid_artifact invalid_artifact subject)
- (-> Artifact Artifact (/.Repository Async) Test)
- (do random.monad
- [expected (_binary.random 100)]
- (in (all unit.and
- (do async.monad
- [.let [good_uri (/remote.uri (the //artifact.#version valid_artifact) valid_artifact //artifact/extension.lux_library)]
- good_upload! (of subject upload good_uri expected)
- good_download! (of subject download good_uri)
-
- .let [bad_uri (/remote.uri (the //artifact.#version invalid_artifact) invalid_artifact //artifact/extension.lux_library)]
- bad_upload! (of subject upload bad_uri expected)
- bad_download! (of subject download bad_uri)]
- (unit.coverage [/.Repository]
- (let [successfull_flow!
- (when [good_upload! good_download!]
- [{try.#Success _} {try.#Success actual}]
- (of binary.equivalence = expected actual)
-
- _
- false)
-
- failed_flow!
- (when [bad_upload! bad_download!]
- [{try.#Failure _} {try.#Failure _}]
- true
-
- _
- false)]
- (and successfull_flow!
- failed_flow!))))
- ))))
diff --git a/stdlib/source/specification/compositor.lux b/stdlib/source/specification/compositor.lux
deleted file mode 100644
index f6fb3f280..000000000
--- a/stdlib/source/specification/compositor.lux
+++ /dev/null
@@ -1,69 +0,0 @@
-(.require
- [library
- [lux (.except)
- [abstract
- [monad (.only do)]]
- [control
- ["[0]" io (.only IO)]
- ["[0]" try]]
- [math
- ["r" random]]
- [meta
- [compiler
- ["[0]" analysis]
- ["[0]" declaration]
- [phase
- [macro (.only Expander)]
- [translation (.only Bundle)]]
- [default
- [platform (.only Platform)]]]]
- [test
- ["_" property (.only Test)]]]]
- ["[0]" /
- ["[1][0]" common (.only Runner Definer)]
- ["[1]./" analysis
- ["[1][0]" type]]
- ["[1]./" translation
- ["[1][0]" primitive]
- ["[1][0]" structure]
- ["[1][0]" reference]
- ["[1][0]" when]
- ["[1][0]" function]
- ["[1][0]" common]]])
-
-(def (test runner definer state expander)
- (-> Runner Definer analysis.State Expander Test)
- (all _.and
- (/analysis/type.spec expander state)
- (/translation/primitive.spec runner)
- (/translation/structure.spec runner)
- (/translation/reference.spec runner definer)
- (/translation/when.spec runner)
- (/translation/function.spec runner)
- (/translation/common.spec runner)
- ))
-
-(def .public (spec platform bundle expander program)
- (All (_ anchor expression declaration)
- (-> (IO (Platform IO anchor expression declaration))
- (Bundle anchor expression declaration)
- Expander
- (-> expression declaration)
- Test))
- (do r.monad
- [_ (in [])
- .let [?state,runner,definer (<| io.run!
- (do io.monad
- [platform platform])
- (/common.executors platform
- bundle
- expander
- program))]]
- (when ?state,runner,definer
- {try.#Success [[declaration_bundle declaration_state] runner definer]}
- (..test runner definer
- (the [declaration.#analysis declaration.#state] declaration_state)
- expander)
-
- {try.#Failure error}
- (_.failure error))))
diff --git a/stdlib/source/specification/compositor/analysis/type.lux b/stdlib/source/specification/compositor/analysis/type.lux
deleted file mode 100644
index 726e438c9..000000000
--- a/stdlib/source/specification/compositor/analysis/type.lux
+++ /dev/null
@@ -1,65 +0,0 @@
-(.require
- [library
- [lux (.except)
- [abstract
- [monad (.only do)]]
- [control
- ["[0]" pipe]
- ["[0]" io]
- ["[0]" try]]
- [math
- ["r" random (.only Random)]]
- [meta
- ["[0]" code]
- [compiler
- [analysis (.only State)]
- ["[0]" phase
- [macro (.only Expander)]
- ["[0]" analysis
- ["[1]/[0]" scope]
- ["[1]/[0]" type]]]]]
- [test
- ["_" property (.only Test)]]]])
-
-(def (check_success+ expander state extension params output_type)
- (-> Expander State Text (List Code) Type Bit)
- (|> (analysis/scope.with_scope ""
- (analysis/type.with_type output_type
- (analysis.phase expander (` ((, (code.text extension)) (,* params))))))
- (phase.result state)
- (pipe.when
- {try.#Success _}
- true
-
- {try.#Failure _}
- false)))
-
-(def check
- (Random [Code Type Code])
- (`` (all r.either
- (,, (with_template [<random> <type> <code>]
- [(do r.monad
- [value <random>]
- (in [(` <type>)
- <type>
- (<code> value)]))]
-
- [r.bit {0 #0 "#Bit" {0 #0}} code.bit]
- [r.nat {0 #0 "#I64" {0 #1 {0 #0 "#Nat" {0 #0}} {0 #0}}} code.nat]
- [r.int {0 #0 "#I64" {0 #1 {0 #0 "#Int" {0 #0}} {0 #0}}} code.int]
- [r.rev {0 #0 "#I64" {0 #1 {0 #0 "#Rev" {0 #0}} {0 #0}}} code.rev]
- [r.safe_frac {0 #0 "#Frac" {0 #0}} code.frac]
- [(r.upper_case_alpha 5) {0 #0 "#Text" {0 #0}} code.text]
- )))))
-
-(def .public (spec expander state)
- (-> Expander State Test)
- (do r.monad
- [[typeC exprT exprC] ..check
- [other_typeC other_exprT other_exprC] ..check]
- (all _.and
- (_.test "lux check"
- (check_success+ expander state "lux check" (list typeC exprC) exprT))
- (_.test "lux coerce"
- (check_success+ expander state "lux coerce" (list typeC other_exprC) exprT))
- )))
diff --git a/stdlib/source/specification/compositor/common.lux b/stdlib/source/specification/compositor/common.lux
deleted file mode 100644
index 6045d8db1..000000000
--- a/stdlib/source/specification/compositor/common.lux
+++ /dev/null
@@ -1,80 +0,0 @@
-(.require
- [lux (.except)
- [abstract
- [monad (.only do)]]
- [control
- ["[0]" io (.only IO)]
- ["[0]" try (.only Try)]]
- [meta
- [compiler
- ["[0]" reference]
- ["[0]" analysis]
- ["[0]" synthesis (.only Synthesis)]
- ["[0]" declaration]
- ["[0]" phase
- ["[0]" macro (.only Expander)]
- ["[0]" translation (.only Operation)]
- [extension (.only Extender)
- ["[0]" bundle]]]
- [default
- ["[0]" platform (.only Platform)]]]]])
-
-(type .public Runner
- (-> Text Synthesis (Try Any)))
-
-(type .public Definer
- (-> Symbol Synthesis (Try Any)))
-
-(type .public (Instancer what)
- (All (_ anchor expression declaration)
- (-> (Platform IO anchor expression declaration)
- (translation.State anchor expression declaration)
- what)))
-
-(def (runner (open "[0]") state)
- (Instancer Runner)
- (function (_ evaluation_name expressionS)
- (do try.monad
- [expressionG (<| (phase.result state)
- translation.with_buffer
- (do phase.monad
- [_ runtime]
- (phase expressionS)))]
- (of host evaluate! evaluation_name expressionG))))
-
-(def (definer (open "[0]") state)
- (Instancer Definer)
- (function (_ lux_name expressionS)
- (do try.monad
- [definitionG (<| (phase.result state)
- translation.with_buffer
- (do phase.monad
- [_ runtime
- expressionG (phase expressionS)
- [host_name host_value host_declaration] (translation.define! lux_name expressionG)
- _ (translation.learn lux_name host_name)]
- (phase (synthesis.constant lux_name))))]
- (of host evaluate! "definer" definitionG))))
-
-(def .public (executors target expander platform
- analysis_bundle translation_bundle declaration_bundle
- program extender)
- (All (_ anchor expression declaration)
- (-> Text Expander (Platform IO anchor expression declaration)
- analysis.Bundle
- (translation.Bundle anchor expression declaration)
- (declaration.Bundle anchor expression declaration)
- (-> expression declaration) Extender
- (IO (Try [(declaration.State anchor expression declaration)
- Runner
- Definer]))))
- (do io.monad
- [?state (platform.initialize target expander analysis_bundle platform translation_bundle declaration_bundle program extender)]
- (in (do try.monad
- [[declaration_bundle declaration_state] ?state
- .let [translation_state (the [declaration.#translation
- declaration.#state]
- declaration_state)]]
- (in [[declaration_bundle declaration_state]
- (..runner platform translation_state)
- (..definer platform translation_state)])))))
diff --git a/stdlib/source/specification/compositor/generation/case.lux b/stdlib/source/specification/compositor/generation/case.lux
deleted file mode 100644
index 5b36db339..000000000
--- a/stdlib/source/specification/compositor/generation/case.lux
+++ /dev/null
@@ -1,290 +0,0 @@
-(.require
- [library
- [lux (.except when)
- [abstract
- [monad (.only do)]]
- [control
- ["[0]" pipe]
- ["[0]" try (.only Try)]]
- [data
- ["[0]" text (.use "[1]#[0]" equivalence)
- ["%" \\format (.only format)]]
- [number
- ["n" nat]
- ["f" frac]]
- [collection
- ["[0]" list (.use "[1]#[0]" mix)]]]
- [math
- ["r" random (.only Random)]]
- [meta
- [compiler
- ["[0]" reference]
- ["[0]" analysis]
- ["[0]" synthesis (.only Path Synthesis)]
- ["[0]" phase
- ["[1]/[0]" synthesis
- ["[0]" when]]
- ["[0]" extension/synthesis]]]]
- [test
- ["_" property (.only Test)]]]]
- [///
- [common (.only Runner)]])
-
-(def limit Nat 10)
-
-(def size
- (Random Nat)
- (|> r.nat (of r.monad each (|>> (n.% ..limit) (n.max 2)))))
-
-(def (tail? size idx)
- (-> Nat Nat Bit)
- (n.= (-- size) idx))
-
-(def .public (verify expected)
- (-> Frac (Try Any) Bit)
- (|>> (pipe.when
- {try.#Success actual}
- (f.= expected (as Frac actual))
-
- {try.#Failure _}
- false)))
-
-(def when
- (Random [Synthesis Path])
- (<| r.rec (function (_ when))
- (`` (all r.either
- (do r.monad
- [value r.i64]
- (in [(synthesis.i64 value)
- synthesis.path/pop]))
- (,, (with_template [<gen> <synth> <path>]
- [(do r.monad
- [value <gen>]
- (in [(<synth> value)
- (<path> value)]))]
-
- [r.bit synthesis.bit synthesis.path/bit]
- [r.i64 synthesis.i64 synthesis.path/i64]
- [r.frac synthesis.f64 synthesis.path/f64]
- [(r.unicode 5) synthesis.text synthesis.path/text]))
- (do [! r.monad]
- [size ..size
- idx (|> r.nat (of ! each (n.% size)))
- [subS subP] when
- .let [unitS (synthesis.text synthesis.unit)
- whenS (synthesis.tuple
- (list.together (list (list.repeated idx unitS)
- (list subS)
- (list.repeated (|> size -- (n.- idx)) unitS))))
- whenP (all synthesis.path/seq
- (if (tail? size idx)
- (synthesis.member/right idx)
- (synthesis.member/left idx))
- subP)]]
- (in [whenS whenP]))
- (do [! r.monad]
- [size ..size
- idx (|> r.nat (of ! each (n.% size)))
- [subS subP] when
- .let [right? (tail? size idx)
- whenS (synthesis.variant
- [analysis.#lefts idx
- analysis.#right? right?
- analysis.#value subS])
- whenP (all synthesis.path/seq
- (if right?
- (synthesis.side/right idx)
- (synthesis.side/left idx))
- subP)]]
- (in [whenS whenP]))
- ))))
-
-(def (let_spec run)
- (-> Runner Test)
- (do r.monad
- [value r.safe_frac]
- (_.test (%.symbol (symbol synthesis.branch/let))
- (|> (synthesis.branch/let [(synthesis.f64 value)
- 0
- (synthesis.variable/local 0)])
- (run "let_spec")
- (verify value)))))
-
-(def (if_spec run)
- (-> Runner Test)
- (do r.monad
- [on_true r.safe_frac
- on_false (|> r.safe_frac (r.only (|>> (f.= on_true) not)))
- verdict r.bit]
- (_.test (%.symbol (symbol synthesis.branch/if))
- (|> (synthesis.branch/if [(synthesis.bit verdict)
- (synthesis.f64 on_true)
- (synthesis.f64 on_false)])
- (run "if_spec")
- (verify (if verdict on_true on_false))))))
-
-(def (when_spec run)
- (-> Runner Test)
- (do r.monad
- [[inputS pathS] ..when
- on_success r.safe_frac
- on_failure (|> r.safe_frac (r.only (|>> (f.= on_success) not)))]
- (_.test (%.symbol (symbol synthesis.branch/when))
- (|> (synthesis.branch/when
- [inputS
- (all synthesis.path/alt
- (all synthesis.path/seq
- pathS
- (synthesis.path/then (synthesis.f64 on_success)))
- (synthesis.path/then (synthesis.f64 on_failure)))])
- (run "when_spec")
- (verify on_success)))))
-
-(def special_input
- Synthesis
- (let [_cursor_ (is Synthesis
- (synthesis.tuple (list (synthesis.text .prelude)
- (synthesis.i64 +901)
- (synthesis.i64 +13))))
- _code_ (is (-> Synthesis Synthesis)
- (function (_ content)
- (synthesis.tuple (list _cursor_ content))))
- _end_ (is Synthesis
- (synthesis.variant [0 #0 (synthesis.text "")]))
- _item_ (is (-> Synthesis Synthesis Synthesis)
- (function (_ head tail)
- (synthesis.variant [0 #1 (synthesis.tuple (list head tail))])))
- _list_ (is (-> (List Synthesis) Synthesis)
- (list#mix _item_ _end_))]
- (let [__tuple__ (is (-> (List Synthesis) Synthesis)
- (|>> list.reversed _list_ [9 #0] synthesis.variant _code_))
- __form__ (is (-> (List Synthesis) Synthesis)
- (|>> list.reversed _list_ [7 #0] synthesis.variant _code_))
- __text__ (is (-> Text Synthesis)
- (function (_ value)
- (_code_ (synthesis.variant [5 #0 (synthesis.text value)]))))
- __symbol__ (is (-> Symbol Synthesis)
- (function (_ [module short])
- (_code_ (synthesis.variant [6 #0 (synthesis.tuple (list (synthesis.text module)
- (synthesis.text short)))]))))
- __list__ (is (-> (List Synthesis) Synthesis)
- (list#mix (function (_ head tail)
- (__form__ (list (__tag__ ["" "Item"]) head tail)))
- (__tag__ ["" "End"])))
- __apply__ (is (-> Synthesis Synthesis Synthesis)
- (function (_ func arg)
- (__form__ (list func arg))))]
- (|> _end_
- (_item_ (__apply__ (__symbol__ ["" "form$"])
- (__list__ (list (__apply__ (__symbol__ ["" "tag$"])
- (__tuple__ (list (__text__ .prelude)
- (__text__ "Item"))))
- (__symbol__ ["" "export?-meta"])
- (__symbol__ ["" "tail"])))))
- (_item_ (__tuple__ (list (__symbol__ ["" "tail"]))))
- ))))
-
-(def special_path
- Path
- (let [_end_ (synthesis.path/side {.#Left 0})
- _item_ (synthesis.path/side {.#Right 0})
- _head_ (synthesis.path/member {.#Left 0})
- _tail_ (synthesis.path/member {.#Right 0})
- _tuple_ (synthesis.path/side {.#Left 9})]
- (all synthesis.path/alt
- (all synthesis.path/seq
- _item_
- _head_
- _head_ (synthesis.path/bind 2) synthesis.path/pop
- _tail_ _tuple_ _item_
- _head_ (synthesis.path/bind 3) synthesis.path/pop
- _tail_ (synthesis.path/bind 4) synthesis.path/pop
- synthesis.path/pop synthesis.path/pop synthesis.path/pop synthesis.path/pop
- _tail_ _item_
- _head_ (synthesis.path/bind 5) synthesis.path/pop
- _tail_ _end_
- ... THEN
- (synthesis.path/then (synthesis.bit #1)))
- (all synthesis.path/seq
- (synthesis.path/bind 2)
- ... THEN
- (synthesis.path/then (synthesis.bit #0))))))
-
-(def special_pattern
- analysis.Pattern
- (let [... [_ {#Tuple {#Item arg args'}}]
- head (<| analysis.pattern/tuple (list (analysis.pattern/bind 2))
- analysis.pattern/variant [9 #0]
- analysis.pattern/variant [0 #1]
- analysis.pattern/tuple (list (analysis.pattern/bind 3)
- (analysis.pattern/bind 4)))
- ... {#Item body {#End}}
- tail (<| analysis.pattern/variant [0 #1]
- analysis.pattern/tuple (list (analysis.pattern/bind 5))
- analysis.pattern/variant [0 #0]
- (analysis.pattern/unit))]
- ... {#Item <head> <tail>}
- (<| analysis.pattern/variant [0 #1]
- (analysis.pattern/tuple (list head tail)))))
-
-(def special_pattern_path
- Path
- (all synthesis.path/alt
- (<| try.trusted
- (phase.result [extension/synthesis.bundle
- synthesis.init])
- (when.path phase/synthesis.phase
- special_pattern)
- (analysis.bit #1))
- (all synthesis.path/seq
- (synthesis.path/bind 2)
- ... THEN
- (synthesis.path/then (synthesis.bit #0)))))
-
-... TODO: Get rid of this ASAP
-(def (special_spec run)
- (-> Runner Test)
- (all _.and
- (_.test "==="
- (and (text#= (synthesis.%path special_path)
- (synthesis.%path special_pattern_path))
- (of synthesis.path_equivalence = special_path special_pattern_path)))
- (_.test "CODE"
- (|> special_input
- (run "special_input")
- (pipe.when
- {try.#Success output}
- true
-
- {try.#Failure _}
- false)))
- (_.test "PATTERN_MATCHING 0"
- (|> (synthesis.branch/when [special_input
- special_path])
- (run "special_path")
- (pipe.when
- {try.#Success output}
- true
-
- {try.#Failure _}
- false)))
- (_.test "PATTERN_MATCHING 1"
- (|> (synthesis.branch/when [special_input
- special_pattern_path])
- (run "special_pattern_path")
- (pipe.when
- {try.#Success output}
- true
-
- {try.#Failure _}
- false)))
- ))
-
-(def .public (spec run)
- (-> Runner Test)
- (all _.and
- (..special_spec run)
- (..let_spec run)
- (..if_spec run)
- (..when_spec run)
- ))
diff --git a/stdlib/source/specification/compositor/generation/common.lux b/stdlib/source/specification/compositor/generation/common.lux
deleted file mode 100644
index acb782c1f..000000000
--- a/stdlib/source/specification/compositor/generation/common.lux
+++ /dev/null
@@ -1,350 +0,0 @@
-(.require
- [library
- [lux (.except i64)
- [abstract
- [monad (.only do)]]
- [control
- ["[0]" pipe]
- ["[0]" try (.only Try)]]
- [data
- ["[0]" bit (.use "[1]#[0]" equivalence)]
- [number
- ["[0]" i64]
- ["n" nat]
- ["i" int]
- ["f" frac]]
- ["[0]" text (.use "[1]#[0]" equivalence)
- ["%" \\format (.only format)]]
- [collection
- ["[0]" list]]]
- [math
- ["r" random (.only Random)]]
- [meta
- [macro
- ["^" pattern]]
- [compiler
- ["[0]" reference]
- ["[0]" synthesis]]]
- [test
- ["_" property (.only Test)]]]]
- ["[0]" //
- ["[1][0]" when]
- [//
- [common (.only Runner)]]])
-
-(def safe
- (-> Text Text)
- (text.replaced " " "_"))
-
-(def (bit run)
- (-> Runner Test)
- (do r.monad
- [param r.i64
- subject r.i64]
- (with_expansions [<binary> (with_template [<extension> <reference> <param_expr>]
- [(_.test <extension>
- (|> {synthesis.#Extension (symbol <extension>) (list (synthesis.i64 param)
- (synthesis.i64 subject))}
- (run (..safe <extension>))
- (pipe.when
- {try.#Success valueT}
- (n.= (<reference> param subject) (as Nat valueT))
-
- {try.#Failure _}
- false)
- (let [param <param_expr>])))]
-
- [.i64_and# i64.and param]
- [.i64_or# i64.or param]
- [.i64_xor# i64.xor param]
- [.i64_left# i64.left_shifted (n.% 64 param)]
- ["lux i64 logical-right-shift" i64.logic_right_shifted (n.% 64 param)]
- )]
- (all _.and
- <binary>
- (_.test "lux i64 arithmetic-right-shift"
- (|> {synthesis.#Extension "lux i64 arithmetic-right-shift"
- (list (synthesis.i64 subject)
- (synthesis.i64 param))}
- (run (..safe "lux i64 arithmetic-right-shift"))
- (pipe.when
- {try.#Success valueT}
- (.i64_=# (i64.arithmetic_right_shifted param subject)
- (as I64 valueT))
-
- {try.#Failure _}
- false)
- (let [param (n.% 64 param)])))
- ))))
-
-(def (i64 run)
- (-> Runner Test)
- (do r.monad
- [param (|> r.i64 (r.only (|>> (.i64_=# 0) not)))
- subject r.i64]
- (`` (all _.and
- (,, (with_template [<extension> <type> <prepare> <comp> <subject_expr>]
- [(_.test <extension>
- (|> {synthesis.#Extension (symbol <extension>) (list (synthesis.i64 subject))}
- (run (..safe <extension>))
- (pipe.when
- {try.#Success valueT}
- (<comp> (<prepare> subject) (as <type> valueT))
-
- {try.#Failure _}
- false)
- (let [subject <subject_expr>])))]
-
- [.int_f64# Frac i.frac f.= subject]
- [.int_char# Text (|>> (as Nat) text.from_code) text#= (|> subject
- (as Nat)
- (n.% (i64.left_shifted 8 1))
- (as Int))]
- ))
- (,, (with_template [<extension> <reference> <outputT> <comp>]
- [(_.test <extension>
- (|> {synthesis.#Extension (symbol <extension>) (list (synthesis.i64 param)
- (synthesis.i64 subject))}
- (run (..safe <extension>))
- (pipe.when
- {try.#Success valueT}
- (<comp> (<reference> param subject) (as <outputT> valueT))
-
- {try.#Failure _}
- false)))]
-
- [.i64_+# i.+ Int i.=]
- [.i64_-# i.- Int i.=]
- [.i64_=# i.= Bit bit#=]
-
- [.int_<# i.< Bit bit#=]
- [.int_*# i.* Int i.=]
- [.int_/# i./ Int i.=]
- [.int_%# i.% Int i.=]
- ))
- ))))
-
-(def simple_frac
- (Random Frac)
- (|> r.nat (of r.monad each (|>> (n.% 1000) .int i.frac))))
-
-(def (f64 run)
- (-> Runner Test)
- (do r.monad
- [param (|> ..simple_frac (r.only (|>> (f.= +0.0) not)))
- subject ..simple_frac]
- (`` (all _.and
- (,, (with_template [<extension> <reference> <comp>]
- [(_.test <extension>
- (|> {synthesis.#Extension (symbol <extension>) (list (synthesis.f64 param)
- (synthesis.f64 subject))}
- (run (..safe <extension>))
- (//when.verify (<reference> param subject))))]
-
- [.f64_+# f.+ f.=]
- [.f64_-# f.- f.=]
- [.f64_*# f.* f.=]
- [.f64_/# f./ f.=]
- [.f64_%# f.% f.=]
- ))
- (,, (with_template [<extension> <text>]
- [(_.test <extension>
- (|> {synthesis.#Extension (symbol <extension>) (list (synthesis.f64 param)
- (synthesis.f64 subject))}
- (run (..safe <extension>))
- (pipe.when
- {try.#Success valueV}
- (bit#= (<text> param subject)
- (as Bit valueV))
-
- _
- false)))]
-
- [.f64_=# f.=]
- [.f64_<# f.<]
- ))
- (_.test ".f64_int# && .int_f64#"
- (|> (run (..safe .f64_int#)
- (|> subject synthesis.f64
- (list) {synthesis.#Extension (symbol .f64_int#)}
- (list) {synthesis.#Extension (symbol .int_f64#)}))
- (//when.verify subject)))
- ))))
-
-(def (text run)
- (-> Runner Test)
- (do [! r.monad]
- [sample_size (|> r.nat (of ! each (|>> (n.% 10) (n.max 1))))
- sample_lower (r.lower_case_alpha sample_size)
- sample_upper (r.upper_case_alpha sample_size)
- sample_alpha (|> (r.alphabetic sample_size)
- (r.only (|>> (text#= sample_upper) not)))
- char_idx (|> r.nat (of ! each (n.% sample_size)))
- .let [sample_lowerS (synthesis.text sample_lower)
- sample_upperS (synthesis.text sample_upper)
- sample_alphaS (synthesis.text sample_alpha)
- concatenatedS {synthesis.#Extension (symbol .text_composite#) (list sample_lowerS sample_upperS)}
- pre_rep_once (format sample_lower sample_upper)
- post_rep_once (format sample_lower sample_alpha)
- pre_rep_all (|> sample_lower (list.repeated sample_size) (text.interposed sample_upper))
- post_rep_all (|> sample_lower (list.repeated sample_size) (text.interposed sample_alpha))]]
- (all _.and
- (_.test "Can compare texts for equality."
- (and (|> {synthesis.#Extension (symbol .text_=#) (list sample_lowerS sample_lowerS)}
- (run (..safe .text_=#))
- (pipe.when
- {try.#Success valueV}
- (as Bit valueV)
-
- _
- false))
- (|> {synthesis.#Extension (symbol .text_=#) (list sample_upperS sample_lowerS)}
- (run (..safe .text_=#))
- (pipe.when
- {try.#Success valueV}
- (not (as Bit valueV))
-
- _
- false))))
- (_.test "Can compare texts for order."
- (|> {synthesis.#Extension (symbol .text_<#) (list sample_lowerS sample_upperS)}
- (run (..safe .text_<#))
- (pipe.when
- {try.#Success valueV}
- (as Bit valueV)
-
- {try.#Failure _}
- false)))
- (_.test "Can get length of text."
- (|> {synthesis.#Extension (symbol .text_size#) (list sample_lowerS)}
- (run (..safe .text_size#))
- (pipe.when
- {try.#Success valueV}
- (n.= sample_size (as Nat valueV))
-
- _
- false)))
- (_.test "Can concatenate text."
- (|> {synthesis.#Extension (symbol .text_size#) (list concatenatedS)}
- (run (..safe .text_size#))
- (pipe.when
- {try.#Success valueV}
- (n.= (n.* 2 sample_size) (as Nat valueV))
-
- _
- false)))
- (_.test "Can find index of sub-text."
- (and (|> {synthesis.#Extension (symbol .text_index#)
- (list concatenatedS sample_lowerS
- (synthesis.i64 +0))}
- (run (..safe .text_index#))
- (pipe.when
- (^.multi {try.#Success valueV}
- [(as (Maybe Nat) valueV)
- {.#Some valueV}])
- (n.= 0 valueV)
-
- _
- false))
- (|> {synthesis.#Extension (symbol .text_index#)
- (list concatenatedS sample_upperS
- (synthesis.i64 +0))}
- (run (..safe .text_index#))
- (pipe.when
- (^.multi {try.#Success valueV}
- [(as (Maybe Nat) valueV)
- {.#Some valueV}])
- (n.= sample_size valueV)
-
- _
- false))))
- (let [test_clip (is (-> (I64 Any) (I64 Any) Text Bit)
- (function (_ offset length expected)
- (|> {synthesis.#Extension (symbol .text_clip#)
- (list concatenatedS
- (synthesis.i64 offset)
- (synthesis.i64 length))}
- (run (..safe .text_clip#))
- (pipe.when
- (^.multi {try.#Success valueV}
- [(as (Maybe Text) valueV)
- {.#Some valueV}])
- (text#= expected valueV)
-
- _
- false))))]
- (_.test "Can clip text to extract sub-text."
- (and (test_clip 0 sample_size sample_lower)
- (test_clip sample_size sample_size sample_upper))))
- (_.test "Can extract individual characters from text."
- (|> {synthesis.#Extension (symbol .text_char#)
- (list sample_lowerS
- (synthesis.i64 char_idx))}
- (run (..safe .text_char#))
- (pipe.when
- (^.multi {try.#Success valueV}
- [(as (Maybe Int) valueV)
- {.#Some valueV}])
- (text.contains? (.int_char# valueV)
- sample_lower)
-
- _
- false)))
- )))
-
-(def (io run)
- (-> Runner Test)
- (do r.monad
- [message (r.alphabetic 5)]
- (all _.and
- (_.test "Can log messages."
- (|> {synthesis.#Extension .log!#
- (list (synthesis.text (format "LOG: " message)))}
- (run (..safe .log!#))
- (pipe.when
- {try.#Success valueV}
- true
-
- {try.#Failure _}
- false)))
- (_.test "Can throw runtime errors."
- (and (|> {synthesis.#Extension .try#
- (list (synthesis.function/abstraction
- [synthesis.#environment (list)
- synthesis.#arity 1
- synthesis.#body {synthesis.#Extension (symbol .error#)
- (list (synthesis.text message))}]))}
- (run (..safe .try#))
- (pipe.when
- (^.multi {try.#Success valueV}
- [(as (Try Text) valueV)
- {try.#Failure error}])
- (text.contains? message error)
-
- _
- false))
- (|> {synthesis.#Extension .try#
- (list (synthesis.function/abstraction
- [synthesis.#environment (list)
- synthesis.#arity 1
- synthesis.#body (synthesis.text message)]))}
- (run (..safe .try#))
- (pipe.when
- (^.multi {try.#Success valueV}
- [(as (Try Text) valueV)
- {try.#Success valueV}])
- (text#= message valueV)
-
- _
- false))))
- )))
-
-(def .public (spec runner)
- (-> Runner Test)
- (all _.and
- (..bit runner)
- (..i64 runner)
- (..f64 runner)
- (..text runner)
- (..io runner)
- ))
diff --git a/stdlib/source/specification/compositor/generation/function.lux b/stdlib/source/specification/compositor/generation/function.lux
deleted file mode 100644
index 63b025065..000000000
--- a/stdlib/source/specification/compositor/generation/function.lux
+++ /dev/null
@@ -1,96 +0,0 @@
-(.require
- [library
- [lux (.except function)
- [abstract
- [monad (.only do)]
- ["[0]" enum]]
- [control
- ["[0]" maybe]]
- [data
- [number
- ["n" nat]]
- [collection
- ["[0]" list (.use "[1]#[0]" functor)]]]
- [math
- ["r" random (.only Random) (.use "[1]#[0]" monad)]]
- [meta
- [compiler
- [analysis (.only Arity)]
- ["[0]" reference (.only Register)]
- ["[0]" synthesis (.only Synthesis)]]]]
- [test
- ["_" property (.only Test)]]]
- ["[0]" //
- ["[1][0]" case]
- [//
- [common (.only Runner)]]])
-
-(def max_arity
- Arity
- 10)
-
-(def arity
- (Random Arity)
- (|> r.nat (r#each (|>> (n.% max_arity) (n.max 1)))))
-
-(def (local arity)
- (-> Arity (Random Register))
- (|> r.nat (r#each (|>> (n.% arity) ++))))
-
-(def function
- (Random [Arity Register Synthesis])
- (do r.monad
- [arity ..arity
- local (..local arity)]
- (in [arity local
- (synthesis.function/abstraction
- [synthesis.#environment (list)
- synthesis.#arity arity
- synthesis.#body (synthesis.variable/local local)])])))
-
-(def .public (spec run)
- (-> Runner Test)
- (do [! r.monad]
- [[arity local functionS] ..function
- partial_arity (|> r.nat (of ! each (|>> (n.% arity) (n.max 1))))
- inputs (r.list arity r.safe_frac)
- .let [expectation (maybe.trusted (list.item (-- local) inputs))
- inputsS (list#each (|>> synthesis.f64) inputs)]]
- (all _.and
- (_.test "Can read arguments."
- (|> (synthesis.function/apply [synthesis.#function functionS
- synthesis.#arguments inputsS])
- (run "with_local")
- (//case.verify expectation)))
- (_.test "Can partially apply functions."
- (or (n.= 1 arity)
- (let [preS (list.first partial_arity inputsS)
- postS (list.after partial_arity inputsS)
- partialS (synthesis.function/apply [synthesis.#function functionS
- synthesis.#arguments preS])]
- (|> (synthesis.function/apply [synthesis.#function partialS
- synthesis.#arguments postS])
- (run "partial_application")
- (//case.verify expectation)))))
- (_.test "Can read environment."
- (or (n.= 1 arity)
- (let [environment (|> partial_arity
- (enum.range n.enum 1)
- (list#each (|>> {reference.#Local})))
- variableS (if (n.<= partial_arity local)
- (synthesis.variable/foreign (-- local))
- (synthesis.variable/local (|> local (n.- partial_arity))))
- inner_arity (n.- partial_arity arity)
- innerS (synthesis.function/abstraction
- [synthesis.#environment environment
- synthesis.#arity inner_arity
- synthesis.#body variableS])
- outerS (synthesis.function/abstraction
- [synthesis.#environment (list)
- synthesis.#arity partial_arity
- synthesis.#body innerS])]
- (|> (synthesis.function/apply [synthesis.#function outerS
- synthesis.#arguments inputsS])
- (run "with_foreign")
- (//case.verify expectation)))))
- )))
diff --git a/stdlib/source/specification/compositor/generation/primitive.lux b/stdlib/source/specification/compositor/generation/primitive.lux
deleted file mode 100644
index 167f219e8..000000000
--- a/stdlib/source/specification/compositor/generation/primitive.lux
+++ /dev/null
@@ -1,51 +0,0 @@
-(.require
- [library
- [lux (.except)
- [abstract
- [monad (.only do)]]
- [control
- ["[0]" pipe]
- ["[0]" try]]
- [data
- ["[0]" bit (.use "[1]#[0]" equivalence)]
- [number
- ["f" frac]]
- ["[0]" text (.use "[1]#[0]" equivalence)
- ["%" \\format (.only format)]]]
- [math
- ["r" random]]
- [meta
- [compiler
- ["[0]" synthesis]]]
- [test
- ["_" property (.only Test)]]]]
- [///
- [common (.only Runner)]])
-
-(def (f/=' reference subject)
- (-> Frac Frac Bit)
- (or (f.= reference subject)
- (and (f.not_a_number? reference)
- (f.not_a_number? subject))))
-
-(def .public (spec run)
- (-> Runner Test)
- (`` (all _.and
- (,, (with_template [<evaluation_name> <synthesis> <gen> <test>]
- [(do r.monad
- [expected <gen>]
- (_.test (%.symbol (symbol <synthesis>))
- (|> (run <evaluation_name> (<synthesis> expected))
- (pipe.when
- {try.#Success actual}
- (<test> expected (as_expected actual))
-
- {try.#Failure _}
- false))))]
-
- ["bit" synthesis.bit r.bit bit#=]
- ["i64" synthesis.i64 r.i64 .i64_=#]
- ["f64" synthesis.f64 r.frac f.=']
- ["text" synthesis.text (r.ascii 5) text#=]
- ))
- )))
diff --git a/stdlib/source/specification/compositor/generation/reference.lux b/stdlib/source/specification/compositor/generation/reference.lux
deleted file mode 100644
index 74c556d80..000000000
--- a/stdlib/source/specification/compositor/generation/reference.lux
+++ /dev/null
@@ -1,64 +0,0 @@
-(.require
- [library
- [lux (.except symbol)
- [abstract
- [monad (.only do)]]
- [control
- ["[0]" pipe]
- ["[0]" try]]
- [data
- [number
- ["n" nat]
- ["f" frac]]]
- [meta
- [compiler
- ["[0]" reference]
- ["[0]" synthesis]]]
- [math
- ["r" random (.only Random)]]
- [test
- ["_" property (.only Test)]]]]
- [///
- [common (.only Runner Definer)]])
-
-(def symbol
- (Random Symbol)
- (let [symbol_part (r.upper_case_alpha 5)]
- [(r.and symbol_part symbol_part)]))
-
-(def (definition define)
- (-> Definer Test)
- (do r.monad
- [name ..symbol
- expected r.safe_frac]
- (_.test "Definitions."
- (|> (define name (synthesis.f64 expected))
- (pipe.when
- {try.#Success actual}
- (f.= expected (as Frac actual))
-
- {try.#Failure _}
- false)))))
-
-(def (variable run)
- (-> Runner Test)
- (do [! r.monad]
- [register (|> r.nat (of ! each (n.% 100)))
- expected r.safe_frac]
- (_.test "Local variables."
- (|> (synthesis.branch/let [(synthesis.f64 expected)
- register
- (synthesis.variable/local register)])
- (run "variable")
- (pipe.when
- {try.#Success actual}
- (f.= expected (as Frac actual))
-
- {try.#Failure _}
- false)))))
-
-(def .public (spec runner definer)
- (-> Runner Definer Test)
- (all _.and
- (..definition definer)
- (..variable runner)))
diff --git a/stdlib/source/specification/compositor/generation/structure.lux b/stdlib/source/specification/compositor/generation/structure.lux
deleted file mode 100644
index b28648520..000000000
--- a/stdlib/source/specification/compositor/generation/structure.lux
+++ /dev/null
@@ -1,93 +0,0 @@
-(.require
- [library
- [lux (.except)
- ["[0]" ffi (.only import)]
- [abstract
- [monad (.only do)]]
- [control
- ["[0]" pipe]
- ["[0]" maybe]
- ["[0]" try]]
- [data
- [number
- ["n" nat]
- ["i" int]]
- ["[0]" text (.use "[1]#[0]" equivalence)
- ["%" \\format (.only format)]]
- [collection
- ["[0]" array (.only Array)]
- ["[0]" list (.use "[1]#[0]" functor)]]]
- [math
- ["r" random]]
- [meta
- [compiler
- ["[0]" analysis]
- ["[0]" synthesis]]]
- [test
- ["_" property (.only Test)]]]]
- [///
- [common (.only Runner)]])
-
-(import java/lang/Integer)
-
-(def (variant run)
- (-> Runner Test)
- (do [! r.monad]
- [num_tags (|> r.nat (of ! each (|>> (n.% 10) (n.max 2))))
- tag_in (|> r.nat (of ! each (n.% num_tags)))
- .let [last?_in (|> num_tags -- (n.= tag_in))]
- value_in r.i64]
- (_.test (%.symbol (symbol synthesis.variant))
- (|> (synthesis.variant [analysis.#lefts (if last?_in
- (-- tag_in)
- tag_in)
- analysis.#right? last?_in
- analysis.#value (synthesis.i64 value_in)])
- (run "variant")
- (pipe.when
- {try.#Success valueT}
- (let [valueT (as (Array Any) valueT)]
- (and (n.= 3 (array.size valueT))
- (let [tag_out (as java/lang/Integer (maybe.trusted (array.read! 0 valueT)))
- last?_out (array.read! 1 valueT)
- value_out (as Any (maybe.trusted (array.read! 2 valueT)))
- same_tag? (|> tag_out ffi.int_to_long (as Nat) (n.= tag_in))
- same_flag? (when last?_out
- {.#Some last?_out'}
- (and last?_in (text#= "" (as Text last?_out')))
-
- {.#None}
- (not last?_in))
- same_value? (|> value_out (as Int) (i.= value_in))]
- (and same_tag?
- same_flag?
- same_value?))))
-
- {try.#Failure _}
- false)))))
-
-(def (tuple run)
- (-> Runner Test)
- (do [! r.monad]
- [size (|> r.nat (of ! each (|>> (n.% 10) (n.max 2))))
- tuple_in (r.list size r.i64)]
- (_.test (%.symbol (symbol synthesis.tuple))
- (|> (synthesis.tuple (list#each (|>> synthesis.i64) tuple_in))
- (run "tuple")
- (pipe.when
- {try.#Success tuple_out}
- (let [tuple_out (as (Array Any) tuple_out)]
- (and (n.= size (array.size tuple_out))
- (list.every? (function (_ [left right])
- (i.= left (as Int right)))
- (list.zipped_2 tuple_in (array.list tuple_out)))))
-
- {try.#Failure _}
- false)))))
-
-(def .public (spec runner)
- (-> Runner Test)
- (all _.and
- (..variant runner)
- (..tuple runner)
- ))
diff --git a/stdlib/source/test/aedifex.lux b/stdlib/source/test/aedifex.lux
index 8b859955e..c9ce5c95e 100644
--- a/stdlib/source/test/aedifex.lux
+++ b/stdlib/source/test/aedifex.lux
@@ -59,5 +59,5 @@
(program args
(<| io.io
_.run!
- (_.times 100)
+ (_.times 100 _.announce_success)
..test)))
diff --git a/stdlib/source/test/aedifex/artifact.lux b/stdlib/source/test/aedifex/artifact.lux
index 7e0d2c1cb..373393f2e 100644
--- a/stdlib/source/test/aedifex/artifact.lux
+++ b/stdlib/source/test/aedifex/artifact.lux
@@ -35,7 +35,8 @@
(all random.and
(random.lower_cased size)
(random.lower_cased size)
- (random.lower_cased size))))
+ (random.lower_cased size)
+ )))
(def .public test
Test
@@ -43,7 +44,9 @@
(do random.monad
[sample ..random])
(_.for [/.Group /.Name /.Version
- /.Artifact]
+
+ /.Artifact
+ /.#group /.#name /.#version]
(all _.and
(_.for [/.equivalence]
(equivalenceT.spec /.equivalence ..random))
diff --git a/stdlib/source/test/aedifex/dependency/deployment.lux b/stdlib/source/test/aedifex/dependency/deployment.lux
index 3e7350050..9db5b07b5 100644
--- a/stdlib/source/test/aedifex/dependency/deployment.lux
+++ b/stdlib/source/test/aedifex/dependency/deployment.lux
@@ -26,11 +26,12 @@
["n" nat]]]
[world
[net (.only URL)
- ["[0]" uri (.only URI)]
- ["[0]" http
- ["[1]" client]
- ["[1]/[0]" status]
- ["@[1]" /]]]]
+ [uri (.only URI)
+ ["[0]" path]]
+ ["[0]" http (.only)
+ [response (.only Response)]
+ ["[0]" client (.only Client)]
+ ["[0]" status]]]]
[test
["[0]" unit]
["_" property (.only Test)]]]]
@@ -52,25 +53,25 @@
["[0]" remote]]]]]])
(def good_upload
- (@http.Response IO)
- [http/status.created
- [@http.#headers (http.headers (list))
- @http.#body (function (_ _)
- (|> [0 (binary.empty 0)]
- {try.#Success}
- io.io))]])
+ (Response IO)
+ [status.created
+ [http.#headers (client.headers (list))
+ http.#body (function (_ _)
+ (|> [0 (binary.empty 0)]
+ {try.#Success}
+ io.io))]])
(type Cache
(Atom (Dictionary URL Binary)))
(def (http cache)
- (-> Cache (http.Client IO))
+ (-> Cache (Client IO))
(implementation
(def (request method url headers input)
(do io.monad
[_ (is (IO Any)
(when [method input]
- [{@http.#Put} {.#Some input}]
+ [{http.#Put} {.#Some input}]
(atom.update! (dictionary.has url input) cache)
_
@@ -149,7 +150,7 @@
Test
(<| (_.covering /._)
(do [! random.monad]
- [address (of ! each (text.suffix uri.separator)
+ [address (of ! each (text.suffix path.separator)
(random.upper_cased 10))]
(all _.and
(do [! random.monad]
diff --git a/stdlib/source/test/aedifex/repository.lux b/stdlib/source/test/aedifex/repository.lux
index f61f1ec50..6b4f02130 100644
--- a/stdlib/source/test/aedifex/repository.lux
+++ b/stdlib/source/test/aedifex/repository.lux
@@ -7,11 +7,14 @@
["[0]" monad (.only do)]]
[control
["[0]" io]
- ["[0]" try]
- ["[0]" exception (.only Exception)]]
+ ["[0]" try (.only Try)]
+ ["[0]" exception (.only Exception)]
+ [concurrency
+ ["[0]" async (.only Async)]]]
[data
["[0]" product]
- ["[0]" binary (.only Binary)]
+ ["[0]" binary (.only Binary)
+ ["_[1]" \\test]]
["[0]" text (.only)
["%" \\format (.only format)]]
[collection
@@ -22,7 +25,8 @@
[net
["[0]" uri (.only URI)]]]
[test
- ["_" property (.only Test)]]]]
+ ["_" property (.only Test)]
+ ["[0]" unit]]]]
["[0]" /
["[1][0]" identity]
["[1][0]" origin]
@@ -30,8 +34,6 @@
["[1][0]" remote]
[//
["@[0]" artifact]]]
- [\\specification
- ["$[0]" /]]
[\\program
["[0]" / (.only)
["[0]" remote]
@@ -39,6 +41,40 @@
["[1][0]" artifact (.only Version Artifact)
["[1]/[0]" extension (.only Extension)]]]]])
+(def .public (spec valid_artifact invalid_artifact subject)
+ (-> Artifact Artifact (/.Repository Async)
+ Test)
+ (do random.monad
+ [expected (_binary.random 100)]
+ (in (all unit.and
+ (do async.monad
+ [.let [good_uri (remote.uri (the //artifact.#version valid_artifact) valid_artifact //artifact/extension.lux_library)]
+ good_upload! (of subject upload good_uri expected)
+ good_download! (of subject download good_uri)
+
+ .let [bad_uri (remote.uri (the //artifact.#version invalid_artifact) invalid_artifact //artifact/extension.lux_library)]
+ bad_upload! (of subject upload bad_uri expected)
+ bad_download! (of subject download bad_uri)]
+ (unit.coverage [/.Repository]
+ (let [successfull_flow!
+ (when [good_upload! good_download!]
+ [{try.#Success _} {try.#Success actual}]
+ (of binary.equivalence = expected actual)
+
+ _
+ false)
+
+ failed_flow!
+ (when [bad_upload! bad_download!]
+ [{try.#Failure _} {try.#Failure _}]
+ true
+
+ _
+ false)]
+ (and successfull_flow!
+ failed_flow!))))
+ ))))
+
(def artifact
(-> Version Artifact)
(|>> ["com.github.luxlang" "test-artifact"]))
@@ -94,14 +130,14 @@
(_.for [/.mock /.Mock]
(do random.monad
[_ (in [])]
- ($/.spec (..artifact ..valid_version)
- (..artifact ..invalid_version)
- (/.mock ..mock
- (|> ..empty
- (dictionary.has (remote.uri ..invalid_version
- (..artifact ..invalid_version)
- //artifact/extension.lux_library)
- (binary.empty 0)))))))
+ (..spec (..artifact ..valid_version)
+ (..artifact ..invalid_version)
+ (/.mock ..mock
+ (|> ..empty
+ (dictionary.has (remote.uri ..invalid_version
+ (..artifact ..invalid_version)
+ //artifact/extension.lux_library)
+ (binary.empty 0)))))))
/identity.test
/origin.test
diff --git a/stdlib/source/test/lux/meta/compiler/language/lux/phase.lux b/stdlib/source/test/lux/meta/compiler/language/lux/phase.lux
index ce1def236..922290058 100644
--- a/stdlib/source/test/lux/meta/compiler/language/lux/phase.lux
+++ b/stdlib/source/test/lux/meta/compiler/language/lux/phase.lux
@@ -29,7 +29,8 @@
["[1][0]" translation
["[1]/[0]" jvm
["[1]/[0]" host]
- ["[1]/[0]" primitive]]]])
+ ["[1]/[0]" primitive]
+ ["[1]/[0]" type]]]])
(def (injection value)
(All (_ of)
@@ -215,4 +216,5 @@
/translation/jvm/host.test
/translation/jvm/primitive.test
+ /translation/jvm/type.test
)))
diff --git a/stdlib/source/test/lux/meta/compiler/language/lux/phase/translation/jvm/type.lux b/stdlib/source/test/lux/meta/compiler/language/lux/phase/translation/jvm/type.lux
new file mode 100644
index 000000000..e99233eca
--- /dev/null
+++ b/stdlib/source/test/lux/meta/compiler/language/lux/phase/translation/jvm/type.lux
@@ -0,0 +1,45 @@
+(.require
+ [library
+ [lux (.except Type)
+ [abstract
+ [monad (.only do)]]
+ [math
+ ["[0]" random (.only Random)]]
+ [meta
+ [target
+ [jvm
+ ["[0]" type (.only Type) (.use "[1]#[0]" equivalence)
+ [category (.only Primitive Array Class)]]]]]
+ [test
+ ["_" property (.only Test)]]]]
+ [\\library
+ ["[0]" /]])
+
+(def .public test
+ Test
+ (<| (_.covering /._)
+ (do [! random.monad]
+ [])
+ (all _.and
+ (_.coverage [/.frac /.text]
+ (not (type#= /.frac /.text)))
+ (_.coverage [/.value /.error]
+ (not (type#= /.value /.error)))
+ (_.coverage [/.lefts]
+ (exec
+ (is (Type Primitive)
+ /.lefts)
+ true))
+ (_.coverage [/.right?]
+ (exec
+ (is (Type Class)
+ /.right?)
+ true))
+ (_.coverage [/.variant /.tuple]
+ (type#= /.variant /.tuple))
+ (_.coverage [/.stack]
+ (exec
+ (is (Type Array)
+ /.stack)
+ true))
+ )))
diff --git a/stdlib/source/test/lux/meta/compiler/meta/archive/artifact.lux b/stdlib/source/test/lux/meta/compiler/meta/archive/artifact.lux
index b233a404b..7d5bba9e1 100644
--- a/stdlib/source/test/lux/meta/compiler/meta/archive/artifact.lux
+++ b/stdlib/source/test/lux/meta/compiler/meta/archive/artifact.lux
@@ -24,7 +24,10 @@
(def .public test
Test
(<| (_.covering /._)
- (_.for [/.Artifact /.ID])
+ (_.for [/.ID
+
+ /.Artifact
+ /.#id /.#category /.#mandatory?])
(all _.and
(_.for [/.equivalence]
(equivalenceT.spec /.equivalence ..random))