aboutsummaryrefslogtreecommitdiff
path: root/stdlib
diff options
context:
space:
mode:
Diffstat (limited to '')
-rw-r--r--stdlib/source/lux/lang/compiler.lux46
-rw-r--r--stdlib/source/lux/lang/extension.lux13
-rw-r--r--stdlib/source/lux/lang/synthesis.lux118
-rw-r--r--stdlib/source/lux/lang/synthesis/case.lux51
-rw-r--r--stdlib/source/lux/lang/synthesis/expression.lux17
-rw-r--r--stdlib/source/lux/lang/synthesis/function.lux19
-rw-r--r--stdlib/test/test/lux/lang/synthesis/case.lux10
-rw-r--r--stdlib/test/test/lux/lang/synthesis/function.lux16
-rw-r--r--stdlib/test/test/lux/lang/synthesis/primitive.lux4
-rw-r--r--stdlib/test/test/lux/lang/synthesis/structure.lux9
10 files changed, 155 insertions, 148 deletions
diff --git a/stdlib/source/lux/lang/compiler.lux b/stdlib/source/lux/lang/compiler.lux
new file mode 100644
index 000000000..c2f9af1e2
--- /dev/null
+++ b/stdlib/source/lux/lang/compiler.lux
@@ -0,0 +1,46 @@
+(.module:
+ lux
+ (lux (control [state]
+ ["ex" exception #+ Exception exception:]
+ [monad #+ do])
+ (data [product]
+ [error #+ Error])
+ [function]))
+
+(type: #export (Operation s o)
+ (state.State' Error s o))
+
+(def: #export (run state operation)
+ (All [s o]
+ (-> s (Operation s o) (Error o)))
+ (|> state
+ operation
+ (:: error.Monad<Error> map product.right)))
+
+(def: #export (throw exception parameters)
+ (All [e] (-> (Exception e) e Operation))
+ (state.lift error.Monad<Error>
+ (ex.throw exception parameters)))
+
+(def: #export (localized transform)
+ (All [s o]
+ (-> (-> s s)
+ (-> (Operation s o) (Operation s o))))
+ (function (_ operation)
+ (function (_ state)
+ (case (operation (transform state))
+ (#error.Error error)
+ (#error.Error error)
+
+ (#error.Success [state' output])
+ (#error.Success [state output])))))
+
+(def: #export (with-state state)
+ (All [s o] (-> s (-> (Operation s o) (Operation s o))))
+ (localized (function.constant state)))
+
+(def: #export Monad<Operation>
+ (state.Monad<State'> error.Monad<Error>))
+
+(type: #export (Compiler s i o)
+ (-> i (Operation s o)))
diff --git a/stdlib/source/lux/lang/extension.lux b/stdlib/source/lux/lang/extension.lux
index 6da453148..d9eb90fc9 100644
--- a/stdlib/source/lux/lang/extension.lux
+++ b/stdlib/source/lux/lang/extension.lux
@@ -7,8 +7,9 @@
(coll (dictionary ["dict" unordered #+ Dict])))
[macro])
[// #+ Eval]
- (// [".L" analysis #+ Analyser]
- [".L" synthesis #+ Synthesizer]))
+ [//compiler #+ Operation Compiler]
+ [//analysis #+ Analyser]
+ [//synthesis #+ Synthesizer])
(do-template [<name>]
[(exception: #export (<name> {message Text})
@@ -26,11 +27,13 @@
)
(type: #export Analysis
- (-> Analyser Eval (List Code) (Meta analysisL.Analysis)))
+ (-> Analyser Eval (List Code) (Meta //analysis.Analysis)))
(type: #export Synthesis
- (-> Synthesizer (List analysisL.Analysis)
- (synthesisL.Operation synthesisL.Synthesis)))
+ (-> Synthesizer
+ (Compiler //synthesis.State
+ (List //analysis.Analysis)
+ //synthesis.Synthesis)))
(type: #export Translation
(-> (List Code) (Meta Code)))
diff --git a/stdlib/source/lux/lang/synthesis.lux b/stdlib/source/lux/lang/synthesis.lux
index d68b535dc..359ef445a 100644
--- a/stdlib/source/lux/lang/synthesis.lux
+++ b/stdlib/source/lux/lang/synthesis.lux
@@ -1,15 +1,11 @@
(.module:
[lux #- Scope]
- (lux (control [state]
- ["ex" exception #+ Exception exception:]
- [monad #+ do])
- (data [product]
- [error #+ Error]
- [number]
- (coll (dictionary ["dict" unordered #+ Dict])))
- [function])
+ (lux (control [monad #+ do])
+ (data [error #+ Error]
+ (coll (dictionary ["dict" unordered #+ Dict]))))
[//reference #+ Register Variable Reference]
- [//analysis #+ Environment Special Analysis])
+ [//analysis #+ Environment Special Analysis]
+ [//compiler #+ Operation Compiler])
(type: #export Arity Nat)
@@ -32,12 +28,6 @@
#direct? false
#locals +0})
-(type: (Operation' s o)
- (state.State' Error s o))
-
-(type: #export (Compiler s i o)
- (-> i (Operation' ..State o)))
-
(type: #export Primitive
(#Bool Bool)
(#I64 I64)
@@ -132,84 +122,42 @@
(type: #export Abstraction
(Abstraction' Synthesis))
-(type: #export (Operation a)
- (Operation' ..State a))
-
(def: #export unit Text "")
(type: #export Synthesizer
(Compiler ..State Analysis Synthesis))
-(def: #export (throw exception parameters)
- (All [e] (-> (Exception e) e Operation'))
- (state.lift error.Monad<Error>
- (ex.throw exception parameters)))
-
-(def: #export (run synthesizer analysis)
- (-> Synthesizer Analysis (Error Synthesis))
- (:: error.Monad<Error> map product.right
- (synthesizer analysis ..init)))
-
-(def: (localized' transform)
- (-> (-> State State)
- (All [a] (-> (Operation a) (Operation a))))
- (function (_ operation)
- (function (_ state)
- (case (operation (transform state))
- (#error.Error error)
- (#error.Error error)
-
- (#error.Success [state' output])
- (#error.Success [state output])))))
-
-(def: (localized transform)
- (-> (-> State State)
- (-> Synthesizer Synthesizer))
- (function (_ synthesize)
- (function (_ analysis)
- (localized' transform (synthesize analysis)))))
-
-(do-template [<operation> <synthesizer> <value>]
- [(def: #export <operation>
- (All [a] (-> (Operation a) (Operation a)))
- (localized' (set@ #direct? <value>)))
-
- (def: #export <synthesizer>
- (-> Synthesizer Synthesizer)
- (localized (set@ #direct? <value>)))]
-
- [indirectly' indirectly false]
- [directly' directly true]
- )
+(do-template [<name> <value>]
+ [(def: #export <name>
+ (All [a] (-> (Operation ..State a) (Operation ..State a)))
+ (//compiler.localized (set@ #direct? <value>)))]
-(do-template [<operation> <synthesizer> <type> <tag>]
- [(def: #export (<operation> value)
- (-> <type> (All [a] (-> (Operation a) (Operation a))))
- (localized' (set@ <tag> value)))
+ [indirectly false]
+ [directly true]
+ )
- (def: #export (<synthesizer> value)
- (-> <type> (-> Synthesizer Synthesizer))
- (localized (set@ <tag> value)))]
+(do-template [<name> <type> <tag>]
+ [(def: #export (<name> value)
+ (-> <type> (All [a] (-> (Operation ..State a) (Operation ..State a))))
+ (//compiler.localized (set@ <tag> value)))]
- [with-scope-arity' with-scope-arity Arity #scope-arity]
- [with-resolver' with-resolver Resolver #resolver]
- [with-locals' with-locals Nat #locals]
+ [with-scope-arity Arity #scope-arity]
+ [with-resolver Resolver #resolver]
+ [with-locals Nat #locals]
)
-(def: #export (with-state value)
- (-> ..State (-> Synthesizer Synthesizer))
- (localized (function.constant value)))
-
-(def: #export (with-abstraction-state arity resolver)
- (-> Arity Resolver (-> Synthesizer Synthesizer))
- (with-state {#scope-arity arity
- #resolver resolver
- #direct? true
- #locals arity}))
+(def: #export (with-abstraction arity resolver)
+ (All [o]
+ (-> Arity Resolver
+ (-> (Operation ..State o) (Operation ..State o))))
+ (//compiler.with-state {#scope-arity arity
+ #resolver resolver
+ #direct? true
+ #locals arity}))
(do-template [<name> <tag> <type>]
[(def: #export <name>
- (Operation <type>)
+ (Operation ..State <type>)
(function (_ state)
(#error.Success [state (get@ <tag> state)])))]
@@ -219,13 +167,11 @@
[locals #locals Nat]
)
-(def: #export Operation@Monad (state.Monad<State'> error.Monad<Error>))
-
-(def: #export with-new-local'
- (All [a] (-> (Operation a) (Operation a)))
- (<<| (do Operation@Monad
+(def: #export with-new-local
+ (All [a] (-> (Operation ..State a) (Operation ..State a)))
+ (<<| (do //compiler.Monad<Operation>
[locals ..locals])
- (..with-locals' (inc locals))))
+ (..with-locals (inc locals))))
(do-template [<name> <tag>]
[(template: #export (<name> content)
diff --git a/stdlib/source/lux/lang/synthesis/case.lux b/stdlib/source/lux/lang/synthesis/case.lux
index 5fe32e62d..85065393d 100644
--- a/stdlib/source/lux/lang/synthesis/case.lux
+++ b/stdlib/source/lux/lang/synthesis/case.lux
@@ -10,12 +10,13 @@
[number "frac/" Eq<Frac>]
(coll [list "list/" Fold<List> Monoid<List>])))
[///reference]
+ [///compiler #+ Operation "operation/" Monad<Operation>]
[///analysis #+ Pattern Match Analysis]
- [// #+ Path Synthesis Operation]
+ [// #+ Path Synthesis]
[//function])
(def: (path' pattern bodyC)
- (-> Pattern (Operation Path) (Operation Path))
+ (-> Pattern (Operation //.State Path) (Operation //.State Path))
(case pattern
(#///analysis.Simple simple)
(case simple
@@ -24,9 +25,8 @@
(^template [<from> <to>]
(<from> value)
- (:: //.Operation@Monad map
- (|>> (#//.Seq (#//.Test (|> value <to>))))
- bodyC))
+ (operation/map (|>> (#//.Seq (#//.Test (|> value <to>))))
+ bodyC))
([#///analysis.Bool #//.Bool]
[#///analysis.Nat (<| #//.I64 .i64)]
[#///analysis.Int (<| #//.I64 .i64)]
@@ -35,21 +35,21 @@
[#///analysis.Text #//.Text]))
(#///analysis.Bind register)
- (do //.Operation@Monad
- [arity //.scope-arity]
- (:: @ map (|>> (#//.Seq (#//.Bind (if (//function.nested? arity)
- (n/+ (dec arity) register)
- register))))
- (//.with-new-local' bodyC)))
+ (<| (do ///compiler.Monad<Operation>
+ [arity //.scope-arity])
+ (:: @ map (|>> (#//.Seq (#//.Bind (if (//function.nested? arity)
+ (n/+ (dec arity) register)
+ register)))))
+ //.with-new-local
+ bodyC)
(#///analysis.Complex _)
(case (///analysis.variant-pattern pattern)
(#.Some [lefts right? value-pattern])
- (:: //.Operation@Monad map
- (|>> (#//.Seq (#//.Access (#//.Side (if right?
- (#.Right lefts)
- (#.Left lefts))))))
- (path' value-pattern bodyC))
+ (operation/map (|>> (#//.Seq (#//.Access (#//.Side (if right?
+ (#.Right lefts)
+ (#.Left lefts))))))
+ (path' value-pattern bodyC))
#.None
(let [tuple (///analysis.tuple-pattern pattern)
@@ -64,18 +64,17 @@
(|> (if (or last?
(is? bodyC thenC))
thenC
- (:: //.Operation@Monad map (|>> (#//.Seq #//.Pop)) thenC))
+ (operation/map (|>> (#//.Seq #//.Pop)) thenC))
(path' tuple/member)
- (:: //.Operation@Monad map
- (|>> (#//.Seq (#//.Access (#//.Member (if last?
- (#.Right (dec tuple/idx))
- (#.Left tuple/idx)))))))))))
+ (operation/map (|>> (#//.Seq (#//.Access (#//.Member (if last?
+ (#.Right (dec tuple/idx))
+ (#.Left tuple/idx)))))))))))
bodyC
(list.reverse (list.enumerate tuple)))))))
(def: #export (path synthesize pattern bodyA)
- (-> //.Synthesizer Pattern Analysis (Operation Path))
- (path' pattern (:: //.Operation@Monad map (|>> #//.Then) (synthesize bodyA))))
+ (-> //.Synthesizer Pattern Analysis (Operation //.State Path))
+ (path' pattern (operation/map (|>> #//.Then) (synthesize bodyA))))
(def: #export (weave leftP rightP)
(-> Path Path Path)
@@ -124,8 +123,8 @@
<default>)))
(def: #export (synthesize synthesize^ inputA [headB tailB+])
- (-> //.Synthesizer Analysis Match (Operation Synthesis))
- (do //.Operation@Monad
+ (-> //.Synthesizer Analysis Match (Operation //.State Synthesis))
+ (do ///compiler.Monad<Operation>
[inputS (synthesize^ inputA)]
(case [headB tailB+]
[[(#///analysis.Bind inputR) headB/bodyA]
@@ -139,7 +138,7 @@
_
(do @
[arity //.scope-arity
- headB/bodyS (//.with-new-local'
+ headB/bodyS (//.with-new-local
(synthesize^ headB/bodyA))]
(wrap (//.branch/let [inputS
(if (//function.nested? arity)
diff --git a/stdlib/source/lux/lang/synthesis/expression.lux b/stdlib/source/lux/lang/synthesis/expression.lux
index aab092777..2985d2d08 100644
--- a/stdlib/source/lux/lang/synthesis/expression.lux
+++ b/stdlib/source/lux/lang/synthesis/expression.lux
@@ -6,6 +6,7 @@
(coll [list "list/" Functor<List>]
(dictionary ["dict" unordered #+ Dict]))))
[///reference]
+ [///compiler "operation/" Monad<Operation>]
[///analysis #+ Analysis]
[///extension #+ Extension]
[// #+ Synthesis]
@@ -35,8 +36,6 @@
[#///analysis.Int #//.I64]
[#///analysis.Deg #//.I64])))
-(open: "operation/" //.Operation@Monad)
-
(def: #export (synthesizer extensions)
(-> (Extension ///extension.Synthesis) //.Synthesizer)
(function (synthesize analysis)
@@ -47,17 +46,17 @@
(#///analysis.Structure composite)
(case (///analysis.variant analysis)
(#.Some variant)
- (do //.Operation@Monad
+ (do ///compiler.Monad<Operation>
[valueS (synthesize (get@ #///analysis.value variant))]
(wrap (#//.Structure (#//.Variant (set@ #///analysis.value valueS variant)))))
_
- (do //.Operation@Monad
+ (do ///compiler.Monad<Operation>
[tupleS (monad.map @ synthesize (///analysis.tuple analysis))]
(wrap (#//.Structure (#//.Tuple tupleS)))))
(#///analysis.Apply _)
- (//function.apply (//.indirectly synthesize) analysis)
+ (//function.apply (|>> synthesize //.indirectly) analysis)
(#///analysis.Function environmentA bodyA)
(//function.function synthesize environmentA bodyA)
@@ -65,10 +64,10 @@
(#///analysis.Special name args)
(case (dict.get name extensions)
#.None
- (//.throw unknown-synthesis-extension name)
+ (///compiler.throw unknown-synthesis-extension name)
(#.Some extension)
- (extension (//.indirectly synthesize) args))
+ (extension (|>> synthesize //.indirectly) args))
(#///analysis.Reference reference)
(case reference
@@ -76,7 +75,7 @@
(operation/wrap (#//.Reference reference))
(#///reference.Variable var)
- (do //.Operation@Monad
+ (do ///compiler.Monad<Operation>
[resolver //.resolver]
(case var
(#///reference.Local register)
@@ -96,5 +95,5 @@
(wrap (|> resolver (dict.get var) (maybe.default var) #///reference.Variable #//.Reference)))))
(#///analysis.Case inputA branchesAB+)
- (//case.synthesize (//.indirectly synthesize) inputA branchesAB+)
+ (//case.synthesize (|>> synthesize //.indirectly) inputA branchesAB+)
)))
diff --git a/stdlib/source/lux/lang/synthesis/function.lux b/stdlib/source/lux/lang/synthesis/function.lux
index 8014c3b4a..cc40bea4d 100644
--- a/stdlib/source/lux/lang/synthesis/function.lux
+++ b/stdlib/source/lux/lang/synthesis/function.lux
@@ -9,12 +9,11 @@
(coll [list "list/" Functor<List> Monoid<List> Fold<List>]
(dictionary ["dict" unordered #+ Dict]))))
[///reference #+ Variable]
+ [///compiler #+ Operation]
[///analysis #+ Environment Analysis]
[// #+ Arity Synthesis Synthesizer]
[//loop])
-(def: Operation@Monad (state.Monad<State'> error.Monad<Error>))
-
(def: #export nested?
(-> Arity Bool)
(n/> +1))
@@ -72,16 +71,16 @@
"")
(def: return
- (All [a] (-> (Maybe a) (//.Operation a)))
+ (All [a] (-> (Maybe a) (Operation //.State a)))
(|>> (case> (#.Some output)
- (:: Operation@Monad wrap output)
+ (:: ///compiler.Monad<Operation> wrap output)
#.None
- (//.throw cannot-prepare-function-body []))))
+ (///compiler.throw cannot-prepare-function-body []))))
(def: #export (function synthesize environment body)
- (-> Synthesizer Environment Analysis (//.Operation Synthesis))
- (do Operation@Monad
+ (-> Synthesizer Environment Analysis (Operation //.State Synthesis))
+ (do ///compiler.Monad<Operation>
[direct? //.direct?
arity //.scope-arity
resolver //.resolver
@@ -115,9 +114,9 @@
(list/fold (.function (_ var resolver')
(dict.put var var resolver'))
//.fresh-resolver
- down-environment))
- synthesize' (//.with-abstraction-state function-arity resolver' synthesize)]
- bodyS (synthesize' body)]
+ down-environment))]
+ bodyS (//.with-abstraction function-arity resolver'
+ (synthesize body))]
(case bodyS
(^ (//.function/abstraction [env' down-arity' bodyS']))
(let [arity' (inc down-arity')]
diff --git a/stdlib/test/test/lux/lang/synthesis/case.lux b/stdlib/test/test/lux/lang/synthesis/case.lux
index f2541ee0e..228ed2920 100644
--- a/stdlib/test/test/lux/lang/synthesis/case.lux
+++ b/stdlib/test/test/lux/lang/synthesis/case.lux
@@ -4,6 +4,7 @@
pipe)
(data [error "error/" Functor<Error>])
(lang ["///." reference]
+ ["///." compiler]
[".L" analysis #+ Branch Analysis]
["//" synthesis #+ Synthesis]
(synthesis [".S" expression])
@@ -24,7 +25,8 @@
(list)]])]]
(test "Dummy variables created to mask expressions get eliminated during synthesis."
(|> maskA
- (//.run (expressionS.synthesizer extensionL.empty))
+ (expressionS.synthesizer extensionL.empty)
+ (///compiler.run //.init)
(error/map (//primitive.corresponds? maskedA))
(error.default false))))))
@@ -41,7 +43,8 @@
(list)]])]]
(test "Can detect and reify simple 'let' expressions."
(|> letA
- (//.run (expressionS.synthesizer extensionL.empty))
+ (expressionS.synthesizer extensionL.empty)
+ (///compiler.run //.init)
(case> (^ (#error.Success (//.branch/let [inputS registerS outputS])))
(and (n/= registerA registerS)
(//primitive.corresponds? inputA inputS)
@@ -68,7 +71,8 @@
(analysisL.control/case [inputA [elseB (list thenB)]]))]]
(test "Can detect and reify simple 'if' expressions."
(|> ifA
- (//.run (expressionS.synthesizer extensionL.empty))
+ (expressionS.synthesizer extensionL.empty)
+ (///compiler.run //.init)
(case> (^ (#error.Success (//.branch/if [inputS thenS elseS])))
(and (//primitive.corresponds? inputA inputS)
(//primitive.corresponds? thenA thenS)
diff --git a/stdlib/test/test/lux/lang/synthesis/function.lux b/stdlib/test/test/lux/lang/synthesis/function.lux
index c0cfc5587..65a4825e3 100644
--- a/stdlib/test/test/lux/lang/synthesis/function.lux
+++ b/stdlib/test/test/lux/lang/synthesis/function.lux
@@ -12,6 +12,7 @@
(dictionary ["dict" unordered #+ Dict])
(set ["set" unordered])))
(lang ["///." reference #+ Variable "variable/" Equality<Variable>]
+ ["///." compiler]
[".L" analysis #+ Analysis]
["//" synthesis #+ Arity Synthesis]
(synthesis [".S" expression])
@@ -106,7 +107,8 @@
($_ seq
(test "Nested functions will get folded together."
(|> function//constant
- (//.run (expressionS.synthesizer extensionL.empty))
+ (expressionS.synthesizer extensionL.empty)
+ (///compiler.run //.init)
(case> (^ (#error.Success (//.function/abstraction [environment arity output])))
(and (n/= arity//constant arity)
(//primitive.corresponds? prediction//constant output))
@@ -115,7 +117,8 @@
(n/= +0 arity//constant))))
(test "Folded functions provide direct access to environment variables."
(|> function//environment
- (//.run (expressionS.synthesizer extensionL.empty))
+ (expressionS.synthesizer extensionL.empty)
+ (///compiler.run //.init)
(case> (^ (#error.Success (//.function/abstraction [environment arity (#//.Reference (///reference.variable output))])))
(and (n/= arity//environment arity)
(variable/= prediction//environment output))
@@ -124,7 +127,8 @@
false)))
(test "Folded functions properly offset local variables."
(|> function//local
- (//.run (expressionS.synthesizer extensionL.empty))
+ (expressionS.synthesizer extensionL.empty)
+ (///compiler.run //.init)
(case> (^ (#error.Success (//.function/abstraction [environment arity (#//.Reference (///reference.variable output))])))
(and (n/= arity//local arity)
(variable/= prediction//local output))
@@ -142,7 +146,8 @@
($_ seq
(test "Can synthesize function application."
(|> (analysisL.apply [funcA argsA])
- (//.run (expressionS.synthesizer extensionL.empty))
+ (expressionS.synthesizer extensionL.empty)
+ (///compiler.run //.init)
(case> (^ (#error.Success (//.function/apply [funcS argsS])))
(and (//primitive.corresponds? funcA funcS)
(list.every? (product.uncurry //primitive.corresponds?)
@@ -152,7 +157,8 @@
false)))
(test "Function application on no arguments just synthesizes to the function itself."
(|> (analysisL.apply [funcA (list)])
- (//.run (expressionS.synthesizer extensionL.empty))
+ (expressionS.synthesizer extensionL.empty)
+ (///compiler.run //.init)
(case> (#error.Success funcS)
(//primitive.corresponds? funcA funcS)
diff --git a/stdlib/test/test/lux/lang/synthesis/primitive.lux b/stdlib/test/test/lux/lang/synthesis/primitive.lux
index ffe0eb795..1c8368204 100644
--- a/stdlib/test/test/lux/lang/synthesis/primitive.lux
+++ b/stdlib/test/test/lux/lang/synthesis/primitive.lux
@@ -7,6 +7,7 @@
text/format)
[lang]
(lang [".L" extension]
+ ["///." compiler]
[".L" analysis #+ Analysis]
["//" synthesis #+ Synthesis]
(synthesis [".S" expression]))
@@ -74,7 +75,8 @@
(~~ (do-template [<desc> <analysis> <synthesis> <sample>]
[(test (format "Can synthesize " <desc> ".")
(|> (#analysisL.Primitive (<analysis> <sample>))
- (//.run (expressionS.synthesizer extensionL.empty))
+ (expressionS.synthesizer extensionL.empty)
+ (///compiler.run //.init)
(case> (#error.Success (#//.Primitive (<synthesis> value)))
(is? <sample> value)
diff --git a/stdlib/test/test/lux/lang/synthesis/structure.lux b/stdlib/test/test/lux/lang/synthesis/structure.lux
index a8e298bf5..e61386044 100644
--- a/stdlib/test/test/lux/lang/synthesis/structure.lux
+++ b/stdlib/test/test/lux/lang/synthesis/structure.lux
@@ -7,7 +7,8 @@
[product]
[error]
(coll [list]))
- (lang [".L" analysis]
+ (lang ["///." compiler]
+ [".L" analysis]
["//" synthesis #+ Synthesis]
(synthesis [".S" expression])
[".L" extension])
@@ -24,7 +25,8 @@
($_ seq
(test "Can synthesize variants."
(|> (analysisL.sum-analysis size tagA memberA)
- (//.run (expressionS.synthesizer extensionL.empty))
+ (expressionS.synthesizer extensionL.empty)
+ (///compiler.run //.init)
(case> (#error.Success (#//.Structure (#//.Variant [leftsS right?S valueS])))
(let [tagS (if right?S (inc leftsS) leftsS)]
(and (n/= tagA tagS)
@@ -43,7 +45,8 @@
($_ seq
(test "Can synthesize tuple."
(|> (analysisL.product-analysis membersA)
- (//.run (expressionS.synthesizer extensionL.empty))
+ (expressionS.synthesizer extensionL.empty)
+ (///compiler.run //.init)
(case> (#error.Success (#//.Structure (#//.Tuple membersS)))
(and (n/= size (list.size membersS))
(list.every? (product.uncurry //primitive.corresponds?)