diff options
Diffstat (limited to '')
24 files changed, 1747 insertions, 187 deletions
diff --git a/stdlib/source/lux/data/text/format.lux b/stdlib/source/lux/data/text/format.lux index 83701c972..f6a53358d 100644 --- a/stdlib/source/lux/data/text/format.lux +++ b/stdlib/source/lux/data/text/format.lux @@ -1,7 +1,7 @@ (.module: [lux #* [control - [monad (#+ do Monad)] + [monad (#+ do)] ["p" parser]] [data ["." bit] @@ -16,7 +16,7 @@ ["." xml] ["." json]] [collection - ["." list ("#;." monad)]]] + ["." list ("#@." monad)]]] [time ["." instant] ["." duration] @@ -25,7 +25,7 @@ ["." modular]] ["." macro ["." code] - ["s" syntax (#+ syntax: Syntax)]] + ["s" syntax (#+ Syntax syntax:)]] ["." type]]) ## [Syntax] @@ -85,4 +85,4 @@ "(list)" _ - (format "(list " (text.join-with " " (list;map formatter values)) ")")))) + (format "(list " (text.join-with " " (list@map formatter values)) ")")))) diff --git a/stdlib/source/lux/host/js.lux b/stdlib/source/lux/host/js.lux index 45f3d42c6..be8759a35 100644 --- a/stdlib/source/lux/host/js.lux +++ b/stdlib/source/lux/host/js.lux @@ -123,27 +123,6 @@ (format (:representation function)) :abstraction)) - (do-template [<apply> <arg>+ <type>+ <function>+] - [(`` (def: #export (<apply> function) - (-> Expression (~~ (template.splice <type>+)) Computation) - (.function (_ (~~ (template.splice <arg>+))) - (..apply/* function (list (~~ (template.splice <arg>+))))))) - - (`` (do-template [<definition> <function>] - [(def: #export <definition> (<apply> (..var <function>)))] - - (~~ (template.splice <function>+))))] - - [apply/1 [_0] [Expression] - [[not-a-number? "isNaN"]]] - - [apply/2 [_0 _1] [Expression Expression] - []] - - [apply/3 [_0 _1 _2] [Expression Expression Expression] - []] - ) - (def: #export (do method inputs object) (-> Text (List Expression) Expression Computation) (apply/* (..the method object) inputs)) @@ -395,3 +374,24 @@ (..if test then! next!)) else! (list.reverse clauses))) + +(do-template [<apply> <arg>+ <type>+ <function>+] + [(`` (def: #export (<apply> function) + (-> Expression (~~ (template.splice <type>+)) Computation) + (.function (_ (~~ (template.splice <arg>+))) + (..apply/* function (list (~~ (template.splice <arg>+))))))) + + (`` (do-template [<definition> <function>] + [(def: #export <definition> (<apply> (..var <function>)))] + + (~~ (template.splice <function>+))))] + + [apply/1 [_0] [Expression] + [[not-a-number? "isNaN"]]] + + [apply/2 [_0 _1] [Expression Expression] + []] + + [apply/3 [_0 _1 _2] [Expression Expression Expression] + []] + ) diff --git a/stdlib/source/lux/host/python.lux b/stdlib/source/lux/host/python.lux new file mode 100644 index 000000000..afdb923fc --- /dev/null +++ b/stdlib/source/lux/host/python.lux @@ -0,0 +1,402 @@ +(.module: + [lux (#- Code not or and list if cond int) + [control + pipe] + [data + [number + ["." frac]] + ["." text + format] + [collection + ["." list ("#@." functor fold)]]] + [macro + ["." template] + ["." code] + ["s" syntax (#+ syntax:)]] + [type + abstract]]) + +(def: expression (-> Text Text) (text.enclose ["(" ")"])) + +(def: nest + (-> Text Text) + (|>> (format text.new-line) + (text.replace-all text.new-line (format text.new-line text.tab)))) + +(abstract: #export (Code brand) + {} + + Text + + (def: #export manual + (-> Text Code) + (|>> :abstraction)) + + (def: #export code + (-> (Code Any) Text) + (|>> :representation)) + + (do-template [<type> <super>] + [(with-expansions [<brand> (template.identifier [<type> "'"])] + (`` (abstract: #export (<brand> brand) {} Any)) + (`` (type: #export (<type> brand) + (<super> (<brand> brand)))))] + + [Expression Code] + [Computation Expression] + [Location Computation] + [Var Location] + [Statement Code] + ) + + (do-template [<type> <super>] + [(with-expansions [<brand> (template.identifier [<type> "'"])] + (`` (abstract: #export <brand> {} Any)) + (`` (type: #export <type> (<super> <brand>))))] + + [Literal Computation] + [Access Location] + [Loop Statement] + [Label Code] + ) + + (abstract: #export Single {} Any) + (abstract: #export Poly {} Any) + (abstract: #export Keyword {} Any) + + (type: #export SVar (Var Single)) + (type: #export PVar (Var Poly)) + (type: #export KVar (Var Keyword)) + + (def: #export var + (-> Text SVar) + (|>> :abstraction)) + + (do-template [<name> <kind> <prefix>] + [(def: #export <name> + (-> SVar (Var <kind>)) + (|>> :representation (format <prefix>) :abstraction))] + + [poly Poly "*"] + [keyword Keyword "**"] + ) + + (def: #export none + Literal + (:abstraction "None")) + + (def: #export bool + (-> Bit Literal) + (|>> (case> #0 "False" + #1 "True") + :abstraction)) + + (def: #export int + (-> Int Literal) + (|>> %i :abstraction)) + + (def: #export float + (-> Frac Literal) + (`` (|>> (cond> (~~ (do-template [<lux> <python>] + [[(f/= <lux>)] + [(new> (format "float(" text.double-quote <python> text.double-quote ")") [])]] + + [frac.positive-infinity "inf"] + [frac.negative-infinity "-inf"] + [frac.not-a-number "nan"] + )) + + ## else + [%f]) + :abstraction))) + + (def: #export string + (-> Text Literal) + (|>> (text.enclose' text.double-quote) :abstraction)) + + (def: (composite-literal left-delimiter right-delimiter entry-serializer) + (All [a] + (-> Text Text (-> a Text) + (-> (List a) Literal))) + (function (_ entries) + (<| :abstraction + ..expression + (format left-delimiter + (|> entries (list@map entry-serializer) (text.join-with ",")) + right-delimiter)))) + + (do-template [<name> <pre> <post>] + [(def: #export <name> + (-> (List (Expression Any)) Literal) + (composite-literal <pre> <post> ..code))] + + [tuple "(" ")"] + [list "[" "]"] + ) + + (def: #export (slice from to list) + (-> (Expression Any) (Expression Any) (Expression Any) Access) + (<| :abstraction + ..expression + (format (:representation list) "[" (:representation from) ":" (:representation to) "]"))) + + (def: #export (slice-from from list) + (-> (Expression Any) (Expression Any) Access) + (<| :abstraction + ..expression + (format (:representation list) "[" (:representation from) ":]"))) + + (def: #export dict + (-> (List [(Expression Any) (Expression Any)]) (Computation Any)) + (composite-literal "{" "}" (.function (_ [k v]) (format (:representation k) " : " (:representation v))))) + + (def: #export (apply/* func args) + (-> (Expression Any) (List (Expression Any)) (Computation Any)) + (<| :abstraction + ..expression + (format (:representation func) "(" (text.join-with "," (list@map ..code args)) ")"))) + + (do-template [<name> <kind> <prefix>] + [(def: (<name> var) + (-> (Expression Any) Text) + (format <prefix> (:representation var)))] + + [splat-poly Poly "*"] + [splat-keyword Keyword "**"] + ) + + (do-template [<name> <splat>] + [(def: #export (<name> args extra func) + (-> (List (Expression Any)) (Expression Any) (Expression Any) (Computation Any)) + (<| :abstraction + ..expression + (format (:representation func) + (format "(" (|> args + (list@map (function (_ arg) (format (:representation arg) ", "))) + (text.join-with "")) + (<splat> extra) ")"))))] + + [apply-poly splat-poly] + [apply-keyword splat-keyword] + ) + + (def: #export (the name object) + (-> Text (Expression Any) (Computation Any)) + (:abstraction (format (:representation object) "." name))) + + (def: #export (do method args object) + (-> Text (List (Expression Any)) (Expression Any) (Computation Any)) + (..apply/* (..the method object) args)) + + (do-template [<name> <apply>] + [(def: #export (<name> args extra method) + (-> (List (Expression Any)) (Expression Any) Text + (-> (Expression Any) (Computation Any))) + (|>> (..the method) (<apply> args extra)))] + + [do-poly apply-poly] + [do-keyword apply-keyword] + ) + + (def: #export (nth idx array) + (-> (Expression Any) (Expression Any) Location) + (:abstraction (format (:representation array) "[" (:representation idx) "]"))) + + (def: #export (? test then else) + (-> (Expression Any) (Expression Any) (Expression Any) (Computation Any)) + (<| :abstraction + ..expression + (format (:representation then) " if " (:representation test) " else " (:representation else)))) + + (do-template [<name> <op>] + [(def: #export (<name> param subject) + (-> (Expression Any) (Expression Any) (Computation Any)) + (<| :abstraction + ..expression + (format (:representation subject) " " <op> " " (:representation param))))] + + [is "is"] + [= "=="] + [< "<"] + [<= "<="] + [> ">"] + [>= ">="] + [+ "+"] + [- "-"] + [* "*"] + [/ "/"] + [% "%"] + [** "**"] + [bit-or "|"] + [bit-and "&"] + [bit-xor "^"] + [bit-shl "<<"] + [bit-shr ">>"] + + [or "or"] + [and "and"] + ) + + (def: #export (not subject) + (-> (Expression Any) (Computation Any)) + (<| :abstraction + ..expression + (format "not " (:representation subject)))) + + (def: #export (lambda arguments body) + (-> (List (Var Any)) (Expression Any) (Computation Any)) + (<| :abstraction + ..expression + (format "lambda " (|> arguments (list@map ..code) (text.join-with ", ")) ": " + (:representation body)))) + + (def: #export (set vars value) + (-> (List (Location Any)) (Expression Any) (Statement Any)) + (:abstraction + (format (|> vars (list@map ..code) (text.join-with ", ")) + " = " + (:representation value)))) + + (def: #export (delete where) + (-> (Location Any) (Statement Any)) + (:abstraction (format "del " (:representation where)))) + + (def: #export (if test then! else!) + (-> (Expression Any) (Statement Any) (Statement Any) (Statement Any)) + (:abstraction + (format "if " (:representation test) ":" + (..nest (:representation then!)) + text.new-line "else:" + (..nest (:representation else!))))) + + (def: #export (when test then!) + (-> (Expression Any) (Statement Any) (Statement Any)) + (:abstraction + (format "if " (:representation test) ":" + (..nest (:representation then!))))) + + (def: #export (then pre! post!) + (-> (Statement Any) (Statement Any) (Statement Any)) + (:abstraction + (format (:representation pre!) + text.new-line + (:representation post!)))) + + (do-template [<keyword> <0>] + [(def: #export <0> + Statement + (:abstraction <keyword>))] + + ["break" break] + ["continue" continue] + ) + + (def: #export (while test body!) + (-> (Expression Any) (Statement Any) Loop) + (:abstraction + (format "while " (:representation test) ":" + (..nest (:representation body!))))) + + (def: #export (for-in var inputs body!) + (-> SVar (Expression Any) (Statement Any) Loop) + (:abstraction + (format "for " (:representation var) " in " (:representation inputs) ":" + (..nest (:representation body!))))) + + (def: #export (statement expression) + (-> (Expression Any) (Statement Any)) + (:abstraction + (format (:representation expression) ";"))) + + (def: #export no-op! + (Statement Any) + (:abstraction text.new-line)) + + (type: #export Except + {#classes (List SVar) + #exception SVar + #handler (Statement Any)}) + + (def: #export (try body! excepts) + (-> (Statement Any) (List Except) (Statement Any)) + (:abstraction + (format "try:" + (..nest (:representation body!)) + (|> excepts + (list@map (function (_ [classes exception catch!]) + (format text.new-line "except (" (text.join-with "," (list@map ..code classes)) + ") as " (:representation exception) ":" + (..nest (:representation catch!))))) + (text.join-with ""))))) + + (do-template [<name> <keyword>] + [(def: #export (<name> message) + (-> (Expression Any) (Statement Any)) + (:abstraction + (format <keyword> " " (:representation message))))] + + [raise "raise"] + [return "return"] + [print "print"] + ) + + (def: #export (def name args body) + (-> SVar (List (Ex [k] (Var k))) (Statement Any) (Statement Any)) + (:abstraction + (format "def " (:representation name) + "(" (|> args (list@map ..code) (text.join-with ",")) "):" + (..nest (:representation body))))) + + (def: #export (import module-name) + (-> Text (Statement Any)) + (:abstraction (format "import " module-name))) + ) + +(def: #export (cond clauses else!) + (-> (List [(Expression Any) (Statement Any)]) (Statement Any) (Statement Any)) + (list@fold (.function (_ [test then!] next!) + (..if test then! next!)) + else! + (list.reverse clauses))) + +(syntax: (arity-inputs {arity s.nat}) + (wrap (case arity + 0 (.list) + _ (|> (dec arity) + (list.n/range 0) + (list@map (|>> %n code.local-identifier)))))) + +(syntax: (arity-types {arity s.nat}) + (wrap (list.repeat arity (` (Expression Any))))) + +(do-template [<arity> <function>+] + [(with-expansions [<apply> (template.identifier ["apply/" <arity>]) + <inputs> (arity-inputs <arity>) + <types> (arity-types <arity>) + <definitions> (template.splice <function>+)] + (def: #export (<apply> function <inputs>) + (-> (Expression Any) <types> (Computation Any)) + (..apply/* function (.list <inputs>))) + + (do-template [<function>] + [(`` (def: #export (~~ (template.identifier [<function> "/" <arity>])) + (<apply> (..var <function>))))] + + <definitions>))] + + [1 + [["str"] + ["ord"] + ["float"] + ["int"] + ["len"] + ["chr"] + ["repr"] + ["Exception"]]] + + [2 + []] + + [3 + []] + ) diff --git a/stdlib/source/lux/macro/template.lux b/stdlib/source/lux/macro/template.lux index 1f098ff4a..d0e9714a2 100644 --- a/stdlib/source/lux/macro/template.lux +++ b/stdlib/source/lux/macro/template.lux @@ -2,11 +2,17 @@ [lux #* [control ["." monad (#+ do)] - ["p" parser]] + ["p" parser ("#@." functor)]] [data + ["." bit ("#@." codec)] ["." text] + [number + ["." nat ("#@." decimal)] + ["." int ("#@." decimal)] + ["." rev ("#@." decimal)] + ["." frac ("#@." decimal)]] [collection - ["." list ("#;." monad)]]]] + ["." list ("#@." monad)]]]] ["." // ["." code] ["s" syntax (#+ Syntax syntax:)]]) @@ -21,9 +27,9 @@ (list.repeat (list.size locals)) (monad.seq @))] (wrap (list (` (.with-expansions [(~+ (|> (list.zip2 locals g!locals) - (list;map (function (_ [name identifier]) + (list@map (function (_ [name identifier]) (list (code.local-identifier name) (as-is identifier)))) - list;join))] + list@join))] (~ body))))))) (def: snippet @@ -31,7 +37,13 @@ ($_ p.either s.text s.local-identifier - s.local-tag)) + s.local-tag + (p@map bit@encode s.bit) + (p@map nat@encode s.nat) + (p@map int@encode s.int) + (p@map rev@encode s.rev) + (p@map frac@encode s.frac) + )) (def: part (Syntax (List Text)) diff --git a/stdlib/source/lux/tool/compiler/phase/generation/extension.lux b/stdlib/source/lux/tool/compiler/phase/generation/extension.lux new file mode 100644 index 000000000..681fd35f8 --- /dev/null +++ b/stdlib/source/lux/tool/compiler/phase/generation/extension.lux @@ -0,0 +1,58 @@ +(.module: + [lux #* + [control + ["." monad (#+ do)]] + [data + [collection + ["." list ("#@." functor)]]] + ["." macro (#+ with-gensyms) + ["." code] + ["s" syntax (#+ syntax:)]]] + ["." // + ["#/" // + ["#." extension] + [// + [synthesis (#+ Synthesis)]]]]) + +(syntax: (Vector {size s.nat} elemT) + (wrap (list (` [(~+ (list.repeat size elemT))])))) + +(type: #export (Nullary of) (-> (Vector 0 of) of)) +(type: #export (Unary of) (-> (Vector 1 of) of)) +(type: #export (Binary of) (-> (Vector 2 of) of)) +(type: #export (Trinary of) (-> (Vector 3 of) of)) +(type: #export (Variadic of) (-> (List of) of)) + +(syntax: (arity: {arity s.nat} {name s.local-identifier} type) + (with-gensyms [g!_ g!extension g!name g!phase g!inputs g!of g!anchor g!expression g!statement] + (do @ + [g!input+ (monad.seq @ (list.repeat arity (macro.gensym "input")))] + (wrap (list (` (def: #export ((~ (code.local-identifier name)) (~ g!extension)) + (All [(~ g!anchor) (~ g!expression) (~ g!statement)] + (-> ((~ type) (~ g!expression)) (//.Handler (~ g!anchor) (~ g!expression) (~ g!statement)))) + (function ((~ g!_) (~ g!name) (~ g!phase) (~ g!inputs)) + (case (~ g!inputs) + (^ (list (~+ g!input+))) + (do ///.monad + [(~+ (|> g!input+ + (list@map (function (_ g!input) + (list g!input (` ((~ g!phase) (~ g!input)))))) + list.concat))] + ((~' wrap) ((~ g!extension) [(~+ g!input+)]))) + + (~' _) + (///.throw ///extension.incorrect-arity [(~ g!name) 1 (list.size (~ g!inputs))])))))))))) + +(arity: 0 nullary ..Nullary) +(arity: 1 unary ..Unary) +(arity: 2 binary ..Binary) +(arity: 3 trinary ..Trinary) + +(def: #export (variadic extension) + (All [anchor expression statement] + (-> (Variadic expression) (//.Handler anchor expression statement))) + (function (_ extension-name) + (function (_ phase inputsS) + (do ///.monad + [inputsI (monad.map @ phase inputsS)] + (wrap (extension inputsI)))))) diff --git a/stdlib/source/lux/tool/compiler/phase/generation/js.lux b/stdlib/source/lux/tool/compiler/phase/generation/js.lux index 5da2a016e..29c95ff43 100644 --- a/stdlib/source/lux/tool/compiler/phase/generation/js.lux +++ b/stdlib/source/lux/tool/compiler/phase/generation/js.lux @@ -6,7 +6,7 @@ [runtime (#+ Phase)] ["." primitive] ["." structure] - ["." reference ("#;." system)] + ["." reference ("#@." system)] ["." function] ["." case] ["." loop] @@ -33,7 +33,7 @@ (structure.tuple generate members) (#synthesis.Reference value) - (reference;reference value) + (reference@reference value) (^ (synthesis.branch/case case)) (case.case generate case) diff --git a/stdlib/source/lux/tool/compiler/phase/generation/js/case.lux b/stdlib/source/lux/tool/compiler/phase/generation/js/case.lux index ed2c74a4b..4a28ccb3f 100644 --- a/stdlib/source/lux/tool/compiler/phase/generation/js/case.lux +++ b/stdlib/source/lux/tool/compiler/phase/generation/js/case.lux @@ -4,11 +4,10 @@ [monad (#+ do)] ["ex" exception (#+ exception:)]] [data - ["." number] ["." text format] [collection - ["." list ("#;." functor fold)]]] + ["." list ("#@." functor fold)]]] [host ["_" js (#+ Expression Computation Var Statement)]]] ["." // #_ @@ -17,7 +16,9 @@ ["#." primitive] ["#/" // #_ ["#." reference] - ["#/" // ("#;." monad) + ["#/" // ("#@." monad) + [synthesis + ["." case]] ["#/" // #_ [reference (#+ Register)] ["#." synthesis (#+ Synthesis Path)]]]]]) @@ -32,18 +33,16 @@ [valueO (generate valueS) bodyO (generate bodyS)] ## TODO: Find some way to do 'let' without paying the price of the closure. - (wrap (_.apply/* (<| (_.closure (list)) - ($_ _.then - (_.define (..register register) valueO) - (_.return bodyO))) - (list))))) + (wrap (_.apply/* (_.closure (list (..register register)) + (_.return bodyO)) + (list valueO))))) (def: #export (record-get generate valueS pathP) (-> Phase Synthesis (List [Nat Bit]) (Operation Expression)) (do ////.monad [valueO (generate valueS)] - (wrap (list;fold (function (_ [idx tail?] source) + (wrap (list@fold (function (_ [idx tail?] source) (.let [method (.if tail? //runtime.product//right //runtime.product//left)] @@ -63,7 +62,6 @@ (def: @savepoint (_.var "lux_pm_cursor_savepoint")) (def: @cursor (_.var "lux_pm_cursor")) (def: @temp (_.var "lux_pm_temp")) -(def: @alt-error (_.var "alt_error")) (def: (push-cursor! value) (-> Expression Statement) @@ -98,17 +96,7 @@ (def: fail-pm! _.break) -(def: (count-pops path) - (-> Path [Nat Path]) - (.case path - (^ ($_ /////synthesis.path/seq - #/////synthesis.Pop - path')) - (.let [[pops post-pops] (count-pops path')] - [(inc pops) post-pops]) - - _ - [0 path])) +(exception: #export unrecognized-path) (def: (multi-pop-cursor! pops) (-> Nat Statement) @@ -116,8 +104,6 @@ (_.statement (|> @cursor (_.do "splice" (list (|> @cursor ..length (_.- popsJS)) popsJS)))))) -(exception: #export unrecognized-path) - (def: (pattern-matching' generate pathP) (-> Phase Path (Operation Statement)) (.case pathP @@ -127,14 +113,14 @@ (wrap (_.return body!))) #/////synthesis.Pop - (////;wrap pop-cursor!) + (////@wrap pop-cursor!) (#/////synthesis.Bind register) - (////;wrap (_.define (..register register) ..peek-cursor)) + (////@wrap (_.define (..register register) ..peek-cursor)) (^template [<tag> <format> <=>] (^ (<tag> value)) - (////;wrap (_.when (|> value <format> (<=> ..peek-cursor) _.not) + (////@wrap (_.when (|> value <format> (<=> ..peek-cursor) _.not) fail-pm!))) ([/////synthesis.path/bit //primitive.bit _.=] [/////synthesis.path/i64 (<| //primitive.i64 .int) //runtime.i64//=] @@ -143,7 +129,7 @@ (^template [<pm> <flag> <prep>] (^ (<pm> idx)) - (////;wrap ($_ _.then + (////@wrap ($_ _.then (_.set @temp (|> idx <prep> .int _.i32 (//runtime.sum//get ..peek-cursor <flag>))) (_.if (_.= _.null @temp) fail-pm! @@ -153,7 +139,7 @@ (^template [<pm> <getter> <prep>] (^ (<pm> idx)) - (////;wrap (|> idx <prep> .int _.i32 (<getter> ..peek-cursor) push-cursor!))) + (////@wrap (|> idx <prep> .int _.i32 (<getter> ..peek-cursor) push-cursor!))) ([/////synthesis.member/left //runtime.product//left (<|)] [/////synthesis.member/right //runtime.product//right inc]) @@ -163,7 +149,7 @@ thenP)) (do ////.monad [then! (pattern-matching' generate thenP)] - (////;wrap ($_ _.then + (////@wrap ($_ _.then (_.define (..register register) ..peek-and-pop-cursor) then!))) @@ -171,10 +157,10 @@ #/////synthesis.Pop #/////synthesis.Pop nextP)) - (.let [[extra-pops nextP'] (count-pops nextP)] + (.let [[extra-pops nextP'] (case.count-pops nextP)] (do ////.monad [next! (pattern-matching' generate nextP')] - (////;wrap ($_ _.then + (////@wrap ($_ _.then (multi-pop-cursor! (n/+ 2 extra-pops)) next!)))) @@ -204,7 +190,7 @@ (wrap ($_ _.then (_.do-while _.false pattern-matching!) - (_.throw (_.string "Invalid expression for pattern-matching.")))))) + (_.throw (_.string case.pattern-matching-error)))))) (def: #export (case generate [valueS pathP]) (-> Phase [Synthesis Path] (Operation Computation)) diff --git a/stdlib/source/lux/tool/compiler/phase/generation/js/extension/common.lux b/stdlib/source/lux/tool/compiler/phase/generation/js/extension/common.lux index dfd0e4aee..2e661dc29 100644 --- a/stdlib/source/lux/tool/compiler/phase/generation/js/extension/common.lux +++ b/stdlib/source/lux/tool/compiler/phase/generation/js/extension/common.lux @@ -1,77 +1,29 @@ (.module: [lux #* [control - ["." monad (#+ do)] - ["ex" exception (#+ exception:)]] + ["." monad (#+ do)]] [data - ["e" error] ["." product] - [number (#+ hex)] [collection - ["." list ("#;." functor)] ["." dictionary]]] - ["." macro (#+ with-gensyms) - ["." code] - ["s" syntax (#+ syntax:)]] [host (#+ import:) - ["_" js (#+ Expression Computation)]]] + ["_" js (#+ Expression)]]] ["." /// #_ ["#." runtime (#+ Operation Phase Handler Bundle)] ["#." primitive] - ["#//" /// - ["#." extension - ["." bundle]] - ["#/" // #_ - [synthesis (#+ Synthesis)]]]]) - -(syntax: (Vector {size s.nat} elemT) - (wrap (list (` [(~+ (list.repeat size elemT))])))) - -(type: #export Nullary (-> (Vector 0 Expression) Computation)) -(type: #export Unary (-> (Vector 1 Expression) Computation)) -(type: #export Binary (-> (Vector 2 Expression) Computation)) -(type: #export Trinary (-> (Vector 3 Expression) Computation)) -(type: #export Variadic (-> (List Expression) Computation)) - -(syntax: (arity: {name s.local-identifier} {arity s.nat}) - (with-gensyms [g!_ g!extension g!name g!phase g!inputs] - (do @ - [g!input+ (monad.seq @ (list.repeat arity (macro.gensym "input")))] - (wrap (list (` (def: #export ((~ (code.local-identifier name)) (~ g!extension)) - (-> (-> (..Vector (~ (code.nat arity)) Expression) Computation) - Handler) - (function ((~ g!_) (~ g!name) (~ g!phase) (~ g!inputs)) - (case (~ g!inputs) - (^ (list (~+ g!input+))) - (do /////.monad - [(~+ (|> g!input+ - (list;map (function (_ g!input) - (list g!input (` ((~ g!phase) (~ g!input)))))) - list.concat))] - ((~' wrap) ((~ g!extension) [(~+ g!input+)]))) - - (~' _) - (/////.throw /////extension.incorrect-arity [(~ g!name) 1 (list.size (~ g!inputs))])))))))))) - -(arity: nullary 0) -(arity: unary 1) -(arity: binary 2) -(arity: trinary 3) - -(def: #export (variadic extension) - (-> Variadic Handler) - (function (_ extension-name) - (function (_ phase inputsS) - (do /////.monad - [inputsI (monad.map @ phase inputsS)] - (wrap (extension inputsI)))))) + [// + [extension (#+ Nullary Unary Binary Trinary + nullary unary binary trinary)] + [// + [extension + ["." bundle]]]]]) ## [Procedures] ## [[Bits]] (do-template [<name> <op>] - [(def: (<name> [paramJS subjectJS]) - Binary - (<op> subjectJS (///runtime.i64//to-number paramJS)))] + [(def: (<name> [paramG subjectG]) + (Binary Expression) + (<op> subjectG (///runtime.i64//to-number paramG)))] [i64//left-shift ///runtime.i64//left-shift] [i64//arithmetic-right-shift ///runtime.i64//arithmetic-right-shift] @@ -85,7 +37,7 @@ (do-template [<name> <const>] [(def: (<name> _) - Nullary + (Nullary Expression) (///primitive.f64 <const>))] [frac//smallest (java/lang/Double::MIN_VALUE)] @@ -94,7 +46,7 @@ ) (def: frac//decode - Unary + (Unary Expression) (|>> list (_.apply/* (_.var "parseFloat")) _.return @@ -102,34 +54,34 @@ ///runtime.lux//try)) (def: int//char - Unary + (Unary Expression) (|>> ///runtime.i64//to-number (list) (_.apply/* (_.var "String.fromCharCode")))) ## [[Text]] -(def: (text//concat [subjectJS paramJS]) - Binary - (|> subjectJS (_.do "concat" (list paramJS)))) +(def: (text//concat [subjectG paramG]) + (Binary Expression) + (|> subjectG (_.do "concat" (list paramG)))) (do-template [<name> <runtime>] - [(def: (<name> [subjectJS paramJS extraJS]) - Trinary - (<runtime> subjectJS paramJS extraJS))] + [(def: (<name> [subjectG paramG extraG]) + (Trinary Expression) + (<runtime> subjectG paramG extraG))] [text//clip ///runtime.text//clip] [text//index ///runtime.text//index] ) ## [[IO]] -(def: (io//log messageJS) - Unary +(def: (io//log messageG) + (Unary Expression) ($_ _., - (///runtime.io//log messageJS) + (///runtime.io//log messageG) ///runtime.unit)) -(def: (io//exit codeJS) - Unary +(def: (io//exit codeG) + (Unary Expression) (let [@@process (_.var "process") @@window (_.var "window") @@location (_.var "location")] @@ -137,12 +89,12 @@ ($_ _.and (_.not (_.= _.undefined (_.type-of @@process))) (_.the "exit" @@process) - (_.do "exit" (list (///runtime.i64//to-number codeJS)) @@process)) + (_.do "exit" (list (///runtime.i64//to-number codeG)) @@process)) (_.do "close" (list) @@window) (_.do "reload" (list) @@location)))) (def: (io//current-time _) - Nullary + (Nullary Expression) (|> (_.new (_.var "Date") (list)) (_.do "getTime" (list)) ///runtime.i64//from-number)) diff --git a/stdlib/source/lux/tool/compiler/phase/generation/js/extension/host.lux b/stdlib/source/lux/tool/compiler/phase/generation/js/extension/host.lux index f623242a0..aed6c4711 100644 --- a/stdlib/source/lux/tool/compiler/phase/generation/js/extension/host.lux +++ b/stdlib/source/lux/tool/compiler/phase/generation/js/extension/host.lux @@ -7,19 +7,20 @@ [collection ["." dictionary]]] [host - ["_" js]]] - ["." // #_ - ["#." common (#+ Nullary Binary Trinary Variadic)] + ["_" js (#+ Expression)]]] + ["." /// #_ + ["#." runtime (#+ Handler Bundle)] ["#/" // #_ - ["#." runtime (#+ Handler Bundle)] - ["#//" /// + ["#." extension (#+ Nullary Unary Binary Trinary Variadic + nullary unary binary trinary variadic)] + ["#/" // ["#." extension ["." bundle]] ["#/" // #_ ["#." synthesis]]]]]) (do-template [<name> <js>] - [(def: (<name> _) Nullary <js>)] + [(def: (<name> _) (Nullary Expression) <js>)] [js//null _.null] [js//undefined _.undefined] @@ -50,10 +51,10 @@ (def: js Bundle (|> bundle.empty - (bundle.install "null" (//common.nullary js//null)) - (bundle.install "undefined" (//common.nullary js//undefined)) - (bundle.install "object" (//common.nullary js//object)) - (bundle.install "array" (//common.variadic _.array)) + (bundle.install "null" (nullary js//null)) + (bundle.install "undefined" (nullary js//undefined)) + (bundle.install "object" (nullary js//object)) + (bundle.install "array" (variadic _.array)) (bundle.install "global" js//global) (bundle.install "call" js//call))) @@ -85,7 +86,7 @@ (/////.throw /////extension.incorrect-syntax name))) (def: (object//set [fieldJS valueJS objectJS]) - Trinary + (Trinary Expression) (///runtime.js//set objectJS fieldJS valueJS)) (def: object @@ -94,23 +95,23 @@ (|> bundle.empty (bundle.install "new" object//new) (bundle.install "call" object//call) - (bundle.install "read" (//common.binary (product.uncurry ///runtime.js//get))) - (bundle.install "write" (//common.trinary object//set)) - (bundle.install "delete" (//common.binary (product.uncurry ///runtime.js//delete))) + (bundle.install "read" (binary (product.uncurry ///runtime.js//get))) + (bundle.install "write" (trinary object//set)) + (bundle.install "delete" (binary (product.uncurry ///runtime.js//delete))) ))) (def: (array//write [indexJS valueJS arrayJS]) - Trinary + (Trinary Expression) (///runtime.array//write indexJS valueJS arrayJS)) (def: array Bundle (<| (bundle.prefix "array") (|> bundle.empty - (bundle.install "read" (//common.binary (product.uncurry ///runtime.array//read))) - (bundle.install "write" (//common.trinary array//write)) - (bundle.install "delete" (//common.binary (product.uncurry ///runtime.array//delete))) - (bundle.install "length" (//common.unary (_.the "length"))) + (bundle.install "read" (binary (product.uncurry ///runtime.array//read))) + (bundle.install "write" (trinary array//write)) + (bundle.install "delete" (binary (product.uncurry ///runtime.array//delete))) + (bundle.install "length" (unary (_.the "length"))) ))) (def: #export bundle diff --git a/stdlib/source/lux/tool/compiler/phase/generation/js/function.lux b/stdlib/source/lux/tool/compiler/phase/generation/js/function.lux index a99546957..10a53986f 100644 --- a/stdlib/source/lux/tool/compiler/phase/generation/js/function.lux +++ b/stdlib/source/lux/tool/compiler/phase/generation/js/function.lux @@ -8,7 +8,7 @@ [text format] [collection - ["." list ("#;." functor fold)]]] + ["." list ("#@." functor fold)]]] [host ["_" js (#+ Expression Computation Var)]]] ["." // #_ @@ -17,7 +17,7 @@ ["#." case] ["#/" // ["#." reference] - ["#/" // ("#;." monad) + ["#/" // ("#@." monad) ["." // #_ [reference (#+ Register Variable)] [analysis (#+ Variant Tuple Environment Arity Abstraction Application Analysis)] @@ -35,14 +35,14 @@ (def: (with-closure inits function-definition) (-> (List Expression) Computation (Operation Computation)) - (////;wrap + (////@wrap (case inits #.Nil function-definition _ (let [closure (_.closure (|> (list.enumerate inits) - (list;map (|>> product.left ..capture))) + (list@map (|>> product.left ..capture))) (_.return function-definition))] (_.apply/* closure inits))))) @@ -69,7 +69,7 @@ apply-poly (.function (_ args func) (|> func (_.do "apply" (list _.null args)))) initialize-self! (_.define (//case.register 0) @self) - initialize! (list;fold (.function (_ post pre!) + initialize! (list@fold (.function (_ post pre!) ($_ _.then pre! (_.define (..input post) (_.at (_.i32 (.int post)) @@arguments)))) diff --git a/stdlib/source/lux/tool/compiler/phase/generation/js/runtime.lux b/stdlib/source/lux/tool/compiler/phase/generation/js/runtime.lux index cb65b8b85..b5ef432f6 100644 --- a/stdlib/source/lux/tool/compiler/phase/generation/js/runtime.lux +++ b/stdlib/source/lux/tool/compiler/phase/generation/js/runtime.lux @@ -89,16 +89,13 @@ (def: runtime-name (-> Text Var) (|>> /////name.normalize - (format prefix "$") + (format ..prefix "$") _.var)) (def: (feature name definition) (-> Var (-> Var Expression) Statement) (_.define name (definition name))) -(syntax: (code-name {definition-name s.local-identifier}) - (wrap (list (code.local-identifier (format "@" definition-name))))) - (syntax: #export (with-vars {vars (s.tuple (p.some s.local-identifier))} body) (wrap (list (` (let [(~+ (|> vars diff --git a/stdlib/source/lux/tool/compiler/phase/generation/python.lux b/stdlib/source/lux/tool/compiler/phase/generation/python.lux new file mode 100644 index 000000000..29c95ff43 --- /dev/null +++ b/stdlib/source/lux/tool/compiler/phase/generation/python.lux @@ -0,0 +1,60 @@ +(.module: + [lux #* + [control + [monad (#+ do)]]] + [/ + [runtime (#+ Phase)] + ["." primitive] + ["." structure] + ["." reference ("#@." system)] + ["." function] + ["." case] + ["." loop] + ["." /// + ["." extension] + [// + ["." synthesis]]]]) + +(def: #export (generate synthesis) + Phase + (case synthesis + (^template [<tag> <generator>] + (^ (<tag> value)) + (:: ///.monad wrap (<generator> value))) + ([synthesis.bit primitive.bit] + [synthesis.i64 primitive.i64] + [synthesis.f64 primitive.f64] + [synthesis.text primitive.text]) + + (^ (synthesis.variant variantS)) + (structure.variant generate variantS) + + (^ (synthesis.tuple members)) + (structure.tuple generate members) + + (#synthesis.Reference value) + (reference@reference value) + + (^ (synthesis.branch/case case)) + (case.case generate case) + + (^ (synthesis.branch/let let)) + (case.let generate let) + + (^ (synthesis.branch/if if)) + (case.if generate if) + + (^ (synthesis.loop/scope scope)) + (loop.scope generate scope) + + (^ (synthesis.loop/recur updates)) + (loop.recur generate updates) + + (^ (synthesis.function/abstraction abstraction)) + (function.function generate abstraction) + + (^ (synthesis.function/apply application)) + (function.apply generate application) + + (#synthesis.Extension extension) + (extension.apply generate extension))) diff --git a/stdlib/source/lux/tool/compiler/phase/generation/python/case.lux b/stdlib/source/lux/tool/compiler/phase/generation/python/case.lux new file mode 100644 index 000000000..82a96836d --- /dev/null +++ b/stdlib/source/lux/tool/compiler/phase/generation/python/case.lux @@ -0,0 +1,218 @@ +(.module: + [lux (#- case let if) + [control + [monad (#+ do)] + ["ex" exception (#+ exception:)]] + [data + ["." text + format] + [collection + ["." list ("#@." functor fold)] + ["." set]]] + [host + ["_" python (#+ Expression SVar Statement)]]] + ["." // #_ + ["#." runtime (#+ Operation Phase)] + ["#." reference] + ["#." primitive] + ["#/" // + ["#." reference] + ["#/" // ("#@." monad) + [synthesis + ["." case]] + ["#/" // #_ + ["." reference (#+ Register)] + ["#." synthesis (#+ Synthesis Path)]]]]]) + +(def: #export register + (///reference.local _.var)) + +(def: #export capture + (///reference.foreign _.var)) + +(def: #export (let generate [valueS register bodyS]) + (-> Phase [Synthesis Register Synthesis] + (Operation (Expression Any))) + (do ////.monad + [valueO (generate valueS) + bodyO (generate bodyS)] + ## TODO: Find some way to do 'let' without paying the price of the closure. + (wrap (_.apply/* (_.lambda (list (..register register)) + bodyO) + (list valueO))))) + +(def: #export (record-get generate valueS pathP) + (-> Phase Synthesis (List [Nat Bit]) + (Operation (Expression Any))) + (do ////.monad + [valueO (generate valueS)] + (wrap (list@fold (function (_ [idx tail?] source) + (.let [method (.if tail? + //runtime.product//right + //runtime.product//left)] + (method source (_.int (.int idx))))) + valueO + pathP)))) + +(def: #export (if generate [testS thenS elseS]) + (-> Phase [Synthesis Synthesis Synthesis] + (Operation (Expression Any))) + (do ////.monad + [testO (generate testS) + thenO (generate thenS) + elseO (generate elseS)] + (wrap (_.? testO thenO elseO)))) + +(def: @savepoint (_.var "lux_pm_cursor_savepoint")) +(def: @cursor (_.var "lux_pm_cursor")) +(def: @temp (_.var "lux_pm_temp")) + +(def: (push-cursor! value) + (-> (Expression Any) (Statement Any)) + (_.statement (|> @cursor (_.do "append" (list value))))) + +(def: peek-and-pop-cursor + (Expression Any) + (|> @cursor (_.do "pop" (list)))) + +(def: pop-cursor! + (Statement Any) + (_.statement ..peek-and-pop-cursor)) + +(def: peek-cursor + (Expression Any) + (_.nth (_.int -1) @cursor)) + +(def: save-cursor! + (Statement Any) + (.let [cursor (_.slice-from (_.int +0) @cursor)] + (_.statement (|> @savepoint (_.do "append" (list cursor)))))) + +(def: restore-cursor! + (Statement Any) + (_.set (list @cursor) (|> @savepoint (_.do "pop" (list))))) + +(def: fail-pm! _.break) + +(exception: #export unrecognized-path) + +(def: (multi-pop-cursor! pops) + (-> Nat (Statement Any)) + (_.delete (_.slice-from (_.int (i/* -1 (.int pops))) @cursor))) + +(def: (pattern-matching' generate pathP) + (-> Phase Path (Operation (Statement Any))) + (.case pathP + (^ (/////synthesis.path/then bodyS)) + (do ////.monad + [body! (generate bodyS)] + (wrap (_.return body!))) + + #/////synthesis.Pop + (////@wrap pop-cursor!) + + (#/////synthesis.Bind register) + (////@wrap (_.set (list (..register register)) ..peek-cursor)) + + (^template [<tag> <format>] + (^ (<tag> value)) + (////@wrap (_.when (|> value <format> (_.= ..peek-cursor) _.not) + fail-pm!))) + ([/////synthesis.path/bit //primitive.bit] + [/////synthesis.path/i64 //primitive.i64] + [/////synthesis.path/f64 //primitive.f64] + [/////synthesis.path/text //primitive.text]) + + (^template [<pm> <flag> <prep>] + (^ (<pm> idx)) + (////@wrap ($_ _.then + (_.set (list @temp) (|> idx <prep> .int _.int (//runtime.sum//get ..peek-cursor <flag>))) + (_.if (_.= _.none @temp) + fail-pm! + (push-cursor! @temp))))) + ([/////synthesis.side/left _.none (<|)] + [/////synthesis.side/right (_.string "") inc]) + + (^template [<pm> <getter> <prep>] + (^ (<pm> idx)) + (////@wrap (|> idx <prep> .int _.int (<getter> ..peek-cursor) push-cursor!))) + ([/////synthesis.member/left //runtime.product//left (<|)] + [/////synthesis.member/right //runtime.product//right inc]) + + (^ ($_ /////synthesis.path/seq + (#/////synthesis.Bind register) + #/////synthesis.Pop + thenP)) + (do ////.monad + [then! (pattern-matching' generate thenP)] + (////@wrap ($_ _.then + (_.set (list (..register register)) ..peek-and-pop-cursor) + then!))) + + (^ ($_ /////synthesis.path/seq + #/////synthesis.Pop + #/////synthesis.Pop + nextP)) + (.let [[extra-pops nextP'] (case.count-pops nextP)] + (do ////.monad + [next! (pattern-matching' generate nextP')] + (////@wrap ($_ _.then + (multi-pop-cursor! (n/+ 2 extra-pops)) + next!)))) + + (^template [<tag> <computation>] + (^ (<tag> leftP rightP)) + (do ////.monad + [left! (pattern-matching' generate leftP) + right! (pattern-matching' generate rightP)] + (wrap <computation>))) + ([/////synthesis.path/seq (_.then left! right!)] + [/////synthesis.path/alt ($_ _.then + (_.while (_.bool true) + ($_ _.then + ..save-cursor! + left!)) + ($_ _.then + ..restore-cursor! + right!))]) + + _ + (////.throw unrecognized-path []))) + +(def: (pattern-matching generate pathP) + (-> Phase Path (Operation (Statement Any))) + (do ////.monad + [pattern-matching! (pattern-matching' generate pathP)] + (wrap ($_ _.then + (_.while (_.bool true) + pattern-matching!) + (_.raise (_.Exception/1 (_.string case.pattern-matching-error))))))) + +(def: (gensym prefix) + (-> Text (Operation SVar)) + (:: ////.monad map (|>> %n (format prefix) _.var) ///.next)) + +(def: #export (case generate [valueS pathP]) + (-> Phase [Synthesis Path] (Operation (Expression Any))) + (do ////.monad + [initG (generate valueS) + pattern-matching! (pattern-matching generate pathP) + @case (..gensym "case") + @init (..gensym "init") + #let [@dependencies+ (|> (case.storage pathP) + (get@ #case.dependencies) + set.to-list + (list@map (function (_ variable) + (.case variable + (#reference.Local register) + (..register register) + + (#reference.Foreign register) + (..capture register)))))] + _ (///.save! ["" (_.code @case)] + (_.def @case (list& @init @dependencies+) + ($_ _.then + (_.set (list @cursor) (_.list (list @init))) + (_.set (list @savepoint) (_.list (list))) + pattern-matching!)))] + (wrap (_.apply/* @case (list& initG @dependencies+))))) diff --git a/stdlib/source/lux/tool/compiler/phase/generation/python/extension.lux b/stdlib/source/lux/tool/compiler/phase/generation/python/extension.lux new file mode 100644 index 000000000..a40b4953f --- /dev/null +++ b/stdlib/source/lux/tool/compiler/phase/generation/python/extension.lux @@ -0,0 +1,15 @@ +(.module: + [lux #* + [data + [collection + ["." dictionary]]]] + [// + [runtime (#+ Bundle)]] + [/ + ["." common] + ["." host]]) + +(def: #export bundle + Bundle + (|> common.bundle + (dictionary.merge host.bundle))) diff --git a/stdlib/source/lux/tool/compiler/phase/generation/python/extension/common.lux b/stdlib/source/lux/tool/compiler/phase/generation/python/extension/common.lux new file mode 100644 index 000000000..48fd005fb --- /dev/null +++ b/stdlib/source/lux/tool/compiler/phase/generation/python/extension/common.lux @@ -0,0 +1,130 @@ +(.module: + [lux #* + ["." function] + [control + ["." monad (#+ do)]] + [data + ["." product] + [collection + ["." dictionary]]] + [host (#+ import:) + ["_" python (#+ Expression)]]] + ["." /// #_ + ["#." runtime (#+ Operation Phase Handler Bundle)] + ["#." primitive] + [// + [extension (#+ Nullary Unary Binary Trinary + nullary unary binary trinary)] + [// + [extension + ["." bundle]]]]]) + +(def: lux-procs + Bundle + (|> bundle.empty + (bundle.install "is" (binary (product.uncurry _.is))) + (bundle.install "try" (unary ///runtime.lux//try)))) + +(def: i64-procs + Bundle + (<| (bundle.prefix "i64") + (|> bundle.empty + (bundle.install "and" (binary (product.uncurry _.bit-and))) + (bundle.install "or" (binary (product.uncurry _.bit-or))) + (bundle.install "xor" (binary (product.uncurry _.bit-xor))) + (bundle.install "left-shift" (binary (|>> (product.uncurry _.bit-shl) ///runtime.i64//64))) + (bundle.install "logical-right-shift" (binary (product.uncurry (function.flip ///runtime.i64//logic-right-shift)))) + (bundle.install "arithmetic-right-shift" (binary (product.uncurry (function.flip _.bit-shr)))) + (bundle.install "=" (binary (product.uncurry _.=))) + (bundle.install "+" (binary (product.uncurry _.+))) + (bundle.install "-" (binary (product.uncurry (function.flip _.-)))) + ))) + +(import: #long java/lang/Double + (#static MIN_VALUE Double) + (#static MAX_VALUE Double)) + +(do-template [<name> <const>] + [(def: (<name> _) + (Nullary (Expression Any)) + (_.float <const>))] + + [frac//smallest (java/lang/Double::MIN_VALUE)] + [frac//min (f/* -1.0 (java/lang/Double::MAX_VALUE))] + [frac//max (java/lang/Double::MAX_VALUE)] + ) + +(def: int-procs + Bundle + (<| (bundle.prefix "int") + (|> bundle.empty + (bundle.install "<" (binary (product.uncurry (function.flip _.<)))) + (bundle.install "*" (binary (product.uncurry _.*))) + (bundle.install "/" (binary (product.uncurry (function.flip _./)))) + (bundle.install "%" (binary (product.uncurry (function.flip _.%)))) + (bundle.install "frac" (unary _.float/1)) + (bundle.install "char" (unary _.chr/1))))) + +(def: frac-procs + Bundle + (<| (bundle.prefix "frac") + (|> bundle.empty + (bundle.install "+" (binary (product.uncurry _.+))) + (bundle.install "-" (binary (product.uncurry (function.flip _.-)))) + (bundle.install "*" (binary (product.uncurry _.*))) + (bundle.install "/" (binary (product.uncurry (function.flip _./)))) + (bundle.install "%" (binary (product.uncurry (function.flip _.%)))) + (bundle.install "=" (binary (product.uncurry _.=))) + (bundle.install "<" (binary (product.uncurry (function.flip _.<)))) + (bundle.install "smallest" (nullary frac//smallest)) + (bundle.install "min" (nullary frac//min)) + (bundle.install "max" (nullary frac//max)) + (bundle.install "int" (unary _.int/1)) + (bundle.install "encode" (unary _.repr/1)) + (bundle.install "decode" (unary ///runtime.frac//decode))))) + +(def: (text//char [subjectO paramO]) + (Binary (Expression Any)) + (///runtime.text//char subjectO paramO)) + +(def: (text//clip [subjectO paramO extraO]) + (Trinary (Expression Any)) + (///runtime.text//clip subjectO paramO extraO)) + +(def: (text//index [textO partO startO]) + (Trinary (Expression Any)) + (///runtime.text//index textO partO startO)) + +(def: text-procs + Bundle + (<| (bundle.prefix "text") + (|> bundle.empty + (bundle.install "=" (binary (product.uncurry _.=))) + (bundle.install "<" (binary (product.uncurry (function.flip _.<)))) + (bundle.install "concat" (binary (product.uncurry (function.flip _.+)))) + (bundle.install "index" (trinary text//index)) + (bundle.install "size" (unary _.len/1)) + (bundle.install "char" (binary (product.uncurry ///runtime.text//char))) + (bundle.install "clip" (trinary text//clip)) + ))) + +(def: io-procs + Bundle + (<| (bundle.prefix "io") + (|> bundle.empty + (bundle.install "log" (unary ///runtime.io//log!)) + (bundle.install "error" (unary ///runtime.io//throw!)) + (bundle.install "exit" (unary ///runtime.io//exit!)) + (bundle.install "current-time" (nullary (function (_ _) + (///runtime.io//current-time! ///runtime.unit))))))) + +(def: #export bundle + Bundle + (<| (bundle.prefix "lux") + (|> lux-procs + (dictionary.merge i64-procs) + (dictionary.merge int-procs) + (dictionary.merge frac-procs) + (dictionary.merge text-procs) + (dictionary.merge io-procs) + ))) diff --git a/stdlib/source/lux/tool/compiler/phase/generation/python/extension/host.lux b/stdlib/source/lux/tool/compiler/phase/generation/python/extension/host.lux new file mode 100644 index 000000000..92887899b --- /dev/null +++ b/stdlib/source/lux/tool/compiler/phase/generation/python/extension/host.lux @@ -0,0 +1,25 @@ +(.module: + [lux #* + [control + ["." monad (#+ do)]] + [data + ["." product] + [collection + ["." dictionary]]] + [host + ["_" python (#+ Expression)]]] + ["." /// #_ + ["#." runtime (#+ Handler Bundle)] + ["#/" // #_ + ["#." extension (#+ Nullary Unary Binary Trinary Variadic + nullary unary binary trinary variadic)] + ["#/" // + ["#." extension + ["." bundle]] + ["#/" // #_ + ["#." synthesis]]]]]) + +(def: #export bundle + Bundle + (<| (bundle.prefix "python") + bundle.empty)) diff --git a/stdlib/source/lux/tool/compiler/phase/generation/python/function.lux b/stdlib/source/lux/tool/compiler/phase/generation/python/function.lux new file mode 100644 index 000000000..c92f6dd37 --- /dev/null +++ b/stdlib/source/lux/tool/compiler/phase/generation/python/function.lux @@ -0,0 +1,107 @@ +(.module: + [lux (#- function) + [control + ["." monad (#+ do)] + pipe] + [data + ["." product] + [text + format] + [collection + ["." list ("#@." functor fold)]]] + [host + ["_" python (#+ Expression Statement)]]] + ["." // #_ + [runtime (#+ Operation Phase)] + ["#." reference] + ["#." case] + ["#/" // + ["#." reference] + ["#/" // + ["." // #_ + [reference (#+ Register Variable)] + [analysis (#+ Variant Tuple Environment Arity Abstraction Application Analysis)] + [synthesis (#+ Synthesis)]]]]]) + +(def: #export (apply generate [functionS argsS+]) + (-> Phase (Application Synthesis) (Operation (Expression Any))) + (do ////.monad + [functionO (generate functionS) + argsO+ (monad.map @ generate argsS+)] + (wrap (_.apply/* functionO argsO+)))) + +(def: #export capture + (///reference.foreign _.var)) + +(def: (with-closure function-name inits function-definition) + (-> Text (List (Expression Any)) (Statement Any) (Operation (Expression Any))) + (case inits + #.Nil + (do ////.monad + [_ (///.save! ["" function-name] + function-definition)] + (wrap (_.apply/* (_.var function-name) inits))) + + _ + (do ////.monad + [@closure (:: @ map (|>> %n (format "closure") _.var) ///.next) + _ (///.save! ["" (_.code @closure)] + (_.def @closure + (|> (list.enumerate inits) + (list@map (|>> product.left ..capture))) + ($_ _.then + function-definition + (_.return (_.var function-name)))))] + (wrap (_.apply/* @closure inits))))) + +(def: @curried (_.var "curried")) + +(def: input + (|>> inc //case.register)) + +(def: #export (function generate [environment arity bodyS]) + (-> Phase (Abstraction Synthesis) (Operation (Expression Any))) + (do ////.monad + [[function-name bodyO] (///.with-context + (do @ + [function-name ///.context] + (///.with-anchor (_.var function-name) + (generate bodyS)))) + closureO+ (: (Operation (List (Expression Any))) + (monad.map @ (:: //reference.system variable) environment)) + #let [arityO (|> arity .int _.int) + @num-args (_.var "num_args") + @self (_.var function-name) + apply-poly (.function (_ args func) + (_.apply-poly (list) args func)) + initialize-self! (_.set (list (//case.register 0)) @self) + initialize! (list@fold (.function (_ post pre!) + ($_ _.then + pre! + (_.set (list (..input post)) (_.nth (|> post .int _.int) @curried)))) + initialize-self! + (list.indices arity))]] + (with-closure function-name closureO+ + (_.def @self (list) + ($_ _.then + (_.set (list @num-args) (_.len/1 @curried)) + (_.cond (list [(|> @num-args (_.= arityO)) + ($_ _.then + initialize! + (_.return bodyO))] + [(|> @num-args (_.> arityO)) + (let [arity-inputs (_.slice (_.int +0) arityO @curried) + extra-inputs (_.slice arityO @num-args @curried)] + (_.return (|> @self + (apply-poly arity-inputs) + (apply-poly extra-inputs))))]) + ## (|> @num-args (_.< arityO)) + (let [@next (_.var "next") + @missing (_.var "missing")] + ($_ _.then + (_.def @next (list (_.poly @missing)) + (_.return (|> @self (apply-poly (|> @curried (_.+ @missing)))))) + (_.return @next) + ))) + ))) + )) diff --git a/stdlib/source/lux/tool/compiler/phase/generation/python/loop.lux b/stdlib/source/lux/tool/compiler/phase/generation/python/loop.lux new file mode 100644 index 000000000..7666319bf --- /dev/null +++ b/stdlib/source/lux/tool/compiler/phase/generation/python/loop.lux @@ -0,0 +1,40 @@ +(.module: + [lux (#- Scope) + [control + ["." monad (#+ do)]] + [data + ["." product] + [text + format] + [collection + ["." list ("#@." functor)]]] + [host + ["_" python (#+ Expression)]]] + ["." // #_ + [runtime (#+ Operation Phase)] + ["#." case] + ["#/" // + ["#/" // + [// + [synthesis (#+ Scope Synthesis)]]]]]) + +(def: #export (scope generate [start initsS+ bodyS]) + (-> Phase (Scope Synthesis) (Operation (Expression Any))) + (do ////.monad + [@loop (:: @ map (|>> %n (format "loop") _.var) ///.next) + initsO+ (monad.map @ generate initsS+) + bodyO (///.with-anchor @loop + (generate bodyS)) + _ (///.save! ["" (_.code @loop)] + (_.def @loop (|> initsS+ + list.enumerate + (list@map (|>> product.left (n/+ start) //case.register))) + (_.return bodyO)))] + (wrap (_.apply/* @loop initsO+)))) + +(def: #export (recur generate argsS+) + (-> Phase (List Synthesis) (Operation (Expression Any))) + (do ////.monad + [@scope ///.anchor + argsO+ (monad.map @ generate argsS+)] + (wrap (_.apply/* @scope argsO+)))) diff --git a/stdlib/source/lux/tool/compiler/phase/generation/python/primitive.lux b/stdlib/source/lux/tool/compiler/phase/generation/python/primitive.lux new file mode 100644 index 000000000..1ddd3950e --- /dev/null +++ b/stdlib/source/lux/tool/compiler/phase/generation/python/primitive.lux @@ -0,0 +1,27 @@ +(.module: + [lux (#- i64) + [control + [pipe (#+ cond> new>)]] + [data + [number + ["." frac]]] + [host + ["_" python (#+ Expression)]]] + ["." // #_ + ["#." runtime]]) + +(def: #export bit + (-> Bit (Expression Any)) + _.bool) + +(def: #export i64 + (-> (I64 Any) (Expression Any)) + (|>> .int _.int)) + +(def: #export f64 + (-> Frac (Expression Any)) + _.float) + +(def: #export text + (-> Text (Expression Any)) + _.string) diff --git a/stdlib/source/lux/tool/compiler/phase/generation/python/reference.lux b/stdlib/source/lux/tool/compiler/phase/generation/python/reference.lux new file mode 100644 index 000000000..acc09c784 --- /dev/null +++ b/stdlib/source/lux/tool/compiler/phase/generation/python/reference.lux @@ -0,0 +1,11 @@ +(.module: + [lux #* + [host + ["_" python (#+ Expression)]]] + [// + [// + ["." reference]]]) + +(def: #export system + (reference.system (: (-> Text (Expression Any)) _.var) + (: (-> Text (Expression Any)) _.var))) diff --git a/stdlib/source/lux/tool/compiler/phase/generation/python/runtime.lux b/stdlib/source/lux/tool/compiler/phase/generation/python/runtime.lux new file mode 100644 index 000000000..fd847af16 --- /dev/null +++ b/stdlib/source/lux/tool/compiler/phase/generation/python/runtime.lux @@ -0,0 +1,392 @@ +(.module: + [lux (#- inc) + ["." function] + [control + [monad (#+ do)] + ["p" parser]] + [data + [number (#+ hex) + ["." i64]] + ["." text + format] + [collection + ["." list ("#@." functor)]]] + ["." macro + ["." code] + ["s" syntax (#+ syntax:)]] + [host + ["_" python (#+ Expression SVar Computation Literal Statement)]]] + ["." /// + ["//." // + [// + ["/////." name] + ["." synthesis]]]] + ) + +(do-template [<name> <base>] + [(type: #export <name> + (<base> SVar (Expression Any) (Statement Any)))] + + [Operation ///.Operation] + [Phase ///.Phase] + [Handler ///.Handler] + [Bundle ///.Bundle] + ) + +(def: #export variant-tag-field "_lux_tag") +(def: #export variant-flag-field "_lux_flag") +(def: #export variant-value-field "_lux_value") + +(def: prefix Text "LuxRuntime") + +(def: #export unit (_.string synthesis.unit)) + +(def: (flag value) + (-> Bit (Computation Any)) + (if value + (_.string "") + _.none)) + +(def: (variant' tag last? value) + (-> (Expression Any) (Expression Any) (Expression Any) (Computation Any)) + (_.dict (list [(_.string ..variant-tag-field) tag] + [(_.string ..variant-flag-field) last?] + [(_.string ..variant-value-field) value]))) + +(def: #export (variant tag last? value) + (-> Nat Bit (Expression Any) (Computation Any)) + (variant' (_.int (.int tag)) + (flag last?) + value)) + +(def: #export none + (Computation Any) + (..variant 0 #0 unit)) + +(def: #export some + (-> (Expression Any) (Computation Any)) + (..variant 1 #1)) + +(def: #export left + (-> (Expression Any) (Computation Any)) + (..variant 0 #0)) + +(def: #export right + (-> (Expression Any) (Computation Any)) + (..variant 1 #1)) + +(def: runtime-name + (-> Text SVar) + (|>> /////name.normalize + (format ..prefix "$") + _.var)) + +(def: (feature name definition) + (-> SVar (-> SVar (Statement Any)) (Statement Any)) + (_.def name (list) (definition name))) + +(syntax: #export (with-vars {vars (s.tuple (p.some s.local-identifier))} + body) + (wrap (list (` (let [(~+ (|> vars + (list@map (function (_ var) + (list (code.local-identifier var) + (` (_.var (~ (code.text (/////name.normalize var)))))))) + list.concat))] + (~ body)))))) + +(syntax: (runtime: {declaration (p.or s.local-identifier + (s.form (p.and s.local-identifier + (p.some s.local-identifier))))} + code) + (case declaration + (#.Left name) + (macro.with-gensyms [g!_] + (let [nameC (code.local-identifier name) + code-nameC (code.local-identifier (format "@" name)) + runtime-nameC (` (runtime-name (~ (code.text name))))] + (wrap (list (` (def: #export (~ nameC) SVar (~ runtime-nameC))) + (` (def: (~ code-nameC) + (Statement Any) + (..feature (~ runtime-nameC) + (function ((~ g!_) (~ nameC)) + (~ code))))))))) + + (#.Right [name inputs]) + (macro.with-gensyms [g!_] + (let [nameC (code.local-identifier name) + code-nameC (code.local-identifier (format "@" name)) + runtime-nameC (` (runtime-name (~ (code.text name)))) + inputsC (list@map code.local-identifier inputs) + inputs-typesC (list@map (function.constant (` (_.Expression Any))) + inputs)] + (wrap (list (` (def: #export ((~ nameC) (~+ inputsC)) + (-> (~+ inputs-typesC) (Computation Any)) + (_.apply/* (~ runtime-nameC) (list (~+ inputsC))))) + (` (def: (~ code-nameC) + (Statement Any) + (..feature (~ runtime-nameC) + (function ((~ g!_) (~ g!_)) + (..with-vars [(~+ inputsC)] + (_.def (~ g!_) (list (~+ inputsC)) + (~ code))))))))))))) + +(runtime: (lux//try op) + (with-vars [error value] + (_.try ($_ _.then + (_.set (list value) (_.apply/* op (list unit))) + (_.return (right value))) + (list [(list (_.var "Exception")) error + (_.return (left (_.str/1 error)))])))) + +(runtime: (lux//program-args program-args) + (with-vars [inputs value] + ($_ _.then + (_.set (list inputs) none) + (<| (_.for-in value program-args) + (_.set (list inputs) + (some (_.tuple (list value inputs))))) + (_.return inputs)))) + +(def: runtime//lux + (Statement Any) + ($_ _.then + @lux//try + @lux//program-args)) + +(runtime: (io//log! message) + ($_ _.then + (_.print message) + (_.return ..unit))) + +(runtime: (io//throw! message) + ($_ _.then + (_.raise (_.Exception/1 message)) + (_.return ..unit))) + +(runtime: (io//exit! code) + ($_ _.then + (_.import "sys") + (_.statement (|> (_.var "sys") (_.do "exit" (list code)))) + (_.return ..unit))) + +(runtime: (io//current-time! _) + ($_ _.then + (_.import "time") + (_.return (|> (_.var "time") + (_.do "time" (list)) + (_.* (_.int +1,000)) + _.int/1)))) + +(def: runtime//io + (Statement Any) + ($_ _.then + @io//log! + @io//throw! + @io//exit! + @io//current-time!)) + +(runtime: (product//left product index) + (with-vars [index-min-length] + ($_ _.then + (_.set (list index-min-length) (_.+ (_.int +1) index)) + (_.if (_.> index-min-length (_.len/1 product)) + ## No need for recursion + (_.return (_.nth index product)) + ## Needs recursion + (_.return (product//left (_.nth (_.- (_.int +1) + (_.len/1 product)) + product) + (_.- (_.len/1 product) + index-min-length))))))) + +(runtime: (product//right product index) + (with-vars [index-min-length] + ($_ _.then + (_.set (list index-min-length) (_.+ (_.int +1) index)) + (_.cond (list [(_.= index-min-length (_.len/1 product)) + ## Last element. + (_.return (_.nth index product))] + [(_.< index-min-length (_.len/1 product)) + ## Needs recursion + (_.return (product//right (_.nth (_.- (_.int +1) + (_.len/1 product)) + product) + (_.- (_.len/1 product) + index-min-length)))]) + ## Must slice + (_.return (_.slice-from index product)))))) + +(runtime: (sum//get sum wantedTag wantsLast) + (let [no-match! (_.return _.none) + sum-tag (_.nth (_.string ..variant-tag-field) sum) + sum-flag (_.nth (_.string ..variant-flag-field) sum) + sum-value (_.nth (_.string ..variant-value-field) sum) + is-last? (_.= (_.string "") sum-flag) + test-recursion! (_.if is-last? + ## Must recurse. + (_.return (sum//get sum-value (_.- sum-tag wantedTag) wantsLast)) + no-match!)] + (_.cond (list [(_.= sum-tag wantedTag) + (_.if (_.= wantsLast sum-flag) + (_.return sum-value) + test-recursion!)] + + [(_.> sum-tag wantedTag) + test-recursion!] + + [(_.and (_.< sum-tag wantedTag) + (_.= (_.string "") wantsLast)) + (_.return (variant' (_.- wantedTag sum-tag) sum-flag sum-value))]) + + no-match!))) + +(def: runtime//adt + (Statement Any) + ($_ _.then + @product//left + @product//right + @sum//get)) + +(def: full-64-bits + Literal + (_.manual "0xFFFFFFFFFFFFFFFF")) + +(runtime: (i64//64 input) + (with-vars [capped] + (_.cond (list [(|> input (_.> full-64-bits)) + (_.return (|> input (_.bit-and full-64-bits) i64//64))] + [(|> input (_.> (: Literal (_.manual "0x7FFFFFFFFFFFFFFF")))) + ($_ _.then + (_.set (list capped) + (_.int/1 (|> (: Literal (_.manual "0x10000000000000000")) + (_.- input)))) + (_.if (|> capped (_.<= (: Literal (_.manual "9223372036854775807L")))) + (_.return (|> capped (_.* (_.int -1)))) + (_.return (: Literal (_.manual "-9223372036854775808L")))))]) + (_.return input)))) + +(runtime: (i64//logic-right-shift param subject) + (let [mask (|> (_.int +1) + (_.bit-shl (_.- param (_.int +64))) + (_.- (_.int +1)))] + (_.return (|> subject + (_.bit-shr param) + (_.bit-and mask))))) + +(def: runtime//i64 + (Statement Any) + ($_ _.then + @i64//64 + @i64//logic-right-shift)) + +(runtime: (frac//decode input) + (with-vars [ex] + (_.try + (_.return (..some (_.float/1 input))) + (list [(list (_.var "Exception")) ex + (_.return ..none)])))) + +(def: runtime//frac + (Statement Any) + ($_ _.then + @frac//decode)) + +(runtime: (text//index subject param start) + (with-vars [idx] + ($_ _.then + (_.set (list idx) (|> subject (_.do "find" (list param start)))) + (_.if (_.= (_.int -1) idx) + (_.return ..none) + (_.return (..some idx)))))) + +(def: inc (|>> (_.+ (_.int +1)))) + +(do-template [<name> <top-cmp>] + [(def: (<name> top value) + (-> (Expression Any) (Expression Any) (Computation Any)) + (_.and (|> value (_.>= (_.int +0))) + (|> value (<top-cmp> top))))] + + [within? _.<] + [up-to? _.<=] + ) + +(runtime: (text//clip @text @from @to) + (with-vars [length] + ($_ _.then + (_.set (list length) (_.len/1 @text)) + (_.if ($_ _.and + (|> @to (within? length)) + (|> @from (up-to? @to))) + (_.return (..some (|> @text (_.slice @from (inc @to))))) + (_.return ..none))))) + +(runtime: (text//char text idx) + (_.if (|> idx (within? (_.len/1 text))) + (_.return (..some (_.ord/1 (|> text (_.slice idx (inc idx)))))) + (_.return ..none))) + +(def: runtime//text + (Statement Any) + ($_ _.then + @text//index + @text//clip + @text//char)) + +(def: (check-index-out-of-bounds array idx body!) + (-> (Expression Any) (Expression Any) (Statement Any) (Statement Any)) + (_.if (|> idx (_.<= (_.len/1 array))) + body! + (_.raise (_.Exception/1 (_.string "Array index out of bounds!"))))) + +(runtime: (array//get array idx) + (with-vars [temp] + (<| (check-index-out-of-bounds array idx) + ($_ _.then + (_.set (list temp) (_.nth idx array)) + (_.if (_.= _.none temp) + (_.return ..none) + (_.return (..some temp))))))) + +(runtime: (array//put array idx value) + (<| (check-index-out-of-bounds array idx) + ($_ _.then + (_.set (list (_.nth idx array)) value) + (_.return array)))) + +(def: runtime//array + (Statement Any) + ($_ _.then + @array//get + @array//put)) + +(runtime: (box//write value box) + ($_ _.then + (_.set (list (_.nth (_.int +0) box)) value) + (_.return ..unit))) + +(def: runtime//box + (Statement Any) + @box//write) + +(def: runtime + (Statement Any) + ($_ _.then + runtime//lux + runtime//adt + runtime//i64 + runtime//frac + runtime//text + runtime//array + runtime//box + runtime//io + )) + +(def: #export artifact ..prefix) + +(def: #export generate + (Operation Any) + (///.with-buffer + (do ////.monad + [_ (///.save! ["" ..prefix] ..runtime)] + (///.save-buffer! ..artifact)))) diff --git a/stdlib/source/lux/tool/compiler/phase/generation/python/structure.lux b/stdlib/source/lux/tool/compiler/phase/generation/python/structure.lux new file mode 100644 index 000000000..1415251df --- /dev/null +++ b/stdlib/source/lux/tool/compiler/phase/generation/python/structure.lux @@ -0,0 +1,36 @@ +(.module: + [lux #* + [control + ["." monad (#+ do)]] + [host + ["_" python (#+ Expression)]]] + ["." // #_ + ["#." runtime (#+ Operation Phase)] + ["#." primitive] + ["#//" /// + ["#/" // #_ + [analysis (#+ Variant Tuple)] + ["#." synthesis (#+ Synthesis)]]]]) + +(def: #export (tuple generate elemsS+) + (-> Phase (Tuple Synthesis) (Operation (Expression Any))) + (case elemsS+ + #.Nil + (:: ////.monad wrap (//primitive.text /////synthesis.unit)) + + (#.Cons singletonS #.Nil) + (generate singletonS) + + _ + (do ////.monad + [elemsT+ (monad.map @ generate elemsS+)] + (wrap (_.tuple elemsT+))))) + +(def: #export (variant generate [lefts right? valueS]) + (-> Phase (Variant Synthesis) (Operation (Expression Any))) + (:: ////.monad map + (//runtime.variant (if right? + (inc lefts) + lefts) + right?) + (generate valueS))) diff --git a/stdlib/source/lux/tool/compiler/phase/synthesis/case.lux b/stdlib/source/lux/tool/compiler/phase/synthesis/case.lux index 8dd7c342e..841846351 100644 --- a/stdlib/source/lux/tool/compiler/phase/synthesis/case.lux +++ b/stdlib/source/lux/tool/compiler/phase/synthesis/case.lux @@ -6,16 +6,17 @@ ["." monad (#+ do)]] [data ["." product] - ["." bit ("#;." equivalence)] - ["." text ("#;." equivalence) + ["." bit ("#@." equivalence)] + ["." text ("#@." equivalence) format] [number - ["." frac ("#;." equivalence)]] + ["." frac ("#@." equivalence)]] [collection - ["." list ("#;." fold monoid)]]]] - ["." /// ("#;." monad) + ["." list ("#@." functor fold monoid)] + ["." set (#+ Set)]]]] + ["." /// ("#@." monad) ["#/" // - ["#." reference] + ["#." reference (#+ Variable)] ["#." analysis (#+ Pattern Match Analysis)] ["/" synthesis (#+ Path Synthesis Operation Phase)]]]) @@ -33,7 +34,7 @@ (^template [<from> <to>] (<from> value) - (///;map (|>> (#/.Seq (#/.Test (|> value <to>)))) + (///@map (|>> (#/.Seq (#/.Test (|> value <to>)))) thenC)) ([#////analysis.Bit #/.Bit] [#////analysis.Nat (<| #/.I64 .i64)] @@ -48,23 +49,23 @@ thenC) (#////analysis.Complex (#////analysis.Variant [lefts right? value-pattern])) - (<| (///;map (|>> (#/.Seq (#/.Access (#/.Side (if right? + (<| (///@map (|>> (#/.Seq (#/.Access (#/.Side (if right? (#.Right lefts) (#.Left lefts))))))) (path' value-pattern end?) - (when> [(new> (not end?) [])] [(///;map ..clean-up)]) + (when> [(new> (not end?) [])] [(///@map ..clean-up)]) thenC) (#////analysis.Complex (#////analysis.Tuple tuple)) (let [tuple::last (dec (list.size tuple))] - (list;fold (function (_ [tuple::lefts tuple::member] nextC) + (list@fold (function (_ [tuple::lefts tuple::member] nextC) (let [right? (n/= tuple::last tuple::lefts) end?' (and end? right?)] - (<| (///;map (|>> (#/.Seq (#/.Access (#/.Member (if right? + (<| (///@map (|>> (#/.Seq (#/.Access (#/.Member (if right? (#.Right (dec tuple::lefts)) (#.Left tuple::lefts))))))) (path' tuple::member end?') - (when> [(new> (not end?') [])] [(///;map ..clean-up)]) + (when> [(new> (not end?') [])] [(///@map ..clean-up)]) nextC))) thenC (list.reverse (list.enumerate tuple)))) @@ -72,7 +73,7 @@ (def: #export (path synthesize pattern bodyA) (-> Phase Pattern Analysis (Operation Path)) - (path' pattern true (///;map (|>> #/.Then) (synthesize bodyA)))) + (path' pattern true (///@map (|>> #/.Then) (synthesize bodyA)))) (def: #export (weave leftP rightP) (-> Path Path Path) @@ -96,10 +97,10 @@ (if (<eq> leftV rightV) rightP <default>)) - ([#/.Bit bit;=] + ([#/.Bit bit@=] [#/.I64 "lux i64 ="] - [#/.F64 frac;=] - [#/.Text text;=]) + [#/.F64 frac@=] + [#/.Text text@=]) (^template [<access> <side>] [(#/.Access (<access> (<side> leftL))) @@ -157,14 +158,101 @@ list.reverse (case> (#.Cons [lastP lastA] prevsPA) [[lastP lastA] prevsPA] - + _ (undefined)))] (do @ [lastSP (path synthesize^ lastP lastA) prevsSP+ (monad.map @ (product.uncurry (path synthesize^)) prevsPA)] - (wrap (/.branch/case [inputS (list;fold weave lastSP prevsSP+)])))))] + (wrap (/.branch/case [inputS (list@fold weave lastSP prevsSP+)])))))] (case [headB tailB+] <let> <if> <case>)))) + +(def: #export (count-pops path) + (-> Path [Nat Path]) + (case path + (^ (/.path/seq #/.Pop path')) + (let [[pops post-pops] (count-pops path')] + [(inc pops) post-pops]) + + _ + [0 path])) + +(def: #export pattern-matching-error + "Invalid expression for pattern-matching.") + +(type: #export Storage + {#bindings (Set Variable) + #dependencies (Set Variable)}) + +(def: empty + Storage + {#bindings (set.new ////reference.hash) + #dependencies (set.new ////reference.hash)}) + +## TODO: Use this to declare all local variables at the beginning of +## script functions. +## That way, it should be possible to do cheap "let" expressions, +## since the variable will exist before hand so no closure will need +## to be created for it. +## Apply this trick to JS, Python et al. +(def: #export (storage path) + (-> Path Storage) + (loop for-path + [path path + path-storage ..empty] + (case path + (^ (/.path/bind register)) + (update@ #bindings (set.add (#////reference.Local register)) + path-storage) + + (^or (^ (/.path/seq left right)) + (^ (/.path/alt left right))) + (list@fold for-path path-storage (list left right)) + + (^ (/.path/then bodyS)) + (loop for-synthesis + [bodyS bodyS + synthesis-storage path-storage] + (case bodyS + (^ (/.variant [lefts right? valueS])) + (for-synthesis valueS synthesis-storage) + + (^ (/.tuple members)) + (list@fold for-synthesis synthesis-storage members) + + (#/.Reference (#////reference.Variable var)) + (if (set.member? (get@ #bindings synthesis-storage) var) + synthesis-storage + (update@ #dependencies (set.add var) synthesis-storage)) + + (^ (/.function/apply [functionS argsS])) + (list@fold for-synthesis synthesis-storage (#.Cons functionS argsS)) + + (^ (/.function/abstraction [environment arity bodyS])) + (list@fold (function (_ variable storage) + (for-synthesis (#/.Reference (#////reference.Variable variable)) + storage)) + synthesis-storage + environment) + + (^ (/.branch/let [inputS register exprS])) + (list@fold for-synthesis + (update@ #bindings (set.add (#////reference.Local register)) + synthesis-storage) + (list inputS exprS)) + + (^ (/.branch/case [inputS pathS])) + (|> synthesis-storage (for-synthesis inputS) (for-path pathS)) + + (#/.Extension [extension argsS]) + (list@fold for-synthesis synthesis-storage argsS) + + _ + synthesis-storage)) + + _ + path-storage + ))) diff --git a/stdlib/source/test/lux.lux b/stdlib/source/test/lux.lux index d0dc4f257..30abe1b37 100644 --- a/stdlib/source/test/lux.lux +++ b/stdlib/source/test/lux.lux @@ -40,14 +40,17 @@ [markdown (#+)]]] [host [js (#+)] + [python (#+)] [scheme (#+)]] [tool [compiler [phase [generation - [scheme (#+) - <host-modules>] [js (#+) + <host-modules>] + [python (#+) + <host-modules>] + [scheme (#+) <host-modules>]]]]] ## [control ## ["._" contract] |