diff options
Diffstat (limited to 'stdlib/source/lux')
21 files changed, 778 insertions, 767 deletions
diff --git a/stdlib/source/lux/tool/compiler/default/evaluation.lux b/stdlib/source/lux/tool/compiler/default/evaluation.lux index 3310a1fd1..42bb10ca0 100644 --- a/stdlib/source/lux/tool/compiler/default/evaluation.lux +++ b/stdlib/source/lux/tool/compiler/default/evaluation.lux @@ -9,13 +9,13 @@ [/// ["." phase [macro (#+ Expander)] - ["." analysis + [".P" analysis ["." type]] - ["." synthesis - [".S" expression]] + [".P" synthesis] ["." translation] [// - [analysis (#+ Operation)]]]]) + [analysis (#+ Operation)] + ["." synthesis]]]]) (type: #export Eval (-> Nat Type Code (Operation Any))) @@ -27,13 +27,13 @@ (translation.State+ anchor expression statement) (translation.Phase anchor expression statement) Eval)) - (let [analyze (analysis.phase expander)] + (let [analyze (analysisP.phase expander)] (function (eval count type exprC) (do phase.monad [exprA (type.with-type type (analyze exprC))] (phase.lift (do error.monad - [exprS (|> exprA expressionS.phase (phase.run synthesis-state))] + [exprS (|> exprA synthesisP.phase (phase.run synthesis-state))] (phase.run translation-state (do phase.monad [exprO (translate exprS)] diff --git a/stdlib/source/lux/tool/compiler/default/init.lux b/stdlib/source/lux/tool/compiler/default/init.lux index 41ecc851a..0958c3b01 100644 --- a/stdlib/source/lux/tool/compiler/default/init.lux +++ b/stdlib/source/lux/tool/compiler/default/init.lux @@ -18,13 +18,13 @@ ["." evaluation] ["/." // (#+ Instancer) ["." analysis] + ["." synthesis] ["." host] ["." phase [macro (#+ Expander)] [".P" analysis ["." module]] - ["." synthesis - [".S" expression]] + [".P" synthesis] ["." translation] ["." statement [".S" total]] @@ -84,7 +84,7 @@ {#statement.analysis {#statement.state analysis-state #statement.phase (analysisP.phase expander)} #statement.synthesis {#statement.state synthesis-state - #statement.phase expressionS.phase} + #statement.phase synthesisP.phase} #statement.translation {#statement.state translation-state #statement.phase translate}}])) diff --git a/stdlib/source/lux/tool/compiler/phase/extension/statement.lux b/stdlib/source/lux/tool/compiler/phase/extension/statement.lux index ee70ddfc5..37ff93b9c 100644 --- a/stdlib/source/lux/tool/compiler/phase/extension/statement.lux +++ b/stdlib/source/lux/tool/compiler/phase/extension/statement.lux @@ -18,11 +18,11 @@ [analysis ["." module] ["." type]] - ["." synthesis (#+ Synthesis)] ["." translation] ["." statement (#+ Operation Handler Bundle)] [// - ["." analysis]]]]) + ["." analysis] + ["." synthesis (#+ Synthesis)]]]]) ## TODO: Inline "evaluate!'" into "evaluate!" ASAP (def: (evaluate!' translate code//type codeS) diff --git a/stdlib/source/lux/tool/compiler/phase/extension/synthesis.lux b/stdlib/source/lux/tool/compiler/phase/extension/synthesis.lux index 1a2e44f6f..40fb4f89e 100644 --- a/stdlib/source/lux/tool/compiler/phase/extension/synthesis.lux +++ b/stdlib/source/lux/tool/compiler/phase/extension/synthesis.lux @@ -2,7 +2,7 @@ [lux #*] [// ["." bundle] - [// + [/// [synthesis (#+ Bundle)]]]) (def: #export bundle diff --git a/stdlib/source/lux/tool/compiler/phase/statement.lux b/stdlib/source/lux/tool/compiler/phase/statement.lux index f2d508843..ba84d146f 100644 --- a/stdlib/source/lux/tool/compiler/phase/statement.lux +++ b/stdlib/source/lux/tool/compiler/phase/statement.lux @@ -1,11 +1,11 @@ (.module: [lux #*] ["." // - ["." synthesis] ["." translation] ["." extension] [// - ["." analysis]]]) + ["." analysis] + ["." synthesis]]]) (type: #export (Component state phase) {#state state diff --git a/stdlib/source/lux/tool/compiler/phase/synthesis.lux b/stdlib/source/lux/tool/compiler/phase/synthesis.lux index a484067bf..17af9a6fa 100644 --- a/stdlib/source/lux/tool/compiler/phase/synthesis.lux +++ b/stdlib/source/lux/tool/compiler/phase/synthesis.lux @@ -1,468 +1,90 @@ (.module: - [lux (#- i64 Scope) + [lux (#- primitive) [control - [monad (#+ do)] - [equivalence (#+ Equivalence)] - ["ex" exception (#+ exception:)]] + ["." monad (#+ do)] + [pipe (#+ case>)]] [data - ["." bit ("#/." equivalence)] - ["." text ("#/." equivalence) - format] + ["." maybe] + ["." error] [collection ["." list ("#/." functor)] ["." dictionary (#+ Dictionary)]]]] - ["." // - ["." extension (#+ Extension)] - [// - ["." reference (#+ Register Variable Reference)] - ["." analysis (#+ Environment Arity Composite Analysis)]]]) - -(type: #export Resolver (Dictionary Variable Variable)) - -(type: #export State - {#locals Nat}) - -(def: #export fresh-resolver - Resolver - (dictionary.new reference.hash)) - -(def: #export init - State - {#locals 0}) - -(type: #export Primitive - (#Bit Bit) - (#I64 (I64 Any)) - (#F64 Frac) - (#Text Text)) - -(type: #export Side - (Either Nat Nat)) - -(type: #export Member - (Either Nat Nat)) - -(type: #export Access - (#Side Side) - (#Member Member)) - -(type: #export (Path' s) - #Pop - (#Test Primitive) - (#Access Access) - (#Bind Register) - (#Alt (Path' s) (Path' s)) - (#Seq (Path' s) (Path' s)) - (#Then s)) - -(type: #export (Abstraction' s) - {#environment Environment - #arity Arity - #body s}) - -(type: #export (Apply' s) - {#function s - #arguments (List s)}) - -(type: #export (Branch s) - (#Let s Register s) - (#If s s s) - (#Case s (Path' s))) - -(type: #export (Scope s) - {#start Register - #inits (List s) - #iteration s}) - -(type: #export (Loop s) - (#Scope (Scope s)) - (#Recur (List s))) - -(type: #export (Function s) - (#Abstraction (Abstraction' s)) - (#Apply s (List s))) - -(type: #export (Control s) - (#Branch (Branch s)) - (#Loop (Loop s)) - (#Function (Function s))) - -(type: #export #rec Synthesis - (#Primitive Primitive) - (#Structure (Composite Synthesis)) - (#Reference Reference) - (#Control (Control Synthesis)) - (#Extension (Extension Synthesis))) - -(do-template [<special> <general>] - [(type: #export <special> - (<general> ..State Analysis Synthesis))] - - [State+ extension.State] - [Operation extension.Operation] - [Phase extension.Phase] - [Handler extension.Handler] - [Bundle extension.Bundle] - ) - -(type: #export Path - (Path' Synthesis)) - -(def: #export path/pop - Path - #Pop) - -(do-template [<name> <tag>] - [(template: #export (<name> content) - (#..Test (<tag> content)))] - - [path/bit #..Bit] - [path/i64 #..I64] - [path/f64 #..F64] - [path/text #..Text] - ) - -(do-template [<name> <kind>] - [(template: #export (<name> content) - (.<| #..Access - <kind> - content))] - - [path/side #..Side] - [path/member #..Member] - ) - -(do-template [<name> <kind> <side>] - [(template: #export (<name> content) - (.<| #..Access - <kind> - <side> - content))] - - [side/left #..Side #.Left] - [side/right #..Side #.Right] - [member/left #..Member #.Left] - [member/right #..Member #.Right] - ) - -(do-template [<name> <tag>] - [(template: #export (<name> content) - (<tag> content))] - - [path/bind #..Bind] - [path/then #..Then] - ) - -(do-template [<name> <tag>] - [(template: #export (<name> left right) - (<tag> [left right]))] - - [path/alt #..Alt] - [path/seq #..Seq] - ) - -(type: #export Abstraction - (Abstraction' Synthesis)) - -(type: #export Apply - (Apply' Synthesis)) - -(def: #export unit Text "") - -(do-template [<name> <type> <tag>] - [(def: #export (<name> value) - (-> <type> (All [a] (-> (Operation a) (Operation a)))) - (extension.temporary (set@ <tag> value)))] - - [with-locals Nat #locals] - ) - -(def: #export (with-abstraction arity resolver) - (-> Arity Resolver - (All [a] (-> (Operation a) (Operation a)))) - (extension.with-state {#locals arity})) - -(do-template [<name> <tag> <type>] - [(def: #export <name> - (Operation <type>) - (extension.read (get@ <tag>)))] - - [locals #locals Nat] - ) - -(def: #export with-new-local - (All [a] (-> (Operation a) (Operation a))) - (<<| (do //.monad - [locals ..locals]) - (..with-locals (inc locals)))) - -(do-template [<name> <tag>] - [(template: #export (<name> content) - (#..Primitive (<tag> content)))] - - [bit #..Bit] - [i64 #..I64] - [f64 #..F64] - [text #..Text] - ) - -(do-template [<name> <tag>] - [(template: #export (<name> content) - (<| #..Structure - <tag> - content))] - - [variant #analysis.Variant] - [tuple #analysis.Tuple] - ) - -(do-template [<name> <tag>] - [(template: #export (<name> content) - (.<| #..Reference - <tag> - content))] - - [variable/local reference.local] - [variable/foreign reference.foreign] - ) - -(do-template [<name> <tag>] - [(template: #export (<name> content) - (.<| #..Reference - <tag> - content))] - - [variable reference.variable] - [constant reference.constant] - ) - -(do-template [<name> <family> <tag>] - [(template: #export (<name> content) - (.<| #..Control - <family> - <tag> - content))] - - [branch/case #..Branch #..Case] - [branch/let #..Branch #..Let] - [branch/if #..Branch #..If] - - [loop/recur #..Loop #..Recur] - [loop/scope #..Loop #..Scope] - - [function/abstraction #..Function #..Abstraction] - [function/apply #..Function #..Apply] - ) - -(def: #export (%path' %then value) - (All [a] (-> (Format a) (Format (Path' a)))) - (case value - #Pop - "_" - - (#Test primitive) - (format "(? " - (case primitive - (#Bit value) - (%b value) - - (#I64 value) - (%i (.int value)) - - (#F64 value) - (%f value) - - (#Text value) - (%t value)) - ")") - - (#Access access) - (case access - (#Side side) - (case side - (#.Left lefts) - (format "(" (%n lefts) " #0" ")") - - (#.Right lefts) - (format "(" (%n lefts) " #1" ")")) - - (#Member member) - (case member - (#.Left lefts) - (format "[" (%n lefts) " #0" "]") - - (#.Right lefts) - (format "[" (%n lefts) " #1" "]"))) + [/ + ["/." function] + ["/." case] + ["." // ("#/." monad) + ["//." extension] + [// + ["." reference] + ["." analysis (#+ Analysis)] + ["/" synthesis (#+ Synthesis Phase)]]]]) + +(def: (primitive analysis) + (-> analysis.Primitive /.Primitive) + (case analysis + #analysis.Unit + (#/.Text /.unit) - (#Bind register) - (format "(@ " (%n register) ")") - - (#Alt left right) - (format "(| " (%path' %then left) " " (%path' %then right) ")") - - (#Seq left right) - (format "(& " (%path' %then left) " " (%path' %then right) ")") - - (#Then then) - (|> (%then then) - (text.enclose ["(! " ")"])))) - -(def: #export (%synthesis value) - (Format Synthesis) - (case value - (#Primitive primitive) - (case primitive - (^template [<pattern> <format>] - (<pattern> value) - (<format> value)) - ([#Bit %b] - [#F64 %f] - [#Text %t]) - - (#I64 value) - (%i (.int value))) - - (#Structure structure) + (^template [<analysis> <synthesis>] + (<analysis> value) + (<synthesis> value)) + ([#analysis.Bit #/.Bit] + [#analysis.Frac #/.F64] + [#analysis.Text #/.Text]) + + (^template [<analysis> <synthesis>] + (<analysis> value) + (<synthesis> (.i64 value))) + ([#analysis.Nat #/.I64] + [#analysis.Int #/.I64] + [#analysis.Rev #/.I64]))) + +(def: #export (phase analysis) + Phase + (case analysis + (#analysis.Primitive analysis') + (///wrap (#/.Primitive (..primitive analysis'))) + + (#analysis.Structure structure) (case structure - (#analysis.Variant [lefts right? content]) - (|> (%synthesis content) - (format (%n lefts) " " (%b right?) " ") - (text.enclose ["(" ")"])) - - (#analysis.Tuple members) - (|> members - (list/map %synthesis) - (text.join-with " ") - (text.enclose ["[" "]"]))) - - (#Reference reference) - (|> reference - reference.%reference - (text.enclose ["(#@ " ")"])) - - (#Control control) - (case control - (#Function function) - (case function - (#Abstraction [environment arity body]) - (|> (%synthesis body) - (format (%n arity) " ") - (format (|> environment - (list/map reference.%variable) - (text.join-with " ") - (text.enclose ["[" "]"])) - " ") - (text.enclose ["(" ")"])) - - (#Apply func args) - (|> (list/map %synthesis args) - (text.join-with " ") - (format (%synthesis func) " ") - (text.enclose ["(" ")"]))) - - (#Branch branch) - (case branch - (#Let input register body) - (|> (format (%synthesis input) " " (%n register) " " (%synthesis body)) - (text.enclose ["(#let " ")"])) - - (#If test then else) - (|> (format (%synthesis test) " " (%synthesis then) " " (%synthesis else)) - (text.enclose ["(#if " ")"])) - - (#Case input path) - (|> (format (%synthesis input) " " (%path' %synthesis path)) - (text.enclose ["(#case " ")"]))) - - ## (#Loop loop) - _ - "???") - - (#Extension [name args]) - (|> (list/map %synthesis args) - (text.join-with " ") - (format (%t name)) - (text.enclose ["(" ")"])))) - -(def: #export %path - (Format Path) - (%path' %synthesis)) - -(structure: #export primitive-equivalence (Equivalence Primitive) - (def: (= reference sample) - (case [reference sample] - (^template [<tag> <eq> <format>] - [(<tag> reference') (<tag> sample')] - (<eq> reference' sample')) - ([#Bit bit/= %b] - [#F64 f/= %f] - [#Text text/= %t]) - - [(#I64 reference') (#I64 sample')] - (i/= (.int reference') (.int sample')) - - _ - false))) - -(structure: #export access-equivalence (Equivalence Access) - (def: (= reference sample) - (case [reference sample] - (^template [<tag>] - [(<tag> reference') (<tag> sample')] - (case [reference' sample'] - (^template [<side>] - [(<side> reference'') (<side> sample'')] - (n/= reference'' sample'')) - ([#.Left] - [#.Right]) - - _ - false)) - ([#Side] - [#Member]) - - _ - false))) - -(structure: #export (path'-equivalence Equivalence<a>) - (All [a] (-> (Equivalence a) (Equivalence (Path' a)))) - - (def: (= reference sample) - (case [reference sample] - [#Pop #Pop] - true - - (^template [<tag> <equivalence>] - [(<tag> reference') (<tag> sample')] - (:: <equivalence> = reference' sample')) - ([#Test primitive-equivalence] - [#Access access-equivalence] - [#Then Equivalence<a>]) - - [(#Bind reference') (#Bind sample')] - (n/= reference' sample') - - (^template [<tag>] - [(<tag> leftR rightR) (<tag> leftS rightS)] - (and (= leftR leftS) - (= rightR rightS))) - ([#Alt] - [#Seq]) - - _ - false))) - -(structure: #export equivalence (Equivalence Synthesis) - (def: (= reference sample) - (case [reference sample] - (^template [<tag> <equivalence>] - [(<tag> reference') (<tag> sample')] - (:: <equivalence> = reference' sample')) - ([#Primitive primitive-equivalence]) - - _ - false))) - -(def: #export path-equivalence - (Equivalence Path) - (path'-equivalence equivalence)) + (#analysis.Variant variant) + (do //.monad + [valueS (phase (get@ #analysis.value variant))] + (wrap (/.variant (set@ #analysis.value valueS variant)))) + + (#analysis.Tuple tuple) + (|> tuple + (monad.map //.monad phase) + (///map (|>> /.tuple)))) + + (#analysis.Reference reference) + (///wrap (#/.Reference reference)) + + (#analysis.Case inputA branchesAB+) + (/case.synthesize phase inputA branchesAB+) + + (^ (analysis.no-op value)) + (phase value) + + (#analysis.Apply _) + (/function.apply phase analysis) + + (#analysis.Function environmentA bodyA) + (/function.abstraction phase environmentA bodyA) + + (#analysis.Extension name args) + (function (_ state) + (|> (//extension.apply phase [name args]) + (//.run' state) + (case> (#error.Success output) + (#error.Success output) + + (#error.Failure error) + (<| (//.run' state) + (do //.monad + [argsS+ (monad.map @ phase args)] + (wrap (#/.Extension [name argsS+]))))))) + + _ + (///wrap (undefined)) + )) diff --git a/stdlib/source/lux/tool/compiler/phase/synthesis/case.lux b/stdlib/source/lux/tool/compiler/phase/synthesis/case.lux index fe28c26df..94a2637fe 100644 --- a/stdlib/source/lux/tool/compiler/phase/synthesis/case.lux +++ b/stdlib/source/lux/tool/compiler/phase/synthesis/case.lux @@ -13,16 +13,15 @@ ["." frac ("#/." equivalence)]] [collection ["." list ("#/." fold monoid)]]]] - ["." // (#+ Path Synthesis Operation Phase) - ["." function] - ["/." // ("#/." monad) - [// - ["." reference] - ["." analysis (#+ Pattern Match Analysis)]]]]) + ["." /// ("#/." monad) + [// + ["." reference] + ["." analysis (#+ Pattern Match Analysis)] + ["/" synthesis (#+ Path Synthesis Operation Phase)]]]) (def: clean-up (-> Path Path) - (|>> (#//.Seq #//.Pop))) + (|>> (#/.Seq #/.Pop))) (def: (path' pattern end? thenC) (-> Pattern Bit (Operation Path) (Operation Path)) @@ -34,24 +33,24 @@ (^template [<from> <to>] (<from> value) - (////map (|>> (#//.Seq (#//.Test (|> value <to>)))) + (////map (|>> (#/.Seq (#/.Test (|> value <to>)))) thenC)) - ([#analysis.Bit #//.Bit] - [#analysis.Nat (<| #//.I64 .i64)] - [#analysis.Int (<| #//.I64 .i64)] - [#analysis.Rev (<| #//.I64 .i64)] - [#analysis.Frac #//.F64] - [#analysis.Text #//.Text])) + ([#analysis.Bit #/.Bit] + [#analysis.Nat (<| #/.I64 .i64)] + [#analysis.Int (<| #/.I64 .i64)] + [#analysis.Rev (<| #/.I64 .i64)] + [#analysis.Frac #/.F64] + [#analysis.Text #/.Text])) (#analysis.Bind register) - (<| (:: ///.monad map (|>> (#//.Seq (#//.Bind register)))) - //.with-new-local + (<| (:: ///.monad map (|>> (#/.Seq (#/.Bind register)))) + /.with-new-local thenC) (#analysis.Complex (#analysis.Variant [lefts right? value-pattern])) - (<| (////map (|>> (#//.Seq (#//.Access (#//.Side (if right? - (#.Right lefts) - (#.Left lefts))))))) + (<| (////map (|>> (#/.Seq (#/.Access (#/.Side (if right? + (#.Right lefts) + (#.Left lefts))))))) (path' value-pattern end?) (when> [(new> (not end?) [])] [(////map ..clean-up)]) thenC) @@ -61,9 +60,9 @@ (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? - (#.Right (dec tuple::lefts)) - (#.Left tuple::lefts))))))) + (<| (////map (|>> (#/.Seq (#/.Access (#/.Member (if right? + (#.Right (dec tuple::lefts)) + (#.Left tuple::lefts))))))) (path' tuple::member end?') (when> [(new> (not end?') [])] [(////map ..clean-up)]) nextC))) @@ -73,47 +72,47 @@ (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) - (with-expansions [<default> (as-is (#//.Alt leftP rightP))] + (with-expansions [<default> (as-is (#/.Alt leftP rightP))] (case [leftP rightP] - [(#//.Seq preL postL) - (#//.Seq preR postR)] + [(#/.Seq preL postL) + (#/.Seq preR postR)] (case (weave preL preR) - (#//.Alt _) + (#/.Alt _) <default> weavedP - (#//.Seq weavedP (weave postL postR))) + (#/.Seq weavedP (weave postL postR))) - [#//.Pop #//.Pop] + [#/.Pop #/.Pop] rightP (^template [<tag> <eq>] - [(#//.Test (<tag> leftV)) - (#//.Test (<tag> rightV))] + [(#/.Test (<tag> leftV)) + (#/.Test (<tag> rightV))] (if (<eq> leftV rightV) rightP <default>)) - ([#//.Bit bit/=] - [#//.I64 "lux i64 ="] - [#//.F64 frac/=] - [#//.Text text/=]) + ([#/.Bit bit/=] + [#/.I64 "lux i64 ="] + [#/.F64 frac/=] + [#/.Text text/=]) (^template [<access> <side>] - [(#//.Access (<access> (<side> leftL))) - (#//.Access (<access> (<side> rightL)))] + [(#/.Access (<access> (<side> leftL))) + (#/.Access (<access> (<side> rightL)))] (if (n/= leftL rightL) rightP <default>)) - ([#//.Side #.Left] - [#//.Side #.Right] - [#//.Member #.Left] - [#//.Member #.Right]) + ([#/.Side #.Left] + [#/.Side #.Right] + [#/.Member #.Left] + [#/.Member #.Right]) - [(#//.Bind leftR) (#//.Bind rightR)] + [(#/.Bind leftR) (#/.Bind rightR)] (if (n/= leftR rightR) rightP <default>) @@ -138,9 +137,9 @@ _ (do @ - [headB/bodyS (//.with-new-local + [headB/bodyS (/.with-new-local (synthesize^ headB/bodyA))] - (wrap (//.branch/let [inputS inputR headB/bodyS]))))) + (wrap (/.branch/let [inputS inputR headB/bodyS]))))) <if> (as-is (^or (^ [[(analysis.pattern/bit #1) thenA] @@ -150,7 +149,7 @@ (do @ [thenS (synthesize^ thenA) elseS (synthesize^ elseA)] - (wrap (//.branch/if [inputS thenS elseS])))) + (wrap (/.branch/if [inputS thenS elseS])))) <case> (as-is _ @@ -164,7 +163,7 @@ (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> diff --git a/stdlib/source/lux/tool/compiler/phase/synthesis/expression.lux b/stdlib/source/lux/tool/compiler/phase/synthesis/expression.lux deleted file mode 100644 index 29fe623ba..000000000 --- a/stdlib/source/lux/tool/compiler/phase/synthesis/expression.lux +++ /dev/null @@ -1,89 +0,0 @@ -(.module: - [lux (#- primitive) - [control - ["." monad (#+ do)] - [pipe (#+ case>)]] - [data - ["." maybe] - ["." error] - [collection - ["." list ("#/." functor)] - ["." dictionary (#+ Dictionary)]]]] - ["." // (#+ Synthesis Phase) - ["." function] - ["." case] - ["/." // ("#/." monad) - ["." extension] - [// - ["." reference] - ["." analysis (#+ Analysis)]]]]) - -(def: (primitive analysis) - (-> analysis.Primitive //.Primitive) - (case analysis - #analysis.Unit - (#//.Text //.unit) - - (^template [<analysis> <synthesis>] - (<analysis> value) - (<synthesis> value)) - ([#analysis.Bit #//.Bit] - [#analysis.Frac #//.F64] - [#analysis.Text #//.Text]) - - (^template [<analysis> <synthesis>] - (<analysis> value) - (<synthesis> (.i64 value))) - ([#analysis.Nat #//.I64] - [#analysis.Int #//.I64] - [#analysis.Rev #//.I64]))) - -(def: #export (phase analysis) - Phase - (case analysis - (#analysis.Primitive analysis') - (////wrap (#//.Primitive (..primitive analysis'))) - - (#analysis.Structure structure) - (case structure - (#analysis.Variant variant) - (do ///.monad - [valueS (phase (get@ #analysis.value variant))] - (wrap (//.variant (set@ #analysis.value valueS variant)))) - - (#analysis.Tuple tuple) - (|> tuple - (monad.map ///.monad phase) - (////map (|>> //.tuple)))) - - (#analysis.Reference reference) - (////wrap (#//.Reference reference)) - - (#analysis.Case inputA branchesAB+) - (case.synthesize phase inputA branchesAB+) - - (^ (analysis.no-op value)) - (phase value) - - (#analysis.Apply _) - (function.apply phase analysis) - - (#analysis.Function environmentA bodyA) - (function.abstraction phase environmentA bodyA) - - (#analysis.Extension name args) - (function (_ state) - (|> (extension.apply phase [name args]) - (///.run' state) - (case> (#error.Success output) - (#error.Success output) - - (#error.Failure error) - (<| (///.run' state) - (do ///.monad - [argsS+ (monad.map @ phase args)] - (wrap (#//.Extension [name argsS+]))))))) - - _ - (////wrap (undefined)) - )) diff --git a/stdlib/source/lux/tool/compiler/phase/synthesis/function.lux b/stdlib/source/lux/tool/compiler/phase/synthesis/function.lux index a741238ab..b5c97e825 100644 --- a/stdlib/source/lux/tool/compiler/phase/synthesis/function.lux +++ b/stdlib/source/lux/tool/compiler/phase/synthesis/function.lux @@ -10,12 +10,13 @@ [collection ["." list ("#/." functor monoid fold)] ["dict" dictionary (#+ Dictionary)]]]] - ["." // (#+ Path Synthesis Operation Phase) - ["." loop (#+ Transform)] + [// + ["//." loop (#+ Transform)] ["/." // ("#/." monad) [// ["." reference (#+ Register Variable)] - ["." analysis (#+ Environment Arity Analysis)]]]]) + ["." analysis (#+ Environment Arity Analysis)] + ["/" synthesis (#+ Path Synthesis Operation Phase)]]]]) (exception: #export (cannot-find-foreign-variable-in-environment {foreign Register} {environment Environment}) (ex.report ["Foreign" (%n foreign)] @@ -27,14 +28,14 @@ (-> Arity (List Synthesis)) (|>> dec (list.n/range 1) - (list/map (|>> //.variable/local)))) + (list/map (|>> /.variable/local)))) (template: #export (self-reference) - (//.variable/local 0)) + (/.variable/local 0)) (def: (expanded-nested-self-reference arity) (-> Arity Synthesis) - (//.function/apply [(..self-reference) (arity-arguments arity)])) + (/.function/apply [(..self-reference) (arity-arguments arity)])) (def: #export (apply phase) (-> Phase Phase) @@ -43,17 +44,17 @@ (do ///.monad [funcS (phase funcA) argsS (monad.map @ phase argsA) - ## locals //.locals + ## locals /.locals ] - (with-expansions [<apply> (as-is (//.function/apply [funcS argsS]))] + (with-expansions [<apply> (as-is (/.function/apply [funcS argsS]))] (case funcS - ## (^ (//.function/abstraction functionS)) + ## (^ (/.function/abstraction functionS)) ## (wrap (|> functionS - ## (loop.loop (get@ #//.environment functionS) locals argsS) + ## (//loop.loop (get@ #/.environment functionS) locals argsS) ## (maybe.default <apply>))) - (^ (//.function/apply [funcS' argsS'])) - (wrap (//.function/apply [funcS' (list/compose argsS' argsS)])) + (^ (/.function/apply [funcS' argsS'])) + (wrap (/.function/apply [funcS' (list/compose argsS' argsS)])) _ (wrap <apply>))))))) @@ -70,8 +71,8 @@ (def: (grow-path grow path) (-> (-> Synthesis (Operation Synthesis)) Path (Operation Path)) (case path - (#//.Bind register) - (////wrap (#//.Bind (inc register))) + (#/.Bind register) + (////wrap (#/.Bind (inc register))) (^template [<tag>] (<tag> left right) @@ -79,12 +80,12 @@ [left' (grow-path grow left) right' (grow-path grow right)] (wrap (<tag> left' right')))) - ([#//.Alt] [#//.Seq]) + ([#/.Alt] [#/.Seq]) - (#//.Then thenS) + (#/.Then thenS) (|> thenS grow - (////map (|>> #//.Then))) + (////map (|>> #/.Then))) _ (////wrap path))) @@ -104,95 +105,95 @@ (def: (grow environment expression) (-> Environment Synthesis (Operation Synthesis)) (case expression - (#//.Structure structure) + (#/.Structure structure) (case structure (#analysis.Variant [lefts right? subS]) (|> subS (grow environment) - (////map (|>> [lefts right?] //.variant))) + (////map (|>> [lefts right?] /.variant))) (#analysis.Tuple membersS+) (|> membersS+ (monad.map ///.monad (grow environment)) - (////map (|>> //.tuple)))) + (////map (|>> /.tuple)))) (^ (..self-reference)) - (////wrap (//.function/apply [expression (list (//.variable/local 1))])) + (////wrap (/.function/apply [expression (list (/.variable/local 1))])) - (#//.Reference reference) + (#/.Reference reference) (case reference (#reference.Variable variable) (case variable (#reference.Local register) - (////wrap (//.variable/local (inc register))) + (////wrap (/.variable/local (inc register))) (#reference.Foreign register) (|> register (find-foreign environment) - (////map (|>> //.variable)))) + (////map (|>> /.variable)))) (#reference.Constant constant) (////wrap expression)) - (#//.Control control) + (#/.Control control) (case control - (#//.Branch branch) + (#/.Branch branch) (case branch - (#//.Let [inputS register bodyS]) + (#/.Let [inputS register bodyS]) (do ///.monad [inputS' (grow environment inputS) bodyS' (grow environment bodyS)] - (wrap (//.branch/let [inputS' (inc register) bodyS']))) + (wrap (/.branch/let [inputS' (inc register) bodyS']))) - (#//.If [testS thenS elseS]) + (#/.If [testS thenS elseS]) (do ///.monad [testS' (grow environment testS) thenS' (grow environment thenS) elseS' (grow environment elseS)] - (wrap (//.branch/if [testS' thenS' elseS']))) + (wrap (/.branch/if [testS' thenS' elseS']))) - (#//.Case [inputS pathS]) + (#/.Case [inputS pathS]) (do ///.monad [inputS' (grow environment inputS) pathS' (grow-path (grow environment) pathS)] - (wrap (//.branch/case [inputS' pathS'])))) + (wrap (/.branch/case [inputS' pathS'])))) - (#//.Loop loop) + (#/.Loop loop) (case loop - (#//.Scope [start initsS+ iterationS]) + (#/.Scope [start initsS+ iterationS]) (do ///.monad [initsS+' (monad.map @ (grow environment) initsS+) iterationS' (grow environment iterationS)] - (wrap (//.loop/scope [start initsS+' iterationS']))) + (wrap (/.loop/scope [start initsS+' iterationS']))) - (#//.Recur argumentsS+) + (#/.Recur argumentsS+) (|> argumentsS+ (monad.map ///.monad (grow environment)) - (////map (|>> //.loop/recur)))) + (////map (|>> /.loop/recur)))) - (#//.Function function) + (#/.Function function) (case function - (#//.Abstraction [_env _arity _body]) + (#/.Abstraction [_env _arity _body]) (do ///.monad [_env' (grow-sub-environment environment _env)] - (wrap (//.function/abstraction [_env' _arity _body]))) + (wrap (/.function/abstraction [_env' _arity _body]))) - (#//.Apply funcS argsS+) + (#/.Apply funcS argsS+) (case funcS - (^ (//.function/apply [(..self-reference) pre-argsS+])) - (////wrap (//.function/apply [(..self-reference) - (list/compose pre-argsS+ argsS+)])) + (^ (/.function/apply [(..self-reference) pre-argsS+])) + (////wrap (/.function/apply [(..self-reference) + (list/compose pre-argsS+ argsS+)])) _ (do ///.monad [funcS' (grow environment funcS) argsS+' (monad.map @ (grow environment) argsS+)] - (wrap (//.function/apply [funcS' argsS+'])))))) + (wrap (/.function/apply [funcS' argsS+'])))))) - (#//.Extension name argumentsS+) + (#/.Extension name argumentsS+) (|> argumentsS+ (monad.map ///.monad (grow environment)) - (////map (|>> (#//.Extension name)))) + (////map (|>> (#/.Extension name)))) _ (////wrap expression))) @@ -202,10 +203,10 @@ (do ///.monad [bodyS (phase bodyA)] (case bodyS - (^ (//.function/abstraction [env' down-arity' bodyS'])) + (^ (/.function/abstraction [env' down-arity' bodyS'])) (|> bodyS' (grow env') - (:: @ map (|>> [environment (inc down-arity')] //.function/abstraction))) + (:: @ map (|>> [environment (inc down-arity')] /.function/abstraction))) _ - (wrap (//.function/abstraction [environment 1 bodyS]))))) + (wrap (/.function/abstraction [environment 1 bodyS]))))) diff --git a/stdlib/source/lux/tool/compiler/phase/synthesis/loop.lux b/stdlib/source/lux/tool/compiler/phase/synthesis/loop.lux index 8e0d51cd8..ecf13440b 100644 --- a/stdlib/source/lux/tool/compiler/phase/synthesis/loop.lux +++ b/stdlib/source/lux/tool/compiler/phase/synthesis/loop.lux @@ -10,12 +10,13 @@ [macro ["." code] ["." syntax]]] - ["." // (#+ Path Abstraction Synthesis) + [/// + ## TODO: Remove the 'extension' import ASAP. + ["///." extension] [// - ["." extension] - [// - ["." reference (#+ Register Variable)] - ["." analysis (#+ Environment)]]]]) + ["." reference (#+ Register Variable)] + ["." analysis (#+ Environment)] + ["/" synthesis (#+ Path Abstraction Synthesis)]]]) (type: #export (Transform a) (-> a (Maybe a))) @@ -27,10 +28,10 @@ #.None #0)) (template: #export (self) - (#//.Reference (reference.local 0))) + (#/.Reference (reference.local 0))) (template: (recursive-apply args) - (#//.Apply (self) args)) + (#/.Apply (self) args)) (def: improper #0) (def: proper #1) @@ -41,7 +42,7 @@ (^ (self)) improper - (#//.Structure structure) + (#/.Structure structure) (case structure (#analysis.Variant variantS) (proper? (get@ #analysis.value variantS)) @@ -49,51 +50,51 @@ (#analysis.Tuple membersS+) (list.every? proper? membersS+)) - (#//.Control controlS) + (#/.Control controlS) (case controlS - (#//.Branch branchS) + (#/.Branch branchS) (case branchS - (#//.Case inputS pathS) + (#/.Case inputS pathS) (and (proper? inputS) (.loop [pathS pathS] (case pathS - (^or (#//.Alt leftS rightS) (#//.Seq leftS rightS)) + (^or (#/.Alt leftS rightS) (#/.Seq leftS rightS)) (and (recur leftS) (recur rightS)) - (#//.Then bodyS) + (#/.Then bodyS) (proper? bodyS) _ proper))) - (#//.Let inputS register bodyS) + (#/.Let inputS register bodyS) (and (proper? inputS) (proper? bodyS)) - (#//.If inputS thenS elseS) + (#/.If inputS thenS elseS) (and (proper? inputS) (proper? thenS) (proper? elseS))) - (#//.Loop loopS) + (#/.Loop loopS) (case loopS - (#//.Scope scopeS) - (and (list.every? proper? (get@ #//.inits scopeS)) - (proper? (get@ #//.iteration scopeS))) + (#/.Scope scopeS) + (and (list.every? proper? (get@ #/.inits scopeS)) + (proper? (get@ #/.iteration scopeS))) - (#//.Recur argsS) + (#/.Recur argsS) (list.every? proper? argsS)) - (#//.Function functionS) + (#/.Function functionS) (case functionS - (#//.Abstraction environment arity bodyS) + (#/.Abstraction environment arity bodyS) (list.every? reference.self? environment) - (#//.Apply funcS argsS) + (#/.Apply funcS argsS) (and (proper? funcS) (list.every? proper? argsS)))) - (#//.Extension [name argsS]) + (#/.Extension [name argsS]) (list.every? proper? argsS) _ @@ -103,20 +104,20 @@ (-> (Transform Synthesis) (Transform Path)) (function (recur pathS) (case pathS - (#//.Alt leftS rightS) + (#/.Alt leftS rightS) (let [leftS' (recur leftS) rightS' (recur rightS)] (if (or (some? leftS') (some? rightS')) - (#.Some (#//.Alt (maybe.default leftS leftS') - (maybe.default rightS rightS'))) + (#.Some (#/.Alt (maybe.default leftS leftS') + (maybe.default rightS rightS'))) #.None)) - (#//.Seq leftS rightS) - (maybe/map (|>> (#//.Seq leftS)) (recur rightS)) + (#/.Seq leftS rightS) + (maybe/map (|>> (#/.Seq leftS)) (recur rightS)) - (#//.Then bodyS) - (maybe/map (|>> #//.Then) (synthesis-recursion bodyS)) + (#/.Then bodyS) + (maybe/map (|>> #/.Then) (synthesis-recursion bodyS)) _ #.None))) @@ -125,33 +126,33 @@ (-> Nat (Transform Synthesis)) (function (recur exprS) (case exprS - (#//.Control controlS) + (#/.Control controlS) (case controlS - (#//.Branch branchS) + (#/.Branch branchS) (case branchS - (#//.Case inputS pathS) + (#/.Case inputS pathS) (|> pathS (path-recursion recur) - (maybe/map (|>> (#//.Case inputS) #//.Branch #//.Control))) + (maybe/map (|>> (#/.Case inputS) #/.Branch #/.Control))) - (#//.Let inputS register bodyS) - (maybe/map (|>> (#//.Let inputS register) #//.Branch #//.Control) + (#/.Let inputS register bodyS) + (maybe/map (|>> (#/.Let inputS register) #/.Branch #/.Control) (recur bodyS)) - (#//.If inputS thenS elseS) + (#/.If inputS thenS elseS) (let [thenS' (recur thenS) elseS' (recur elseS)] (if (or (some? thenS') (some? elseS')) - (#.Some (|> (#//.If inputS - (maybe.default thenS thenS') - (maybe.default elseS elseS')) - #//.Branch #//.Control)) + (#.Some (|> (#/.If inputS + (maybe.default thenS thenS') + (maybe.default elseS elseS')) + #/.Branch #/.Control)) #.None))) - (^ (#//.Function (recursive-apply argsS))) + (^ (#/.Function (recursive-apply argsS))) (if (n/= arity (list.size argsS)) - (#.Some (|> argsS #//.Recur #//.Loop #//.Control)) + (#.Some (|> argsS #/.Recur #/.Loop #/.Control)) #.None) _ @@ -174,8 +175,8 @@ (-> (Transform Synthesis) Register (Transform Path)) (function (recur pathS) (case pathS - (#//.Bind register) - (#.Some (#//.Bind (n/+ offset register))) + (#/.Bind register) + (#.Some (#/.Bind (n/+ offset register))) (^template [<tag>] (<tag> leftS rightS) @@ -183,10 +184,10 @@ [leftS' (recur leftS) rightS' (recur rightS)] (wrap (<tag> leftS' rightS')))) - ([#//.Alt] [#//.Seq]) + ([#/.Alt] [#/.Seq]) - (#//.Then bodyS) - (|> bodyS adjust-synthesis (maybe/map (|>> #//.Then))) + (#/.Then bodyS) + (|> bodyS adjust-synthesis (maybe/map (|>> #/.Then))) _ (#.Some pathS)))) @@ -195,7 +196,7 @@ (-> Environment Register (Transform Synthesis)) (function (recur exprS) (case exprS - (#//.Structure structureS) + (#/.Structure structureS) (case structureS (#analysis.Variant variantS) (do maybe.monad @@ -203,89 +204,89 @@ (wrap (|> variantS (set@ #analysis.value valueS') #analysis.Variant - #//.Structure))) + #/.Structure))) (#analysis.Tuple membersS+) (|> membersS+ (monad.map maybe.monad recur) - (maybe/map (|>> #analysis.Tuple #//.Structure)))) + (maybe/map (|>> #analysis.Tuple #/.Structure)))) - (#//.Reference reference) + (#/.Reference reference) (case reference (^ (reference.constant constant)) (#.Some exprS) (^ (reference.local register)) - (#.Some (#//.Reference (reference.local (n/+ offset register)))) + (#.Some (#/.Reference (reference.local (n/+ offset register)))) (^ (reference.foreign register)) (|> scope-environment (list.nth register) - (maybe/map (|>> #reference.Variable #//.Reference)))) + (maybe/map (|>> #reference.Variable #/.Reference)))) - (^ (//.branch/case [inputS pathS])) + (^ (/.branch/case [inputS pathS])) (do maybe.monad [inputS' (recur inputS) pathS' (adjust-path recur offset pathS)] - (wrap (|> pathS' [inputS'] //.branch/case))) + (wrap (|> pathS' [inputS'] /.branch/case))) - (^ (//.branch/let [inputS register bodyS])) + (^ (/.branch/let [inputS register bodyS])) (do maybe.monad [inputS' (recur inputS) bodyS' (recur bodyS)] - (wrap (//.branch/let [inputS' register bodyS']))) + (wrap (/.branch/let [inputS' register bodyS']))) - (^ (//.branch/if [inputS thenS elseS])) + (^ (/.branch/if [inputS thenS elseS])) (do maybe.monad [inputS' (recur inputS) thenS' (recur thenS) elseS' (recur elseS)] - (wrap (//.branch/if [inputS' thenS' elseS']))) + (wrap (/.branch/if [inputS' thenS' elseS']))) - (^ (//.loop/scope scopeS)) + (^ (/.loop/scope scopeS)) (do maybe.monad [inits' (|> scopeS - (get@ #//.inits) + (get@ #/.inits) (monad.map maybe.monad recur)) - iteration' (recur (get@ #//.iteration scopeS))] - (wrap (//.loop/scope {#//.start (|> scopeS (get@ #//.start) (n/+ offset)) - #//.inits inits' - #//.iteration iteration'}))) + iteration' (recur (get@ #/.iteration scopeS))] + (wrap (/.loop/scope {#/.start (|> scopeS (get@ #/.start) (n/+ offset)) + #/.inits inits' + #/.iteration iteration'}))) - (^ (//.loop/recur argsS)) + (^ (/.loop/recur argsS)) (|> argsS (monad.map maybe.monad recur) - (maybe/map (|>> //.loop/recur))) + (maybe/map (|>> /.loop/recur))) - (^ (//.function/abstraction [environment arity bodyS])) + (^ (/.function/abstraction [environment arity bodyS])) (do maybe.monad [environment' (monad.map maybe.monad (resolve scope-environment) environment)] - (wrap (//.function/abstraction [environment' arity bodyS]))) + (wrap (/.function/abstraction [environment' arity bodyS]))) - (^ (//.function/apply [function arguments])) + (^ (/.function/apply [function arguments])) (do maybe.monad [function' (recur function) arguments' (monad.map maybe.monad recur arguments)] - (wrap (//.function/apply [function' arguments']))) + (wrap (/.function/apply [function' arguments']))) - (#//.Extension [name argsS]) + (#/.Extension [name argsS]) (|> argsS (monad.map maybe.monad recur) - (maybe/map (|>> [name] #//.Extension))) + (maybe/map (|>> [name] #/.Extension))) _ (#.Some exprS)))) (def: #export (loop environment num-locals inits functionS) (-> Environment Nat (List Synthesis) Abstraction (Maybe Synthesis)) - (let [bodyS (get@ #//.body functionS)] + (let [bodyS (get@ #/.body functionS)] (if (and (n/= (list.size inits) - (get@ #//.arity functionS)) + (get@ #/.arity functionS)) (proper? bodyS)) (|> bodyS (adjust environment num-locals) - (maybe/map (|>> [(inc num-locals) inits] //.loop/scope))) + (maybe/map (|>> [(inc num-locals) inits] /.loop/scope))) #.None))) diff --git a/stdlib/source/lux/tool/compiler/phase/translation.lux b/stdlib/source/lux/tool/compiler/phase/translation.lux index 6ee7f3841..99a4c5517 100644 --- a/stdlib/source/lux/tool/compiler/phase/translation.lux +++ b/stdlib/source/lux/tool/compiler/phase/translation.lux @@ -1,8 +1,8 @@ (.module: [lux #* [control - ["ex" exception (#+ exception:)] - [monad (#+ do)]] + [monad (#+ do)] + ["." exception (#+ exception:)]] [data ["." product] ["." error (#+ Error)] @@ -15,8 +15,9 @@ [world [file (#+ Path)]]] ["." // - [synthesis (#+ Synthesis)] - ["." extension]]) + ["." extension] + [// + [synthesis (#+ Synthesis)]]]) (do-template [<name>] [(exception: #export (<name>) @@ -27,21 +28,25 @@ ) (exception: #export (cannot-interpret {error Text}) - (ex.report ["Error" error])) + (exception.report + ["Error" error])) (exception: #export (unknown-lux-name {name Name}) - (ex.report ["Name" (%name name)])) + (exception.report + ["Name" (%name name)])) (exception: #export (cannot-overwrite-lux-name {lux-name Name} {old-host-name Text} {new-host-name Text}) - (ex.report ["Lux Name" (%name lux-name)] - ["Old Host Name" old-host-name] - ["New Host Name" new-host-name])) + (exception.report + ["Lux Name" (%name lux-name)] + ["Old Host Name" old-host-name] + ["New Host Name" new-host-name])) (do-template [<name>] [(exception: #export (<name> {name Name}) - (ex.report ["Output" (%name name)]))] + (exception.report + ["Output" (%name name)]))] [cannot-overwrite-output] [no-buffer-for-saving-code] @@ -141,7 +146,7 @@ (#error.Success [stateE output]) #.None - (ex.throw <exception> []))))] + (exception.throw <exception> []))))] [#anchor (with-anchor anchor) @@ -181,7 +186,7 @@ (#error.Success [state+ output]) (#error.Failure error) - (ex.throw cannot-interpret error))))] + (exception.throw cannot-interpret error))))] [evaluate! expression] [execute! statement] @@ -196,7 +201,7 @@ (#error.Success [stateE output]) (#error.Failure error) - (ex.throw cannot-interpret error)))) + (exception.throw cannot-interpret error)))) (def: #export (save! name code) (All [anchor expression statement] @@ -231,7 +236,7 @@ (#error.Success [stateE host-name]) #.None - (ex.throw unknown-lux-name lux-name))))) + (exception.throw unknown-lux-name lux-name))))) (def: #export (learn lux-name host-name) (All [anchor expression statement] @@ -247,4 +252,4 @@ []]) (#.Some old-host-name) - (ex.throw cannot-overwrite-lux-name [lux-name old-host-name host-name]))))) + (exception.throw cannot-overwrite-lux-name [lux-name old-host-name host-name]))))) diff --git a/stdlib/source/lux/tool/compiler/phase/translation/common/reference.lux b/stdlib/source/lux/tool/compiler/phase/translation/common/reference.lux index 7cd24b23d..af676ad85 100644 --- a/stdlib/source/lux/tool/compiler/phase/translation/common/reference.lux +++ b/stdlib/source/lux/tool/compiler/phase/translation/common/reference.lux @@ -9,8 +9,8 @@ [// ["/." // ["//." // ("#/." monad) - [synthesis (#+ Synthesis)] [// + [synthesis (#+ Synthesis)] ["." reference (#+ Register Variable Reference)]]]]]) (signature: #export (System expression) diff --git a/stdlib/source/lux/tool/compiler/phase/translation/js/case.lux b/stdlib/source/lux/tool/compiler/phase/translation/js/case.lux index 499486ff9..d989cb223 100644 --- a/stdlib/source/lux/tool/compiler/phase/translation/js/case.lux +++ b/stdlib/source/lux/tool/compiler/phase/translation/js/case.lux @@ -19,9 +19,9 @@ [common ["common-." reference]] ["//." // ("#/." monad) - ["." synthesis (#+ Synthesis Path)] [// - [reference (#+ Register)]]]]]) + [reference (#+ Register)] + ["." synthesis (#+ Synthesis Path)]]]]]) (def: #export register (common-reference.local _.var)) diff --git a/stdlib/source/lux/tool/compiler/phase/translation/js/expression.lux b/stdlib/source/lux/tool/compiler/phase/translation/js/expression.lux index 76b206124..822f51e35 100644 --- a/stdlib/source/lux/tool/compiler/phase/translation/js/expression.lux +++ b/stdlib/source/lux/tool/compiler/phase/translation/js/expression.lux @@ -11,8 +11,9 @@ ["." case] ["." loop] ["." /// - ["." synthesis] - ["." extension]]]) + ["." extension] + [// + ["." synthesis]]]]) (def: #export (translate synthesis) Phase diff --git a/stdlib/source/lux/tool/compiler/phase/translation/js/extension/common.lux b/stdlib/source/lux/tool/compiler/phase/translation/js/extension/common.lux index 3cf3fbc27..85bdb64ba 100644 --- a/stdlib/source/lux/tool/compiler/phase/translation/js/extension/common.lux +++ b/stdlib/source/lux/tool/compiler/phase/translation/js/extension/common.lux @@ -19,9 +19,10 @@ ["///." runtime (#+ Operation Phase Handler Bundle)] ["///." primitive] ["//." /// - ["." synthesis (#+ Synthesis)] ["." extension - ["." bundle]]]]) + ["." bundle]] + [// + ["." synthesis (#+ Synthesis)]]]]) (syntax: (Vector {size s.nat} elemT) (wrap (list (` [(~+ (list.repeat size elemT))])))) diff --git a/stdlib/source/lux/tool/compiler/phase/translation/js/extension/host.lux b/stdlib/source/lux/tool/compiler/phase/translation/js/extension/host.lux index 637cadc5f..8091f7fee 100644 --- a/stdlib/source/lux/tool/compiler/phase/translation/js/extension/host.lux +++ b/stdlib/source/lux/tool/compiler/phase/translation/js/extension/host.lux @@ -13,9 +13,10 @@ [// ["///." runtime (#+ Handler Bundle)] ["//." /// - ["." synthesis] ["." extension - ["." bundle]]]]]) + ["." bundle]] + [// + ["." synthesis]]]]]) (do-template [<name> <js>] [(def: (<name> _) Nullary <js>)] diff --git a/stdlib/source/lux/tool/compiler/phase/translation/js/function.lux b/stdlib/source/lux/tool/compiler/phase/translation/js/function.lux index 89536c579..5727b737d 100644 --- a/stdlib/source/lux/tool/compiler/phase/translation/js/function.lux +++ b/stdlib/source/lux/tool/compiler/phase/translation/js/function.lux @@ -19,10 +19,10 @@ [common ["common-." reference]] ["//." // ("#/." monad) - [synthesis (#+ Synthesis)] [// [reference (#+ Register Variable)] [analysis (#+ Variant Tuple Environment Arity Abstraction Application Analysis)] + [synthesis (#+ Synthesis)] ["." name]]]]]) (def: #export (apply translate [functionS argsS+]) diff --git a/stdlib/source/lux/tool/compiler/phase/translation/js/loop.lux b/stdlib/source/lux/tool/compiler/phase/translation/js/loop.lux index 8d0cefe4e..cbb032153 100644 --- a/stdlib/source/lux/tool/compiler/phase/translation/js/loop.lux +++ b/stdlib/source/lux/tool/compiler/phase/translation/js/loop.lux @@ -16,7 +16,8 @@ ["//." case] ["/." // ["//." // - [synthesis (#+ Scope Synthesis)]]]]) + [// + [synthesis (#+ Scope Synthesis)]]]]]) (def: @scope (_.var "scope")) diff --git a/stdlib/source/lux/tool/compiler/phase/translation/js/runtime.lux b/stdlib/source/lux/tool/compiler/phase/translation/js/runtime.lux index e2014c064..5a37cb8ef 100644 --- a/stdlib/source/lux/tool/compiler/phase/translation/js/runtime.lux +++ b/stdlib/source/lux/tool/compiler/phase/translation/js/runtime.lux @@ -17,9 +17,9 @@ ["_" js (#+ Expression Var Computation Statement)]]] ["." /// ["//." // - ["." synthesis] [// - ["/////." name]]]] + ["/////." name] + ["." synthesis]]]] ) (do-template [<name> <base>] diff --git a/stdlib/source/lux/tool/compiler/phase/translation/js/structure.lux b/stdlib/source/lux/tool/compiler/phase/translation/js/structure.lux index 8af864654..732f48bb9 100644 --- a/stdlib/source/lux/tool/compiler/phase/translation/js/structure.lux +++ b/stdlib/source/lux/tool/compiler/phase/translation/js/structure.lux @@ -8,9 +8,9 @@ ["//." runtime (#+ Operation Phase)] ["//." primitive] ["/." /// - ["." synthesis (#+ Synthesis)] [// - [analysis (#+ Variant Tuple)]]]]) + [analysis (#+ Variant Tuple)] + ["." synthesis (#+ Synthesis)]]]]) (def: #export (tuple translate elemsS+) (-> Phase (Tuple Synthesis) (Operation Expression)) diff --git a/stdlib/source/lux/tool/compiler/synthesis.lux b/stdlib/source/lux/tool/compiler/synthesis.lux new file mode 100644 index 000000000..a287caf5e --- /dev/null +++ b/stdlib/source/lux/tool/compiler/synthesis.lux @@ -0,0 +1,468 @@ +(.module: + [lux (#- i64 Scope) + [control + [monad (#+ do)] + [equivalence (#+ Equivalence)] + ["ex" exception (#+ exception:)]] + [data + ["." bit ("#/." equivalence)] + ["." text ("#/." equivalence) + format] + [collection + ["." list ("#/." functor)] + ["." dictionary (#+ Dictionary)]]]] + [// + ["//." reference (#+ Register Variable Reference)] + ["//." analysis (#+ Environment Arity Composite Analysis)] + ["." phase + ["." extension (#+ Extension)]]]) + +(type: #export Resolver (Dictionary Variable Variable)) + +(type: #export State + {#locals Nat}) + +(def: #export fresh-resolver + Resolver + (dictionary.new //reference.hash)) + +(def: #export init + State + {#locals 0}) + +(type: #export Primitive + (#Bit Bit) + (#I64 (I64 Any)) + (#F64 Frac) + (#Text Text)) + +(type: #export Side + (Either Nat Nat)) + +(type: #export Member + (Either Nat Nat)) + +(type: #export Access + (#Side Side) + (#Member Member)) + +(type: #export (Path' s) + #Pop + (#Test Primitive) + (#Access Access) + (#Bind Register) + (#Alt (Path' s) (Path' s)) + (#Seq (Path' s) (Path' s)) + (#Then s)) + +(type: #export (Abstraction' s) + {#environment Environment + #arity Arity + #body s}) + +(type: #export (Apply' s) + {#function s + #arguments (List s)}) + +(type: #export (Branch s) + (#Let s Register s) + (#If s s s) + (#Case s (Path' s))) + +(type: #export (Scope s) + {#start Register + #inits (List s) + #iteration s}) + +(type: #export (Loop s) + (#Scope (Scope s)) + (#Recur (List s))) + +(type: #export (Function s) + (#Abstraction (Abstraction' s)) + (#Apply s (List s))) + +(type: #export (Control s) + (#Branch (Branch s)) + (#Loop (Loop s)) + (#Function (Function s))) + +(type: #export #rec Synthesis + (#Primitive Primitive) + (#Structure (Composite Synthesis)) + (#Reference Reference) + (#Control (Control Synthesis)) + (#Extension (Extension Synthesis))) + +(do-template [<special> <general>] + [(type: #export <special> + (<general> ..State Analysis Synthesis))] + + [State+ extension.State] + [Operation extension.Operation] + [Phase extension.Phase] + [Handler extension.Handler] + [Bundle extension.Bundle] + ) + +(type: #export Path + (Path' Synthesis)) + +(def: #export path/pop + Path + #Pop) + +(do-template [<name> <tag>] + [(template: #export (<name> content) + (#..Test (<tag> content)))] + + [path/bit #..Bit] + [path/i64 #..I64] + [path/f64 #..F64] + [path/text #..Text] + ) + +(do-template [<name> <kind>] + [(template: #export (<name> content) + (.<| #..Access + <kind> + content))] + + [path/side #..Side] + [path/member #..Member] + ) + +(do-template [<name> <kind> <side>] + [(template: #export (<name> content) + (.<| #..Access + <kind> + <side> + content))] + + [side/left #..Side #.Left] + [side/right #..Side #.Right] + [member/left #..Member #.Left] + [member/right #..Member #.Right] + ) + +(do-template [<name> <tag>] + [(template: #export (<name> content) + (<tag> content))] + + [path/bind #..Bind] + [path/then #..Then] + ) + +(do-template [<name> <tag>] + [(template: #export (<name> left right) + (<tag> [left right]))] + + [path/alt #..Alt] + [path/seq #..Seq] + ) + +(type: #export Abstraction + (Abstraction' Synthesis)) + +(type: #export Apply + (Apply' Synthesis)) + +(def: #export unit Text "") + +(do-template [<name> <type> <tag>] + [(def: #export (<name> value) + (-> <type> (All [a] (-> (Operation a) (Operation a)))) + (extension.temporary (set@ <tag> value)))] + + [with-locals Nat #locals] + ) + +(def: #export (with-abstraction arity resolver) + (-> Arity Resolver + (All [a] (-> (Operation a) (Operation a)))) + (extension.with-state {#locals arity})) + +(do-template [<name> <tag> <type>] + [(def: #export <name> + (Operation <type>) + (extension.read (get@ <tag>)))] + + [locals #locals Nat] + ) + +(def: #export with-new-local + (All [a] (-> (Operation a) (Operation a))) + (<<| (do phase.monad + [locals ..locals]) + (..with-locals (inc locals)))) + +(do-template [<name> <tag>] + [(template: #export (<name> content) + (#..Primitive (<tag> content)))] + + [bit #..Bit] + [i64 #..I64] + [f64 #..F64] + [text #..Text] + ) + +(do-template [<name> <tag>] + [(template: #export (<name> content) + (<| #..Structure + <tag> + content))] + + [variant #//analysis.Variant] + [tuple #//analysis.Tuple] + ) + +(do-template [<name> <tag>] + [(template: #export (<name> content) + (.<| #..Reference + <tag> + content))] + + [variable/local //reference.local] + [variable/foreign //reference.foreign] + ) + +(do-template [<name> <tag>] + [(template: #export (<name> content) + (.<| #..Reference + <tag> + content))] + + [variable //reference.variable] + [constant //reference.constant] + ) + +(do-template [<name> <family> <tag>] + [(template: #export (<name> content) + (.<| #..Control + <family> + <tag> + content))] + + [branch/case #..Branch #..Case] + [branch/let #..Branch #..Let] + [branch/if #..Branch #..If] + + [loop/recur #..Loop #..Recur] + [loop/scope #..Loop #..Scope] + + [function/abstraction #..Function #..Abstraction] + [function/apply #..Function #..Apply] + ) + +(def: #export (%path' %then value) + (All [a] (-> (Format a) (Format (Path' a)))) + (case value + #Pop + "_" + + (#Test primitive) + (format "(? " + (case primitive + (#Bit value) + (%b value) + + (#I64 value) + (%i (.int value)) + + (#F64 value) + (%f value) + + (#Text value) + (%t value)) + ")") + + (#Access access) + (case access + (#Side side) + (case side + (#.Left lefts) + (format "(" (%n lefts) " #0" ")") + + (#.Right lefts) + (format "(" (%n lefts) " #1" ")")) + + (#Member member) + (case member + (#.Left lefts) + (format "[" (%n lefts) " #0" "]") + + (#.Right lefts) + (format "[" (%n lefts) " #1" "]"))) + + (#Bind register) + (format "(@ " (%n register) ")") + + (#Alt left right) + (format "(| " (%path' %then left) " " (%path' %then right) ")") + + (#Seq left right) + (format "(& " (%path' %then left) " " (%path' %then right) ")") + + (#Then then) + (|> (%then then) + (text.enclose ["(! " ")"])))) + +(def: #export (%synthesis value) + (Format Synthesis) + (case value + (#Primitive primitive) + (case primitive + (^template [<pattern> <format>] + (<pattern> value) + (<format> value)) + ([#Bit %b] + [#F64 %f] + [#Text %t]) + + (#I64 value) + (%i (.int value))) + + (#Structure structure) + (case structure + (#//analysis.Variant [lefts right? content]) + (|> (%synthesis content) + (format (%n lefts) " " (%b right?) " ") + (text.enclose ["(" ")"])) + + (#//analysis.Tuple members) + (|> members + (list/map %synthesis) + (text.join-with " ") + (text.enclose ["[" "]"]))) + + (#Reference reference) + (|> reference + //reference.%reference + (text.enclose ["(#@ " ")"])) + + (#Control control) + (case control + (#Function function) + (case function + (#Abstraction [environment arity body]) + (|> (%synthesis body) + (format (%n arity) " ") + (format (|> environment + (list/map //reference.%variable) + (text.join-with " ") + (text.enclose ["[" "]"])) + " ") + (text.enclose ["(" ")"])) + + (#Apply func args) + (|> (list/map %synthesis args) + (text.join-with " ") + (format (%synthesis func) " ") + (text.enclose ["(" ")"]))) + + (#Branch branch) + (case branch + (#Let input register body) + (|> (format (%synthesis input) " " (%n register) " " (%synthesis body)) + (text.enclose ["(#let " ")"])) + + (#If test then else) + (|> (format (%synthesis test) " " (%synthesis then) " " (%synthesis else)) + (text.enclose ["(#if " ")"])) + + (#Case input path) + (|> (format (%synthesis input) " " (%path' %synthesis path)) + (text.enclose ["(#case " ")"]))) + + ## (#Loop loop) + _ + "???") + + (#Extension [name args]) + (|> (list/map %synthesis args) + (text.join-with " ") + (format (%t name)) + (text.enclose ["(" ")"])))) + +(def: #export %path + (Format Path) + (%path' %synthesis)) + +(structure: #export primitive-equivalence (Equivalence Primitive) + (def: (= reference sample) + (case [reference sample] + (^template [<tag> <eq> <format>] + [(<tag> reference') (<tag> sample')] + (<eq> reference' sample')) + ([#Bit bit/= %b] + [#F64 f/= %f] + [#Text text/= %t]) + + [(#I64 reference') (#I64 sample')] + (i/= (.int reference') (.int sample')) + + _ + false))) + +(structure: #export access-equivalence (Equivalence Access) + (def: (= reference sample) + (case [reference sample] + (^template [<tag>] + [(<tag> reference') (<tag> sample')] + (case [reference' sample'] + (^template [<side>] + [(<side> reference'') (<side> sample'')] + (n/= reference'' sample'')) + ([#.Left] + [#.Right]) + + _ + false)) + ([#Side] + [#Member]) + + _ + false))) + +(structure: #export (path'-equivalence Equivalence<a>) + (All [a] (-> (Equivalence a) (Equivalence (Path' a)))) + + (def: (= reference sample) + (case [reference sample] + [#Pop #Pop] + true + + (^template [<tag> <equivalence>] + [(<tag> reference') (<tag> sample')] + (:: <equivalence> = reference' sample')) + ([#Test primitive-equivalence] + [#Access access-equivalence] + [#Then Equivalence<a>]) + + [(#Bind reference') (#Bind sample')] + (n/= reference' sample') + + (^template [<tag>] + [(<tag> leftR rightR) (<tag> leftS rightS)] + (and (= leftR leftS) + (= rightR rightS))) + ([#Alt] + [#Seq]) + + _ + false))) + +(structure: #export equivalence (Equivalence Synthesis) + (def: (= reference sample) + (case [reference sample] + (^template [<tag> <equivalence>] + [(<tag> reference') (<tag> sample')] + (:: <equivalence> = reference' sample')) + ([#Primitive primitive-equivalence]) + + _ + false))) + +(def: #export path-equivalence + (Equivalence Path) + (path'-equivalence equivalence)) |