aboutsummaryrefslogtreecommitdiff
diff options
context:
space:
mode:
-rw-r--r--luxc/src/lux/type.clj4
-rw-r--r--new-luxc/test/test/luxc/lang/analysis/host.jvm.lux (renamed from stdlib/test/test/lux/language/compiler/analysis/procedure/host.jvm.lux)0
-rw-r--r--stdlib/source/lux.lux59
-rw-r--r--stdlib/source/lux/function.lux6
-rw-r--r--stdlib/source/lux/language/compiler.lux23
-rw-r--r--stdlib/source/lux/language/compiler/analysis.lux60
-rw-r--r--stdlib/source/lux/language/compiler/analysis/case.lux36
-rw-r--r--stdlib/source/lux/language/compiler/analysis/expression.lux57
-rw-r--r--stdlib/source/lux/language/compiler/analysis/function.lux37
-rw-r--r--stdlib/source/lux/language/compiler/analysis/inference.lux21
-rw-r--r--stdlib/source/lux/language/compiler/analysis/module.lux255
-rw-r--r--stdlib/source/lux/language/compiler/analysis/primitive.lux13
-rw-r--r--stdlib/source/lux/language/compiler/analysis/reference.lux36
-rw-r--r--stdlib/source/lux/language/compiler/analysis/scope.lux196
-rw-r--r--stdlib/source/lux/language/compiler/analysis/structure.lux51
-rw-r--r--stdlib/source/lux/language/compiler/analysis/type.lux51
-rw-r--r--stdlib/source/lux/language/compiler/extension.lux125
-rw-r--r--stdlib/source/lux/language/compiler/extension/analysis.lux25
-rw-r--r--stdlib/source/lux/language/compiler/extension/analysis/common.lux444
-rw-r--r--stdlib/source/lux/language/compiler/extension/analysis/host.jvm.lux904
-rw-r--r--stdlib/source/lux/language/compiler/extension/bundle.lux6
-rw-r--r--stdlib/source/lux/language/compiler/synthesis.lux58
-rw-r--r--stdlib/source/lux/language/compiler/synthesis/case.lux57
-rw-r--r--stdlib/source/lux/language/compiler/synthesis/expression.lux85
-rw-r--r--stdlib/source/lux/language/compiler/synthesis/function.lux31
-rw-r--r--stdlib/source/lux/language/compiler/synthesis/loop.lux31
-rw-r--r--stdlib/source/lux/language/compiler/translation.lux79
-rw-r--r--stdlib/source/lux/language/compiler/translation/scheme/case.jvm.lux14
-rw-r--r--stdlib/source/lux/language/compiler/translation/scheme/expression.jvm.lux53
-rw-r--r--stdlib/source/lux/language/compiler/translation/scheme/extension.jvm.lux4
-rw-r--r--stdlib/source/lux/language/compiler/translation/scheme/extension/common.jvm.lux4
-rw-r--r--stdlib/source/lux/language/compiler/translation/scheme/function.jvm.lux6
-rw-r--r--stdlib/source/lux/language/compiler/translation/scheme/loop.jvm.lux6
-rw-r--r--stdlib/source/lux/language/compiler/translation/scheme/reference.jvm.lux2
-rw-r--r--stdlib/source/lux/language/compiler/translation/scheme/runtime.jvm.lux20
-rw-r--r--stdlib/source/lux/language/compiler/translation/scheme/structure.jvm.lux6
-rw-r--r--stdlib/source/lux/language/module.lux243
-rw-r--r--stdlib/source/lux/language/scope.lux191
-rw-r--r--stdlib/test/test/lux/language/compiler/analysis/case.lux26
-rw-r--r--stdlib/test/test/lux/language/compiler/analysis/function.lux29
-rw-r--r--stdlib/test/test/lux/language/compiler/analysis/primitive.lux22
-rw-r--r--stdlib/test/test/lux/language/compiler/analysis/procedure/common.lux36
-rw-r--r--stdlib/test/test/lux/language/compiler/analysis/reference.lux59
-rw-r--r--stdlib/test/test/lux/language/compiler/analysis/structure.lux88
-rw-r--r--stdlib/test/test/lux/language/compiler/synthesis/case.lux28
-rw-r--r--stdlib/test/test/lux/language/compiler/synthesis/function.lux44
-rw-r--r--stdlib/test/test/lux/language/compiler/synthesis/primitive.lux32
-rw-r--r--stdlib/test/test/lux/language/compiler/synthesis/structure.lux35
48 files changed, 1883 insertions, 1815 deletions
diff --git a/luxc/src/lux/type.clj b/luxc/src/lux/type.clj
index d0fcf4691..6cc33688e 100644
--- a/luxc/src/lux/type.clj
+++ b/luxc/src/lux/type.clj
@@ -21,6 +21,8 @@
_
false))
+(def max-env-size 128)
+
(def empty-env &/$Nil)
(def I64 (&/$Named (&/T ["lux" "I64"])
@@ -751,7 +753,7 @@
[(&/$Apply A F) _]
(let [fp-pair (&/T [expected actual])
- _ (when (> (&/|length fixpoints) 64)
+ _ (when (> (&/|length fixpoints) max-env-size)
(&/|log! (println-str 'FIXPOINTS (->> (&/|keys fixpoints)
(&/|map (fn [pair]
(|let [[e a] pair]
diff --git a/stdlib/test/test/lux/language/compiler/analysis/procedure/host.jvm.lux b/new-luxc/test/test/luxc/lang/analysis/host.jvm.lux
index 02574a31a..02574a31a 100644
--- a/stdlib/test/test/lux/language/compiler/analysis/procedure/host.jvm.lux
+++ b/new-luxc/test/test/luxc/lang/analysis/host.jvm.lux
diff --git a/stdlib/source/lux.lux b/stdlib/source/lux.lux
index 56fa96018..ecf5584d6 100644
--- a/stdlib/source/lux.lux
+++ b/stdlib/source/lux.lux
@@ -4084,7 +4084,7 @@
(fail "only/exclude requires symbols."))))
defs))
-(def: (parse-short-referrals tokens)
+(def: (parse-referrals tokens)
(-> (List Code) (Meta [Referrals (List Code)]))
(case tokens
(^or (^ (list& [_ (#Form (list& [_ (#Tag ["" "+"])] defs))] tokens'))
@@ -4106,7 +4106,7 @@
_
(return [#Nothing tokens])))
-(def: (parse-short-openings parts)
+(def: (parse-openings parts)
(-> (List Code) (Meta [(List Openings) (List Code)]))
(case parts
#.Nil
@@ -4123,7 +4123,7 @@
_
(fail "Expected all structures of opening form to be symbols.")))
structs)
- next+remainder (parse-short-openings parts')]
+ next+remainder (parse-openings parts')]
(let [[next remainder] next+remainder]
(return [(#.Cons [prefix structs'] next)
remainder])))
@@ -4131,19 +4131,6 @@
_
(return [#.Nil parts])))
-(def: (decorate-sub-importations super-name)
- (-> Text (List Importation) (List Importation))
- (list/map (: (-> Importation Importation)
- (function (_ importation)
- (let [{#import-name _name
- #import-alias _alias
- #import-refer {#refer-defs _referrals
- #refer-open _openings}} importation]
- {#import-name ($_ text/compose super-name "/" _name)
- #import-alias _alias
- #import-refer {#refer-defs _referrals
- #refer-open _openings}})))))
-
(def: (split at x)
(-> Nat Text (Maybe [Text Text]))
(case [(..clip2 +0 at x) (..clip1 at x)]
@@ -4192,11 +4179,13 @@
[_ (#Cons _ a+')]
(list/drop (n/- +1 amount) a+')))
-(def: (clean-module relative-root module)
- (-> Text Text (Meta Text))
+(def: (clean-module nested? relative-root module)
+ (-> Bool Text Text (Meta Text))
(case (count-ups +0 module)
+0
- (return module)
+ (return (if nested?
+ ($_ "lux text concat" relative-root "/" module)
+ module))
ups
(let [parts (text/split "/" relative-root)]
@@ -4217,8 +4206,8 @@
"Importing module: " module "\n"
" Relative Root: " relative-root "\n"))))))
-(def: (parse-imports relative-root imports)
- (-> Text (List Code) (Meta (List Importation)))
+(def: (parse-imports nested? relative-root imports)
+ (-> Bool Text (List Code) (Meta (List Importation)))
(do Monad<Meta>
[imports' (monad/map Monad<Meta>
(: (-> Code (Meta (List Importation)))
@@ -4226,7 +4215,7 @@
(case token
[_ (#Symbol ["" m-name])]
(do Monad<Meta>
- [m-name (clean-module relative-root m-name)]
+ [m-name (clean-module nested? relative-root m-name)]
(wrap (list {#import-name m-name
#import-alias #None
#import-refer {#refer-defs #All
@@ -4234,7 +4223,7 @@
(^ [_ (#Tuple (list [_ (#Symbol ["" m-name])]))])
(do Monad<Meta>
- [import-name (clean-module relative-root m-name)]
+ [import-name (clean-module nested? relative-root m-name)]
(wrap (list {#import-name import-name
#import-alias (#Some m-name)
#import-refer {#refer-defs #Nothing
@@ -4242,13 +4231,12 @@
(^ [_ (#Tuple (list& [_ (#Text alias)] [_ (#Symbol ["" m-name])] extra))])
(do Monad<Meta>
- [import-name (clean-module relative-root m-name)
- referral+extra (parse-short-referrals extra)
+ [import-name (clean-module nested? relative-root m-name)
+ referral+extra (parse-referrals extra)
#let [[referral extra] referral+extra]
- openings+extra (parse-short-openings extra)
+ openings+extra (parse-openings extra)
#let [[openings extra] openings+extra]
- sub-imports (parse-imports relative-root extra)
- #let [sub-imports (decorate-sub-importations import-name sub-imports)]]
+ sub-imports (parse-imports true import-name extra)]
(wrap (list& {#import-name import-name
#import-alias (#Some (replace-all "." m-name alias))
#import-refer {#refer-defs referral
@@ -4257,13 +4245,12 @@
(^ [_ (#Tuple (list& [_ (#Symbol ["" m-name])] extra))])
(do Monad<Meta>
- [import-name (clean-module relative-root m-name)
- referral+extra (parse-short-referrals extra)
+ [import-name (clean-module nested? relative-root m-name)
+ referral+extra (parse-referrals extra)
#let [[referral extra] referral+extra]
- openings+extra (parse-short-openings extra)
+ openings+extra (parse-openings extra)
#let [[openings extra] openings+extra]
- sub-imports (parse-imports relative-root extra)
- #let [sub-imports (decorate-sub-importations import-name sub-imports)]]
+ sub-imports (parse-imports true import-name extra)]
(wrap (case [referral openings]
[#Nothing #Nil] sub-imports
_ (list& {#import-name import-name
@@ -4752,9 +4739,9 @@
(def: (read-refer module-name options)
(-> Text (List Code) (Meta Refer))
(do Monad<Meta>
- [referral+options (parse-short-referrals options)
+ [referral+options (parse-referrals options)
#let [[referral options] referral+options]
- openings+options (parse-short-openings options)
+ openings+options (parse-openings options)
#let [[openings options] openings+options]
current-module current-module-name
#let [test-referrals (: (-> Text (List Text) (List Text) (Meta (List Any)))
@@ -4895,7 +4882,7 @@
_
[(list) tokens]))]
current-module current-module-name
- imports (parse-imports current-module _imports)
+ imports (parse-imports false current-module _imports)
#let [=imports (list/map (: (-> Importation Code)
(function (_ [m-name m-alias =refer])
(` [(~ (text$ m-name)) (~ (text$ (default "" m-alias)))])))
diff --git a/stdlib/source/lux/function.lux b/stdlib/source/lux/function.lux
index f883e36df..4d4af846a 100644
--- a/stdlib/source/lux/function.lux
+++ b/stdlib/source/lux/function.lux
@@ -8,10 +8,10 @@
(-> (-> b c) (-> a b) (-> a c)))
(|>> g f))
-(def: #export (constant c)
+(def: #export (constant value)
{#.doc "Create constant functions."}
- (All [a b] (-> a (-> b a)))
- (function (_ _) c))
+ (All [o] (-> o (All [i] (-> i o))))
+ (function (_ _) value))
(def: #export (flip f)
{#.doc "Flips the order of the arguments of a function."}
diff --git a/stdlib/source/lux/language/compiler.lux b/stdlib/source/lux/language/compiler.lux
index d8b622c31..e714773b7 100644
--- a/stdlib/source/lux/language/compiler.lux
+++ b/stdlib/source/lux/language/compiler.lux
@@ -9,7 +9,6 @@
[error (#+ Error)]
["." text
format]]
- [function]
[macro ["s" syntax (#+ syntax:)]]])
(type: #export (Operation s o)
@@ -21,6 +20,11 @@
(type: #export (Compiler s i o)
(-> i (Operation s o)))
+(def: #export (run' state operation)
+ (All [s o]
+ (-> s (Operation s o) (Error [s o])))
+ (operation state))
+
(def: #export (run state operation)
(All [s o]
(-> s (Operation s o) (Error o)))
@@ -42,23 +46,6 @@
(:: ..Monad<Operation> (~' wrap) [])
(..throw (~ exception) (~ message)))))))
-(def: #export (localized transform)
- (All [s o]
- (-> (-> s s)
- (-> (Operation s o) (Operation s o))))
- (function (_ operation)
- (function (_ state)
- (case (operation (transform state))
- (#error.Error error)
- (#error.Error error)
-
- (#error.Success [state' output])
- (#error.Success [state output])))))
-
-(def: #export (with-state state)
- (All [s o] (-> s (-> (Operation s o) (Operation s o))))
- (localized (function.constant state)))
-
(def: #export (with-stack exception message action)
(All [e s o] (-> (Exception e) e (Operation s o) (Operation s o)))
(<<| (ex.with-stack exception message)
diff --git a/stdlib/source/lux/language/compiler/analysis.lux b/stdlib/source/lux/language/compiler/analysis.lux
index 6956cd0b4..0ca620e42 100644
--- a/stdlib/source/lux/language/compiler/analysis.lux
+++ b/stdlib/source/lux/language/compiler/analysis.lux
@@ -6,8 +6,10 @@
[text ("text/" Equivalence<Text>)]
[collection [list ("list/" Fold<List>)]]]
[function]]
- [///reference (#+ Register Variable Reference)]
- [//])
+ [//
+ [extension (#+ Extension)]
+ [//
+ [reference (#+ Register Variable Reference)]]])
(type: #export #rec Primitive
#Unit
@@ -45,13 +47,20 @@
(#Reference Reference)
(#Case Analysis (Match' Analysis))
(#Function Environment Analysis)
- (#Apply Analysis Analysis))
+ (#Apply Analysis Analysis)
+ (#Extension (Extension Analysis)))
(type: #export Operation
- (//.Operation .Lux))
+ (extension.Operation .Lux Code Analysis))
(type: #export Compiler
- (//.Compiler .Lux Code Analysis))
+ (extension.Compiler .Lux Code Analysis))
+
+(type: #export Handler
+ (extension.Handler .Lux .Code Analysis))
+
+(type: #export Bundle
+ (extension.Bundle .Lux .Code Analysis))
(type: #export Branch
(Branch' Analysis))
@@ -97,7 +106,7 @@
(n/= (dec size) tag))
(template: #export (no-op value)
- (|> +1 #///reference.Local #///reference.Variable #..Reference
+ (|> +1 #reference.Local #reference.Variable #..Reference
(#..Function (list))
(#..Apply value)))
@@ -216,14 +225,14 @@
(def: #export (with-source-code source action)
(All [a] (-> Source (Operation a) (Operation a)))
- (function (_ compiler)
+ (function (_ [bundle compiler])
(let [old-source (get@ #.source compiler)]
- (case (action (set@ #.source source compiler))
+ (case (action [bundle (set@ #.source source compiler)])
(#error.Error error)
(#error.Error error)
- (#error.Success [compiler' output])
- (#error.Success [(set@ #.source old-source compiler')
+ (#error.Success [[bundle' compiler'] output])
+ (#error.Success [[bundle' (set@ #.source old-source compiler')]
output])))))
(def: fresh-bindings
@@ -240,42 +249,35 @@
(def: #export (with-scope action)
(All [a] (-> (Operation a) (Operation [Scope a])))
- (function (_ compiler)
- (case (action (update@ #.scopes (|>> (#.Cons fresh-scope)) compiler))
- (#error.Success [compiler' output])
+ (function (_ [bundle compiler])
+ (case (action [bundle (update@ #.scopes (|>> (#.Cons fresh-scope)) compiler)])
+ (#error.Success [[bundle' compiler'] output])
(case (get@ #.scopes compiler')
#.Nil
(#error.Error "Impossible error: Drained scopes!")
(#.Cons head tail)
- (#error.Success [(set@ #.scopes tail compiler')
+ (#error.Success [[bundle' (set@ #.scopes tail compiler')]
[head output]]))
(#error.Error error)
(#error.Error error))))
-(def: #export (with-current-module name action)
+(def: #export (with-current-module name)
(All [a] (-> Text (Operation a) (Operation a)))
- (function (_ compiler)
- (case (action (set@ #.current-module (#.Some name) compiler))
- (#error.Success [compiler' output])
- (#error.Success [(set@ #.current-module
- (get@ #.current-module compiler)
- compiler')
- output])
-
- (#error.Error error)
- (#error.Error error))))
+ (extension.localized (get@ #.current-module)
+ (set@ #.current-module)
+ (function.constant (#.Some name))))
(def: #export (with-cursor cursor action)
(All [a] (-> Cursor (Operation a) (Operation a)))
(if (text/= "" (product.left cursor))
action
- (function (_ compiler)
+ (function (_ [bundle compiler])
(let [old-cursor (get@ #.cursor compiler)]
- (case (action (set@ #.cursor cursor compiler))
- (#error.Success [compiler' output])
- (#error.Success [(set@ #.cursor old-cursor compiler')
+ (case (action [bundle (set@ #.cursor cursor compiler)])
+ (#error.Success [[bundle' compiler'] output])
+ (#error.Success [[bundle' (set@ #.cursor old-cursor compiler')]
output])
(#error.Error error)
diff --git a/stdlib/source/lux/language/compiler/analysis/case.lux b/stdlib/source/lux/language/compiler/analysis/case.lux
index d1ef6ece1..760ea3b03 100644
--- a/stdlib/source/lux/language/compiler/analysis/case.lux
+++ b/stdlib/source/lux/language/compiler/analysis/case.lux
@@ -12,15 +12,17 @@
[collection [list ("list/" Fold<List> Monoid<List> Functor<List>)]]]
["." macro
[code]]]
- [////
- ["." type
- ["tc" check]]
- [scope]]
- [///]
- [// (#+ Pattern Analysis Operation Compiler)]
- [//type]
- [//structure]
- [/coverage])
+ [// (#+ Pattern Analysis Operation Compiler)
+ [scope]
+ ["//." type]
+ [structure]
+ ["/." //
+ [extension]
+ [//
+ ["." type
+ ["tc" check]]]]]
+ [/
+ [coverage]])
(exception: #export (cannot-match-type-with-pattern {type Type} {pattern Code})
(ex.report ["Type" (%type type)]
@@ -215,8 +217,8 @@
[cursor (#.Record record)]
(do ///.Monad<Operation>
- [record (//structure.normalize record)
- [members recordT] (//structure.order record)
+ [record (structure.normalize record)
+ [members recordT] (structure.order record)
_ (//type.with-env
(tc.check inputT recordT))]
(analyse-pattern (#.Some (list.size members)) inputT [cursor (#.Tuple members)] next))
@@ -257,8 +259,8 @@
(^ [cursor (#.Form (list& [_ (#.Tag tag)] values))])
(//.with-cursor cursor
(do ///.Monad<Operation>
- [tag (macro.normalize tag)
- [idx group variantT] (macro.resolve-tag tag)
+ [tag (extension.lift (macro.normalize tag))
+ [idx group variantT] (extension.lift (macro.resolve-tag tag))
_ (//type.with-env
(tc.check inputT variantT))]
(analyse-pattern (#.Some (list.size group)) inputT (` ((~ (code.nat idx)) (~+ values))) next)))
@@ -282,12 +284,12 @@
(function (_ [patternT bodyT])
(analyse-pattern #.None inputT patternT (analyse bodyT)))
branchesT)
- outputHC (|> outputH product.left /coverage.determine)
- outputTC (monad.map @ (|>> product.left /coverage.determine) outputT)
- _ (.case (monad.fold error.Monad<Error> /coverage.merge outputHC outputTC)
+ outputHC (|> outputH product.left coverage.determine)
+ outputTC (monad.map @ (|>> product.left coverage.determine) outputT)
+ _ (.case (monad.fold error.Monad<Error> coverage.merge outputHC outputTC)
(#error.Success coverage)
(///.assert non-exhaustive-pattern-matching ""
- (/coverage.exhaustive? coverage))
+ (coverage.exhaustive? coverage))
(#error.Error error)
(///.fail error))]
diff --git a/stdlib/source/lux/language/compiler/analysis/expression.lux b/stdlib/source/lux/language/compiler/analysis/expression.lux
index f6ec5d11a..1c5c8794c 100644
--- a/stdlib/source/lux/language/compiler/analysis/expression.lux
+++ b/stdlib/source/lux/language/compiler/analysis/expression.lux
@@ -9,16 +9,16 @@
[text
format]]
[macro]]
- [//// (#+ Eval)
- ## [".L" macro]
- ## [".L" extension]
- ]
- [///]
- [// (#+ Analysis Operation Compiler)]
- [//type]
- [//primitive]
- [//structure]
- [//reference])
+ ["." ///
+ [extension]]
+ [// (#+ Analysis Operation Compiler)
+ [type]
+ [primitive]
+ [structure]
+ [reference]
+ ["/." /// (#+ Eval)
+ ## [".L" macro]
+ ]])
(exception: #export (macro-expansion-failed {message Text})
message)
@@ -35,7 +35,7 @@
(-> Eval Compiler)
(function (compile code)
(do ///.Monad<Operation>
- [expectedT macro.expected-type]
+ [expectedT (extension.lift macro.expected-type)]
(let [[cursor code'] code]
## The cursor must be set in the compiler for the sake
## of having useful error messages.
@@ -44,12 +44,12 @@
(^template [<tag> <analyser>]
(<tag> value)
(<analyser> value))
- ([#.Bool //primitive.bool]
- [#.Nat //primitive.nat]
- [#.Int //primitive.int]
- [#.Rev //primitive.rev]
- [#.Frac //primitive.frac]
- [#.Text //primitive.text])
+ ([#.Bool primitive.bool]
+ [#.Nat primitive.nat]
+ [#.Int primitive.int]
+ [#.Rev primitive.rev]
+ [#.Frac primitive.frac]
+ [#.Text primitive.text])
(^template [<tag> <analyser>]
(^ (#.Form (list& [_ (<tag> tag)]
@@ -60,42 +60,39 @@
_
(<analyser> compile tag (` [(~+ values)]))))
- ([#.Nat //structure.sum]
- [#.Tag //structure.tagged-sum])
+ ([#.Nat structure.sum]
+ [#.Tag structure.tagged-sum])
(#.Tag tag)
- (//structure.tagged-sum compile tag (' []))
+ (structure.tagged-sum compile tag (' []))
(^ (#.Tuple (list)))
- //primitive.unit
+ primitive.unit
(^ (#.Tuple (list singleton)))
(compile singleton)
(^ (#.Tuple elems))
- (//structure.product compile elems)
+ (structure.product compile elems)
(^ (#.Record pairs))
- (//structure.record compile pairs)
+ (structure.record compile pairs)
(#.Symbol reference)
- (//reference.reference reference)
+ (reference.reference reference)
(^ (#.Form (list& [_ (#.Text extension-name)] extension-args)))
- (undefined)
- ## (do ///.Monad<Operation>
- ## [extension (extensionL.find-analysis extension-name)]
- ## (extension compile eval extension-args))
+ (extension.apply compile [extension-name extension-args])
## (^ (#.Form (list& func args)))
## (do ///.Monad<Operation>
- ## [[funcT funcA] (//type.with-inference
+ ## [[funcT funcA] (type.with-inference
## (compile func))]
## (case funcA
## [_ (#.Symbol def-name)]
## (do @
## [?macro (///.with-error-tracking
- ## (macro.find-macro def-name))]
+ ## (extension.lift (macro.find-macro def-name)))]
## (case ?macro
## (#.Some macro)
## (do @
diff --git a/stdlib/source/lux/language/compiler/analysis/function.lux b/stdlib/source/lux/language/compiler/analysis/function.lux
index 95eacc47e..51f1892de 100644
--- a/stdlib/source/lux/language/compiler/analysis/function.lux
+++ b/stdlib/source/lux/language/compiler/analysis/function.lux
@@ -12,12 +12,13 @@
[code]]
[language
["." type
- ["tc" check]]
- [".L" scope]]]
- [///]
- [// (#+ Analysis Compiler)]
- [//type]
- [//inference])
+ ["tc" check]]]]
+ [// (#+ Analysis Operation Compiler)
+ [scope]
+ ["//." type]
+ [inference]
+ ["/." //
+ [extension]]])
(exception: #export (cannot-analyse {expected Type} {function Text} {argument Text} {body Code})
(ex.report ["Type" (%type expected)]
@@ -34,9 +35,9 @@
(text.join-with ""))]))
(def: #export (function analyse function-name arg-name body)
- (-> Compiler Text Text Code (Meta Analysis))
- (do macro.Monad<Meta>
- [functionT macro.expected-type]
+ (-> Compiler Text Text Code (Operation Analysis))
+ (do ///.Monad<Operation>
+ [functionT (extension.lift macro.expected-type)]
(loop [expectedT functionT]
(///.with-stack cannot-analyse [expectedT function-name arg-name body]
(case expectedT
@@ -81,12 +82,12 @@
(#.Function inputT outputT)
(<| (:: @ map (.function (_ [scope bodyA])
- (#//.Function (scopeL.environment scope) bodyA)))
+ (#//.Function (scope.environment scope) bodyA)))
//.with-scope
## Functions have access not only to their argument, but
## also to themselves, through a local variable.
- (scopeL.with-local [function-name expectedT])
- (scopeL.with-local [arg-name inputT])
+ (scope.with-local [function-name expectedT])
+ (scope.with-local [arg-name inputT])
(//type.with-type outputT)
(analyse body))
@@ -94,9 +95,9 @@
(///.fail "")
)))))
-(def: #export (apply analyse functionT functionA args)
- (-> Compiler Type Analysis (List Code) (Meta Analysis))
- (<| (///.with-stack cannot-apply [functionT args])
- (do macro.Monad<Meta>
- [[applyT argsA] (//inference.general analyse functionT args)])
- (wrap (//.apply [functionA argsA]))))
+(def: #export (apply analyse functionT functionA argsC+)
+ (-> Compiler Type Analysis (List Code) (Operation Analysis))
+ (<| (///.with-stack cannot-apply [functionT argsC+])
+ (do ///.Monad<Operation>
+ [[applyT argsA+] (inference.general analyse functionT argsC+)])
+ (wrap (//.apply [functionA argsA+]))))
diff --git a/stdlib/source/lux/language/compiler/analysis/inference.lux b/stdlib/source/lux/language/compiler/analysis/inference.lux
index 1539e1a0d..403ad0092 100644
--- a/stdlib/source/lux/language/compiler/analysis/inference.lux
+++ b/stdlib/source/lux/language/compiler/analysis/inference.lux
@@ -9,9 +9,11 @@
format]
[collection [list ("list/" Functor<List>)]]]
[macro]]
- [//// ["." type
- ["tc" check]]]
- [/// ("operation/" Monad<Operation>)]
+ [////
+ ["." type
+ ["tc" check]]]
+ [/// ("operation/" Monad<Operation>)
+ [extension]]
[// (#+ Tag Analysis Operation Compiler)]
[//type])
@@ -75,16 +77,17 @@
_
type))
+(def: (named-type cursor id)
+ (-> Cursor Nat Type)
+ (let [name (format "{New Type @ " (.cursor-description cursor) " " (%n id) "}")]
+ (#.Primitive name (list))))
+
(def: new-named-type
(Operation Type)
(do ///.Monad<Operation>
- [[module line column] macro.cursor
+ [cursor (extension.lift macro.cursor)
[ex-id _] (//type.with-env tc.existential)]
- (wrap (#.Primitive (format "{New Type @ " (%t module)
- "," (%n line)
- "," (%n column)
- "} " (%n ex-id))
- (list)))))
+ (wrap (named-type cursor ex-id))))
## Type-inference works by applying some (potentially quantified) type
## to a sequence of values.
diff --git a/stdlib/source/lux/language/compiler/analysis/module.lux b/stdlib/source/lux/language/compiler/analysis/module.lux
new file mode 100644
index 000000000..2a2aef5c3
--- /dev/null
+++ b/stdlib/source/lux/language/compiler/analysis/module.lux
@@ -0,0 +1,255 @@
+(.module:
+ [lux #*
+ [control
+ [monad (#+ do)]
+ ["ex" exception (#+ exception:)]
+ pipe]
+ [data
+ [text ("text/" Equivalence<Text>)
+ format]
+ ["e" error]
+ [collection
+ [list ("list/" Fold<List> Functor<List>)]
+ [dictionary
+ [plist]]]]
+ [macro]]
+ [// (#+ Operation)
+ ["/." //
+ [extension]]])
+
+(type: #export Tag Text)
+
+(exception: #export (unknown-module {module Text})
+ module)
+
+(exception: #export (cannot-declare-tag-twice {module Text} {tag Text})
+ (ex.report ["Module" module]
+ ["Tag" tag]))
+
+(do-template [<name>]
+ [(exception: #export (<name> {tags (List Text)} {owner Type})
+ (ex.report ["Tags" (text.join-with " " tags)]
+ ["Type" (%type owner)]))]
+
+ [cannot-declare-tags-for-unnamed-type]
+ [cannot-declare-tags-for-foreign-type]
+ )
+
+(exception: #export (cannot-define-more-than-once {name Ident})
+ (%ident name))
+
+(exception: #export (can-only-change-state-of-active-module {module Text} {state Module-State})
+ (ex.report ["Module" module]
+ ["Desired state" (case state
+ #.Active "Active"
+ #.Compiled "Compiled"
+ #.Cached "Cached")]))
+
+(exception: #export (cannot-set-module-annotations-more-than-once {module Text} {old Code} {new Code})
+ (ex.report ["Module" module]
+ ["Old annotations" (%code old)]
+ ["New annotations" (%code new)]))
+
+(def: (new hash)
+ (-> Nat Module)
+ {#.module-hash hash
+ #.module-aliases (list)
+ #.definitions (list)
+ #.imports (list)
+ #.tags (list)
+ #.types (list)
+ #.module-annotations #.None
+ #.module-state #.Active})
+
+(def: #export (set-annotations annotations)
+ (-> Code (Operation Any))
+ (do ///.Monad<Operation>
+ [self-name (extension.lift macro.current-module-name)
+ self (extension.lift macro.current-module)]
+ (case (get@ #.module-annotations self)
+ #.None
+ (extension.lift
+ (function (_ state)
+ (#e.Success [(update@ #.modules
+ (plist.put self-name (set@ #.module-annotations (#.Some annotations) self))
+ state)
+ []])))
+
+ (#.Some old)
+ (///.throw cannot-set-module-annotations-more-than-once [self-name old annotations]))))
+
+(def: #export (import module)
+ (-> Text (Operation Any))
+ (do ///.Monad<Operation>
+ [self-name (extension.lift macro.current-module-name)]
+ (extension.lift
+ (function (_ state)
+ (#e.Success [(update@ #.modules
+ (plist.update self-name (update@ #.imports (|>> (#.Cons module))))
+ state)
+ []])))))
+
+(def: #export (alias alias module)
+ (-> Text Text (Operation Any))
+ (do ///.Monad<Operation>
+ [self-name (extension.lift macro.current-module-name)]
+ (extension.lift
+ (function (_ state)
+ (#e.Success [(update@ #.modules
+ (plist.update self-name (update@ #.module-aliases (: (-> (List [Text Text]) (List [Text Text]))
+ (|>> (#.Cons [alias module])))))
+ state)
+ []])))))
+
+(def: #export (exists? module)
+ (-> Text (Operation Bool))
+ (extension.lift
+ (function (_ state)
+ (|> state
+ (get@ #.modules)
+ (plist.get module)
+ (case> (#.Some _) true #.None false)
+ [state] #e.Success))))
+
+(def: #export (define name definition)
+ (-> Text Definition (Operation []))
+ (do ///.Monad<Operation>
+ [self-name (extension.lift macro.current-module-name)
+ self (extension.lift macro.current-module)]
+ (extension.lift
+ (function (_ state)
+ (case (plist.get name (get@ #.definitions self))
+ #.None
+ (#e.Success [(update@ #.modules
+ (plist.put self-name
+ (update@ #.definitions
+ (: (-> (List [Text Definition]) (List [Text Definition]))
+ (|>> (#.Cons [name definition])))
+ self))
+ state)
+ []])
+
+ (#.Some already-existing)
+ ((///.throw cannot-define-more-than-once [self-name name]) state))))))
+
+(def: #export (create hash name)
+ (-> Nat Text (Operation []))
+ (extension.lift
+ (function (_ state)
+ (let [module (new hash)]
+ (#e.Success [(update@ #.modules
+ (plist.put name module)
+ state)
+ []])))))
+
+(def: #export (with-module hash name action)
+ (All [a] (-> Nat Text (Operation a) (Operation [Module a])))
+ (do ///.Monad<Operation>
+ [_ (create hash name)
+ output (//.with-current-module name
+ action)
+ module (extension.lift (macro.find-module name))]
+ (wrap [module output])))
+
+(do-template [<setter> <asker> <tag>]
+ [(def: #export (<setter> module-name)
+ (-> Text (Operation Any))
+ (extension.lift
+ (function (_ state)
+ (case (|> state (get@ #.modules) (plist.get module-name))
+ (#.Some module)
+ (let [active? (case (get@ #.module-state module)
+ #.Active true
+ _ false)]
+ (if active?
+ (#e.Success [(update@ #.modules
+ (plist.put module-name (set@ #.module-state <tag> module))
+ state)
+ []])
+ ((///.throw can-only-change-state-of-active-module [module-name <tag>])
+ state)))
+
+ #.None
+ ((///.throw unknown-module module-name) state)))))
+
+ (def: #export (<asker> module-name)
+ (-> Text (Operation Bool))
+ (extension.lift
+ (function (_ state)
+ (case (|> state (get@ #.modules) (plist.get module-name))
+ (#.Some module)
+ (#e.Success [state
+ (case (get@ #.module-state module)
+ <tag> true
+ _ false)])
+
+ #.None
+ ((///.throw unknown-module module-name) state)))))]
+
+ [set-active active? #.Active]
+ [set-compiled compiled? #.Compiled]
+ [set-cached cached? #.Cached]
+ )
+
+(do-template [<name> <tag> <type>]
+ [(def: (<name> module-name)
+ (-> Text (Operation <type>))
+ (extension.lift
+ (function (_ state)
+ (case (|> state (get@ #.modules) (plist.get module-name))
+ (#.Some module)
+ (#e.Success [state (get@ <tag> module)])
+
+ #.None
+ ((///.throw unknown-module module-name) state)))))]
+
+ [tags #.tags (List [Text [Nat (List Ident) Bool Type]])]
+ [types #.types (List [Text [(List Ident) Bool Type]])]
+ [hash #.module-hash Nat]
+ )
+
+(def: (ensure-undeclared-tags module-name tags)
+ (-> Text (List Tag) (Operation Any))
+ (do ///.Monad<Operation>
+ [bindings (..tags module-name)
+ _ (monad.map @
+ (function (_ tag)
+ (case (plist.get tag bindings)
+ #.None
+ (wrap [])
+
+ (#.Some _)
+ (///.throw cannot-declare-tag-twice [module-name tag])))
+ tags)]
+ (wrap [])))
+
+(def: #export (declare-tags tags exported? type)
+ (-> (List Tag) Bool Type (Operation Any))
+ (do ///.Monad<Operation>
+ [self-name (extension.lift macro.current-module-name)
+ [type-module type-name] (case type
+ (#.Named type-ident _)
+ (wrap type-ident)
+
+ _
+ (///.throw cannot-declare-tags-for-unnamed-type [tags type]))
+ _ (ensure-undeclared-tags self-name tags)
+ _ (///.assert cannot-declare-tags-for-foreign-type [tags type]
+ (text/= self-name type-module))]
+ (extension.lift
+ (function (_ state)
+ (case (|> state (get@ #.modules) (plist.get self-name))
+ (#.Some module)
+ (let [namespaced-tags (list/map (|>> [self-name]) tags)]
+ (#e.Success [(update@ #.modules
+ (plist.update self-name
+ (|>> (update@ #.tags (function (_ tag-bindings)
+ (list/fold (function (_ [idx tag] table)
+ (plist.put tag [idx namespaced-tags exported? type] table))
+ tag-bindings
+ (list.enumerate tags))))
+ (update@ #.types (plist.put type-name [namespaced-tags exported? type]))))
+ state)
+ []]))
+ #.None
+ ((///.throw unknown-module self-name) state))))))
diff --git a/stdlib/source/lux/language/compiler/analysis/primitive.lux b/stdlib/source/lux/language/compiler/analysis/primitive.lux
index cbfef367f..eabbcb7d8 100644
--- a/stdlib/source/lux/language/compiler/analysis/primitive.lux
+++ b/stdlib/source/lux/language/compiler/analysis/primitive.lux
@@ -2,14 +2,15 @@
[lux (#- nat int rev)
[control monad]
[macro]]
- [// (#+ Analysis)
- [".A" type]])
+ [// (#+ Analysis Operation)
+ [".A" type]
+ ["/." //]])
## [Analysers]
(do-template [<name> <type> <tag>]
[(def: #export (<name> value)
- (-> <type> (Meta Analysis))
- (do macro.Monad<Meta>
+ (-> <type> (Operation Analysis))
+ (do ///.Monad<Operation>
[_ (typeA.infer <type>)]
(wrap (#//.Primitive (<tag> value)))))]
@@ -22,7 +23,7 @@
)
(def: #export unit
- (Meta Analysis)
- (do macro.Monad<Meta>
+ (Operation Analysis)
+ (do ///.Monad<Operation>
[_ (typeA.infer Any)]
(wrap (#//.Primitive #//.Unit))))
diff --git a/stdlib/source/lux/language/compiler/analysis/reference.lux b/stdlib/source/lux/language/compiler/analysis/reference.lux
index cdffd6870..af134ebe3 100644
--- a/stdlib/source/lux/language/compiler/analysis/reference.lux
+++ b/stdlib/source/lux/language/compiler/analysis/reference.lux
@@ -5,15 +5,19 @@
["ex" exception (#+ exception:)]]
["." macro
[code]]
- [language [type ["tc" check]]]
+ [language
+ [type
+ ["tc" check]]]
[data
[text ("text/" Equivalence<Text>)
format]]]
- [///]
- [// (#+ Analysis Operation)]
- [//type]
- [////reference]
- [////scope])
+ [// (#+ Analysis Operation)
+ [scope]
+ [type]
+ ["/." //
+ [extension]
+ [//
+ [reference]]]])
(exception: #export (foreign-module-has-not-been-imported {current Text} {foreign Text})
(ex.report ["Current" current]
@@ -25,23 +29,23 @@
## [Analysers]
(def: (definition def-name)
(-> Ident (Operation Analysis))
- (with-expansions [<return> (wrap (|> def-name ////reference.constant #//.Reference))]
+ (with-expansions [<return> (wrap (|> def-name reference.constant #//.Reference))]
(do ///.Monad<Operation>
- [[actualT def-anns _] (macro.find-def def-name)]
+ [[actualT def-anns _] (extension.lift (macro.find-def def-name))]
(case (macro.get-symbol-ann (ident-for #.alias) def-anns)
(#.Some real-def-name)
(definition real-def-name)
_
(do @
- [_ (//type.infer actualT)
- (^@ def-name [::module ::name]) (macro.normalize def-name)
- current macro.current-module-name]
+ [_ (type.infer actualT)
+ (^@ def-name [::module ::name]) (extension.lift (macro.normalize def-name))
+ current (extension.lift macro.current-module-name)]
(if (text/= current ::module)
<return>
(if (macro.export? def-anns)
(do @
- [imported! (macro.imported-by? ::module current)]
+ [imported! (extension.lift (macro.imported-by? ::module current))]
(if imported!
<return>
(///.throw foreign-module-has-not-been-imported [current ::module])))
@@ -50,12 +54,12 @@
(def: (variable var-name)
(-> Text (Operation (Maybe Analysis)))
(do ///.Monad<Operation>
- [?var (////scope.find var-name)]
+ [?var (scope.find var-name)]
(case ?var
(#.Some [actualT ref])
(do @
- [_ (//type.infer actualT)]
- (wrap (#.Some (|> ref ////reference.variable #//.Reference))))
+ [_ (type.infer actualT)]
+ (wrap (#.Some (|> ref reference.variable #//.Reference))))
#.None
(wrap #.None))))
@@ -72,7 +76,7 @@
#.None
(do @
- [this-module macro.current-module-name]
+ [this-module (extension.lift macro.current-module-name)]
(definition [this-module simple-name]))))
_
diff --git a/stdlib/source/lux/language/compiler/analysis/scope.lux b/stdlib/source/lux/language/compiler/analysis/scope.lux
new file mode 100644
index 000000000..2468ede27
--- /dev/null
+++ b/stdlib/source/lux/language/compiler/analysis/scope.lux
@@ -0,0 +1,196 @@
+(.module:
+ [lux #*
+ [control
+ monad]
+ [data
+ [text ("text/" Equivalence<Text>)
+ format]
+ [maybe ("maybe/" Monad<Maybe>)]
+ [product]
+ ["e" error]
+ [collection
+ [list ("list/" Functor<List> Fold<List> Monoid<List>)]
+ [dictionary [plist]]]]]
+ [// (#+ Operation Compiler)
+ ["compiler" //
+ [extension]
+ [//
+ [reference (#+ Register Variable)]]]])
+
+(type: Local (Bindings Text [Type Register]))
+(type: Foreign (Bindings Text [Type Variable]))
+
+(def: (local? name scope)
+ (-> Text Scope Bool)
+ (|> scope
+ (get@ [#.locals #.mappings])
+ (plist.contains? name)))
+
+(def: (local name scope)
+ (-> Text Scope (Maybe [Type Variable]))
+ (|> scope
+ (get@ [#.locals #.mappings])
+ (plist.get name)
+ (maybe/map (function (_ [type value])
+ [type (#reference.Local value)]))))
+
+(def: (captured? name scope)
+ (-> Text Scope Bool)
+ (|> scope
+ (get@ [#.captured #.mappings])
+ (plist.contains? name)))
+
+(def: (captured name scope)
+ (-> Text Scope (Maybe [Type Variable]))
+ (loop [idx +0
+ mappings (get@ [#.captured #.mappings] scope)]
+ (case mappings
+ #.Nil
+ #.None
+
+ (#.Cons [_name [_source-type _source-ref]] mappings')
+ (if (text/= name _name)
+ (#.Some [_source-type (#reference.Foreign idx)])
+ (recur (inc idx) mappings')))))
+
+(def: (reference? name scope)
+ (-> Text Scope Bool)
+ (or (local? name scope)
+ (captured? name scope)))
+
+(def: (reference name scope)
+ (-> Text Scope (Maybe [Type Variable]))
+ (case (..local name scope)
+ (#.Some type)
+ (#.Some type)
+
+ _
+ (..captured name scope)))
+
+(def: #export (find name)
+ (-> Text (Operation (Maybe [Type Variable])))
+ (extension.lift
+ (function (_ state)
+ (let [[inner outer] (|> state
+ (get@ #.scopes)
+ (list.split-with (|>> (reference? name) not)))]
+ (case outer
+ #.Nil
+ (#.Right [state #.None])
+
+ (#.Cons top-outer _)
+ (let [[ref-type init-ref] (maybe.default (undefined)
+ (..reference name top-outer))
+ [ref inner'] (list/fold (: (-> Scope [Variable (List Scope)] [Variable (List Scope)])
+ (function (_ scope ref+inner)
+ [(#reference.Foreign (get@ [#.captured #.counter] scope))
+ (#.Cons (update@ #.captured
+ (: (-> Foreign Foreign)
+ (|>> (update@ #.counter inc)
+ (update@ #.mappings (plist.put name [ref-type (product.left ref+inner)]))))
+ scope)
+ (product.right ref+inner))]))
+ [init-ref #.Nil]
+ (list.reverse inner))
+ scopes (list/compose inner' outer)]
+ (#.Right [(set@ #.scopes scopes state)
+ (#.Some [ref-type ref])]))
+ )))))
+
+(def: #export (with-local [name type] action)
+ (All [a] (-> [Text Type] (Operation a) (Operation a)))
+ (function (_ [bundle state])
+ (case (get@ #.scopes state)
+ (#.Cons head tail)
+ (let [old-mappings (get@ [#.locals #.mappings] head)
+ new-var-id (get@ [#.locals #.counter] head)
+ new-head (update@ #.locals
+ (: (-> Local Local)
+ (|>> (update@ #.counter inc)
+ (update@ #.mappings (plist.put name [type new-var-id]))))
+ head)]
+ (case (compiler.run' [bundle (set@ #.scopes (#.Cons new-head tail) state)]
+ action)
+ (#e.Success [[bundle' state'] output])
+ (case (get@ #.scopes state')
+ (#.Cons head' tail')
+ (let [scopes' (#.Cons (set@ #.locals (get@ #.locals head) head')
+ tail')]
+ (#e.Success [[bundle' (set@ #.scopes scopes' state')]
+ output]))
+
+ _
+ (error! "Invalid scope alteration/"))
+
+ (#e.Error error)
+ (#e.Error error)))
+
+ _
+ (#e.Error "Cannot create local binding without a scope."))
+ ))
+
+(do-template [<name> <val-type>]
+ [(def: <name>
+ (Bindings Text [Type <val-type>])
+ {#.counter +0
+ #.mappings (list)})]
+
+ [init-locals Nat]
+ [init-captured Variable]
+ )
+
+(def: (scope parent-name child-name)
+ (-> (List Text) Text Scope)
+ {#.name (list& child-name parent-name)
+ #.inner +0
+ #.locals init-locals
+ #.captured init-captured})
+
+(def: #export (with-scope name action)
+ (All [a] (-> Text (Operation a) (Operation a)))
+ (function (_ [bundle state])
+ (let [parent-name (case (get@ #.scopes state)
+ #.Nil
+ (list)
+
+ (#.Cons top _)
+ (get@ #.name top))]
+ (case (action [bundle (update@ #.scopes
+ (|>> (#.Cons (scope parent-name name)))
+ state)])
+ (#e.Error error)
+ (#e.Error error)
+
+ (#e.Success [[bundle' state'] output])
+ (#e.Success [[bundle' (update@ #.scopes
+ (|>> list.tail (maybe.default (list)))
+ state')]
+ output])
+ ))
+ ))
+
+(def: #export next-local
+ (Operation Register)
+ (extension.lift
+ (function (_ state)
+ (case (get@ #.scopes state)
+ #.Nil
+ (#e.Error "Cannot get next reference when there is no scope.")
+
+ (#.Cons top _)
+ (#e.Success [state (get@ [#.locals #.counter] top)])))))
+
+(def: (ref-to-variable ref)
+ (-> Ref Variable)
+ (case ref
+ (#.Local register)
+ (#reference.Local register)
+
+ (#.Captured register)
+ (#reference.Foreign register)))
+
+(def: #export (environment scope)
+ (-> Scope (List Variable))
+ (|> scope
+ (get@ [#.captured #.mappings])
+ (list/map (function (_ [_ [_ ref]]) (ref-to-variable ref)))))
diff --git a/stdlib/source/lux/language/compiler/analysis/structure.lux b/stdlib/source/lux/language/compiler/analysis/structure.lux
index e30d22bad..382eab486 100644
--- a/stdlib/source/lux/language/compiler/analysis/structure.lux
+++ b/stdlib/source/lux/language/compiler/analysis/structure.lux
@@ -13,14 +13,15 @@
["dict" dictionary (#+ Dictionary)]]]
["." macro
[code]]]
- [////
- ["." type
- ["tc" check]]]
- [///]
- [// (#+ Tag Analysis Operation Compiler)]
- [//type]
- [//primitive]
- [//inference])
+ [// (#+ Tag Analysis Operation Compiler)
+ ["//." type]
+ [primitive]
+ [inference]
+ ["/." //
+ [extension]
+ ["//." //
+ ["." type
+ ["tc" check]]]]])
(exception: #export (invalid-variant-type {type Type} {tag Tag} {code Code})
(ex.report ["Type" (%type type)]
@@ -79,7 +80,7 @@
(def: #export (sum analyse tag valueC)
(-> Compiler Nat Code (Operation Analysis))
(do ///.Monad<Operation>
- [expectedT macro.expected-type]
+ [expectedT (extension.lift macro.expected-type)]
(///.with-stack cannot-analyse-variant [expectedT tag valueC]
(case expectedT
(#.Sum _)
@@ -93,7 +94,7 @@
(wrap (//.sum-analysis type-size tag valueA)))
#.None
- (///.throw //inference.variant-tag-out-of-bounds [type-size tag expectedT])))
+ (///.throw inference.variant-tag-out-of-bounds [type-size tag expectedT])))
(#.Named name unnamedT)
(//type.with-type unnamedT
@@ -152,7 +153,7 @@
(def: (typed-product analyse membersC+)
(-> Compiler (List Code) (Operation Analysis))
(do ///.Monad<Operation>
- [expectedT macro.expected-type]
+ [expectedT (extension.lift macro.expected-type)]
(loop [expectedT expectedT
membersC+ membersC+]
(case [expectedT membersC+]
@@ -191,7 +192,7 @@
(def: #export (product analyse membersC)
(-> Compiler (List Code) (Operation Analysis))
(do ///.Monad<Operation>
- [expectedT macro.expected-type]
+ [expectedT (extension.lift macro.expected-type)]
(///.with-stack cannot-analyse-tuple [expectedT membersC]
(case expectedT
(#.Product _)
@@ -258,15 +259,15 @@
(def: #export (tagged-sum analyse tag valueC)
(-> Compiler Ident Code (Operation Analysis))
(do ///.Monad<Operation>
- [tag (macro.normalize tag)
- [idx group variantT] (macro.resolve-tag tag)
- expectedT macro.expected-type]
+ [tag (extension.lift (macro.normalize tag))
+ [idx group variantT] (extension.lift (macro.resolve-tag tag))
+ expectedT (extension.lift macro.expected-type)]
(case expectedT
(#.Var _)
(do @
[#let [case-size (list.size group)]
- inferenceT (//inference.variant idx case-size variantT)
- [inferredT valueA+] (//inference.general analyse inferenceT (list valueC))]
+ inferenceT (inference.variant idx case-size variantT)
+ [inferredT valueA+] (inference.general analyse inferenceT (list valueC))]
(wrap (//.sum-analysis case-size idx (|> valueA+ list.head maybe.assume))))
_
@@ -283,7 +284,7 @@
(case key
[_ (#.Tag key)]
(do ///.Monad<Operation>
- [key (macro.normalize key)]
+ [key (extension.lift (macro.normalize key))]
(wrap [key val]))
_
@@ -302,8 +303,8 @@
(#.Cons [head-k head-v] _)
(do ///.Monad<Operation>
- [head-k (macro.normalize head-k)
- [_ tag-set recordT] (macro.resolve-tag head-k)
+ [head-k (extension.lift (macro.normalize head-k))
+ [_ tag-set recordT] (extension.lift (macro.resolve-tag head-k))
#let [size-record (list.size record)
size-ts (list.size tag-set)]
_ (if (n/= size-ts size-record)
@@ -314,7 +315,7 @@
idx->val (monad.fold @
(function (_ [key val] idx->val)
(do @
- [key (macro.normalize key)]
+ [key (extension.lift (macro.normalize key))]
(case (dict.get key tag->idx)
#.None
(///.throw tag-does-not-belong-to-record [key recordT])
@@ -338,19 +339,19 @@
[membersC recordT] (order members)]
(case membersC
(^ (list))
- //primitive.unit
+ primitive.unit
(^ (list singletonC))
(analyse singletonC)
_
(do @
- [expectedT macro.expected-type]
+ [expectedT (extension.lift macro.expected-type)]
(case expectedT
(#.Var _)
(do @
- [inferenceT (//inference.record recordT)
- [inferredT membersA] (//inference.general analyse inferenceT membersC)]
+ [inferenceT (inference.record recordT)
+ [inferredT membersA] (inference.general analyse inferenceT membersC)]
(wrap (//.product-analysis membersA)))
_
diff --git a/stdlib/source/lux/language/compiler/analysis/type.lux b/stdlib/source/lux/language/compiler/analysis/type.lux
index 0c73dedab..f87a96758 100644
--- a/stdlib/source/lux/language/compiler/analysis/type.lux
+++ b/stdlib/source/lux/language/compiler/analysis/type.lux
@@ -1,51 +1,42 @@
(.module:
[lux #*
- [control [monad (#+ do)]]
- [data [error]]
+ [control
+ [monad (#+ do)]]
+ [data
+ [error]]
+ [function]
[macro]
- [language [type ["tc" check]]]]
- [///]
- [// (#+ Operation)])
+ [language
+ [type ["tc" check]]]]
+ [// (#+ Operation)
+ ["/." //
+ [extension]]])
-(def: #export (with-type expected action)
+(def: #export (with-type expected)
(All [a] (-> Type (Operation a) (Operation a)))
- (function (_ compiler)
- (case (action (set@ #.expected (#.Some expected) compiler))
- (#error.Success [compiler' output])
- (let [old-expected (get@ #.expected compiler)]
- (#error.Success [(set@ #.expected old-expected compiler')
- output]))
-
- (#error.Error error)
- (#error.Error error))))
+ (extension.localized (get@ #.expected) (set@ #.expected)
+ (function.constant (#.Some expected))))
(def: #export (with-env action)
(All [a] (-> (tc.Check a) (Operation a)))
- (function (_ compiler)
- (case (action (get@ #.type-context compiler))
+ (function (_ (^@ stateE [bundle state]))
+ (case (action (get@ #.type-context state))
(#error.Error error)
- ((///.fail error) compiler)
+ ((///.fail error) stateE)
(#error.Success [context' output])
- (#error.Success [(set@ #.type-context context' compiler)
+ (#error.Success [[bundle (set@ #.type-context context' state)]
output]))))
-(def: #export (with-fresh-env action)
+(def: #export with-fresh-env
(All [a] (-> (Operation a) (Operation a)))
- (function (_ compiler)
- (let [old (get@ #.type-context compiler)]
- (case (action (set@ #.type-context tc.fresh-context compiler))
- (#error.Success [compiler' output])
- (#error.Success [(set@ #.type-context old compiler')
- output])
-
- output
- output))))
+ (extension.localized (get@ #.type-context) (set@ #.type-context)
+ (function.constant tc.fresh-context)))
(def: #export (infer actualT)
(-> Type (Operation Any))
(do ///.Monad<Operation>
- [expectedT macro.expected-type]
+ [expectedT (extension.lift macro.expected-type)]
(with-env
(tc.check expectedT actualT))))
diff --git a/stdlib/source/lux/language/compiler/extension.lux b/stdlib/source/lux/language/compiler/extension.lux
index 478c90564..fc41aa30d 100644
--- a/stdlib/source/lux/language/compiler/extension.lux
+++ b/stdlib/source/lux/language/compiler/extension.lux
@@ -6,61 +6,108 @@
[data
[error (#+ Error)]
[text]
- [collection ["dict" dictionary (#+ Dictionary)]]]]
- [// (#+ Operation Compiler)])
+ [collection ["dict" dictionary (#+ Dictionary)]]]
+ [function]]
+ [//])
(type: #export (Extension i)
- (#Base i)
- (#Extension [Text (List (Extension i))]))
+ [Text (List i)])
-(with-expansions [<Bundle> (as-is (Dictionary Text (-> Text (Handler s i o))))]
+(with-expansions [<Bundle> (as-is (Dictionary Text (Handler s i o)))]
(type: #export (Handler s i o)
- (-> (Compiler [s <Bundle>] (Extension i) (Extension o))
- (Compiler [s <Bundle>] (List (Extension i)) (Extension o))))
+ (-> Text
+ (//.Compiler [<Bundle> s] i o)
+ (//.Compiler [<Bundle> s] (List i) o)))
(type: #export (Bundle s i o)
<Bundle>))
+(type: #export (Operation s i o v)
+ (//.Operation [(Bundle s i o) s] v))
+
+(type: #export (Compiler s i o)
+ (//.Compiler [(Bundle s i o) s] i o))
+
(do-template [<name>]
[(exception: #export (<name> {name Text})
(ex.report ["Name" name]))]
- [unknown-extension]
- [cannot-overwrite-existing-extension]
+ [unknown]
+ [cannot-overwrite]
)
-(def: #export (extend compiler)
+(def: #export (install name handler)
+ (All [s i o]
+ (-> Text (Handler s i o) (Operation s i o Any)))
+ (function (_ [bundle state])
+ (if (dict.contains? name bundle)
+ (ex.throw cannot-overwrite name)
+ (#error.Success [[(dict.put name handler bundle) state]
+ []]))))
+
+(def: #export (apply compiler [name parameters])
(All [s i o]
- (-> (Compiler s i o)
- (Compiler [s (Bundle s i o)]
- (Extension i)
- (Extension o))))
- (function (compiler' input (^@ stateE [stateB bundle]))
- (case input
- (#Base input')
- (do error.Monad<Error>
- [[stateB' output] (compiler input' stateB)]
- (wrap [[stateB' bundle] (#Base output)]))
+ (-> (Compiler s i o) (Extension i) (Operation s i o o)))
+ (function (_ (^@ stateE [bundle state]))
+ (case (dict.get name bundle)
+ #.None
+ (ex.throw unknown name)
- (#Extension name parameters)
- (case (dict.get name bundle)
- (#.Some handler)
- (do error.Monad<Error>
- [[stateE' output] (handler name compiler' parameters stateE)]
- (wrap [stateE' output]))
-
- #.None
- (ex.throw unknown-extension name)))))
+ (#.Some handler)
+ ((handler name compiler) parameters stateE))))
-(def: #export (install name handler)
+(def: #export (localized get set transform)
+ (All [s s' i o v]
+ (-> (-> s s') (-> s' s s) (-> s' s')
+ (-> (Operation s i o v) (Operation s i o v))))
+ (function (_ operation)
+ (function (_ [bundle state])
+ (let [old (get state)]
+ (case (operation [bundle (set (transform old) state)])
+ (#error.Error error)
+ (#error.Error error)
+
+ (#error.Success [[bundle' state'] output])
+ (#error.Success [[bundle' (set old state')] output]))))))
+
+(def: #export (temporary transform)
+ (All [s i o v]
+ (-> (-> s s)
+ (-> (Operation s i o v) (Operation s i o v))))
+ (function (_ operation)
+ (function (_ [bundle state])
+ (case (operation [bundle (transform state)])
+ (#error.Error error)
+ (#error.Error error)
+
+ (#error.Success [[bundle' state'] output])
+ (#error.Success [[bundle' state] output])))))
+
+(def: #export (with-state state)
+ (All [s i o v]
+ (-> s (-> (Operation s i o v) (Operation s i o v))))
+ (..temporary (function.constant state)))
+
+(def: #export (read get)
+ (All [s i o v]
+ (-> (-> s v) (Operation s i o v)))
+ (function (_ [bundle state])
+ (#error.Success [[bundle state] (get state)])))
+
+(def: #export (update transform)
(All [s i o]
- (-> Text (-> Text (Handler s i o))
- (Operation [s (Bundle s i o)] Any)))
- (function (_ (^@ stateE [_ bundle]))
- (if (dict.contains? name bundle)
- (ex.throw cannot-overwrite-existing-extension name)
- (ex.return [stateE (dict.put name handler bundle)]))))
+ (-> (-> s s) (Operation s i o Any)))
+ (function (_ [bundle state])
+ (#error.Success [[bundle (transform state)] []])))
+
+(def: #export (lift action)
+ (All [s i o v]
+ (-> (//.Operation s v)
+ (//.Operation [(Bundle s i o) s] v)))
+ (function (_ [bundle state])
+ (case (action state)
+ (#error.Error error)
+ (#error.Error error)
-(def: #export fresh
- Bundle
- (dict.new text.Hash<Text>))
+ (#error.Success [state' output])
+ (#error.Success [[bundle state] output]))))
diff --git a/stdlib/source/lux/language/compiler/extension/analysis.lux b/stdlib/source/lux/language/compiler/extension/analysis.lux
index ba37b4578..0f57de1ff 100644
--- a/stdlib/source/lux/language/compiler/extension/analysis.lux
+++ b/stdlib/source/lux/language/compiler/extension/analysis.lux
@@ -1,20 +1,15 @@
(.module:
[lux #*
[data
- [text]
[collection
- [list ("list/" Functor<List>)]
- ["dict" dictionary (#+ Dictionary)]]]]
- [///analysis (#+ Analysis State)]
- [///synthesis (#+ Synthesis)]
- [//]
- [/common]
- [/host])
+ [dictionary]]]]
+ [///
+ [analysis (#+ Bundle)]]
+ [/
+ [common]
+ [host]])
-(def: #export defaults
- (//.Bundle State Analysis Synthesis)
- (|> /common.extensions
- (dict.merge /host.extensions)
- dict.entries
- (list/map (function (_ [name proc]) [name (proc name)]))
- (dict.from-list text.Hash<Text>)))
+(def: #export bundle
+ Bundle
+ (dictionary.merge host.bundle
+ common.bundle))
diff --git a/stdlib/source/lux/language/compiler/extension/analysis/common.lux b/stdlib/source/lux/language/compiler/extension/analysis/common.lux
index 0dac69ced..55d479052 100644
--- a/stdlib/source/lux/language/compiler/extension/analysis/common.lux
+++ b/stdlib/source/lux/language/compiler/extension/analysis/common.lux
@@ -15,23 +15,19 @@
["." language
[type ["tc" check]]]
[io (#+ IO)]]
- [////]
- [////
- [analysis (#+ Analysis)
+ ["." ////
+ [analysis (#+ Analysis Bundle)
[".A" type]
[".A" case]
[".A" function]]]
- [///]
- [///bundle])
-
-(type: Handler
- (///.Handler .Lux .Code Analysis))
+ ["." ///
+ [bundle]])
## [Utils]
-(def: (simple extension inputsT+ outputT)
- (-> Text (List Type) Type ..Handler)
+(def: (simple inputsT+ outputT)
+ (-> (List Type) Type analysis.Handler)
(let [num-expected (list.size inputsT+)]
- (function (_ analyse args)
+ (function (_ extension-name analyse args)
(let [num-actual (list.size args)]
(if (n/= num-expected num-actual)
(do ////.Monad<Operation>
@@ -41,40 +37,40 @@
(typeA.with-type argT
(analyse argC)))
(list.zip2 inputsT+ args))]
- (wrap (#///.Extension extension argsA)))
- (language.throw ///bundle.incorrect-arity [extension num-expected num-actual]))))))
+ (wrap (#analysis.Extension extension-name argsA)))
+ (////.throw bundle.incorrect-arity [extension-name num-expected num-actual]))))))
-(def: #export (nullary valueT extension)
- (-> Type Text ..Handler)
- (simple extension (list) valueT))
+(def: #export (nullary valueT)
+ (-> Type analysis.Handler)
+ (simple (list) valueT))
-(def: #export (unary inputT outputT extension)
- (-> Type Type Text ..Handler)
- (simple extension (list inputT) outputT))
+(def: #export (unary inputT outputT)
+ (-> Type Type analysis.Handler)
+ (simple (list inputT) outputT))
-(def: #export (binary subjectT paramT outputT extension)
- (-> Type Type Type Text ..Handler)
- (simple extension (list subjectT paramT) outputT))
+(def: #export (binary subjectT paramT outputT)
+ (-> Type Type Type analysis.Handler)
+ (simple (list subjectT paramT) outputT))
-(def: #export (trinary subjectT param0T param1T outputT extension)
- (-> Type Type Type Type Text ..Handler)
- (simple extension (list subjectT param0T param1T) outputT))
+(def: #export (trinary subjectT param0T param1T outputT)
+ (-> Type Type Type Type analysis.Handler)
+ (simple (list subjectT param0T param1T) outputT))
## [Analysers]
## "lux is" represents reference/pointer equality.
-(def: (lux//is extension)
- (-> Text ..Handler)
- (function (_ analyse args)
+(def: lux::is
+ analysis.Handler
+ (function (_ extension-name analyse args)
(do ////.Monad<Operation>
[[var-id varT] (typeA.with-env tc.var)]
- ((binary varT varT Bool extension)
+ ((binary varT varT Bool extension-name)
analyse args))))
## "lux try" provides a simple way to interact with the host platform's
## error-handling facilities.
-(def: (lux//try extension)
- (-> Text ..Handler)
- (function (_ analyse args)
+(def: lux::try
+ analysis.Handler
+ (function (_ extension-name analyse args)
(case args
(^ (list opC))
(do ////.Monad<Operation>
@@ -82,26 +78,26 @@
_ (typeA.infer (type (Either Text varT)))
opA (typeA.with-type (type (IO varT))
(analyse opC))]
- (wrap (#///.Extension extension (list opA))))
+ (wrap (#analysis.Extension extension-name (list opA))))
_
- (language.throw ///bundle.incorrect-arity [extension +1 (list.size args)]))))
+ (////.throw bundle.incorrect-arity [extension-name +1 (list.size args)]))))
-(def: (lux//in-module extension)
- (-> Text ..Handler)
- (function (_ analyse argsC+)
+(def: lux::in-module
+ analysis.Handler
+ (function (_ extension-name analyse argsC+)
(case argsC+
(^ (list [_ (#.Text module-name)] exprC))
- (language.with-current-module module-name
+ (analysis.with-current-module module-name
(analyse exprC))
_
- (language.throw ///bundle.invalid-syntax [extension]))))
+ (////.throw bundle.invalid-syntax [extension-name]))))
## (do-template [<name> <type>]
-## [(def: (<name> extension)
-## (-> Text ..Handler)
-## (function (_ analyse args)
+## [(def: <name>
+## analysis.Handler
+## (function (_ extension-name analyse args)
## (case args
## (^ (list typeC valueC))
## (do ////.Monad<Operation>
@@ -111,15 +107,15 @@
## (analyse valueC)))
## _
-## (language.throw ///bundle.incorrect-arity [extension +2 (list.size args)]))))]
+## (////.throw bundle.incorrect-arity [extension-name +2 (list.size args)]))))]
-## [lux//check (:coerce Type actualT)]
-## [lux//coerce Any]
+## [lux::check (:coerce Type actualT)]
+## [lux::coerce Any]
## )
-(def: (lux//check//type extension)
- (-> Text ..Handler)
- (function (_ analyse args)
+(def: lux::check::type
+ analysis.Handler
+ (function (_ extension-name analyse args)
(case args
(^ (list valueC))
(do ////.Monad<Operation>
@@ -129,145 +125,145 @@
(wrap valueA))
_
- (language.throw ///bundle.incorrect-arity [extension +1 (list.size args)]))))
-
-(def: bundle/lux
- ///.Bundle
- (|> ///.fresh
- (///bundle.install "is" lux//is)
- (///bundle.install "try" lux//try)
- (///bundle.install "check" lux//check)
- (///bundle.install "coerce" lux//coerce)
- (///bundle.install "check type" lux//check//type)
- (///bundle.install "in-module" lux//in-module)))
-
-(def: bundle/io
- ///.Bundle
- (<| (///bundle.prefix "io")
- (|> ///.fresh
- (///bundle.install "log" (unary Text Any))
- (///bundle.install "error" (unary Text Nothing))
- (///bundle.install "exit" (unary Int Nothing))
- (///bundle.install "current-time" (nullary Int)))))
-
-(def: bundle/bit
- ///.Bundle
- (<| (///bundle.prefix "bit")
- (|> ///.fresh
- (///bundle.install "and" (binary Nat Nat Nat))
- (///bundle.install "or" (binary Nat Nat Nat))
- (///bundle.install "xor" (binary Nat Nat Nat))
- (///bundle.install "left-shift" (binary Nat Nat Nat))
- (///bundle.install "logical-right-shift" (binary Nat Nat Nat))
- (///bundle.install "arithmetic-right-shift" (binary Int Nat Int))
+ (////.throw bundle.incorrect-arity [extension-name +1 (list.size args)]))))
+
+(def: bundle::lux
+ Bundle
+ (|> bundle.empty
+ (bundle.install "is" lux::is)
+ (bundle.install "try" lux::try)
+ ## (bundle.install "check" lux::check)
+ ## (bundle.install "coerce" lux::coerce)
+ (bundle.install "check type" lux::check::type)
+ (bundle.install "in-module" lux::in-module)))
+
+(def: bundle::io
+ Bundle
+ (<| (bundle.prefix "io")
+ (|> bundle.empty
+ (bundle.install "log" (unary Text Any))
+ (bundle.install "error" (unary Text Nothing))
+ (bundle.install "exit" (unary Int Nothing))
+ (bundle.install "current-time" (nullary Int)))))
+
+(def: bundle::bit
+ Bundle
+ (<| (bundle.prefix "bit")
+ (|> bundle.empty
+ (bundle.install "and" (binary Nat Nat Nat))
+ (bundle.install "or" (binary Nat Nat Nat))
+ (bundle.install "xor" (binary Nat Nat Nat))
+ (bundle.install "left-shift" (binary Nat Nat Nat))
+ (bundle.install "logical-right-shift" (binary Nat Nat Nat))
+ (bundle.install "arithmetic-right-shift" (binary Int Nat Int))
)))
-(def: bundle/int
- ///.Bundle
- (<| (///bundle.prefix "int")
- (|> ///.fresh
- (///bundle.install "+" (binary Int Int Int))
- (///bundle.install "-" (binary Int Int Int))
- (///bundle.install "*" (binary Int Int Int))
- (///bundle.install "/" (binary Int Int Int))
- (///bundle.install "%" (binary Int Int Int))
- (///bundle.install "=" (binary Int Int Bool))
- (///bundle.install "<" (binary Int Int Bool))
- (///bundle.install "to-frac" (unary Int Frac))
- (///bundle.install "char" (unary Int Text)))))
-
-(def: bundle/frac
- ///.Bundle
- (<| (///bundle.prefix "frac")
- (|> ///.fresh
- (///bundle.install "+" (binary Frac Frac Frac))
- (///bundle.install "-" (binary Frac Frac Frac))
- (///bundle.install "*" (binary Frac Frac Frac))
- (///bundle.install "/" (binary Frac Frac Frac))
- (///bundle.install "%" (binary Frac Frac Frac))
- (///bundle.install "=" (binary Frac Frac Bool))
- (///bundle.install "<" (binary Frac Frac Bool))
- (///bundle.install "smallest" (nullary Frac))
- (///bundle.install "min" (nullary Frac))
- (///bundle.install "max" (nullary Frac))
- (///bundle.install "to-rev" (unary Frac Rev))
- (///bundle.install "to-int" (unary Frac Int))
- (///bundle.install "encode" (unary Frac Text))
- (///bundle.install "decode" (unary Text (type (Maybe Frac)))))))
-
-(def: bundle/text
- ///.Bundle
- (<| (///bundle.prefix "text")
- (|> ///.fresh
- (///bundle.install "=" (binary Text Text Bool))
- (///bundle.install "<" (binary Text Text Bool))
- (///bundle.install "concat" (binary Text Text Text))
- (///bundle.install "index" (trinary Text Text Nat (type (Maybe Nat))))
- (///bundle.install "size" (unary Text Nat))
- (///bundle.install "char" (binary Text Nat (type (Maybe Nat))))
- (///bundle.install "clip" (trinary Text Nat Nat (type (Maybe Text))))
+(def: bundle::int
+ Bundle
+ (<| (bundle.prefix "int")
+ (|> bundle.empty
+ (bundle.install "+" (binary Int Int Int))
+ (bundle.install "-" (binary Int Int Int))
+ (bundle.install "*" (binary Int Int Int))
+ (bundle.install "/" (binary Int Int Int))
+ (bundle.install "%" (binary Int Int Int))
+ (bundle.install "=" (binary Int Int Bool))
+ (bundle.install "<" (binary Int Int Bool))
+ (bundle.install "to-frac" (unary Int Frac))
+ (bundle.install "char" (unary Int Text)))))
+
+(def: bundle::frac
+ Bundle
+ (<| (bundle.prefix "frac")
+ (|> bundle.empty
+ (bundle.install "+" (binary Frac Frac Frac))
+ (bundle.install "-" (binary Frac Frac Frac))
+ (bundle.install "*" (binary Frac Frac Frac))
+ (bundle.install "/" (binary Frac Frac Frac))
+ (bundle.install "%" (binary Frac Frac Frac))
+ (bundle.install "=" (binary Frac Frac Bool))
+ (bundle.install "<" (binary Frac Frac Bool))
+ (bundle.install "smallest" (nullary Frac))
+ (bundle.install "min" (nullary Frac))
+ (bundle.install "max" (nullary Frac))
+ (bundle.install "to-rev" (unary Frac Rev))
+ (bundle.install "to-int" (unary Frac Int))
+ (bundle.install "encode" (unary Frac Text))
+ (bundle.install "decode" (unary Text (type (Maybe Frac)))))))
+
+(def: bundle::text
+ Bundle
+ (<| (bundle.prefix "text")
+ (|> bundle.empty
+ (bundle.install "=" (binary Text Text Bool))
+ (bundle.install "<" (binary Text Text Bool))
+ (bundle.install "concat" (binary Text Text Text))
+ (bundle.install "index" (trinary Text Text Nat (type (Maybe Nat))))
+ (bundle.install "size" (unary Text Nat))
+ (bundle.install "char" (binary Text Nat (type (Maybe Nat))))
+ (bundle.install "clip" (trinary Text Nat Nat (type (Maybe Text))))
)))
-(def: (array//get extension)
- (-> Text ..Handler)
- (function (_ analyse args)
+(def: array::get
+ analysis.Handler
+ (function (_ extension-name analyse args)
(do ////.Monad<Operation>
[[var-id varT] (typeA.with-env tc.var)]
- ((binary (type (Array varT)) Nat (type (Maybe varT)) extension)
+ ((binary (type (Array varT)) Nat (type (Maybe varT)) extension-name)
analyse args))))
-(def: (array//put extension)
- (-> Text ..Handler)
- (function (_ analyse args)
+(def: array::put
+ analysis.Handler
+ (function (_ extension-name analyse args)
(do ////.Monad<Operation>
[[var-id varT] (typeA.with-env tc.var)]
- ((trinary (type (Array varT)) Nat varT (type (Array varT)) extension)
+ ((trinary (type (Array varT)) Nat varT (type (Array varT)) extension-name)
analyse args))))
-(def: (array//remove extension)
- (-> Text ..Handler)
- (function (_ analyse args)
+(def: array::remove
+ analysis.Handler
+ (function (_ extension-name analyse args)
(do ////.Monad<Operation>
[[var-id varT] (typeA.with-env tc.var)]
- ((binary (type (Array varT)) Nat (type (Array varT)) extension)
+ ((binary (type (Array varT)) Nat (type (Array varT)) extension-name)
analyse args))))
-(def: bundle/array
- ///.Bundle
- (<| (///bundle.prefix "array")
- (|> ///.fresh
- (///bundle.install "new" (unary Nat Array))
- (///bundle.install "get" array//get)
- (///bundle.install "put" array//put)
- (///bundle.install "remove" array//remove)
- (///bundle.install "size" (unary (type (Ex [a] (Array a))) Nat))
+(def: bundle::array
+ Bundle
+ (<| (bundle.prefix "array")
+ (|> bundle.empty
+ (bundle.install "new" (unary Nat Array))
+ (bundle.install "get" array::get)
+ (bundle.install "put" array::put)
+ (bundle.install "remove" array::remove)
+ (bundle.install "size" (unary (type (Ex [a] (Array a))) Nat))
)))
-(def: bundle/math
- ///.Bundle
- (<| (///bundle.prefix "math")
- (|> ///.fresh
- (///bundle.install "cos" (unary Frac Frac))
- (///bundle.install "sin" (unary Frac Frac))
- (///bundle.install "tan" (unary Frac Frac))
- (///bundle.install "acos" (unary Frac Frac))
- (///bundle.install "asin" (unary Frac Frac))
- (///bundle.install "atan" (unary Frac Frac))
- (///bundle.install "cosh" (unary Frac Frac))
- (///bundle.install "sinh" (unary Frac Frac))
- (///bundle.install "tanh" (unary Frac Frac))
- (///bundle.install "exp" (unary Frac Frac))
- (///bundle.install "log" (unary Frac Frac))
- (///bundle.install "ceil" (unary Frac Frac))
- (///bundle.install "floor" (unary Frac Frac))
- (///bundle.install "round" (unary Frac Frac))
- (///bundle.install "atan2" (binary Frac Frac Frac))
- (///bundle.install "pow" (binary Frac Frac Frac))
+(def: bundle::math
+ Bundle
+ (<| (bundle.prefix "math")
+ (|> bundle.empty
+ (bundle.install "cos" (unary Frac Frac))
+ (bundle.install "sin" (unary Frac Frac))
+ (bundle.install "tan" (unary Frac Frac))
+ (bundle.install "acos" (unary Frac Frac))
+ (bundle.install "asin" (unary Frac Frac))
+ (bundle.install "atan" (unary Frac Frac))
+ (bundle.install "cosh" (unary Frac Frac))
+ (bundle.install "sinh" (unary Frac Frac))
+ (bundle.install "tanh" (unary Frac Frac))
+ (bundle.install "exp" (unary Frac Frac))
+ (bundle.install "log" (unary Frac Frac))
+ (bundle.install "ceil" (unary Frac Frac))
+ (bundle.install "floor" (unary Frac Frac))
+ (bundle.install "round" (unary Frac Frac))
+ (bundle.install "atan2" (binary Frac Frac Frac))
+ (bundle.install "pow" (binary Frac Frac Frac))
)))
-(def: (atom-new extension)
- (-> Text ..Handler)
- (function (_ analyse args)
+(def: atom::new
+ analysis.Handler
+ (function (_ extension-name analyse args)
(case args
(^ (list initC))
(do ////.Monad<Operation>
@@ -275,39 +271,39 @@
_ (typeA.infer (type (Atom varT)))
initA (typeA.with-type varT
(analyse initC))]
- (wrap (#///.Extension extension (list initA))))
+ (wrap (#analysis.Extension extension-name (list initA))))
_
- (language.throw ///bundle.incorrect-arity [extension +1 (list.size args)]))))
+ (////.throw bundle.incorrect-arity [extension-name +1 (list.size args)]))))
-(def: (atom-read extension)
- (-> Text ..Handler)
- (function (_ analyse args)
+(def: atom::read
+ analysis.Handler
+ (function (_ extension-name analyse args)
(do ////.Monad<Operation>
[[var-id varT] (typeA.with-env tc.var)]
- ((unary (type (Atom varT)) varT extension)
+ ((unary (type (Atom varT)) varT extension-name)
analyse args))))
-(def: (atom//compare-and-swap extension)
- (-> Text ..Handler)
- (function (_ analyse args)
+(def: atom::compare-and-swap
+ analysis.Handler
+ (function (_ extension-name analyse args)
(do ////.Monad<Operation>
[[var-id varT] (typeA.with-env tc.var)]
- ((trinary (type (Atom varT)) varT varT Bool extension)
+ ((trinary (type (Atom varT)) varT varT Bool extension-name)
analyse args))))
-(def: bundle/atom
- ///.Bundle
- (<| (///bundle.prefix "atom")
- (|> ///.fresh
- (///bundle.install "new" atom-new)
- (///bundle.install "read" atom-read)
- (///bundle.install "compare-and-swap" atom//compare-and-swap)
+(def: bundle::atom
+ Bundle
+ (<| (bundle.prefix "atom")
+ (|> bundle.empty
+ (bundle.install "new" atom::new)
+ (bundle.install "read" atom::read)
+ (bundle.install "compare-and-swap" atom::compare-and-swap)
)))
-(def: (box//new extension)
- (-> Text ..Handler)
- (function (_ analyse args)
+(def: box::new
+ analysis.Handler
+ (function (_ extension-name analyse args)
(case args
(^ (list initC))
(do ////.Monad<Operation>
@@ -315,59 +311,59 @@
_ (typeA.infer (type (All [!] (Box ! varT))))
initA (typeA.with-type varT
(analyse initC))]
- (wrap (#///.Extension extension (list initA))))
+ (wrap (#analysis.Extension extension-name (list initA))))
_
- (language.throw ///bundle.incorrect-arity [extension +1 (list.size args)]))))
+ (////.throw bundle.incorrect-arity [extension-name +1 (list.size args)]))))
-(def: (box//read extension)
- (-> Text ..Handler)
- (function (_ analyse args)
+(def: box::read
+ analysis.Handler
+ (function (_ extension-name analyse args)
(do ////.Monad<Operation>
[[thread-id threadT] (typeA.with-env tc.var)
[var-id varT] (typeA.with-env tc.var)]
- ((unary (type (Box threadT varT)) varT extension)
+ ((unary (type (Box threadT varT)) varT extension-name)
analyse args))))
-(def: (box//write extension)
- (-> Text ..Handler)
- (function (_ analyse args)
+(def: box::write
+ analysis.Handler
+ (function (_ extension-name analyse args)
(do ////.Monad<Operation>
[[thread-id threadT] (typeA.with-env tc.var)
[var-id varT] (typeA.with-env tc.var)]
- ((binary varT (type (Box threadT varT)) Any extension)
+ ((binary varT (type (Box threadT varT)) Any extension-name)
analyse args))))
-(def: bundle/box
- ///.Bundle
- (<| (///bundle.prefix "box")
- (|> ///.fresh
- (///bundle.install "new" box//new)
- (///bundle.install "read" box//read)
- (///bundle.install "write" box//write)
+(def: bundle::box
+ Bundle
+ (<| (bundle.prefix "box")
+ (|> bundle.empty
+ (bundle.install "new" box::new)
+ (bundle.install "read" box::read)
+ (bundle.install "write" box::write)
)))
-(def: bundle/process
- ///.Bundle
- (<| (///bundle.prefix "process")
- (|> ///.fresh
- (///bundle.install "parallelism" (nullary Nat))
- (///bundle.install "schedule" (binary Nat (type (IO Any)) Any))
+(def: bundle::process
+ Bundle
+ (<| (bundle.prefix "process")
+ (|> bundle.empty
+ (bundle.install "parallelism" (nullary Nat))
+ (bundle.install "schedule" (binary Nat (type (IO Any)) Any))
)))
(def: #export bundle
- ///.Bundle
- (<| (///bundle.prefix "lux")
- (|> ///.fresh
- (dict.merge bundle/lux)
- (dict.merge bundle/bit)
- (dict.merge bundle/int)
- (dict.merge bundle/frac)
- (dict.merge bundle/text)
- (dict.merge bundle/array)
- (dict.merge bundle/math)
- (dict.merge bundle/atom)
- (dict.merge bundle/box)
- (dict.merge bundle/process)
- (dict.merge bundle/io))
+ Bundle
+ (<| (bundle.prefix "lux")
+ (|> bundle.empty
+ (dict.merge bundle::lux)
+ (dict.merge bundle::bit)
+ (dict.merge bundle::int)
+ (dict.merge bundle::frac)
+ (dict.merge bundle::text)
+ (dict.merge bundle::array)
+ (dict.merge bundle::math)
+ (dict.merge bundle::atom)
+ (dict.merge bundle::box)
+ (dict.merge bundle::process)
+ (dict.merge bundle::io))
))
diff --git a/stdlib/source/lux/language/compiler/extension/analysis/host.jvm.lux b/stdlib/source/lux/language/compiler/extension/analysis/host.jvm.lux
index e13b32c08..d25be6e40 100644
--- a/stdlib/source/lux/language/compiler/extension/analysis/host.jvm.lux
+++ b/stdlib/source/lux/language/compiler/extension/analysis/host.jvm.lux
@@ -3,43 +3,50 @@
[control
[monad (#+ do)]
["p" parser]
- ["ex" exception (#+ exception:)]]
+ ["ex" exception (#+ exception:)]
+ pipe]
[data
["e" error]
[maybe]
[product]
- [bool ("bool/" Equivalence<Bool>)]
[text ("text/" Equivalence<Text>)
- format
- ["l" lexer]]
+ format]
[collection
[list ("list/" Fold<List> Functor<List> Monoid<List>)]
[array]
- ["dict" dictionary (#+ Dictionary)]]]
- [macro ("macro/" Monad<Meta>)
- [code]
+ [dictionary (#+ Dictionary)]]]
+ ["." macro
["s" syntax]]
- ["." language
+ [language
["." type
- ["tc" check]]]
+ [check]]]
[host]]
- ["/" //common]
- [////
- [".L" analysis (#+ Analysis)
- [".A" type]
- [".A" inference]]]
- [///]
+ [//
+ [common]
+ ["/." //
+ [bundle]
+ ["//." // ("operation/" Monad<Operation>)
+ [analysis (#+ Analysis Operation Handler Bundle)
+ [".A" type]
+ [".A" inference]]]]]
)
+(type: Method-Signature
+ {#method Type
+ #exceptions (List Type)})
+
(host.import: #long java/lang/reflect/Type
(getTypeName [] String))
-(def: jvm-type-name
- (-> java/lang/reflect/Type Text)
- (java/lang/reflect/Type::getTypeName []))
+(do-template [<name>]
+ [(exception: #export (<name> {jvm-type java/lang/reflect/Type})
+ (ex.report ["JVM Type" (java/lang/reflect/Type::getTypeName [] jvm-type)]))]
-(exception: #export (jvm-type-is-not-a-class {jvm-type java/lang/reflect/Type})
- (jvm-type-name jvm-type))
+ [jvm-type-is-not-a-class]
+ [cannot-convert-to-a-class]
+ [cannot-convert-to-a-parameter]
+ [cannot-convert-to-a-lux-type]
+ )
(do-template [<name>]
[(exception: #export (<name> {type Type})
@@ -77,20 +84,19 @@
[cannot-possibly-be-an-instance]
- [cannot-convert-to-a-class]
- [cannot-convert-to-a-parameter]
- [cannot-convert-to-a-lux-type]
[unknown-type-var]
[type-parameter-mismatch]
[cannot-correspond-type-with-a-class]
)
(do-template [<name>]
- [(exception: #export (<name> {class Text} {method Text} {hints (List [Type (List Type)])})
+ [(exception: #export (<name> {class Text}
+ {method Text}
+ {hints (List Method-Signature)})
(ex.report ["Class" class]
["Method" method]
["Hints" (|> hints
- (list/map (|>> %type (format "\n\t")))
+ (list/map (|>> product.left %type (format "\n\t")))
(text.join-with ""))]))]
[no-candidates]
@@ -122,83 +128,83 @@
[char "char"]
)
-(def: conversion-procs
- /.Bundle
- (<| (/.prefix "convert")
- (|> (dict.new text.Hash<Text>)
- (/.install "double-to-float" (/.unary Double Float))
- (/.install "double-to-int" (/.unary Double Integer))
- (/.install "double-to-long" (/.unary Double Long))
- (/.install "float-to-double" (/.unary Float Double))
- (/.install "float-to-int" (/.unary Float Integer))
- (/.install "float-to-long" (/.unary Float Long))
- (/.install "int-to-byte" (/.unary Integer Byte))
- (/.install "int-to-char" (/.unary Integer Character))
- (/.install "int-to-double" (/.unary Integer Double))
- (/.install "int-to-float" (/.unary Integer Float))
- (/.install "int-to-long" (/.unary Integer Long))
- (/.install "int-to-short" (/.unary Integer Short))
- (/.install "long-to-double" (/.unary Long Double))
- (/.install "long-to-float" (/.unary Long Float))
- (/.install "long-to-int" (/.unary Long Integer))
- (/.install "long-to-short" (/.unary Long Short))
- (/.install "long-to-byte" (/.unary Long Byte))
- (/.install "char-to-byte" (/.unary Character Byte))
- (/.install "char-to-short" (/.unary Character Short))
- (/.install "char-to-int" (/.unary Character Integer))
- (/.install "char-to-long" (/.unary Character Long))
- (/.install "byte-to-long" (/.unary Byte Long))
- (/.install "short-to-long" (/.unary Short Long))
+(def: bundle::conversion
+ Bundle
+ (<| (bundle.prefix "convert")
+ (|> bundle.empty
+ (bundle.install "double-to-float" (common.unary Double Float))
+ (bundle.install "double-to-int" (common.unary Double Integer))
+ (bundle.install "double-to-long" (common.unary Double Long))
+ (bundle.install "float-to-double" (common.unary Float Double))
+ (bundle.install "float-to-int" (common.unary Float Integer))
+ (bundle.install "float-to-long" (common.unary Float Long))
+ (bundle.install "int-to-byte" (common.unary Integer Byte))
+ (bundle.install "int-to-char" (common.unary Integer Character))
+ (bundle.install "int-to-double" (common.unary Integer Double))
+ (bundle.install "int-to-float" (common.unary Integer Float))
+ (bundle.install "int-to-long" (common.unary Integer Long))
+ (bundle.install "int-to-short" (common.unary Integer Short))
+ (bundle.install "long-to-double" (common.unary Long Double))
+ (bundle.install "long-to-float" (common.unary Long Float))
+ (bundle.install "long-to-int" (common.unary Long Integer))
+ (bundle.install "long-to-short" (common.unary Long Short))
+ (bundle.install "long-to-byte" (common.unary Long Byte))
+ (bundle.install "char-to-byte" (common.unary Character Byte))
+ (bundle.install "char-to-short" (common.unary Character Short))
+ (bundle.install "char-to-int" (common.unary Character Integer))
+ (bundle.install "char-to-long" (common.unary Character Long))
+ (bundle.install "byte-to-long" (common.unary Byte Long))
+ (bundle.install "short-to-long" (common.unary Short Long))
)))
(do-template [<name> <prefix> <type>]
[(def: <name>
- /.Bundle
- (<| (/.prefix <prefix>)
- (|> (dict.new text.Hash<Text>)
- (/.install "+" (/.binary <type> <type> <type>))
- (/.install "-" (/.binary <type> <type> <type>))
- (/.install "*" (/.binary <type> <type> <type>))
- (/.install "/" (/.binary <type> <type> <type>))
- (/.install "%" (/.binary <type> <type> <type>))
- (/.install "=" (/.binary <type> <type> Boolean))
- (/.install "<" (/.binary <type> <type> Boolean))
- (/.install "and" (/.binary <type> <type> <type>))
- (/.install "or" (/.binary <type> <type> <type>))
- (/.install "xor" (/.binary <type> <type> <type>))
- (/.install "shl" (/.binary <type> Integer <type>))
- (/.install "shr" (/.binary <type> Integer <type>))
- (/.install "ushr" (/.binary <type> Integer <type>))
+ Bundle
+ (<| (bundle.prefix <prefix>)
+ (|> bundle.empty
+ (bundle.install "+" (common.binary <type> <type> <type>))
+ (bundle.install "-" (common.binary <type> <type> <type>))
+ (bundle.install "*" (common.binary <type> <type> <type>))
+ (bundle.install "/" (common.binary <type> <type> <type>))
+ (bundle.install "%" (common.binary <type> <type> <type>))
+ (bundle.install "=" (common.binary <type> <type> Boolean))
+ (bundle.install "<" (common.binary <type> <type> Boolean))
+ (bundle.install "and" (common.binary <type> <type> <type>))
+ (bundle.install "or" (common.binary <type> <type> <type>))
+ (bundle.install "xor" (common.binary <type> <type> <type>))
+ (bundle.install "shl" (common.binary <type> Integer <type>))
+ (bundle.install "shr" (common.binary <type> Integer <type>))
+ (bundle.install "ushr" (common.binary <type> Integer <type>))
)))]
- [int-procs "int" Integer]
- [long-procs "long" Long]
+ [bundle::int "int" Integer]
+ [bundle::long "long" Long]
)
(do-template [<name> <prefix> <type>]
[(def: <name>
- /.Bundle
- (<| (/.prefix <prefix>)
- (|> (dict.new text.Hash<Text>)
- (/.install "+" (/.binary <type> <type> <type>))
- (/.install "-" (/.binary <type> <type> <type>))
- (/.install "*" (/.binary <type> <type> <type>))
- (/.install "/" (/.binary <type> <type> <type>))
- (/.install "%" (/.binary <type> <type> <type>))
- (/.install "=" (/.binary <type> <type> Boolean))
- (/.install "<" (/.binary <type> <type> Boolean))
+ Bundle
+ (<| (bundle.prefix <prefix>)
+ (|> bundle.empty
+ (bundle.install "+" (common.binary <type> <type> <type>))
+ (bundle.install "-" (common.binary <type> <type> <type>))
+ (bundle.install "*" (common.binary <type> <type> <type>))
+ (bundle.install "/" (common.binary <type> <type> <type>))
+ (bundle.install "%" (common.binary <type> <type> <type>))
+ (bundle.install "=" (common.binary <type> <type> Boolean))
+ (bundle.install "<" (common.binary <type> <type> Boolean))
)))]
- [float-procs "float" Float]
- [double-procs "double" Double]
+ [bundle::float "float" Float]
+ [bundle::double "double" Double]
)
-(def: char-procs
- /.Bundle
- (<| (/.prefix "char")
- (|> (dict.new text.Hash<Text>)
- (/.install "=" (/.binary Character Character Boolean))
- (/.install "<" (/.binary Character Character Boolean))
+(def: bundle::char
+ Bundle
+ (<| (bundle.prefix "char")
+ (|> bundle.empty
+ (bundle.install "=" (common.binary Character Character Boolean))
+ (bundle.install "<" (common.binary Character Character Boolean))
)))
(def: #export boxes
@@ -211,33 +217,33 @@
["float" "java.lang.Float"]
["double" "java.lang.Double"]
["char" "java.lang.Character"])
- (dict.from-list text.Hash<Text>)))
+ (dictionary.from-list text.Hash<Text>)))
-(def: (array//length proc)
- (-> Text ///.Analysis)
- (function (_ analyse eval args)
+(def: array::length
+ Handler
+ (function (_ extension-name analyse args)
(case args
(^ (list arrayC))
- (do macro.Monad<Meta>
+ (do ////.Monad<Operation>
[_ (typeA.infer Nat)
- [var-id varT] (typeA.with-env tc.var)
+ [var-id varT] (typeA.with-env check.var)
arrayA (typeA.with-type (type (Array varT))
(analyse arrayC))]
- (wrap (#analysisL.Extension proc (list arrayA))))
+ (wrap (#analysis.Extension extension-name (list arrayA))))
_
- (language.throw /.incorrect-extension-arity [proc +1 (list.size args)]))))
+ (////.throw bundle.incorrect-arity [extension-name +1 (list.size args)]))))
-(def: (array//new proc)
- (-> Text ///.Analysis)
- (function (_ analyse eval args)
+(def: array::new
+ Handler
+ (function (_ extension-name analyse args)
(case args
(^ (list lengthC))
- (do macro.Monad<Meta>
+ (do ////.Monad<Operation>
[lengthA (typeA.with-type Nat
(analyse lengthC))
- expectedT macro.expected-type
- [level elem-class] (: (Meta [Nat Text])
+ expectedT (///.lift macro.expected-type)
+ [level elem-class] (: (Operation [Nat Text])
(loop [analysisT expectedT
level +0]
(case analysisT
@@ -247,7 +253,7 @@
(recur outputT level)
#.None
- (language.throw non-array expectedT))
+ (////.throw non-array expectedT))
(^ (#.Primitive "#Array" (list elemT)))
(recur elemT (inc level))
@@ -256,28 +262,28 @@
(wrap [level class])
_
- (language.throw non-array expectedT))))
+ (////.throw non-array expectedT))))
_ (if (n/> +0 level)
(wrap [])
- (language.throw non-array expectedT))]
- (wrap (#analysisL.Extension proc (list (analysisL.nat (dec level))
- (analysisL.text elem-class)
- lengthA))))
+ (////.throw non-array expectedT))]
+ (wrap (#analysis.Extension extension-name (list (analysis.nat (dec level))
+ (analysis.text elem-class)
+ lengthA))))
_
- (language.throw /.incorrect-extension-arity [proc +1 (list.size args)]))))
+ (////.throw bundle.incorrect-arity [extension-name +1 (list.size args)]))))
(def: (check-jvm objectT)
- (-> Type (Meta Text))
+ (-> Type (Operation Text))
(case objectT
(#.Primitive name _)
- (macro/wrap name)
+ (operation/wrap name)
(#.Named name unnamed)
(check-jvm unnamed)
(#.Var id)
- (macro/wrap "java.lang.Object")
+ (operation/wrap "java.lang.Object")
(^template [<tag>]
(<tag> env unquantified)
@@ -291,130 +297,130 @@
(check-jvm outputT)
#.None
- (language.throw non-object objectT))
+ (////.throw non-object objectT))
_
- (language.throw non-object objectT)))
+ (////.throw non-object objectT)))
(def: (check-object objectT)
- (-> Type (Meta Text))
- (do macro.Monad<Meta>
+ (-> Type (Operation Text))
+ (do ////.Monad<Operation>
[name (check-jvm objectT)]
- (if (dict.contains? name boxes)
- (language.throw primitives-are-not-objects name)
- (macro/wrap name))))
+ (if (dictionary.contains? name boxes)
+ (////.throw primitives-are-not-objects name)
+ (operation/wrap name))))
(def: (box-array-element-type elemT)
- (-> Type (Meta [Type Text]))
+ (-> Type (Operation [Type Text]))
(case elemT
(#.Primitive name #.Nil)
- (let [boxed-name (|> (dict.get name boxes)
+ (let [boxed-name (|> (dictionary.get name boxes)
(maybe.default name))]
- (macro/wrap [(#.Primitive boxed-name #.Nil)
- boxed-name]))
+ (operation/wrap [(#.Primitive boxed-name #.Nil)
+ boxed-name]))
(#.Primitive name _)
- (if (dict.contains? name boxes)
- (language.throw primitives-cannot-have-type-parameters name)
- (macro/wrap [elemT name]))
+ (if (dictionary.contains? name boxes)
+ (////.throw primitives-cannot-have-type-parameters name)
+ (operation/wrap [elemT name]))
_
- (language.throw invalid-type-for-array-element (%type elemT))))
+ (////.throw invalid-type-for-array-element (%type elemT))))
-(def: (array//read proc)
- (-> Text ///.Analysis)
- (function (_ analyse eval args)
+(def: array::read
+ Handler
+ (function (_ extension-name analyse args)
(case args
(^ (list arrayC idxC))
- (do macro.Monad<Meta>
- [[var-id varT] (typeA.with-env tc.var)
+ (do ////.Monad<Operation>
+ [[var-id varT] (typeA.with-env check.var)
_ (typeA.infer varT)
arrayA (typeA.with-type (type (Array varT))
(analyse arrayC))
?elemT (typeA.with-env
- (tc.read var-id))
+ (check.read var-id))
[elemT elem-class] (box-array-element-type (maybe.default varT ?elemT))
idxA (typeA.with-type Nat
(analyse idxC))]
- (wrap (#analysisL.Extension proc (list (analysisL.text elem-class) idxA arrayA))))
+ (wrap (#analysis.Extension extension-name (list (analysis.text elem-class) idxA arrayA))))
_
- (language.throw /.incorrect-extension-arity [proc +2 (list.size args)]))))
+ (////.throw bundle.incorrect-arity [extension-name +2 (list.size args)]))))
-(def: (array//write proc)
- (-> Text ///.Analysis)
- (function (_ analyse eval args)
+(def: array::write
+ Handler
+ (function (_ extension-name analyse args)
(case args
(^ (list arrayC idxC valueC))
- (do macro.Monad<Meta>
- [[var-id varT] (typeA.with-env tc.var)
+ (do ////.Monad<Operation>
+ [[var-id varT] (typeA.with-env check.var)
_ (typeA.infer (type (Array varT)))
arrayA (typeA.with-type (type (Array varT))
(analyse arrayC))
?elemT (typeA.with-env
- (tc.read var-id))
+ (check.read var-id))
[valueT elem-class] (box-array-element-type (maybe.default varT ?elemT))
idxA (typeA.with-type Nat
(analyse idxC))
valueA (typeA.with-type valueT
(analyse valueC))]
- (wrap (#analysisL.Extension proc (list (analysisL.text elem-class) idxA valueA arrayA))))
+ (wrap (#analysis.Extension extension-name (list (analysis.text elem-class) idxA valueA arrayA))))
_
- (language.throw /.incorrect-extension-arity [proc +3 (list.size args)]))))
-
-(def: array-procs
- /.Bundle
- (<| (/.prefix "array")
- (|> (dict.new text.Hash<Text>)
- (/.install "length" array//length)
- (/.install "new" array//new)
- (/.install "read" array//read)
- (/.install "write" array//write)
+ (////.throw bundle.incorrect-arity [extension-name +3 (list.size args)]))))
+
+(def: bundle::array
+ Bundle
+ (<| (bundle.prefix "array")
+ (|> bundle.empty
+ (bundle.install "length" array::length)
+ (bundle.install "new" array::new)
+ (bundle.install "read" array::read)
+ (bundle.install "write" array::write)
)))
-(def: (object//null proc)
- (-> Text ///.Analysis)
- (function (_ analyse eval args)
+(def: object::null
+ Handler
+ (function (_ extension-name analyse args)
(case args
(^ (list))
- (do macro.Monad<Meta>
- [expectedT macro.expected-type
+ (do ////.Monad<Operation>
+ [expectedT (///.lift macro.expected-type)
_ (check-object expectedT)]
- (wrap (#analysisL.Extension proc (list))))
+ (wrap (#analysis.Extension extension-name (list))))
_
- (language.throw /.incorrect-extension-arity [proc +0 (list.size args)]))))
+ (////.throw bundle.incorrect-arity [extension-name +0 (list.size args)]))))
-(def: (object//null? proc)
- (-> Text ///.Analysis)
- (function (_ analyse eval args)
+(def: object::null?
+ Handler
+ (function (_ extension-name analyse args)
(case args
(^ (list objectC))
- (do macro.Monad<Meta>
+ (do ////.Monad<Operation>
[_ (typeA.infer Bool)
[objectT objectA] (typeA.with-inference
(analyse objectC))
_ (check-object objectT)]
- (wrap (#analysisL.Extension proc (list objectA))))
+ (wrap (#analysis.Extension extension-name (list objectA))))
_
- (language.throw /.incorrect-extension-arity [proc +1 (list.size args)]))))
+ (////.throw bundle.incorrect-arity [extension-name +1 (list.size args)]))))
-(def: (object//synchronized proc)
- (-> Text ///.Analysis)
- (function (_ analyse eval args)
+(def: object::synchronized
+ Handler
+ (function (_ extension-name analyse args)
(case args
(^ (list monitorC exprC))
- (do macro.Monad<Meta>
+ (do ////.Monad<Operation>
[[monitorT monitorA] (typeA.with-inference
(analyse monitorC))
_ (check-object monitorT)
exprA (analyse exprC)]
- (wrap (#analysisL.Extension proc (list monitorA exprA))))
+ (wrap (#analysis.Extension extension-name (list monitorA exprA))))
_
- (language.throw /.incorrect-extension-arity [proc +2 (list.size args)]))))
+ (////.throw bundle.incorrect-arity [extension-name +2 (list.size args)]))))
(host.import: java/lang/Object
(equals [Object] boolean))
@@ -476,110 +482,110 @@
(getDeclaredMethods [] (Array Method)))
(def: (load-class name)
- (-> Text (Meta (Class Object)))
- (do macro.Monad<Meta>
+ (-> Text (Operation (Class Object)))
+ (do ////.Monad<Operation>
[]
(case (Class::forName [name])
(#e.Success [class])
(wrap class)
(#e.Error error)
- (language.throw unknown-class name))))
+ (////.throw unknown-class name))))
(def: (sub-class? super sub)
- (-> Text Text (Meta Bool))
- (do macro.Monad<Meta>
+ (-> Text Text (Operation Bool))
+ (do ////.Monad<Operation>
[super (load-class super)
sub (load-class sub)]
(wrap (Class::isAssignableFrom [sub] super))))
-(def: (object//throw proc)
- (-> Text ///.Analysis)
- (function (_ analyse eval args)
+(def: object::throw
+ Handler
+ (function (_ extension-name analyse args)
(case args
(^ (list exceptionC))
- (do macro.Monad<Meta>
+ (do ////.Monad<Operation>
[_ (typeA.infer Nothing)
[exceptionT exceptionA] (typeA.with-inference
(analyse exceptionC))
exception-class (check-object exceptionT)
? (sub-class? "java.lang.Throwable" exception-class)
- _ (: (Meta Any)
+ _ (: (Operation Any)
(if ?
(wrap [])
- (language.throw non-throwable exception-class)))]
- (wrap (#analysisL.Extension proc (list exceptionA))))
+ (////.throw non-throwable exception-class)))]
+ (wrap (#analysis.Extension extension-name (list exceptionA))))
_
- (language.throw /.incorrect-extension-arity [proc +1 (list.size args)]))))
+ (////.throw bundle.incorrect-arity [extension-name +1 (list.size args)]))))
-(def: (object//class proc)
- (-> Text ///.Analysis)
- (function (_ analyse eval args)
+(def: object::class
+ Handler
+ (function (_ extension-name analyse args)
(case args
(^ (list classC))
(case classC
[_ (#.Text class)]
- (do macro.Monad<Meta>
+ (do ////.Monad<Operation>
[_ (typeA.infer (#.Primitive "java.lang.Class" (list (#.Primitive class (list)))))
_ (load-class class)]
- (wrap (#analysisL.Extension proc (list (analysisL.text class)))))
+ (wrap (#analysis.Extension extension-name (list (analysis.text class)))))
_
- (language.throw /.invalid-syntax [proc args]))
+ (////.throw bundle.invalid-syntax extension-name))
_
- (language.throw /.incorrect-extension-arity [proc +1 (list.size args)]))))
+ (////.throw bundle.incorrect-arity [extension-name +1 (list.size args)]))))
-(def: (object//instance? proc)
- (-> Text ///.Analysis)
- (function (_ analyse eval args)
+(def: object::instance?
+ Handler
+ (function (_ extension-name analyse args)
(case args
(^ (list classC objectC))
(case classC
[_ (#.Text class)]
- (do macro.Monad<Meta>
+ (do ////.Monad<Operation>
[_ (typeA.infer Bool)
[objectT objectA] (typeA.with-inference
(analyse objectC))
object-class (check-object objectT)
? (sub-class? class object-class)]
(if ?
- (wrap (#analysisL.Extension proc (list (analysisL.text class))))
- (language.throw cannot-possibly-be-an-instance (format object-class " !<= " class))))
+ (wrap (#analysis.Extension extension-name (list (analysis.text class))))
+ (////.throw cannot-possibly-be-an-instance (format object-class " !<= " class))))
_
- (language.throw /.invalid-syntax [proc args]))
+ (////.throw bundle.invalid-syntax extension-name))
_
- (language.throw /.incorrect-extension-arity [proc +2 (list.size args)]))))
+ (////.throw bundle.incorrect-arity [extension-name +2 (list.size args)]))))
-(def: (java-type-to-class type)
- (-> java/lang/reflect/Type (Meta Text))
- (cond (host.instance? Class type)
- (macro/wrap (Class::getName [] (:coerce Class type)))
+(def: (java-type-to-class jvm-type)
+ (-> java/lang/reflect/Type (Operation Text))
+ (cond (host.instance? Class jvm-type)
+ (operation/wrap (Class::getName [] (:coerce Class jvm-type)))
- (host.instance? ParameterizedType type)
- (java-type-to-class (ParameterizedType::getRawType [] (:coerce ParameterizedType type)))
+ (host.instance? ParameterizedType jvm-type)
+ (java-type-to-class (ParameterizedType::getRawType [] (:coerce ParameterizedType jvm-type)))
## else
- (language.throw cannot-convert-to-a-class (jvm-type-name type))))
+ (////.throw cannot-convert-to-a-class jvm-type)))
(type: Mappings
(Dictionary Text Type))
-(def: fresh-mappings Mappings (dict.new text.Hash<Text>))
+(def: fresh-mappings Mappings (dictionary.new text.Hash<Text>))
(def: (java-type-to-lux-type mappings java-type)
- (-> Mappings java/lang/reflect/Type (Meta Type))
+ (-> Mappings java/lang/reflect/Type (Operation Type))
(cond (host.instance? TypeVariable java-type)
(let [var-name (TypeVariable::getName [] (:coerce TypeVariable java-type))]
- (case (dict.get var-name mappings)
+ (case (dictionary.get var-name mappings)
(#.Some var-type)
- (macro/wrap var-type)
+ (operation/wrap var-type)
#.None
- (language.throw unknown-type-var var-name)))
+ (////.throw unknown-type-var var-name)))
(host.instance? WildcardType java-type)
(let [java-type (:coerce WildcardType java-type)]
@@ -589,47 +595,47 @@
(java-type-to-lux-type mappings bound)
_
- (macro/wrap Any)))
+ (operation/wrap Any)))
(host.instance? Class java-type)
(let [java-type (:coerce (Class Object) java-type)
class-name (Class::getName [] java-type)]
- (macro/wrap (case (array.size (Class::getTypeParameters [] java-type))
- +0
- (#.Primitive class-name (list))
-
- arity
- (|> (list.n/range +0 (dec arity))
- list.reverse
- (list/map (|>> (n/* +2) inc #.Parameter))
- (#.Primitive class-name)
- (type.univ-q arity)))))
+ (operation/wrap (case (array.size (Class::getTypeParameters [] java-type))
+ +0
+ (#.Primitive class-name (list))
+
+ arity
+ (|> (list.n/range +0 (dec arity))
+ list.reverse
+ (list/map (|>> (n/* +2) inc #.Parameter))
+ (#.Primitive class-name)
+ (type.univ-q arity)))))
(host.instance? ParameterizedType java-type)
(let [java-type (:coerce ParameterizedType java-type)
raw (ParameterizedType::getRawType [] java-type)]
(if (host.instance? Class raw)
- (do macro.Monad<Meta>
+ (do ////.Monad<Operation>
[paramsT (|> java-type
(ParameterizedType::getActualTypeArguments [])
array.to-list
(monad.map @ (java-type-to-lux-type mappings)))]
- (macro/wrap (#.Primitive (Class::getName [] (:coerce (Class Object) raw))
- paramsT)))
- (language.throw jvm-type-is-not-a-class raw)))
+ (operation/wrap (#.Primitive (Class::getName [] (:coerce (Class Object) raw))
+ paramsT)))
+ (////.throw jvm-type-is-not-a-class raw)))
(host.instance? GenericArrayType java-type)
- (do macro.Monad<Meta>
+ (do ////.Monad<Operation>
[innerT (|> (:coerce GenericArrayType java-type)
(GenericArrayType::getGenericComponentType [])
(java-type-to-lux-type mappings))]
(wrap (#.Primitive "#Array" (list innerT))))
## else
- (language.throw cannot-convert-to-a-lux-type (jvm-type-name java-type))))
+ (////.throw cannot-convert-to-a-lux-type java-type)))
(def: (correspond-type-params class type)
- (-> (Class Object) Type (Meta Mappings))
+ (-> (Class Object) Type (Operation Mappings))
(case type
(#.Primitive name params)
(let [class-name (Class::getName [] class)
@@ -637,38 +643,38 @@
num-class-params (list.size class-params)
num-type-params (list.size params)]
(cond (not (text/= class-name name))
- (language.throw cannot-correspond-type-with-a-class
- (format "Class = " class-name "\n"
- "Type = " (%type type)))
+ (////.throw cannot-correspond-type-with-a-class
+ (format "Class = " class-name "\n"
+ "Type = " (%type type)))
(not (n/= num-class-params num-type-params))
- (language.throw type-parameter-mismatch
- (format "Expected: " (%i (.int num-class-params)) "\n"
- " Actual: " (%i (.int num-type-params)) "\n"
- " Class: " class-name "\n"
- " Type: " (%type type)))
+ (////.throw type-parameter-mismatch
+ (format "Expected: " (%i (.int num-class-params)) "\n"
+ " Actual: " (%i (.int num-type-params)) "\n"
+ " Class: " class-name "\n"
+ " Type: " (%type type)))
## else
- (macro/wrap (|> params
- (list.zip2 (list/map (TypeVariable::getName []) class-params))
- (dict.from-list text.Hash<Text>)))
+ (operation/wrap (|> params
+ (list.zip2 (list/map (TypeVariable::getName []) class-params))
+ (dictionary.from-list text.Hash<Text>)))
))
_
- (language.throw non-jvm-type type)))
+ (////.throw non-jvm-type type)))
-(def: (object//cast proc)
- (-> Text ///.Analysis)
- (function (_ analyse eval args)
+(def: object::cast
+ Handler
+ (function (_ extension-name analyse args)
(case args
(^ (list valueC))
- (do macro.Monad<Meta>
- [toT macro.expected-type
+ (do ////.Monad<Operation>
+ [toT (///.lift macro.expected-type)
to-name (check-jvm toT)
[valueT valueA] (typeA.with-inference
(analyse valueC))
from-name (check-jvm valueT)
- can-cast? (: (Meta Bool)
+ can-cast? (: (Operation Bool)
(case [from-name to-name]
(^template [<primitive> <object>]
(^or [<primitive> <object>]
@@ -687,10 +693,10 @@
_
(do @
- [_ (language.assert primitives-are-not-objects from-name
- (not (dict.contains? from-name boxes)))
- _ (language.assert primitives-are-not-objects to-name
- (not (dict.contains? to-name boxes)))
+ [_ (////.assert primitives-are-not-objects from-name
+ (not (dictionary.contains? from-name boxes)))
+ _ (////.assert primitives-are-not-objects to-name
+ (not (dictionary.contains? to-name boxes)))
to-class (load-class to-name)]
(loop [[current-name currentT] [from-name valueT]]
(if (text/= to-name current-name)
@@ -699,10 +705,10 @@
(wrap true))
(do @
[current-class (load-class current-name)
- _ (language.assert cannot-cast (format "From class/primitive: " current-name "\n"
- " To class/primitive: " to-name "\n"
- " For value: " (%code valueC) "\n")
- (Class::isAssignableFrom [current-class] to-class))
+ _ (////.assert cannot-cast (format "From class/primitive: " current-name "\n"
+ " To class/primitive: " to-name "\n"
+ " For value: " (%code valueC) "\n")
+ (Class::isAssignableFrom [current-class] to-class))
candiate-parents (monad.map @
(function (_ java-type)
(do @
@@ -721,54 +727,54 @@
(recur [next-name nextT]))
#.Nil
- (language.throw cannot-cast (format "From class/primitive: " from-name "\n"
- " To class/primitive: " to-name "\n"
- " For value: " (%code valueC) "\n")))
+ (////.throw cannot-cast (format "From class/primitive: " from-name "\n"
+ " To class/primitive: " to-name "\n"
+ " For value: " (%code valueC) "\n")))
))))))]
(if can-cast?
- (wrap (#analysisL.Extension proc (list (analysisL.text from-name)
- (analysisL.text to-name)
- valueA)))
- (language.throw cannot-cast (format "From class/primitive: " from-name "\n"
- " To class/primitive: " to-name "\n"
- " For value: " (%code valueC) "\n"))))
+ (wrap (#analysis.Extension extension-name (list (analysis.text from-name)
+ (analysis.text to-name)
+ valueA)))
+ (////.throw cannot-cast (format "From class/primitive: " from-name "\n"
+ " To class/primitive: " to-name "\n"
+ " For value: " (%code valueC) "\n"))))
_
- (language.throw /.invalid-syntax [proc args]))))
-
-(def: object-procs
- /.Bundle
- (<| (/.prefix "object")
- (|> (dict.new text.Hash<Text>)
- (/.install "null" object//null)
- (/.install "null?" object//null?)
- (/.install "synchronized" object//synchronized)
- (/.install "throw" object//throw)
- (/.install "class" object//class)
- (/.install "instance?" object//instance?)
- (/.install "cast" object//cast)
+ (////.throw bundle.invalid-syntax extension-name))))
+
+(def: bundle::object
+ Bundle
+ (<| (bundle.prefix "object")
+ (|> bundle.empty
+ (bundle.install "null" object::null)
+ (bundle.install "null?" object::null?)
+ (bundle.install "synchronized" object::synchronized)
+ (bundle.install "throw" object::throw)
+ (bundle.install "class" object::class)
+ (bundle.install "instance?" object::instance?)
+ (bundle.install "cast" object::cast)
)))
(def: (find-field class-name field-name)
- (-> Text Text (Meta [(Class Object) Field]))
- (do macro.Monad<Meta>
+ (-> Text Text (Operation [(Class Object) Field]))
+ (do ////.Monad<Operation>
[class (load-class class-name)]
(case (Class::getDeclaredField [field-name] class)
(#e.Success field)
(let [owner (Field::getDeclaringClass [] field)]
(if (is? owner class)
(wrap [class field])
- (language.throw mistaken-field-owner
- (format " Field: " field-name "\n"
- " Owner Class: " (Class::getName [] owner) "\n"
- "Target Class: " class-name "\n"))))
+ (////.throw mistaken-field-owner
+ (format " Field: " field-name "\n"
+ " Owner Class: " (Class::getName [] owner) "\n"
+ "Target Class: " class-name "\n"))))
(#e.Error _)
- (language.throw unknown-field (format class-name "#" field-name)))))
+ (////.throw unknown-field (format class-name "#" field-name)))))
(def: (static-field class-name field-name)
- (-> Text Text (Meta [Type Bool]))
- (do macro.Monad<Meta>
+ (-> Text Text (Operation [Type Bool]))
+ (do ////.Monad<Operation>
[[class fieldJ] (find-field class-name field-name)
#let [modifiers (Field::getModifiers [] fieldJ)]]
(if (Modifier::isStatic [modifiers])
@@ -776,11 +782,11 @@
(do @
[fieldT (java-type-to-lux-type fresh-mappings fieldJT)]
(wrap [fieldT (Modifier::isFinal [modifiers])])))
- (language.throw not-a-static-field (format class-name "#" field-name)))))
+ (////.throw not-a-static-field (format class-name "#" field-name)))))
(def: (virtual-field class-name field-name objectT)
- (-> Text Text Type (Meta [Type Bool]))
- (do macro.Monad<Meta>
+ (-> Text Text Type (Operation [Type Bool]))
+ (do ////.Monad<Operation>
[[class fieldJ] (find-field class-name field-name)
#let [modifiers (Field::getModifiers [] fieldJ)]]
(if (not (Modifier::isStatic [modifiers]))
@@ -790,130 +796,130 @@
(Class::getTypeParameters [])
array.to-list
(list/map (TypeVariable::getName [])))]
- mappings (: (Meta Mappings)
+ mappings (: (Operation Mappings)
(case objectT
(#.Primitive _class-name _class-params)
(do @
[#let [num-params (list.size _class-params)
num-vars (list.size var-names)]
- _ (language.assert type-parameter-mismatch
- (format "Expected: " (%i (.int num-params)) "\n"
- " Actual: " (%i (.int num-vars)) "\n"
- " Class: " _class-name "\n"
- " Type: " (%type objectT))
- (n/= num-params num-vars))]
+ _ (////.assert type-parameter-mismatch
+ (format "Expected: " (%i (.int num-params)) "\n"
+ " Actual: " (%i (.int num-vars)) "\n"
+ " Class: " _class-name "\n"
+ " Type: " (%type objectT))
+ (n/= num-params num-vars))]
(wrap (|> (list.zip2 var-names _class-params)
- (dict.from-list text.Hash<Text>))))
+ (dictionary.from-list text.Hash<Text>))))
_
- (language.throw non-object objectT)))
+ (////.throw non-object objectT)))
fieldT (java-type-to-lux-type mappings fieldJT)]
(wrap [fieldT (Modifier::isFinal [modifiers])]))
- (language.throw not-a-virtual-field (format class-name "#" field-name)))))
+ (////.throw not-a-virtual-field (format class-name "#" field-name)))))
-(def: (static//get proc)
- (-> Text ///.Analysis)
- (function (_ analyse eval args)
+(def: static::get
+ Handler
+ (function (_ extension-name analyse args)
(case args
(^ (list classC fieldC))
(case [classC fieldC]
[[_ (#.Text class)] [_ (#.Text field)]]
- (do macro.Monad<Meta>
+ (do ////.Monad<Operation>
[[fieldT final?] (static-field class field)]
- (wrap (#analysisL.Extension proc (list (analysisL.text class) (analysisL.text field)))))
+ (wrap (#analysis.Extension extension-name (list (analysis.text class) (analysis.text field)))))
_
- (language.throw /.invalid-syntax [proc args]))
+ (////.throw bundle.invalid-syntax extension-name))
_
- (language.throw /.incorrect-extension-arity [proc +2 (list.size args)]))))
+ (////.throw bundle.incorrect-arity [extension-name +2 (list.size args)]))))
-(def: (static//put proc)
- (-> Text ///.Analysis)
- (function (_ analyse eval args)
+(def: static::put
+ Handler
+ (function (_ extension-name analyse args)
(case args
(^ (list classC fieldC valueC))
(case [classC fieldC]
[[_ (#.Text class)] [_ (#.Text field)]]
- (do macro.Monad<Meta>
+ (do ////.Monad<Operation>
[_ (typeA.infer Any)
[fieldT final?] (static-field class field)
- _ (language.assert cannot-set-a-final-field (format class "#" field)
- (not final?))
+ _ (////.assert cannot-set-a-final-field (format class "#" field)
+ (not final?))
valueA (typeA.with-type fieldT
(analyse valueC))]
- (wrap (#analysisL.Extension proc (list (analysisL.text class) (analysisL.text field) valueA))))
+ (wrap (#analysis.Extension extension-name (list (analysis.text class) (analysis.text field) valueA))))
_
- (language.throw /.invalid-syntax [proc args]))
+ (////.throw bundle.invalid-syntax extension-name))
_
- (language.throw /.incorrect-extension-arity [proc +3 (list.size args)]))))
+ (////.throw bundle.incorrect-arity [extension-name +3 (list.size args)]))))
-(def: (virtual//get proc)
- (-> Text ///.Analysis)
- (function (_ analyse eval args)
+(def: virtual::get
+ Handler
+ (function (_ extension-name analyse args)
(case args
(^ (list classC fieldC objectC))
(case [classC fieldC]
[[_ (#.Text class)] [_ (#.Text field)]]
- (do macro.Monad<Meta>
+ (do ////.Monad<Operation>
[[objectT objectA] (typeA.with-inference
(analyse objectC))
[fieldT final?] (virtual-field class field objectT)]
- (wrap (#analysisL.Extension proc (list (analysisL.text class) (analysisL.text field) objectA))))
+ (wrap (#analysis.Extension extension-name (list (analysis.text class) (analysis.text field) objectA))))
_
- (language.throw /.invalid-syntax [proc args]))
+ (////.throw bundle.invalid-syntax extension-name))
_
- (language.throw /.incorrect-extension-arity [proc +3 (list.size args)]))))
+ (////.throw bundle.incorrect-arity [extension-name +3 (list.size args)]))))
-(def: (virtual//put proc)
- (-> Text ///.Analysis)
- (function (_ analyse eval args)
+(def: virtual::put
+ Handler
+ (function (_ extension-name analyse args)
(case args
(^ (list classC fieldC valueC objectC))
(case [classC fieldC]
[[_ (#.Text class)] [_ (#.Text field)]]
- (do macro.Monad<Meta>
+ (do ////.Monad<Operation>
[[objectT objectA] (typeA.with-inference
(analyse objectC))
_ (typeA.infer objectT)
[fieldT final?] (virtual-field class field objectT)
- _ (language.assert cannot-set-a-final-field (format class "#" field)
- (not final?))
+ _ (////.assert cannot-set-a-final-field (format class "#" field)
+ (not final?))
valueA (typeA.with-type fieldT
(analyse valueC))]
- (wrap (#analysisL.Extension proc (list (analysisL.text class) (analysisL.text field) valueA objectA))))
+ (wrap (#analysis.Extension extension-name (list (analysis.text class) (analysis.text field) valueA objectA))))
_
- (language.throw /.invalid-syntax [proc args]))
+ (////.throw bundle.invalid-syntax extension-name))
_
- (language.throw /.incorrect-extension-arity [proc +4 (list.size args)]))))
+ (////.throw bundle.incorrect-arity [extension-name +4 (list.size args)]))))
(def: (java-type-to-parameter type)
- (-> java/lang/reflect/Type (Meta Text))
+ (-> java/lang/reflect/Type (Operation Text))
(cond (host.instance? Class type)
- (macro/wrap (Class::getName [] (:coerce Class type)))
+ (operation/wrap (Class::getName [] (:coerce Class type)))
(host.instance? ParameterizedType type)
(java-type-to-parameter (ParameterizedType::getRawType [] (:coerce ParameterizedType type)))
(or (host.instance? TypeVariable type)
(host.instance? WildcardType type))
- (macro/wrap "java.lang.Object")
+ (operation/wrap "java.lang.Object")
(host.instance? GenericArrayType type)
- (do macro.Monad<Meta>
+ (do ////.Monad<Operation>
[componentP (java-type-to-parameter (GenericArrayType::getGenericComponentType [] (:coerce GenericArrayType type)))]
(wrap (format componentP "[]")))
## else
- (language.throw cannot-convert-to-a-parameter (jvm-type-name type))))
+ (////.throw cannot-convert-to-a-parameter type)))
-(type: Method-style
+(type: Method-Style
#Static
#Abstract
#Virtual
@@ -921,8 +927,8 @@
#Interface)
(def: (check-method class method-name method-style arg-classes method)
- (-> (Class Object) Text Method-style (List Text) Method (Meta Bool))
- (do macro.Monad<Meta>
+ (-> (Class Object) Text Method-Style (List Text) Method (Operation Bool))
+ (do ////.Monad<Operation>
[parameters (|> (Method::getGenericParameterTypes [] method)
array.to-list
(monad.map @ java-type-to-parameter))
@@ -950,8 +956,8 @@
(list.zip2 arg-classes parameters))))))
(def: (check-constructor class arg-classes constructor)
- (-> (Class Object) (List Text) (Constructor Object) (Meta Bool))
- (do macro.Monad<Meta>
+ (-> (Class Object) (List Text) (Constructor Object) (Operation Bool))
+ (do ////.Monad<Operation>
[parameters (|> (Constructor::getGenericParameterTypes [] constructor)
array.to-list
(monad.map @ java-type-to-parameter))]
@@ -974,8 +980,8 @@
(|> (list.n/range offset (|> amount dec (n/+ offset)))
(list/map idx-to-parameter))))
-(def: (method-to-type method-style method)
- (-> Method-style Method (Meta [Type (List Type)]))
+(def: (method-signature method-style method)
+ (-> Method-Style Method (Operation Method-Signature))
(let [owner (Method::getDeclaringClass [] method)
owner-name (Class::getName [] owner)
owner-tvars (case method-style
@@ -1001,8 +1007,8 @@
(|> (list/compose owner-tvarsT method-tvarsT)
list.reverse
(list.zip2 all-tvars)
- (dict.from-list text.Hash<Text>))))]
- (do macro.Monad<Meta>
+ (dictionary.from-list text.Hash<Text>))))]
+ (do ////.Monad<Operation>
[inputsT (|> (Method::getGenericParameterTypes [] method)
array.to-list
(monad.map @ (java-type-to-lux-type mappings)))
@@ -1021,14 +1027,14 @@
outputT)]]
(wrap [methodT exceptionsT]))))
-(type: (Evaluation a)
- (#Pass a)
- (#Hint a)
+(type: Evaluation
+ (#Pass Method-Signature)
+ (#Hint Method-Signature)
#Fail)
(do-template [<name> <tag>]
[(def: <name>
- (All [a] (-> (Evaluation a) (Maybe a)))
+ (-> Evaluation (Maybe Method-Signature))
(|>> (case> (<tag> output)
(#.Some output)
@@ -1040,40 +1046,36 @@
)
(def: (method-candidate class-name method-name method-style arg-classes)
- (-> Text Text Method-style (List Text) (Meta [Type (List Type)]))
- (do macro.Monad<Meta>
+ (-> Text Text Method-Style (List Text) (Operation Method-Signature))
+ (do ////.Monad<Operation>
[class (load-class class-name)
candidates (|> class
(Class::getDeclaredMethods [])
array.to-list
- (monad.map @ (: (-> Method (Meta (Evaluation Method)))
+ (monad.map @ (: (-> Method (Operation Evaluation))
(function (_ method)
(do @
[passes? (check-method class method-name method-style arg-classes method)]
- (wrap (cond passes?
- (#Pass method)
+ (cond passes?
+ (:: @ map (|>> #Pass) (method-signature method-style method))
- (text/= method-name (Method::getName [] method))
- (#Hint method)
+ (text/= method-name (Method::getName [] method))
+ (:: @ map (|>> #Hint) (method-signature method-style method))
- ## else
- #Fail)))))))]
+ ## else
+ (wrap #Fail)))))))]
(case (list.search-all pass! candidates)
#.Nil
- (language.throw no-candidates [class-name method-name
- (|> candidates
- (list.search-all hint!)
- (list/map (method-to-type method-style)))])
+ (////.throw no-candidates [class-name method-name (list.search-all hint! candidates)])
(#.Cons method #.Nil)
- (method-to-type method-style method)
+ (wrap method)
candidates
- (language.throw too-many-candidates [class-name method-name
- (list/map (method-to-type method-style) candidates)]))))
+ (////.throw too-many-candidates [class-name method-name candidates]))))
-(def: (constructor-to-type constructor)
- (-> (Constructor Object) (Meta [Type (List Type)]))
+(def: (constructor-signature constructor)
+ (-> (Constructor Object) (Operation Method-Signature))
(let [owner (Constructor::getDeclaringClass [] constructor)
owner-name (Class::getName [] owner)
owner-tvars (|> (Class::getTypeParameters [] owner)
@@ -1093,8 +1095,8 @@
(|> (list/compose owner-tvarsT constructor-tvarsT)
list.reverse
(list.zip2 all-tvars)
- (dict.from-list text.Hash<Text>))))]
- (do macro.Monad<Meta>
+ (dictionary.from-list text.Hash<Text>))))]
+ (do ////.Monad<Operation>
[inputsT (|> (Constructor::getGenericParameterTypes [] constructor)
array.to-list
(monad.map @ (java-type-to-lux-type mappings)))
@@ -1110,8 +1112,8 @@
(def: constructor-method "<init>")
(def: (constructor-candidate class-name arg-classes)
- (-> Text (List Text) (Meta [Type (List Type)]))
- (do macro.Monad<Meta>
+ (-> Text (List Text) (Operation Method-Signature))
+ (do ////.Monad<Operation>
[class (load-class class-name)
candidates (|> class
(Class::getConstructors [])
@@ -1119,52 +1121,50 @@
(monad.map @ (function (_ constructor)
(do @
[passes? (check-constructor class arg-classes constructor)]
- (wrap [passes? constructor])))))]
+ (:: @ map
+ (if passes? (|>> #Pass) (|>> #Hint))
+ (constructor-signature constructor))))))]
(case (list.search-all pass! candidates)
#.Nil
- (language.throw no-candidates [class-name ..constructor-method
- (|> candidates
- (list.search-all hint!)
- (list/map constructor-to-type))])
+ (////.throw no-candidates [class-name ..constructor-method (list.search-all hint! candidates)])
(#.Cons constructor #.Nil)
- (constructor-to-type constructor)
+ (wrap constructor)
candidates
- (language.throw too-many-candidates [class-name ..constructor-method
- (list/map constructor-to-type candidates)]))))
+ (////.throw too-many-candidates [class-name ..constructor-method candidates]))))
(def: (decorate-inputs typesT inputsA)
(-> (List Text) (List Analysis) (List Analysis))
(|> inputsA
- (list.zip2 (list/map analysisL.text typesT))
+ (list.zip2 (list/map analysis.text typesT))
(list/map (function (_ [type value])
- (analysisL.product-analysis (list type value))))))
+ (analysis.product-analysis (list type value))))))
-(def: (invoke//static proc)
- (-> Text ///.Analysis)
- (function (_ analyse eval args)
+(def: invoke::static
+ Handler
+ (function (_ extension-name analyse args)
(case (: (e.Error [Text Text (List [Text Code])])
(s.run args ($_ p.seq s.text s.text (p.some (s.tuple (p.seq s.text s.any))))))
(#e.Success [class method argsTC])
- (do macro.Monad<Meta>
+ (do ////.Monad<Operation>
[#let [argsT (list/map product.left argsTC)]
[methodT exceptionsT] (method-candidate class method #Static argsT)
[outputT argsA] (inferenceA.general analyse methodT (list/map product.right argsTC))
outputJC (check-jvm outputT)]
- (wrap (#analysisL.Extension proc (list& (analysisL.text class) (analysisL.text method)
- (analysisL.text outputJC) (decorate-inputs argsT argsA)))))
+ (wrap (#analysis.Extension extension-name (list& (analysis.text class) (analysis.text method)
+ (analysis.text outputJC) (decorate-inputs argsT argsA)))))
_
- (language.throw /.invalid-syntax [proc args]))))
+ (////.throw bundle.invalid-syntax extension-name))))
-(def: (invoke//virtual proc)
- (-> Text ///.Analysis)
- (function (_ analyse eval args)
+(def: invoke::virtual
+ Handler
+ (function (_ extension-name analyse args)
(case (: (e.Error [Text Text Code (List [Text Code])])
(s.run args ($_ p.seq s.text s.text s.any (p.some (s.tuple (p.seq s.text s.any))))))
(#e.Success [class method objectC argsTC])
- (do macro.Monad<Meta>
+ (do ////.Monad<Operation>
[#let [argsT (list/map product.left argsTC)]
[methodT exceptionsT] (method-candidate class method #Virtual argsT)
[outputT allA] (inferenceA.general analyse methodT (list& objectC (list/map product.right argsTC)))
@@ -1175,98 +1175,98 @@
_
(undefined))]
outputJC (check-jvm outputT)]
- (wrap (#analysisL.Extension proc (list& (analysisL.text class) (analysisL.text method)
- (analysisL.text outputJC) objectA (decorate-inputs argsT argsA)))))
+ (wrap (#analysis.Extension extension-name (list& (analysis.text class) (analysis.text method)
+ (analysis.text outputJC) objectA (decorate-inputs argsT argsA)))))
_
- (language.throw /.invalid-syntax [proc args]))))
+ (////.throw bundle.invalid-syntax extension-name))))
-(def: (invoke//special proc)
- (-> Text ///.Analysis)
- (function (_ analyse eval args)
+(def: invoke::special
+ Handler
+ (function (_ extension-name analyse args)
(case (: (e.Error [(List Code) [Text Text Code (List [Text Code]) Any]])
(p.run args ($_ p.seq s.text s.text s.any (p.some (s.tuple (p.seq s.text s.any))) s.end!)))
(#e.Success [_ [class method objectC argsTC _]])
- (do macro.Monad<Meta>
+ (do ////.Monad<Operation>
[#let [argsT (list/map product.left argsTC)]
[methodT exceptionsT] (method-candidate class method #Special argsT)
[outputT argsA] (inferenceA.general analyse methodT (list& objectC (list/map product.right argsTC)))
outputJC (check-jvm outputT)]
- (wrap (#analysisL.Extension proc (list& (analysisL.text class) (analysisL.text method)
- (analysisL.text outputJC) (decorate-inputs argsT argsA)))))
+ (wrap (#analysis.Extension extension-name (list& (analysis.text class) (analysis.text method)
+ (analysis.text outputJC) (decorate-inputs argsT argsA)))))
_
- (language.throw /.invalid-syntax [proc args]))))
+ (////.throw bundle.invalid-syntax extension-name))))
-(def: (invoke//interface proc)
- (-> Text ///.Analysis)
- (function (_ analyse eval args)
+(def: invoke::interface
+ Handler
+ (function (_ extension-name analyse args)
(case (: (e.Error [Text Text Code (List [Text Code])])
(s.run args ($_ p.seq s.text s.text s.any (p.some (s.tuple (p.seq s.text s.any))))))
(#e.Success [class-name method objectC argsTC])
- (do macro.Monad<Meta>
+ (do ////.Monad<Operation>
[#let [argsT (list/map product.left argsTC)]
class (load-class class-name)
- _ (language.assert non-interface class-name
- (Modifier::isInterface [(Class::getModifiers [] class)]))
+ _ (////.assert non-interface class-name
+ (Modifier::isInterface [(Class::getModifiers [] class)]))
[methodT exceptionsT] (method-candidate class-name method #Interface argsT)
[outputT argsA] (inferenceA.general analyse methodT (list& objectC (list/map product.right argsTC)))
outputJC (check-jvm outputT)]
- (wrap (#analysisL.Extension proc
- (list& (analysisL.text class-name) (analysisL.text method) (analysisL.text outputJC)
- (decorate-inputs argsT argsA)))))
+ (wrap (#analysis.Extension extension-name
+ (list& (analysis.text class-name) (analysis.text method) (analysis.text outputJC)
+ (decorate-inputs argsT argsA)))))
_
- (language.throw /.invalid-syntax [proc args]))))
+ (////.throw bundle.invalid-syntax extension-name))))
-(def: (invoke//constructor proc)
- (-> Text ///.Analysis)
- (function (_ analyse eval args)
+(def: invoke::constructor
+ Handler
+ (function (_ extension-name analyse args)
(case (: (e.Error [Text (List [Text Code])])
(s.run args ($_ p.seq s.text (p.some (s.tuple (p.seq s.text s.any))))))
(#e.Success [class argsTC])
- (do macro.Monad<Meta>
+ (do ////.Monad<Operation>
[#let [argsT (list/map product.left argsTC)]
[methodT exceptionsT] (constructor-candidate class argsT)
[outputT argsA] (inferenceA.general analyse methodT (list/map product.right argsTC))]
- (wrap (#analysisL.Extension proc (list& (analysisL.text class) (decorate-inputs argsT argsA)))))
+ (wrap (#analysis.Extension extension-name (list& (analysis.text class) (decorate-inputs argsT argsA)))))
_
- (language.throw /.invalid-syntax [proc args]))))
-
-(def: member-procs
- /.Bundle
- (<| (/.prefix "member")
- (|> (dict.new text.Hash<Text>)
- (dict.merge (<| (/.prefix "static")
- (|> (dict.new text.Hash<Text>)
- (/.install "get" static//get)
- (/.install "put" static//put))))
- (dict.merge (<| (/.prefix "virtual")
- (|> (dict.new text.Hash<Text>)
- (/.install "get" virtual//get)
- (/.install "put" virtual//put))))
- (dict.merge (<| (/.prefix "invoke")
- (|> (dict.new text.Hash<Text>)
- (/.install "static" invoke//static)
- (/.install "virtual" invoke//virtual)
- (/.install "special" invoke//special)
- (/.install "interface" invoke//interface)
- (/.install "constructor" invoke//constructor)
- )))
+ (////.throw bundle.invalid-syntax extension-name))))
+
+(def: bundle::member
+ Bundle
+ (<| (bundle.prefix "member")
+ (|> bundle.empty
+ (dictionary.merge (<| (bundle.prefix "static")
+ (|> bundle.empty
+ (bundle.install "get" static::get)
+ (bundle.install "put" static::put))))
+ (dictionary.merge (<| (bundle.prefix "virtual")
+ (|> bundle.empty
+ (bundle.install "get" virtual::get)
+ (bundle.install "put" virtual::put))))
+ (dictionary.merge (<| (bundle.prefix "invoke")
+ (|> bundle.empty
+ (bundle.install "static" invoke::static)
+ (bundle.install "virtual" invoke::virtual)
+ (bundle.install "special" invoke::special)
+ (bundle.install "interface" invoke::interface)
+ (bundle.install "constructor" invoke::constructor)
+ )))
)))
-(def: #export extensions
- /.Bundle
- (<| (/.prefix "jvm")
- (|> (dict.new text.Hash<Text>)
- (dict.merge conversion-procs)
- (dict.merge int-procs)
- (dict.merge long-procs)
- (dict.merge float-procs)
- (dict.merge double-procs)
- (dict.merge char-procs)
- (dict.merge array-procs)
- (dict.merge object-procs)
- (dict.merge member-procs)
+(def: #export bundle
+ Bundle
+ (<| (bundle.prefix "jvm")
+ (|> bundle.empty
+ (dictionary.merge bundle::conversion)
+ (dictionary.merge bundle::int)
+ (dictionary.merge bundle::long)
+ (dictionary.merge bundle::float)
+ (dictionary.merge bundle::double)
+ (dictionary.merge bundle::char)
+ (dictionary.merge bundle::array)
+ (dictionary.merge bundle::object)
+ (dictionary.merge bundle::member)
)))
diff --git a/stdlib/source/lux/language/compiler/extension/bundle.lux b/stdlib/source/lux/language/compiler/extension/bundle.lux
index 315d05523..222ad7f5e 100644
--- a/stdlib/source/lux/language/compiler/extension/bundle.lux
+++ b/stdlib/source/lux/language/compiler/extension/bundle.lux
@@ -20,9 +20,13 @@
(ex.report ["Extension" name]))
## [Utils]
+(def: #export empty
+ //.Bundle
+ (dict.new text.Hash<Text>))
+
(def: #export (install name anonymous)
(All [s i o]
- (-> Text (-> Text (//.Handler s i o))
+ (-> Text (//.Handler s i o)
(-> (//.Bundle s i o) (//.Bundle s i o))))
(dict.put name anonymous))
diff --git a/stdlib/source/lux/language/compiler/synthesis.lux b/stdlib/source/lux/language/compiler/synthesis.lux
index 2e359d2ea..05be98f3c 100644
--- a/stdlib/source/lux/language/compiler/synthesis.lux
+++ b/stdlib/source/lux/language/compiler/synthesis.lux
@@ -4,9 +4,11 @@
[data
[error (#+ Error)]
[collection ["dict" dictionary (#+ Dictionary)]]]]
- [///reference (#+ Register Variable Reference)]
- [// (#+ Operation Compiler)]
- [//analysis (#+ Environment Arity Analysis)])
+ ["." //
+ [analysis (#+ Environment Arity Analysis)]
+ [extension (#+ Extension)]
+ [//
+ [reference (#+ Register Variable Reference)]]])
(type: #export Resolver (Dictionary Variable Variable))
@@ -18,7 +20,7 @@
(def: #export fresh-resolver
Resolver
- (dict.new ///reference.Hash<Variable>))
+ (dict.new reference.Hash<Variable>))
(def: #export init
State
@@ -34,8 +36,8 @@
(#Text Text))
(type: #export (Structure a)
- (#Variant (//analysis.Variant a))
- (#Tuple (//analysis.Tuple a)))
+ (#Variant (analysis.Variant a))
+ (#Tuple (analysis.Tuple a)))
(type: #export Side
(Either Nat Nat))
@@ -88,7 +90,14 @@
(#Primitive Primitive)
(#Structure (Structure Synthesis))
(#Reference Reference)
- (#Control (Control Synthesis)))
+ (#Control (Control Synthesis))
+ (#Extension (Extension Synthesis)))
+
+(type: #export Operation
+ (extension.Operation ..State Analysis Synthesis))
+
+(type: #export Compiler
+ (extension.Compiler ..State Analysis Synthesis))
(type: #export Path
(Path' Synthesis))
@@ -144,13 +153,10 @@
(def: #export unit Text "")
-(type: #export Synthesizer
- (Compiler ..State Analysis Synthesis))
-
(do-template [<name> <value>]
[(def: #export <name>
- (All [a] (-> (Operation ..State a) (Operation ..State a)))
- (//.localized (set@ #direct? <value>)))]
+ (All [a] (-> (Operation a) (Operation a)))
+ (extension.temporary (set@ #direct? <value>)))]
[indirectly false]
[directly true]
@@ -158,8 +164,8 @@
(do-template [<name> <type> <tag>]
[(def: #export (<name> value)
- (-> <type> (All [a] (-> (Operation ..State a) (Operation ..State a))))
- (//.localized (set@ <tag> value)))]
+ (-> <type> (All [a] (-> (Operation a) (Operation a))))
+ (extension.temporary (set@ <tag> value)))]
[with-scope-arity Arity #scope-arity]
[with-resolver Resolver #resolver]
@@ -167,19 +173,17 @@
)
(def: #export (with-abstraction arity resolver)
- (All [o]
- (-> Arity Resolver
- (-> (Operation ..State o) (Operation ..State o))))
- (//.with-state {#scope-arity arity
- #resolver resolver
- #direct? true
- #locals arity}))
+ (-> Arity Resolver
+ (All [a] (-> (Operation a) (Operation a))))
+ (extension.with-state {#scope-arity arity
+ #resolver resolver
+ #direct? true
+ #locals arity}))
(do-template [<name> <tag> <type>]
[(def: #export <name>
- (Operation ..State <type>)
- (function (_ state)
- (#error.Success [state (get@ <tag> state)])))]
+ (Operation <type>)
+ (extension.read (get@ <tag>)))]
[scope-arity #scope-arity Arity]
[resolver #resolver Resolver]
@@ -188,7 +192,7 @@
)
(def: #export with-new-local
- (All [a] (-> (Operation ..State a) (Operation ..State a)))
+ (All [a] (-> (Operation a) (Operation a)))
(<<| (do //.Monad<Operation>
[locals ..locals])
(..with-locals (inc locals))))
@@ -219,8 +223,8 @@
<tag>
content))]
- [variable/local ///reference.local]
- [variable/foreign ///reference.foreign]
+ [variable/local reference.local]
+ [variable/foreign reference.foreign]
)
(do-template [<name> <family> <tag>]
diff --git a/stdlib/source/lux/language/compiler/synthesis/case.lux b/stdlib/source/lux/language/compiler/synthesis/case.lux
index 7dd8b3157..de7a4f9fd 100644
--- a/stdlib/source/lux/language/compiler/synthesis/case.lux
+++ b/stdlib/source/lux/language/compiler/synthesis/case.lux
@@ -11,42 +11,43 @@
format]
[number ("frac/" Equivalence<Frac>)]
[collection [list ("list/" Fold<List> Monoid<List>)]]]]
- [///reference]
- [///compiler (#+ Operation) ("operation/" Monad<Operation>)]
- [///analysis (#+ Pattern Match Analysis)]
- [// (#+ Path Synthesis)]
- [//function])
+ [// (#+ Path Synthesis)
+ [function]
+ [///
+ [reference]
+ [compiler (#+ Operation) ("operation/" Monad<Operation>)]
+ [analysis (#+ Pattern Match Analysis)]]])
(def: (path' pattern bodyC)
(-> Pattern (Operation //.State Path) (Operation //.State Path))
(case pattern
- (#///analysis.Simple simple)
+ (#analysis.Simple simple)
(case simple
- #///analysis.Unit
+ #analysis.Unit
bodyC
(^template [<from> <to>]
(<from> value)
(operation/map (|>> (#//.Seq (#//.Test (|> value <to>))))
bodyC))
- ([#///analysis.Bool #//.Bool]
- [#///analysis.Nat (<| #//.I64 .i64)]
- [#///analysis.Int (<| #//.I64 .i64)]
- [#///analysis.Rev (<| #//.I64 .i64)]
- [#///analysis.Frac #//.F64]
- [#///analysis.Text #//.Text]))
+ ([#analysis.Bool #//.Bool]
+ [#analysis.Nat (<| #//.I64 .i64)]
+ [#analysis.Int (<| #//.I64 .i64)]
+ [#analysis.Rev (<| #//.I64 .i64)]
+ [#analysis.Frac #//.F64]
+ [#analysis.Text #//.Text]))
- (#///analysis.Bind register)
- (<| (do ///compiler.Monad<Operation>
+ (#analysis.Bind register)
+ (<| (do compiler.Monad<Operation>
[arity //.scope-arity])
- (:: @ map (|>> (#//.Seq (#//.Bind (if (//function.nested? arity)
+ (:: @ map (|>> (#//.Seq (#//.Bind (if (function.nested? arity)
(n/+ (dec arity) register)
register)))))
//.with-new-local
bodyC)
- (#///analysis.Complex _)
- (case (///analysis.variant-pattern pattern)
+ (#analysis.Complex _)
+ (case (analysis.variant-pattern pattern)
(#.Some [lefts right? value-pattern])
(operation/map (|>> (#//.Seq (#//.Access (#//.Side (if right?
(#.Right lefts)
@@ -54,11 +55,11 @@
(path' value-pattern bodyC))
#.None
- (let [tuple (///analysis.tuple-pattern pattern)
+ (let [tuple (analysis.tuple-pattern pattern)
tuple/last (dec (list.size tuple))]
(list/fold (function (_ [tuple/idx tuple/member] thenC)
(case tuple/member
- (#///analysis.Simple #///analysis.Unit)
+ (#analysis.Simple #analysis.Unit)
thenC
_
@@ -126,15 +127,15 @@
(def: #export (synthesize synthesize^ inputA [headB tailB+])
(-> //.Synthesizer Analysis Match (Operation //.State Synthesis))
- (do ///compiler.Monad<Operation>
+ (do compiler.Monad<Operation>
[inputS (synthesize^ inputA)]
(with-expansions [<unnecesary-let>
- (as-is (^multi (^ (#///analysis.Reference (///reference.local outputR)))
+ (as-is (^multi (^ (#analysis.Reference (reference.local outputR)))
(n/= inputR outputR))
(wrap inputS))
<let>
- (as-is [[(#///analysis.Bind inputR) headB/bodyA]
+ (as-is [[(#analysis.Bind inputR) headB/bodyA]
#.Nil]
(case headB/bodyA
<unnecesary-let>
@@ -145,16 +146,16 @@
headB/bodyS (//.with-new-local
(synthesize^ headB/bodyA))]
(wrap (//.branch/let [inputS
- (if (//function.nested? arity)
+ (if (function.nested? arity)
(n/+ (dec arity) inputR)
inputR)
headB/bodyS])))))
<if>
- (as-is (^or (^ [[(///analysis.pattern/bool true) thenA]
- (list [(///analysis.pattern/bool false) elseA])])
- (^ [[(///analysis.pattern/bool false) elseA]
- (list [(///analysis.pattern/bool true) thenA])]))
+ (as-is (^or (^ [[(analysis.pattern/bool true) thenA]
+ (list [(analysis.pattern/bool false) elseA])])
+ (^ [[(analysis.pattern/bool false) elseA]
+ (list [(analysis.pattern/bool true) thenA])]))
(do @
[thenS (synthesize^ thenA)
elseS (synthesize^ elseA)]
diff --git a/stdlib/source/lux/language/compiler/synthesis/expression.lux b/stdlib/source/lux/language/compiler/synthesis/expression.lux
index ffc22d89a..80480de68 100644
--- a/stdlib/source/lux/language/compiler/synthesis/expression.lux
+++ b/stdlib/source/lux/language/compiler/synthesis/expression.lux
@@ -8,95 +8,96 @@
[collection
[list ("list/" Functor<List>)]
["dict" dictionary (#+ Dictionary)]]]]
- [///reference]
- [///compiler ("operation/" Monad<Operation>)]
- [///analysis (#+ Analysis)]
- [///extension (#+ Extension)]
- [// (#+ Synthesis)]
- [//function]
- [//case])
+ [// (#+ Synthesis)
+ [function]
+ [case]
+ [///
+ [reference]
+ ["." compiler ("operation/" Monad<Operation>)
+ [analysis (#+ Analysis)]
+ [extension (#+ Extension)]]]])
(exception: #export (unknown-synthesis-extension {name Text})
name)
(def: (primitive analysis)
- (-> ///analysis.Primitive //.Primitive)
+ (-> analysis.Primitive //.Primitive)
(case analysis
- #///analysis.Unit
+ #analysis.Unit
(#//.Text //.unit)
(^template [<analysis> <synthesis>]
(<analysis> value)
(<synthesis> value))
- ([#///analysis.Bool #//.Bool]
- [#///analysis.Frac #//.F64]
- [#///analysis.Text #//.Text])
+ ([#analysis.Bool #//.Bool]
+ [#analysis.Frac #//.F64]
+ [#analysis.Text #//.Text])
(^template [<analysis> <synthesis>]
(<analysis> value)
(<synthesis> (.i64 value)))
- ([#///analysis.Nat #//.I64]
- [#///analysis.Int #//.I64]
- [#///analysis.Rev #//.I64])))
+ ([#analysis.Nat #//.I64]
+ [#analysis.Int #//.I64]
+ [#analysis.Rev #//.I64])))
(def: #export (synthesizer extensions)
- (-> (Extension ///extension.Synthesis) //.Synthesizer)
+ (-> (Extension extension.Synthesis) //.Synthesizer)
(function (synthesize analysis)
(case analysis
- (#///analysis.Primitive analysis')
+ (#analysis.Primitive analysis')
(operation/wrap (#//.Primitive (..primitive analysis')))
- (#///analysis.Structure composite)
- (case (///analysis.variant analysis)
+ (#analysis.Structure composite)
+ (case (analysis.variant analysis)
(#.Some variant)
- (do ///compiler.Monad<Operation>
- [valueS (synthesize (get@ #///analysis.value variant))]
- (wrap (#//.Structure (#//.Variant (set@ #///analysis.value valueS variant)))))
+ (do compiler.Monad<Operation>
+ [valueS (synthesize (get@ #analysis.value variant))]
+ (wrap (#//.Structure (#//.Variant (set@ #analysis.value valueS variant)))))
_
- (do ///compiler.Monad<Operation>
- [tupleS (monad.map @ synthesize (///analysis.tuple analysis))]
+ (do compiler.Monad<Operation>
+ [tupleS (monad.map @ synthesize (analysis.tuple analysis))]
(wrap (#//.Structure (#//.Tuple tupleS)))))
- (#///analysis.Apply _)
- (//function.apply (|>> synthesize //.indirectly) analysis)
+ (#analysis.Apply _)
+ (function.apply (|>> synthesize //.indirectly) analysis)
- (#///analysis.Function environmentA bodyA)
- (//function.function synthesize environmentA bodyA)
+ (#analysis.Function environmentA bodyA)
+ (function.function synthesize environmentA bodyA)
- (#///analysis.Extension name args)
+ (#analysis.Extension name args)
(case (dict.get name extensions)
#.None
- (///compiler.throw unknown-synthesis-extension name)
+ (compiler.throw unknown-synthesis-extension name)
(#.Some extension)
(extension (|>> synthesize //.indirectly) args))
- (#///analysis.Reference reference)
+ (#analysis.Reference reference)
(case reference
- (#///reference.Constant constant)
+ (#reference.Constant constant)
(operation/wrap (#//.Reference reference))
- (#///reference.Variable var)
- (do ///compiler.Monad<Operation>
+ (#reference.Variable var)
+ (do compiler.Monad<Operation>
[resolver //.resolver]
(case var
- (#///reference.Local register)
+ (#reference.Local register)
(do @
[arity //.scope-arity]
- (wrap (if (//function.nested? arity)
+ (wrap (if (function.nested? arity)
(if (n/= +0 register)
(|> (dec arity)
(list.n/range +1)
(list/map (|>> //.variable/local))
[(//.variable/local +0)]
//.function/apply)
- (#//.Reference (#///reference.Variable (//function.adjust arity false var))))
- (#//.Reference (#///reference.Variable var)))))
+ (#//.Reference (#reference.Variable (function.adjust arity false var))))
+ (#//.Reference (#reference.Variable var)))))
- (#///reference.Foreign register)
- (wrap (|> resolver (dict.get var) (maybe.default var) #///reference.Variable #//.Reference)))))
+ (#reference.Foreign register)
+ (wrap (|> resolver (dict.get var) (maybe.default var) #reference.Variable #//.Reference)))))
- (#///analysis.Case inputA branchesAB+)
- (//case.synthesize (|>> synthesize //.indirectly) inputA branchesAB+)
+ (#analysis.Case inputA branchesAB+)
+ (case.synthesize (|>> synthesize //.indirectly) inputA branchesAB+)
)))
diff --git a/stdlib/source/lux/language/compiler/synthesis/function.lux b/stdlib/source/lux/language/compiler/synthesis/function.lux
index 2b9cffd19..92e75dc94 100644
--- a/stdlib/source/lux/language/compiler/synthesis/function.lux
+++ b/stdlib/source/lux/language/compiler/synthesis/function.lux
@@ -11,11 +11,12 @@
[collection
[list ("list/" Functor<List> Monoid<List> Fold<List>)]
["dict" dictionary (#+ Dictionary)]]]]
- [///reference (#+ Variable)]
- [///compiler (#+ Operation)]
- [///analysis (#+ Environment Arity Analysis)]
- [// (#+ Synthesis Synthesizer)]
- [//loop])
+ [// (#+ Synthesis Synthesizer)
+ [loop]
+ [///
+ [reference (#+ Variable)]
+ [compiler (#+ Operation)
+ [analysis (#+ Environment Arity Analysis)]]]])
(def: #export nested?
(-> Arity Bool)
@@ -24,9 +25,9 @@
(def: #export (adjust up-arity after? var)
(-> Arity Bool Variable Variable)
(case var
- (#///reference.Local register)
+ (#reference.Local register)
(if (and after? (n/>= up-arity register))
- (#///reference.Local (n/+ (dec up-arity) register))
+ (#reference.Local (n/+ (dec up-arity) register))
var)
_
@@ -37,7 +38,7 @@
(loop [apply apply
args (list)]
(case apply
- (#///analysis.Apply arg func)
+ (#analysis.Apply arg func)
(recur func (#.Cons arg args))
_
@@ -54,7 +55,7 @@
(case funcS
(^ (//.function/abstraction functionS))
(wrap (|> functionS
- (//loop.loop (get@ #//.environment functionS) locals argsS)
+ (loop.loop (get@ #//.environment functionS) locals argsS)
(maybe.default (//.function/apply [funcS argsS]))))
(^ (//.function/apply [funcS' argsS']))
@@ -64,11 +65,11 @@
(wrap (//.function/apply [funcS argsS])))))))
(def: (prepare up down)
- (-> Arity Arity (//loop.Transform Synthesis))
+ (-> Arity Arity (loop.Transform Synthesis))
(.function (_ body)
(if (nested? up)
(#.Some body)
- (//loop.recursion down body))))
+ (loop.recursion down body))))
(exception: #export (cannot-prepare-function-body {_ []})
"")
@@ -76,14 +77,14 @@
(def: return
(All [a] (-> (Maybe a) (Operation //.State a)))
(|>> (case> (#.Some output)
- (:: ///compiler.Monad<Operation> wrap output)
+ (:: compiler.Monad<Operation> wrap output)
#.None
- (///compiler.throw cannot-prepare-function-body []))))
+ (compiler.throw cannot-prepare-function-body []))))
(def: #export (function synthesize environment body)
(-> Synthesizer Environment Analysis (Operation //.State Synthesis))
- (do ///compiler.Monad<Operation>
+ (do compiler.Monad<Operation>
[direct? //.direct?
arity //.scope-arity
resolver //.resolver
@@ -107,7 +108,7 @@
_
(|> (list.size environment) dec (list.n/range +0)
- (list/map (|>> #///reference.Foreign)))))
+ (list/map (|>> #reference.Foreign)))))
resolver' (if (and (nested? function-arity)
direct?)
(list/fold (.function (_ [from to] resolver')
diff --git a/stdlib/source/lux/language/compiler/synthesis/loop.lux b/stdlib/source/lux/language/compiler/synthesis/loop.lux
index 05af31a83..564fe5421 100644
--- a/stdlib/source/lux/language/compiler/synthesis/loop.lux
+++ b/stdlib/source/lux/language/compiler/synthesis/loop.lux
@@ -9,10 +9,11 @@
[macro
[code]
[syntax]]]
- [///]
- [///reference (#+ Register Variable)]
- [///analysis (#+ Environment)]
- [// (#+ Path Abstraction Synthesis)])
+ [// (#+ Path Abstraction Synthesis)
+ [///
+ [reference (#+ Register Variable)]
+ [compiler
+ [analysis (#+ Environment)]]]])
(type: #export (Transform a)
(-> a (Maybe a)))
@@ -24,7 +25,7 @@
#.None false))
(template: #export (self)
- (#//.Reference (///reference.local +0)))
+ (#//.Reference (reference.local +0)))
(template: (recursive-apply args)
(#//.Apply (self) args))
@@ -41,7 +42,7 @@
(#//.Structure structure)
(case structure
(#//.Variant variantS)
- (proper? (get@ #///analysis.value variantS))
+ (proper? (get@ #analysis.value variantS))
(#//.Tuple membersS+)
(list.every? proper? membersS+))
@@ -84,7 +85,7 @@
(#//.Function functionS)
(case functionS
(#//.Abstraction environment arity bodyS)
- (list.every? ///reference.self? environment)
+ (list.every? reference.self? environment)
(#//.Apply funcS argsS)
(and (proper? funcS)
@@ -161,7 +162,7 @@
(-> Environment (Transform Variable))
(function (_ variable)
(case variable
- (#///reference.Foreign register)
+ (#reference.Foreign register)
(list.nth register environment)
_
@@ -196,9 +197,9 @@
(case structureS
(#//.Variant variantS)
(do maybe.Monad<Maybe>
- [valueS' (|> variantS (get@ #///analysis.value) recur)]
+ [valueS' (|> variantS (get@ #analysis.value) recur)]
(wrap (|> variantS
- (set@ #///analysis.value valueS')
+ (set@ #analysis.value valueS')
#//.Variant
#//.Structure)))
@@ -209,16 +210,16 @@
(#//.Reference reference)
(case reference
- (^ (///reference.constant constant))
+ (^ (reference.constant constant))
(#.Some exprS)
- (^ (///reference.local register))
- (#.Some (#//.Reference (///reference.local (n/+ offset register))))
+ (^ (reference.local register))
+ (#.Some (#//.Reference (reference.local (n/+ offset register))))
- (^ (///reference.foreign register))
+ (^ (reference.foreign register))
(|> scope-environment
(list.nth register)
- (maybe/map (|>> #///reference.Variable #//.Reference))))
+ (maybe/map (|>> #reference.Variable #//.Reference))))
(^ (//.branch/case [inputS pathS]))
(do maybe.Monad<Maybe>
diff --git a/stdlib/source/lux/language/compiler/translation.lux b/stdlib/source/lux/language/compiler/translation.lux
index 01dc584e6..077076d2f 100644
--- a/stdlib/source/lux/language/compiler/translation.lux
+++ b/stdlib/source/lux/language/compiler/translation.lux
@@ -11,8 +11,10 @@
[collection
[row (#+ Row)]
["dict" dictionary (#+ Dictionary)]]]
+ [function]
[world [file (#+ File)]]]
- [// (#+ Operation Compiler)]
+ ["." //
+ [extension]]
[//synthesis (#+ Synthesis)])
(do-template [<name>]
@@ -47,8 +49,11 @@
#buffer (Maybe (Buffer code))
#artifacts (Artifacts code)})
-(type: #export (Translator anchor code)
- (Compiler (State anchor code) Synthesis code))
+(type: #export (Operation anchor code)
+ (extension.Operation (State anchor code) Synthesis code))
+
+(type: #export (Compiler anchor code)
+ (extension.Compiler (State anchor code) Synthesis code))
(def: #export (init host)
(All [anchor code] (-> (Host code) (..State anchor code)))
@@ -61,26 +66,23 @@
(def: #export (with-context expr)
(All [anchor code output]
- (-> (Operation (..State anchor code) output)
- (Operation (..State anchor code) [Text output])))
- (function (_ state)
+ (-> (Operation anchor code output)
+ (Operation anchor code [Text output])))
+ (function (_ [bundle state])
(let [[old-scope old-inner] (get@ #context state)
new-scope (format old-scope "c___" (%i (.int old-inner)))]
- (case (expr (set@ #context [new-scope +0] state))
- (#error.Success [state' output])
- (#error.Success [(set@ #context [old-scope (inc old-inner)] state')
+ (case (expr [bundle (set@ #context [new-scope +0] state)])
+ (#error.Success [[bundle' state'] output])
+ (#error.Success [[bundle' (set@ #context [old-scope (inc old-inner)] state')]
[new-scope output]])
(#error.Error error)
(#error.Error error)))))
(def: #export context
- (All [anchor code] (Operation (..State anchor code) Text))
- (function (_ state)
- (#error.Success [state
- (|> state
- (get@ #context)
- (get@ #scope-name))])))
+ (All [anchor code] (Operation anchor code Text))
+ (extension.read (|>> (get@ #context)
+ (get@ #scope-name))))
(do-template [<tag>
<with-declaration> <with-type> <with-value>
@@ -88,57 +90,56 @@
[(def: #export <with-declaration>
(All [anchor code output] <with-type>)
(function (_ body)
- (function (_ state)
- (case (body (set@ <tag> (#.Some <with-value>) state))
- (#error.Success [state' output])
- (#error.Success [(set@ <tag> (get@ <tag> state) state')
+ (function (_ [bundle state])
+ (case (body [bundle (set@ <tag> (#.Some <with-value>) state)])
+ (#error.Success [[bundle' state'] output])
+ (#error.Success [[bundle' (set@ <tag> (get@ <tag> state) state')]
output])
(#error.Error error)
(#error.Error error)))))
(def: #export <get>
- (All [anchor code] (Operation (..State anchor code) <get-type>))
- (function (_ state)
+ (All [anchor code] (Operation anchor code <get-type>))
+ (function (_ (^@ stateE [bundle state]))
(case (get@ <tag> state)
(#.Some output)
- (#error.Success [state output])
+ (#error.Success [stateE output])
#.None
(ex.throw <exception> []))))]
[#anchor
(with-anchor anchor)
- (-> anchor (Operation (..State anchor code) output)
- (Operation (..State anchor code) output))
+ (-> anchor (Operation anchor code output)
+ (Operation anchor code output))
anchor
anchor anchor no-anchor]
[#buffer
with-buffer
- (-> (Operation (..State anchor code) output)
- (Operation (..State anchor code) output))
+ (-> (Operation anchor code output)
+ (Operation anchor code output))
row.empty
buffer (Buffer code) no-active-buffer]
)
(def: #export artifacts
(All [anchor code]
- (Operation (..State anchor code) (Artifacts code)))
- (function (_ state)
- (#error.Success [state (get@ #artifacts state)])))
+ (Operation anchor code (Artifacts code)))
+ (extension.read (get@ #artifacts)))
(do-template [<name>]
[(def: #export (<name> code)
(All [anchor code]
- (-> code (Operation (..State anchor code) Any)))
- (function (_ state)
+ (-> code (Operation anchor code Any)))
+ (function (_ (^@ stateE [bundle state]))
(case (:: (get@ #host state) <name> code)
(#error.Error error)
(ex.throw cannot-interpret error)
(#error.Success output)
- (#error.Success [state output]))))]
+ (#error.Success [stateE output]))))]
[execute!]
[evaluate!]
@@ -146,20 +147,14 @@
(def: #export (save! name code)
(All [anchor code]
- (-> Ident code (Operation (..State anchor code) Any)))
+ (-> Ident code (Operation anchor code Any)))
(do //.Monad<Operation>
[_ (execute! code)]
- (function (_ state)
- (#error.Success [(update@ #buffer
- (maybe/map (row.add [name code]))
- state)
- []]))))
+ (extension.update (update@ #buffer (maybe/map (row.add [name code]))))))
(def: #export (save-buffer! target)
(All [anchor code]
- (-> File (Operation (..State anchor code) Any)))
+ (-> File (Operation anchor code Any)))
(do //.Monad<Operation>
[buffer ..buffer]
- (function (_ state)
- (#error.Success [(update@ #artifacts (dict.put target buffer) state)
- []]))))
+ (extension.update (update@ #artifacts (dict.put target buffer)))))
diff --git a/stdlib/source/lux/language/compiler/translation/scheme/case.jvm.lux b/stdlib/source/lux/language/compiler/translation/scheme/case.jvm.lux
index 4460a3102..3ef368c18 100644
--- a/stdlib/source/lux/language/compiler/translation/scheme/case.jvm.lux
+++ b/stdlib/source/lux/language/compiler/translation/scheme/case.jvm.lux
@@ -15,11 +15,11 @@
[host ["_" scheme (#+ Expression Computation Var)]]
[compiler ("operation/" Monad<Operation>)
[synthesis (#+ Synthesis Path)]]]
- [//runtime (#+ Operation Translator)]
+ [//runtime (#+ Operation Compiler)]
[//reference])
(def: #export (let translate [valueS register bodyS])
- (-> Translator [Synthesis Register Synthesis]
+ (-> Compiler [Synthesis Register Synthesis]
(Operation Computation))
(do compiler.Monad<Operation>
[valueO (translate valueS)
@@ -28,7 +28,7 @@
bodyO))))
(def: #export (record-get translate valueS pathP)
- (-> Translator Synthesis (List [Nat Bool])
+ (-> Compiler Synthesis (List [Nat Bool])
(Operation Expression))
(do compiler.Monad<Operation>
[valueO (translate valueS)]
@@ -41,7 +41,7 @@
pathP))))
(def: #export (if translate [testS thenS elseS])
- (-> Translator [Synthesis Synthesis Synthesis]
+ (-> Compiler [Synthesis Synthesis Synthesis]
(Operation Computation))
(do compiler.Monad<Operation>
[testO (translate testS)
@@ -102,7 +102,7 @@
(_.raise/1 $alt_error))))
(def: (pattern-matching' translate pathP)
- (-> Translator Path (Operation Expression))
+ (-> Compiler Path (Operation Expression))
(.case pathP
(^ (synthesis.path/then bodyS))
(translate bodyS)
@@ -157,7 +157,7 @@
(compiler.throw unrecognized-path [])))
(def: (pattern-matching translate pathP)
- (-> Translator Path (Operation Computation))
+ (-> Compiler Path (Operation Computation))
(do compiler.Monad<Operation>
[pattern-matching! (pattern-matching' translate pathP)]
(wrap (_.with-exception-handler
@@ -166,7 +166,7 @@
pattern-matching!)))))
(def: #export (case translate [valueS pathP])
- (-> Translator [Synthesis Path] (Operation Computation))
+ (-> Compiler [Synthesis Path] (Operation Computation))
(do compiler.Monad<Operation>
[valueO (translate valueS)]
(<| (:: @ map (_.let (list [@cursor (_.list/* (list valueO))]
diff --git a/stdlib/source/lux/language/compiler/translation/scheme/expression.jvm.lux b/stdlib/source/lux/language/compiler/translation/scheme/expression.jvm.lux
index 464f2c27d..d7ef01e61 100644
--- a/stdlib/source/lux/language/compiler/translation/scheme/expression.jvm.lux
+++ b/stdlib/source/lux/language/compiler/translation/scheme/expression.jvm.lux
@@ -1,55 +1,58 @@
(.module:
[lux #*
[control [monad (#+ do)]]]
- [/////
- ["." compiler
+ [//
+ [runtime (#+ Compiler)]
+ [primitive]
+ [structure]
+ [reference]
+ [function]
+ [case]
+ [loop]
+ ["." ///
[synthesis]
- [extension]]]
- [//runtime (#+ Translator)]
- [//primitive]
- [//structure]
- [//reference]
- [//function]
- [//case]
- [//loop])
+ [extension]]])
(def: #export (translate synthesis)
- Translator
+ Compiler
(case synthesis
(^template [<tag> <generator>]
(^ (<tag> value))
(<generator> value))
- ([synthesis.bool //primitive.bool]
- [synthesis.i64 //primitive.i64]
- [synthesis.f64 //primitive.f64]
- [synthesis.text //primitive.text])
+ ([synthesis.bool primitive.bool]
+ [synthesis.i64 primitive.i64]
+ [synthesis.f64 primitive.f64]
+ [synthesis.text primitive.text])
(^ (synthesis.variant variantS))
- (//structure.variant translate variantS)
+ (structure.variant translate variantS)
(^ (synthesis.tuple members))
- (//structure.tuple translate members)
+ (structure.tuple translate members)
(#synthesis.Reference reference)
- (//reference.reference reference)
+ (reference.reference reference)
(^ (synthesis.branch/case case))
- (//case.case translate case)
+ (case.case translate case)
(^ (synthesis.branch/let let))
- (//case.let translate let)
+ (case.let translate let)
(^ (synthesis.branch/if if))
- (//case.if translate if)
+ (case.if translate if)
(^ (synthesis.loop/scope scope))
- (//loop.scope translate scope)
+ (loop.scope translate scope)
(^ (synthesis.loop/recur updates))
- (//loop.recur translate updates)
+ (loop.recur translate updates)
(^ (synthesis.function/abstraction abstraction))
- (//function.function translate abstraction)
+ (function.function translate abstraction)
(^ (synthesis.function/apply application))
- (//function.apply translate application)))
+ (function.apply translate application)
+
+ (#synthesis.Extension extension)
+ (extension.apply translate extension)))
diff --git a/stdlib/source/lux/language/compiler/translation/scheme/extension.jvm.lux b/stdlib/source/lux/language/compiler/translation/scheme/extension.jvm.lux
index a54d67425..c7d161f14 100644
--- a/stdlib/source/lux/language/compiler/translation/scheme/extension.jvm.lux
+++ b/stdlib/source/lux/language/compiler/translation/scheme/extension.jvm.lux
@@ -13,7 +13,7 @@
[host ["_" scheme (#+ Computation)]]
[compiler ("operation/" Monad<Operation>)
[synthesis (#+ Synthesis)]]]
- [//runtime (#+ Operation Translator)]
+ [//runtime (#+ Operation Compiler)]
[/common]
## [/host]
)
@@ -28,7 +28,7 @@
))
(def: #export (extension translate name args)
- (-> Translator Text (List Synthesis)
+ (-> Compiler Text (List Synthesis)
(Operation Computation))
(<| (maybe.default (compiler.throw unknown-extension (%t name)))
(do maybe.Monad<Maybe>
diff --git a/stdlib/source/lux/language/compiler/translation/scheme/extension/common.jvm.lux b/stdlib/source/lux/language/compiler/translation/scheme/extension/common.jvm.lux
index 377fed8f5..40f817aea 100644
--- a/stdlib/source/lux/language/compiler/translation/scheme/extension/common.jvm.lux
+++ b/stdlib/source/lux/language/compiler/translation/scheme/extension/common.jvm.lux
@@ -20,11 +20,11 @@
[host ["_" scheme (#+ Expression Computation)]]
["." compiler
[synthesis (#+ Synthesis)]]]
- [///runtime (#+ Operation Translator)])
+ [///runtime (#+ Operation Compiler)])
## [Types]
(type: #export Extension
- (-> Translator (List Synthesis) (Operation Computation)))
+ (-> Compiler (List Synthesis) (Operation Computation)))
(type: #export Bundle
(Dictionary Text Extension))
diff --git a/stdlib/source/lux/language/compiler/translation/scheme/function.jvm.lux b/stdlib/source/lux/language/compiler/translation/scheme/function.jvm.lux
index 6afb04799..d5dc4541f 100644
--- a/stdlib/source/lux/language/compiler/translation/scheme/function.jvm.lux
+++ b/stdlib/source/lux/language/compiler/translation/scheme/function.jvm.lux
@@ -16,12 +16,12 @@
[analysis (#+ Variant Tuple Environment Arity Abstraction Application Analysis)]
[synthesis (#+ Synthesis)]]]
[///]
- [//runtime (#+ Operation Translator)]
+ [//runtime (#+ Operation Compiler)]
[//primitive]
[//reference])
(def: #export (apply translate [functionS argsS+])
- (-> Translator (Application Synthesis) (Operation Computation))
+ (-> Compiler (Application Synthesis) (Operation Computation))
(do compiler.Monad<Operation>
[functionO (translate functionS)
argsO+ (monad.map @ translate argsS+)]
@@ -50,7 +50,7 @@
(|>> inc //reference.local'))
(def: #export (function translate [environment arity bodyS])
- (-> Translator (Abstraction Synthesis) (Operation Computation))
+ (-> Compiler (Abstraction Synthesis) (Operation Computation))
(do compiler.Monad<Operation>
[[function-name bodyO] (///.with-context
(do @
diff --git a/stdlib/source/lux/language/compiler/translation/scheme/loop.jvm.lux b/stdlib/source/lux/language/compiler/translation/scheme/loop.jvm.lux
index 227a2eda9..4e8d90341 100644
--- a/stdlib/source/lux/language/compiler/translation/scheme/loop.jvm.lux
+++ b/stdlib/source/lux/language/compiler/translation/scheme/loop.jvm.lux
@@ -14,13 +14,13 @@
["." compiler
[synthesis (#+ Scope Synthesis)]]]
[///]
- [//runtime (#+ Operation Translator)]
+ [//runtime (#+ Operation Compiler)]
[//reference])
(def: @scope (_.var "scope"))
(def: #export (scope translate [start initsS+ bodyS])
- (-> Translator (Scope Synthesis) (Operation Computation))
+ (-> Compiler (Scope Synthesis) (Operation Computation))
(do compiler.Monad<Operation>
[initsO+ (monad.map @ translate initsS+)
bodyO (///.with-anchor @scope
@@ -33,7 +33,7 @@
(_.apply/* @scope initsO+)))))
(def: #export (recur translate argsS+)
- (-> Translator (List Synthesis) (Operation Computation))
+ (-> Compiler (List Synthesis) (Operation Computation))
(do compiler.Monad<Operation>
[@scope ///.anchor
argsO+ (monad.map @ translate argsS+)]
diff --git a/stdlib/source/lux/language/compiler/translation/scheme/reference.jvm.lux b/stdlib/source/lux/language/compiler/translation/scheme/reference.jvm.lux
index 51dd2f515..f9eba9bd7 100644
--- a/stdlib/source/lux/language/compiler/translation/scheme/reference.jvm.lux
+++ b/stdlib/source/lux/language/compiler/translation/scheme/reference.jvm.lux
@@ -12,7 +12,7 @@
[compiler ("operation/" Monad<Operation>)
[analysis (#+ Variant Tuple)]
[synthesis (#+ Synthesis)]]]
- [//runtime (#+ Operation Translator)]
+ [//runtime (#+ Operation)]
[//primitive])
(do-template [<name> <prefix>]
diff --git a/stdlib/source/lux/language/compiler/translation/scheme/runtime.jvm.lux b/stdlib/source/lux/language/compiler/translation/scheme/runtime.jvm.lux
index d2a72d140..a1ce941d2 100644
--- a/stdlib/source/lux/language/compiler/translation/scheme/runtime.jvm.lux
+++ b/stdlib/source/lux/language/compiler/translation/scheme/runtime.jvm.lux
@@ -12,19 +12,19 @@
[macro
[code]
["s" syntax (#+ syntax:)]]]
- [/// (#+ State)]
- [/////
- [name]
- [host ["_" scheme (#+ Expression Computation Var)]]
- ["." compiler
+ ["." ///
+ ["//." //
[analysis (#+ Variant)]
- [synthesis]]])
+ [synthesis]
+ [//
+ [name]
+ [host ["_" scheme (#+ Expression Computation Var)]]]]])
(type: #export Operation
- (compiler.Operation (State Var Expression)))
+ (///.Operation Var Expression))
-(type: #export Translator
- (///.Translator Var Expression))
+(type: #export Compiler
+ (///.Compiler Var Expression))
(def: prefix Text "LuxRuntime")
@@ -362,6 +362,6 @@
(def: #export translate
(Operation Any)
(///.with-buffer
- (do compiler.Monad<Operation>
+ (do ////.Monad<Operation>
[_ (///.save! ["" ..prefix] ..runtime)]
(///.save-buffer! ""))))
diff --git a/stdlib/source/lux/language/compiler/translation/scheme/structure.jvm.lux b/stdlib/source/lux/language/compiler/translation/scheme/structure.jvm.lux
index ea5440d67..4637d1a25 100644
--- a/stdlib/source/lux/language/compiler/translation/scheme/structure.jvm.lux
+++ b/stdlib/source/lux/language/compiler/translation/scheme/structure.jvm.lux
@@ -7,11 +7,11 @@
["." compiler
[analysis (#+ Variant Tuple)]
[synthesis (#+ Synthesis)]]]
- [//runtime (#+ Operation Translator)]
+ [//runtime (#+ Operation Compiler)]
[//primitive])
(def: #export (tuple translate elemsS+)
- (-> Translator (Tuple Synthesis) (Operation Expression))
+ (-> Compiler (Tuple Synthesis) (Operation Expression))
(case elemsS+
#.Nil
(//primitive.text synthesis.unit)
@@ -25,7 +25,7 @@
(wrap (_.vector/* elemsT+)))))
(def: #export (variant translate [lefts right? valueS])
- (-> Translator (Variant Synthesis) (Operation Expression))
+ (-> Compiler (Variant Synthesis) (Operation Expression))
(do compiler.Monad<Operation>
[valueT (translate valueS)]
(wrap (//runtime.variant [lefts right? valueT]))))
diff --git a/stdlib/source/lux/language/module.lux b/stdlib/source/lux/language/module.lux
deleted file mode 100644
index 75a1ab302..000000000
--- a/stdlib/source/lux/language/module.lux
+++ /dev/null
@@ -1,243 +0,0 @@
-(.module:
- [lux #*
- [control
- [monad (#+ do)]
- ["ex" exception (#+ exception:)]
- pipe]
- [data
- [text ("text/" Equivalence<Text>)
- format]
- ["e" error]
- [collection
- [list ("list/" Fold<List> Functor<List>)]
- [dictionary [plist]]]]
- [macro]]
- ["." //compiler
- [analysis]])
-
-(type: #export Tag Text)
-
-(exception: #export (unknown-module {module Text})
- module)
-
-(exception: #export (cannot-declare-tag-twice {module Text} {tag Text})
- (ex.report ["Module" module]
- ["Tag" tag]))
-
-(do-template [<name>]
- [(exception: #export (<name> {tags (List Text)} {owner Type})
- (ex.report ["Tags" (text.join-with " " tags)]
- ["Type" (%type owner)]))]
-
- [cannot-declare-tags-for-unnamed-type]
- [cannot-declare-tags-for-foreign-type]
- )
-
-(exception: #export (cannot-define-more-than-once {name Ident})
- (%ident name))
-
-(exception: #export (can-only-change-state-of-active-module {module Text} {state Module-State})
- (ex.report ["Module" module]
- ["Desired state" (case state
- #.Active "Active"
- #.Compiled "Compiled"
- #.Cached "Cached")]))
-
-(exception: #export (cannot-set-module-annotations-more-than-once {module Text} {old Code} {new Code})
- (ex.report ["Module" module]
- ["Old annotations" (%code old)]
- ["New annotations" (%code new)]))
-
-(def: (new hash)
- (-> Nat Module)
- {#.module-hash hash
- #.module-aliases (list)
- #.definitions (list)
- #.imports (list)
- #.tags (list)
- #.types (list)
- #.module-annotations #.None
- #.module-state #.Active})
-
-(def: #export (set-annotations annotations)
- (-> Code (Meta Any))
- (do macro.Monad<Meta>
- [self-name macro.current-module-name
- self macro.current-module]
- (case (get@ #.module-annotations self)
- #.None
- (function (_ compiler)
- (#e.Success [(update@ #.modules
- (plist.put self-name (set@ #.module-annotations (#.Some annotations) self))
- compiler)
- []]))
-
- (#.Some old)
- (//compiler.throw cannot-set-module-annotations-more-than-once [self-name old annotations]))))
-
-(def: #export (import module)
- (-> Text (Meta Any))
- (do macro.Monad<Meta>
- [self-name macro.current-module-name]
- (function (_ compiler)
- (#e.Success [(update@ #.modules
- (plist.update self-name (update@ #.imports (|>> (#.Cons module))))
- compiler)
- []]))))
-
-(def: #export (alias alias module)
- (-> Text Text (Meta Any))
- (do macro.Monad<Meta>
- [self-name macro.current-module-name]
- (function (_ compiler)
- (#e.Success [(update@ #.modules
- (plist.update self-name (update@ #.module-aliases (: (-> (List [Text Text]) (List [Text Text]))
- (|>> (#.Cons [alias module])))))
- compiler)
- []]))))
-
-(def: #export (exists? module)
- (-> Text (Meta Bool))
- (function (_ compiler)
- (|> compiler
- (get@ #.modules)
- (plist.get module)
- (case> (#.Some _) true #.None false)
- [compiler] #e.Success)))
-
-(def: #export (define name definition)
- (-> Text Definition (Meta []))
- (do macro.Monad<Meta>
- [self-name macro.current-module-name
- self macro.current-module]
- (function (_ compiler)
- (case (plist.get name (get@ #.definitions self))
- #.None
- (#e.Success [(update@ #.modules
- (plist.put self-name
- (update@ #.definitions
- (: (-> (List [Text Definition]) (List [Text Definition]))
- (|>> (#.Cons [name definition])))
- self))
- compiler)
- []])
-
- (#.Some already-existing)
- ((//compiler.throw cannot-define-more-than-once [self-name name]) compiler)))))
-
-(def: #export (create hash name)
- (-> Nat Text (Meta []))
- (function (_ compiler)
- (let [module (new hash)]
- (#e.Success [(update@ #.modules
- (plist.put name module)
- compiler)
- []]))))
-
-(def: #export (with-module hash name action)
- (All [a] (-> Nat Text (Meta a) (Meta [Module a])))
- (do macro.Monad<Meta>
- [_ (create hash name)
- output (analysis.with-current-module name
- action)
- module (macro.find-module name)]
- (wrap [module output])))
-
-(do-template [<setter> <asker> <tag>]
- [(def: #export (<setter> module-name)
- (-> Text (Meta Any))
- (function (_ compiler)
- (case (|> compiler (get@ #.modules) (plist.get module-name))
- (#.Some module)
- (let [active? (case (get@ #.module-state module)
- #.Active true
- _ false)]
- (if active?
- (#e.Success [(update@ #.modules
- (plist.put module-name (set@ #.module-state <tag> module))
- compiler)
- []])
- ((//compiler.throw can-only-change-state-of-active-module [module-name <tag>])
- compiler)))
-
- #.None
- ((//compiler.throw unknown-module module-name) compiler))))
-
- (def: #export (<asker> module-name)
- (-> Text (Meta Bool))
- (function (_ compiler)
- (case (|> compiler (get@ #.modules) (plist.get module-name))
- (#.Some module)
- (#e.Success [compiler
- (case (get@ #.module-state module)
- <tag> true
- _ false)])
-
- #.None
- ((//compiler.throw unknown-module module-name) compiler))))]
-
- [set-active active? #.Active]
- [set-compiled compiled? #.Compiled]
- [set-cached cached? #.Cached]
- )
-
-(do-template [<name> <tag> <type>]
- [(def: (<name> module-name)
- (-> Text (Meta <type>))
- (function (_ compiler)
- (case (|> compiler (get@ #.modules) (plist.get module-name))
- (#.Some module)
- (#e.Success [compiler (get@ <tag> module)])
-
- #.None
- ((//compiler.throw unknown-module module-name) compiler))))]
-
- [tags #.tags (List [Text [Nat (List Ident) Bool Type]])]
- [types #.types (List [Text [(List Ident) Bool Type]])]
- [hash #.module-hash Nat]
- )
-
-(def: (ensure-undeclared-tags module-name tags)
- (-> Text (List Tag) (Meta Any))
- (do macro.Monad<Meta>
- [bindings (..tags module-name)
- _ (monad.map @
- (function (_ tag)
- (case (plist.get tag bindings)
- #.None
- (wrap [])
-
- (#.Some _)
- (//compiler.throw cannot-declare-tag-twice [module-name tag])))
- tags)]
- (wrap [])))
-
-(def: #export (declare-tags tags exported? type)
- (-> (List Tag) Bool Type (Meta Any))
- (do macro.Monad<Meta>
- [self-name macro.current-module-name
- [type-module type-name] (case type
- (#.Named type-ident _)
- (wrap type-ident)
-
- _
- (//compiler.throw cannot-declare-tags-for-unnamed-type [tags type]))
- _ (ensure-undeclared-tags self-name tags)
- _ (//compiler.assert cannot-declare-tags-for-foreign-type [tags type]
- (text/= self-name type-module))]
- (function (_ compiler)
- (case (|> compiler (get@ #.modules) (plist.get self-name))
- (#.Some module)
- (let [namespaced-tags (list/map (|>> [self-name]) tags)]
- (#e.Success [(update@ #.modules
- (plist.update self-name
- (|>> (update@ #.tags (function (_ tag-bindings)
- (list/fold (function (_ [idx tag] table)
- (plist.put tag [idx namespaced-tags exported? type] table))
- tag-bindings
- (list.enumerate tags))))
- (update@ #.types (plist.put type-name [namespaced-tags exported? type]))))
- compiler)
- []]))
- #.None
- ((//compiler.throw unknown-module self-name) compiler)))))
diff --git a/stdlib/source/lux/language/scope.lux b/stdlib/source/lux/language/scope.lux
deleted file mode 100644
index 1f0cbffc4..000000000
--- a/stdlib/source/lux/language/scope.lux
+++ /dev/null
@@ -1,191 +0,0 @@
-(.module:
- [lux #*
- [control
- monad]
- [data
- [text ("text/" Equivalence<Text>)
- format]
- [maybe ("maybe/" Monad<Maybe>)]
- [product]
- ["e" error]
- [collection
- [list ("list/" Functor<List> Fold<List> Monoid<List>)]
- [dictionary [plist]]]]
- [macro]]
- [//reference (#+ Register Variable)])
-
-(type: Locals (Bindings Text [Type Register]))
-(type: Foreign (Bindings Text [Type Variable]))
-
-(def: (is-local? name scope)
- (-> Text Scope Bool)
- (|> scope
- (get@ [#.locals #.mappings])
- (plist.contains? name)))
-
-(def: (get-local name scope)
- (-> Text Scope (Maybe [Type Variable]))
- (|> scope
- (get@ [#.locals #.mappings])
- (plist.get name)
- (maybe/map (function (_ [type value])
- [type (#//reference.Local value)]))))
-
-(def: (is-captured? name scope)
- (-> Text Scope Bool)
- (|> scope
- (get@ [#.captured #.mappings])
- (plist.contains? name)))
-
-(def: (get-captured name scope)
- (-> Text Scope (Maybe [Type Variable]))
- (loop [idx +0
- mappings (get@ [#.captured #.mappings] scope)]
- (case mappings
- #.Nil
- #.None
-
- (#.Cons [_name [_source-type _source-ref]] mappings')
- (if (text/= name _name)
- (#.Some [_source-type (#//reference.Foreign idx)])
- (recur (inc idx) mappings')))))
-
-(def: (is-ref? name scope)
- (-> Text Scope Bool)
- (or (is-local? name scope)
- (is-captured? name scope)))
-
-(def: (get-ref name scope)
- (-> Text Scope (Maybe [Type Variable]))
- (case (get-local name scope)
- (#.Some type)
- (#.Some type)
-
- _
- (get-captured name scope)))
-
-(def: #export (find name)
- (-> Text (Meta (Maybe [Type Variable])))
- (function (_ compiler)
- (let [[inner outer] (|> compiler
- (get@ #.scopes)
- (list.split-with (|>> (is-ref? name) not)))]
- (case outer
- #.Nil
- (#.Right [compiler #.None])
-
- (#.Cons top-outer _)
- (let [[ref-type init-ref] (maybe.default (undefined)
- (get-ref name top-outer))
- [ref inner'] (list/fold (: (-> Scope [Variable (List Scope)] [Variable (List Scope)])
- (function (_ scope ref+inner)
- [(#//reference.Foreign (get@ [#.captured #.counter] scope))
- (#.Cons (update@ #.captured
- (: (-> Foreign Foreign)
- (|>> (update@ #.counter inc)
- (update@ #.mappings (plist.put name [ref-type (product.left ref+inner)]))))
- scope)
- (product.right ref+inner))]))
- [init-ref #.Nil]
- (list.reverse inner))
- scopes (list/compose inner' outer)]
- (#.Right [(set@ #.scopes scopes compiler)
- (#.Some [ref-type ref])]))
- ))))
-
-(def: #export (with-local [name type] action)
- (All [a] (-> [Text Type] (Meta a) (Meta a)))
- (function (_ compiler)
- (case (get@ #.scopes compiler)
- (#.Cons head tail)
- (let [old-mappings (get@ [#.locals #.mappings] head)
- new-var-id (get@ [#.locals #.counter] head)
- new-head (update@ #.locals
- (: (-> Locals Locals)
- (|>> (update@ #.counter inc)
- (update@ #.mappings (plist.put name [type new-var-id]))))
- head)]
- (case (macro.run' (set@ #.scopes (#.Cons new-head tail) compiler)
- action)
- (#e.Success [compiler' output])
- (case (get@ #.scopes compiler')
- (#.Cons head' tail')
- (let [scopes' (#.Cons (set@ #.locals (get@ #.locals head) head')
- tail')]
- (#e.Success [(set@ #.scopes scopes' compiler')
- output]))
-
- _
- (error! "Invalid scope alteration/"))
-
- (#e.Error error)
- (#e.Error error)))
-
- _
- (#e.Error "Cannot create local binding without a scope."))
- ))
-
-(do-template [<name> <val-type>]
- [(def: <name>
- (Bindings Text [Type <val-type>])
- {#.counter +0
- #.mappings (list)})]
-
- [init-locals Nat]
- [init-captured Variable]
- )
-
-(def: (scope parent-name child-name)
- (-> (List Text) Text Scope)
- {#.name (list& child-name parent-name)
- #.inner +0
- #.locals init-locals
- #.captured init-captured})
-
-(def: #export (with-scope name action)
- (All [a] (-> Text (Meta a) (Meta a)))
- (function (_ compiler)
- (let [parent-name (case (get@ #.scopes compiler)
- #.Nil
- (list)
-
- (#.Cons top _)
- (get@ #.name top))]
- (case (action (update@ #.scopes
- (|>> (#.Cons (scope parent-name name)))
- compiler))
- (#e.Error error)
- (#e.Error error)
-
- (#e.Success [compiler' output])
- (#e.Success [(update@ #.scopes
- (|>> list.tail (maybe.default (list)))
- compiler')
- output])
- ))
- ))
-
-(def: #export next-local
- (Meta Register)
- (function (_ compiler)
- (case (get@ #.scopes compiler)
- #.Nil
- (#e.Error "Cannot get next reference when there is no scope.")
-
- (#.Cons top _)
- (#e.Success [compiler (get@ [#.locals #.counter] top)]))))
-
-(def: (ref-to-variable ref)
- (-> Ref Variable)
- (case ref
- (#.Local register)
- (#//reference.Local register)
-
- (#.Captured register)
- (#//reference.Foreign register)))
-
-(def: #export (environment scope)
- (-> Scope (List Variable))
- (|> scope
- (get@ [#.captured #.mappings])
- (list/map (function (_ [_ [_ ref]]) (ref-to-variable ref)))))
diff --git a/stdlib/test/test/lux/language/compiler/analysis/case.lux b/stdlib/test/test/lux/language/compiler/analysis/case.lux
index 66b1b0b12..4e01ae3bd 100644
--- a/stdlib/test/test/lux/language/compiler/analysis/case.lux
+++ b/stdlib/test/test/lux/language/compiler/analysis/case.lux
@@ -13,14 +13,14 @@
[set]]]
[math
["r" random ("random/" Monad<Random>)]]
- [macro (#+ Monad<Meta>)
+ [macro
[code]]
[language
["." type
- ["tc" check]]
- [".L" module]
- [compiler
+ [check]]
+ ["." compiler
["." analysis
+ [module]
[".A" type]
["/" case]]]]
test]
@@ -149,7 +149,7 @@
variantTC (list.zip2 variant-tags+ primitivesC)]
inputC (input variant-tags+ record-tags+ primitivesC)
[outputT outputC] _primitive.primitive
- [heterogeneousT heterogeneousC] (r.filter (|>> product.left (tc.checks? outputT) not)
+ [heterogeneousT heterogeneousC] (r.filter (|>> product.left (check.checks? outputT) not)
_primitive.primitive)
exhaustive-patterns (exhaustive-branches true variantTC inputC)
redundant-patterns (exhaustive-branches false variantTC inputC)
@@ -171,14 +171,14 @@
analyse-pm (|>> (/.case _primitive.analyse inputC)
(typeA.with-type outputT)
analysis.with-scope
- (do Monad<Meta>
- [_ (moduleL.declare-tags variant-tags false
- (#.Named [module-name variant-name]
- (type.variant primitivesT)))
- _ (moduleL.declare-tags record-tags false
- (#.Named [module-name record-name]
- (type.tuple primitivesT)))])
- (moduleL.with-module +0 module-name))]]
+ (do compiler.Monad<Operation>
+ [_ (module.declare-tags variant-tags false
+ (#.Named [module-name variant-name]
+ (type.variant primitivesT)))
+ _ (module.declare-tags record-tags false
+ (#.Named [module-name record-name]
+ (type.tuple primitivesT)))])
+ (module.with-module +0 module-name))]]
($_ seq
(test "Will reject empty pattern-matching (no branches)."
(|> (analyse-pm (list))
diff --git a/stdlib/test/test/lux/language/compiler/analysis/function.lux b/stdlib/test/test/lux/language/compiler/analysis/function.lux
index bc1a24811..1edbfd949 100644
--- a/stdlib/test/test/lux/language/compiler/analysis/function.lux
+++ b/stdlib/test/test/lux/language/compiler/analysis/function.lux
@@ -16,30 +16,31 @@
["r" random]]
["." macro
[code]]
- [language]
- [language
- [type ("type/" Equivalence<Type>)]
- [".L" reference]
- [compiler
- [".L" init]
- [".L" analysis (#+ Analysis)
+ ["." language
+ [type]
+ [reference]
+ ["." compiler
+ [init]
+ [analysis (#+ Analysis Operation)
[".A" type]
- [".A" expression]
- ["/" function]]]]
+ [expression]
+ ["/" function]]
+ [extension
+ [".E" analysis]]]]
test]
[//
["_." primitive]
["_." structure]])
-(def: analyse (expressionA.analyser (:coerce language.Eval [])))
+(def: analyse (expression.analyser (:coerce language.Eval [])))
(def: (check-apply expectedT num-args analysis)
- (-> Type Nat (Meta Analysis) Bool)
+ (-> Type Nat (Operation Analysis) Bool)
(|> analysis
(typeA.with-type expectedT)
- (macro.run (initL.compiler []))
+ (compiler.run [analysisE.bundle (init.compiler [])])
(case> (#e.Success applyA)
- (let [[funcA argsA] (analysisL.application applyA)]
+ (let [[funcA argsA] (analysis.application applyA)]
(n/= num-args (list.size argsA)))
(#e.Error error)
@@ -99,7 +100,7 @@
partial-polyT2 (<| (type.univ-q +1)
(type.function (#.Cons varT partial-poly-inputsT))
varT)
- dummy-function (#analysisL.Function (list) (#analysisL.Reference (referenceL.local +1)))]]
+ dummy-function (#analysis.Function (list) (#analysis.Reference (reference.local +1)))]]
($_ seq
(test "Can analyse monomorphic type application."
(|> (/.apply ..analyse funcT dummy-function inputsC)
diff --git a/stdlib/test/test/lux/language/compiler/analysis/primitive.lux b/stdlib/test/test/lux/language/compiler/analysis/primitive.lux
index ba841fbfe..8cd764b00 100644
--- a/stdlib/test/test/lux/language/compiler/analysis/primitive.lux
+++ b/stdlib/test/test/lux/language/compiler/analysis/primitive.lux
@@ -10,18 +10,20 @@
[text format]]
[math
["r" random ("random/" Monad<Random>)]]
- ["." macro
+ [macro
[code]]
["." language
[".L" type ("type/" Equivalence<Type>)]
- [compiler
- [".L" init]
- [analysis (#+ Analysis)
+ ["." compiler
+ [init]
+ [analysis (#+ Analysis Operation)
[".A" type]
- [".A" expression]]]]
+ [expression]]
+ [extension
+ [".E" analysis]]]]
test])
-(def: #export analyse (expressionA.analyser (:coerce language.Eval [])))
+(def: #export analyse (expression.analyser (:coerce language.Eval [])))
(def: unit
(r.Random Code)
@@ -47,10 +49,10 @@
["Inferred" (%type inferred)]))
(def: (infer-primitive expected-type analysis)
- (-> Type (Meta Analysis) (e.Error Analysis))
- (|> (typeA.with-inference
- analysis)
- (macro.run (initL.compiler []))
+ (-> Type (Operation Analysis) (e.Error Analysis))
+ (|> analysis
+ typeA.with-inference
+ (compiler.run [analysisE.bundle (init.compiler [])])
(case> (#e.Success [inferred-type output])
(if (is? expected-type inferred-type)
(#e.Success output)
diff --git a/stdlib/test/test/lux/language/compiler/analysis/procedure/common.lux b/stdlib/test/test/lux/language/compiler/analysis/procedure/common.lux
index 1f7021039..e3b8cc9b5 100644
--- a/stdlib/test/test/lux/language/compiler/analysis/procedure/common.lux
+++ b/stdlib/test/test/lux/language/compiler/analysis/procedure/common.lux
@@ -13,15 +13,17 @@
[collection [array]]]
[math
["r" random]]
- [macro (#+ Monad<Meta>)
+ [macro
[code]]
- ["." language
+ [language
[type ("type/" Equivalence<Type>)]
- [".L" scope]
- [compiler
- [".L" init]
+ ["." compiler
+ [init]
[analysis
- [".A" type]]]]
+ [scope]
+ [".A" type]]
+ [extension
+ [".E" analysis]]]]
test]
[///
["_." primitive]])
@@ -29,10 +31,10 @@
(do-template [<name> <success> <failure>]
[(def: (<name> procedure params output-type)
(-> Text (List Code) Type Bool)
- (|> (scopeL.with-scope ""
+ (|> (scope.with-scope ""
(typeA.with-type output-type
(_primitive.analyse (` ((~ (code.text procedure)) (~+ params))))))
- (macro.run (initL.compiler []))
+ (compiler.run [analysisE.bundle (init.compiler [])])
(case> (#e.Success _)
<success>
@@ -177,11 +179,11 @@
#let [arrayT (type (Array elemT))
g!array (code.local-symbol var-name)
array-operation (function (_ output-type code)
- (|> (scopeL.with-scope ""
- (scopeL.with-local [var-name arrayT]
+ (|> (scope.with-scope ""
+ (scope.with-local [var-name arrayT]
(typeA.with-type output-type
(_primitive.analyse code))))
- (macro.run (initL.compiler []))
+ (compiler.run [analysisE.bundle (init.compiler [])])
(case> (#e.Success _)
true
@@ -247,25 +249,25 @@
(test "Can create atomic reference."
(check-success+ "lux atom new" (list elemC) atomT))
(test "Can read the value of an atomic reference."
- (|> (scopeL.with-scope ""
- (scopeL.with-local [var-name atomT]
+ (|> (scope.with-scope ""
+ (scope.with-local [var-name atomT]
(typeA.with-type elemT
(_primitive.analyse (` ("lux atom read" (~ (code.symbol ["" var-name]))))))))
- (macro.run (initL.compiler []))
+ (compiler.run [analysisE.bundle (init.compiler [])])
(case> (#e.Success _)
true
(#e.Error _)
false)))
(test "Can swap the value of an atomic reference."
- (|> (scopeL.with-scope ""
- (scopeL.with-local [var-name atomT]
+ (|> (scope.with-scope ""
+ (scope.with-local [var-name atomT]
(typeA.with-type Bool
(_primitive.analyse (` ("lux atom compare-and-swap"
(~ (code.symbol ["" var-name]))
(~ elemC)
(~ elemC)))))))
- (macro.run (initL.compiler []))
+ (compiler.run [analysisE.bundle (init.compiler [])])
(case> (#e.Success _)
true
diff --git a/stdlib/test/test/lux/language/compiler/analysis/reference.lux b/stdlib/test/test/lux/language/compiler/analysis/reference.lux
index aaad40584..00ab606a3 100644
--- a/stdlib/test/test/lux/language/compiler/analysis/reference.lux
+++ b/stdlib/test/test/lux/language/compiler/analysis/reference.lux
@@ -10,23 +10,26 @@
[text ("text/" Equivalence<Text>)]]
[math
["r" random]]
- [macro (#+ Monad<Meta>) [code]]
+ [macro
+ [code]]
["." language]
[language
[type ("type/" Equivalence<Type>)]
- [".L" scope]
- [".L" module]
- [".L" reference]
- [compiler
- [".L" init]
- [".L" analysis
+ [reference]
+ ["." compiler
+ [init]
+ ["." analysis
+ [scope]
+ [module]
[".A" type]
- [".A" expression]]]]
+ [expression]]
+ [extension
+ [".E" analysis]]]]
test]
[//
["_." primitive]])
-(def: analyse (expressionA.analyser (:coerce language.Eval [])))
+(def: analyse (expression.analyser (:coerce language.Eval [])))
(type: Check (-> (e.Error Any) Bool))
@@ -45,21 +48,21 @@
(def: (reach-test var-name [export? def-module] [import? dependent-module] check!)
(-> Text [Bool Text] [Bool Text] Check Bool)
- (|> (do Monad<Meta>
- [_ (moduleL.with-module +0 def-module
- (moduleL.define var-name [Any
- (if export?
- (' {#.export? true})
- (' {}))
- []]))]
- (moduleL.with-module +0 dependent-module
+ (|> (do compiler.Monad<Operation>
+ [_ (module.with-module +0 def-module
+ (module.define var-name [Any
+ (if export?
+ (' {#.export? true})
+ (' {}))
+ []]))]
+ (module.with-module +0 dependent-module
(do @
[_ (if import?
- (moduleL.import def-module)
+ (module.import def-module)
(wrap []))]
(typeA.with-inference
(..analyse (code.symbol [def-module var-name]))))))
- (macro.run (initL.compiler []))
+ (compiler.run [analysisE.bundle (init.compiler [])])
check!))
(context: "References"
@@ -73,12 +76,12 @@
(r.filter (|>> (text/= def-module) not)))]
($_ seq
(test "Can analyse variable."
- (|> (scopeL.with-scope scope-name
- (scopeL.with-local [var-name expectedT]
+ (|> (scope.with-scope scope-name
+ (scope.with-local [var-name expectedT]
(typeA.with-inference
(..analyse (code.local-symbol var-name)))))
- (macro.run (initL.compiler []))
- (case> (^ (#e.Success [inferredT (#analysisL.Reference (referenceL.local var))]))
+ (compiler.run [analysisE.bundle (init.compiler [])])
+ (case> (^ (#e.Success [inferredT (#analysis.Reference (reference.local var))]))
(and (type/= expectedT inferredT)
(n/= +0 var))
@@ -86,13 +89,13 @@
false)))
(test "Can analyse definition (in the same module)."
(let [def-name [def-module var-name]]
- (|> (do Monad<Meta>
- [_ (moduleL.define var-name [expectedT (' {}) []])]
+ (|> (do compiler.Monad<Operation>
+ [_ (module.define var-name [expectedT (' {}) []])]
(typeA.with-inference
(..analyse (code.symbol def-name))))
- (moduleL.with-module +0 def-module)
- (macro.run (initL.compiler []))
- (case> (^ (#e.Success [_ inferredT (#analysisL.Reference (referenceL.constant constant-name))]))
+ (module.with-module +0 def-module)
+ (compiler.run [analysisE.bundle (init.compiler [])])
+ (case> (^ (#e.Success [_ inferredT (#analysis.Reference (reference.constant constant-name))]))
(and (type/= expectedT inferredT)
(ident/= def-name constant-name))
diff --git a/stdlib/test/test/lux/language/compiler/analysis/structure.lux b/stdlib/test/test/lux/language/compiler/analysis/structure.lux
index 2777ad93b..664e6e29f 100644
--- a/stdlib/test/test/lux/language/compiler/analysis/structure.lux
+++ b/stdlib/test/test/lux/language/compiler/analysis/structure.lux
@@ -1,6 +1,5 @@
(.module:
[lux #*
- [io]
[control
[monad (#+ do)]
pipe]
@@ -9,35 +8,36 @@
["e" error]
[product]
[maybe]
- ["." text
- format]
+ ["." text]
[collection
[list ("list/" Functor<List>)]
[set]]]
[math
["r" random]]
- ["." macro
+ [macro
[code]]
["." language
[type ("type/" Equivalence<Type>)
- ["tc" check]]
- [".L" module]
- [compiler
- [".L" init]
- [".L" analysis (#+ Analysis Variant Tag)
+ [check]]
+ ["." compiler
+ [init]
+ [analysis (#+ Analysis Variant Tag Operation)
+ [module]
[".A" type]
["/" structure]
- [".A" expression]]]]
+ [expression]]
+ [extension
+ [".E" analysis]]]]
test]
[//
["_." primitive]])
-(def: analyse (expressionA.analyser (:coerce language.Eval [])))
+(def: analyse (expression.analyser (:coerce language.Eval [])))
(do-template [<name> <on-success> <on-error>]
[(def: #export <name>
- (All [a] (-> (Meta a) Bool))
- (|>> (macro.run (initL.compiler []))
+ (All [a] (-> (Operation a) Bool))
+ (|>> (compiler.run [analysisE.bundle (init.compiler [])])
(case> (#e.Success _)
<on-success>
@@ -50,20 +50,20 @@
(def: (check-sum' size tag variant)
(-> Nat Tag (Variant Analysis) Bool)
- (let [variant-tag (if (get@ #analysisL.right? variant)
- (inc (get@ #analysisL.lefts variant))
- (get@ #analysisL.lefts variant))]
+ (let [variant-tag (if (get@ #analysis.right? variant)
+ (inc (get@ #analysis.lefts variant))
+ (get@ #analysis.lefts variant))]
(|> size dec (n/= tag)
- (bool/= (get@ #analysisL.right? variant))
+ (bool/= (get@ #analysis.right? variant))
(and (n/= tag variant-tag)))))
(def: (check-sum type size tag analysis)
- (-> Type Nat Tag (Meta Analysis) Bool)
+ (-> Type Nat Tag (Operation Analysis) Bool)
(|> analysis
(typeA.with-type type)
- (macro.run (initL.compiler []))
+ (compiler.run [analysisE.bundle (init.compiler [])])
(case> (^multi (#e.Success sumA)
- [(analysisL.variant sumA)
+ [(analysis.variant sumA)
(#.Some variant)])
(check-sum' size tag variant)
@@ -71,19 +71,19 @@
false)))
(def: (tagged module tags type)
- (All [a] (-> Text (List moduleL.Tag) Type (Meta a) (Meta [Module a])))
- (|>> (do macro.Monad<Meta>
- [_ (moduleL.declare-tags tags false type)])
- (moduleL.with-module +0 module)))
+ (All [a] (-> Text (List module.Tag) Type (Operation a) (Operation [Module a])))
+ (|>> (do compiler.Monad<Operation>
+ [_ (module.declare-tags tags false type)])
+ (module.with-module +0 module)))
(def: (check-variant module tags type size tag analysis)
- (-> Text (List moduleL.Tag) Type Nat Tag (Meta Analysis) Bool)
+ (-> Text (List module.Tag) Type Nat Tag (Operation Analysis) Bool)
(|> analysis
(tagged module tags type)
(typeA.with-type type)
- (macro.run (initL.compiler []))
+ (compiler.run [analysisE.bundle (init.compiler [])])
(case> (^multi (#e.Success [_ sumA])
- [(analysisL.variant sumA)
+ [(analysis.variant sumA)
(#.Some variant)])
(check-sum' size tag variant)
@@ -92,13 +92,13 @@
(def: (right-size? size)
(-> Nat (-> Analysis Bool))
- (|>> analysisL.tuple list.size (n/= size)))
+ (|>> analysis.tuple list.size (n/= size)))
(def: (check-record-inference module tags type size analysis)
- (-> Text (List moduleL.Tag) Type Nat (Meta [Type Analysis]) Bool)
+ (-> Text (List module.Tag) Type Nat (Operation [Type Analysis]) Bool)
(|> analysis
(tagged module tags type)
- (macro.run (initL.compiler []))
+ (compiler.run [analysisE.bundle (init.compiler [])])
(case> (#e.Success [_ productT productA])
(and (type/= type productT)
(right-size? size productA))
@@ -127,23 +127,23 @@
(check-sum variantT size choice
(/.sum ..analyse choice valueC)))
(test "Can analyse sum through bound type-vars."
- (|> (do macro.Monad<Meta>
- [[_ varT] (typeA.with-env tc.var)
+ (|> (do compiler.Monad<Operation>
+ [[_ varT] (typeA.with-env check.var)
_ (typeA.with-env
- (tc.check varT variantT))]
+ (check.check varT variantT))]
(typeA.with-type varT
(/.sum ..analyse choice valueC)))
- (macro.run (initL.compiler []))
+ (compiler.run [analysisE.bundle (init.compiler [])])
(case> (^multi (#e.Success sumA)
- [(analysisL.variant sumA)
+ [(analysis.variant sumA)
(#.Some variant)])
(check-sum' size choice variant)
_
false)))
(test "Cannot analyse sum through unbound type-vars."
- (|> (do macro.Monad<Meta>
- [[_ varT] (typeA.with-env tc.var)]
+ (|> (do compiler.Monad<Operation>
+ [[_ varT] (typeA.with-env check.var)]
(typeA.with-type varT
(/.sum ..analyse choice valueC)))
check-fails))
@@ -177,7 +177,7 @@
(test "Can analyse product."
(|> (typeA.with-type tupleT
(/.product ..analyse (list/map product.right primitives)))
- (macro.run (initL.compiler []))
+ (compiler.run [analysisE.bundle (init.compiler [])])
(case> (#e.Success tupleA)
(right-size? size tupleA)
@@ -186,7 +186,7 @@
(test "Can infer product."
(|> (typeA.with-inference
(/.product ..analyse (list/map product.right primitives)))
- (macro.run (initL.compiler []))
+ (compiler.run [analysisE.bundle (init.compiler [])])
(case> (#e.Success [_type tupleA])
(and (type/= tupleT _type)
(right-size? size tupleA))
@@ -198,13 +198,13 @@
(..analyse (` [(~ singletonC)])))
check-succeeds))
(test "Can analyse product through bound type-vars."
- (|> (do macro.Monad<Meta>
- [[_ varT] (typeA.with-env tc.var)
+ (|> (do compiler.Monad<Operation>
+ [[_ varT] (typeA.with-env check.var)
_ (typeA.with-env
- (tc.check varT (type.tuple (list/map product.left primitives))))]
+ (check.check varT (type.tuple (list/map product.left primitives))))]
(typeA.with-type varT
(/.product ..analyse (list/map product.right primitives))))
- (macro.run (initL.compiler []))
+ (compiler.run [analysisE.bundle (init.compiler [])])
(case> (#e.Success tupleA)
(right-size? size tupleA)
@@ -290,7 +290,7 @@
(/.record ..analyse recordC))
(check-record-inference module-name tags named-polyT size)))
(test "Can specialize generic records."
- (|> (do macro.Monad<Meta>
+ (|> (do compiler.Monad<Operation>
[recordA (typeA.with-type tupleT
(/.record ..analyse recordC))]
(wrap [tupleT recordA]))
diff --git a/stdlib/test/test/lux/language/compiler/synthesis/case.lux b/stdlib/test/test/lux/language/compiler/synthesis/case.lux
index 7ae02d943..264bc0967 100644
--- a/stdlib/test/test/lux/language/compiler/synthesis/case.lux
+++ b/stdlib/test/test/lux/language/compiler/synthesis/case.lux
@@ -1,16 +1,20 @@
(.module:
- lux
- (lux (control [monad (#+ do)]
- pipe)
- (data [error ("error/" Functor<Error>)])
- (language ["///." reference]
- ["///." compiler]
- [".L" analysis (#+ Branch Analysis)]
- ["//" synthesis (#+ Synthesis)]
- (synthesis [".S" expression])
- [".L" extension])
- ["r" math/random]
- test)
+ [lux #*
+ [control
+ [monad (#+ do)]
+ pipe]
+ [data
+ [error ("error/" Functor<Error>)]]
+ [language
+ ["///." reference]
+ ["///." compiler
+ [".L" analysis (#+ Branch Analysis)]
+ ["//" synthesis (#+ Synthesis)
+ [".S" expression]]
+ [".L" extension]]]
+ [math
+ ["r" random]]
+ test]
[//primitive])
(context: "Dummy variables."
diff --git a/stdlib/test/test/lux/language/compiler/synthesis/function.lux b/stdlib/test/test/lux/language/compiler/synthesis/function.lux
index 8bbc1401d..51b2a2e17 100644
--- a/stdlib/test/test/lux/language/compiler/synthesis/function.lux
+++ b/stdlib/test/test/lux/language/compiler/synthesis/function.lux
@@ -1,24 +1,28 @@
(.module:
- lux
- (lux [io]
- (control [monad (#+ do)]
- pipe)
- (data [product]
- [maybe]
- [error]
- [number]
- text/format
- (collection [list ("list/" Functor<List> Fold<List>)]
- ["dict" dictionary (#+ Dictionary)]
- [set]))
- (language ["///." reference (#+ Variable) ("variable/" Equivalence<Variable>)]
- ["///." compiler]
- [".L" analysis (#+ Arity Analysis)]
- ["//" synthesis (#+ Synthesis)]
- (synthesis [".S" expression])
- [".L" extension])
- ["r" math/random]
- test)
+ [lux #*
+ [io]
+ [control
+ [monad (#+ do)]
+ pipe]
+ [data
+ [product]
+ [maybe]
+ [error]
+ [number]
+ [text format]
+ [collection
+ [list ("list/" Functor<List> Fold<List>)]
+ ["dict" dictionary (#+ Dictionary)]
+ [set]]]
+ [language
+ ["///." reference (#+ Variable) ("variable/" Equivalence<Variable>)]
+ ["///." compiler
+ [".L" analysis (#+ Arity Analysis)]
+ ["//" synthesis (#+ Synthesis)
+ [".S" expression]]
+ [".L" extension]]]
+ [math ["r" random]]
+ test]
[//primitive])
(def: constant-function
diff --git a/stdlib/test/test/lux/language/compiler/synthesis/primitive.lux b/stdlib/test/test/lux/language/compiler/synthesis/primitive.lux
index e90d8cb26..3bea7682d 100644
--- a/stdlib/test/test/lux/language/compiler/synthesis/primitive.lux
+++ b/stdlib/test/test/lux/language/compiler/synthesis/primitive.lux
@@ -1,18 +1,22 @@
(.module:
- [lux (#- primitive)]
- (lux [io]
- (control [monad (#+ do)]
- pipe)
- (data [error]
- text/format)
- [language]
- (language [".L" extension]
- ["///." compiler]
- [".L" analysis (#+ Analysis)]
- ["//" synthesis (#+ Synthesis)]
- (synthesis [".S" expression]))
- ["r" math/random]
- test))
+ [lux (#- primitive)
+ [io]
+ [control
+ [monad (#+ do)]
+ pipe]
+ [data
+ [error]
+ [text
+ format]]
+ ["." language
+ ["///." compiler
+ [".L" analysis (#+ Analysis)]
+ ["//" synthesis (#+ Synthesis)
+ [".S" expression]]
+ [".L" extension]]]
+ [math
+ ["r" random]]
+ test])
(def: #export primitive
(r.Random Analysis)
diff --git a/stdlib/test/test/lux/language/compiler/synthesis/structure.lux b/stdlib/test/test/lux/language/compiler/synthesis/structure.lux
index 8dba248e5..0b9f705ff 100644
--- a/stdlib/test/test/lux/language/compiler/synthesis/structure.lux
+++ b/stdlib/test/test/lux/language/compiler/synthesis/structure.lux
@@ -1,19 +1,24 @@
(.module:
- lux
- (lux [io]
- (control [monad (#+ do)]
- pipe)
- (data [bool ("bool/" Equivalence<Bool>)]
- [product]
- [error]
- (collection [list]))
- (language ["///." compiler]
- [".L" analysis]
- ["//" synthesis (#+ Synthesis)]
- (synthesis [".S" expression])
- [".L" extension])
- (math ["r" random])
- test)
+ [lux #*
+ [io]
+ [control
+ [monad (#+ do)]
+ pipe]
+ [data
+ [bool ("bool/" Equivalence<Bool>)]
+ [product]
+ [error]
+ [collection
+ [list]]]
+ [language
+ ["///." compiler
+ [".L" analysis]
+ ["//" synthesis (#+ Synthesis)
+ [".S" expression]]
+ [".L" extension]]]
+ [math
+ ["r" random]]
+ test]
[//primitive])
(context: "Variants"