diff options
8 files changed, 167 insertions, 171 deletions
diff --git a/stdlib/source/lux/language/compiler/synthesis/case.lux b/stdlib/source/lux/language/compiler/synthesis/case.lux index 045abbde7..92a17fa71 100644 --- a/stdlib/source/lux/language/compiler/synthesis/case.lux +++ b/stdlib/source/lux/language/compiler/synthesis/case.lux @@ -11,15 +11,15 @@ format] [number ("frac/" Equivalence<Frac>)] [collection [list ("list/" Fold<List> Monoid<List>)]]]] - [// (#+ Path Synthesis) + [// (#+ Path Synthesis Operation Compiler) [function] - [/// - [reference] - [compiler (#+ Operation) ("operation/" Monad<Operation>)] - [analysis (#+ Pattern Match Analysis)]]]) + ["/." // ("operation/" Monad<Operation>) + [analysis (#+ Pattern Match Analysis)] + [// + [reference]]]]) (def: (path' pattern bodyC) - (-> Pattern (Operation //.State Path) (Operation //.State Path)) + (-> Pattern (Operation Path) (Operation Path)) (case pattern (#analysis.Simple simple) (case simple @@ -38,7 +38,7 @@ [#analysis.Text #//.Text])) (#analysis.Bind register) - (<| (do compiler.Monad<Operation> + (<| (do ///.Monad<Operation> [arity //.scope-arity]) (:: @ map (|>> (#//.Seq (#//.Bind (if (function.nested? arity) (n/+ (dec arity) register) @@ -76,7 +76,7 @@ (list.reverse (list.enumerate tuple))))))) (def: #export (path synthesize pattern bodyA) - (-> //.Synthesizer Pattern Analysis (Operation //.State Path)) + (-> Compiler Pattern Analysis (Operation Path)) (path' pattern (operation/map (|>> #//.Then) (synthesize bodyA)))) (def: #export (weave leftP rightP) @@ -126,8 +126,8 @@ <default>))) (def: #export (synthesize synthesize^ inputA [headB tailB+]) - (-> //.Synthesizer Analysis Match (Operation //.State Synthesis)) - (do compiler.Monad<Operation> + (-> Compiler Analysis Match (Operation Synthesis)) + (do ///.Monad<Operation> [inputS (synthesize^ inputA)] (with-expansions [<unnecesary-let> (as-is (^multi (^ (#analysis.Reference (reference.local outputR))) diff --git a/stdlib/source/lux/language/compiler/synthesis/expression.lux b/stdlib/source/lux/language/compiler/synthesis/expression.lux index f6d68fc05..be20b7b0b 100644 --- a/stdlib/source/lux/language/compiler/synthesis/expression.lux +++ b/stdlib/source/lux/language/compiler/synthesis/expression.lux @@ -1,24 +1,20 @@ (.module: [lux (#- primitive) [control - [monad (#+ do)] - ["ex" exception (#+ exception:)]] + [monad (#+ do)]] [data [maybe] [collection [list ("list/" Functor<List>)] ["dict" dictionary (#+ Dictionary)]]]] - [// (#+ Synthesis) + [// (#+ Synthesis Compiler) [function] [case] - [/// - [reference] - ["." compiler ("operation/" Monad<Operation>) - [analysis (#+ Analysis)] - [extension (#+ Extension)]]]]) - -(exception: #export (unknown-synthesis-extension {name Text}) - name) + ["/." // ("operation/" Monad<Operation>) + [analysis (#+ Analysis)] + [extension] + [// + [reference]]]]) (def: (primitive analysis) (-> analysis.Primitive //.Primitive) @@ -40,64 +36,59 @@ [#analysis.Int #//.I64] [#analysis.Rev #//.I64]))) -(def: #export (synthesizer extensions) - (-> (Extension extension.Synthesis) //.Synthesizer) - (function (synthesize analysis) - (case analysis - (#analysis.Primitive analysis') - (operation/wrap (#//.Primitive (..primitive analysis'))) +(def: #export (synthesize analysis) + Compiler + (case analysis + (#analysis.Primitive analysis') + (operation/wrap (#//.Primitive (..primitive analysis'))) - (#analysis.Structure composite) - (case (analysis.variant analysis) - (#.Some variant) - (do compiler.Monad<Operation> - [valueS (synthesize (get@ #analysis.value variant))] - (wrap (#//.Structure (#//.Variant (set@ #analysis.value valueS variant))))) + (#analysis.Structure composite) + (case (analysis.variant analysis) + (#.Some variant) + (do ///.Monad<Operation> + [valueS (synthesize (get@ #analysis.value variant))] + (wrap (#//.Structure (#//.Variant (set@ #analysis.value valueS variant))))) - _ - (do compiler.Monad<Operation> - [tupleS (monad.map @ synthesize (analysis.tuple analysis))] - (wrap (#//.Structure (#//.Tuple tupleS))))) + _ + (do ///.Monad<Operation> + [tupleS (monad.map @ synthesize (analysis.tuple analysis))] + (wrap (#//.Structure (#//.Tuple tupleS))))) - (#analysis.Apply _) - (function.apply (|>> synthesize //.indirectly) analysis) + (#analysis.Apply _) + (function.apply (|>> synthesize //.indirectly) analysis) - (#analysis.Function environmentA bodyA) - (function.function synthesize environmentA bodyA) + (#analysis.Function environmentA bodyA) + (function.function synthesize environmentA bodyA) - (#analysis.Extension name args) - (case (dict.get name extensions) - #.None - (compiler.throw unknown-synthesis-extension name) - - (#.Some extension) - (extension (|>> synthesize //.indirectly) args)) + (#analysis.Extension name args) + (extension.apply (|>> synthesize //.indirectly) + [name args]) - (#analysis.Reference reference) - (case reference - (#reference.Constant constant) - (operation/wrap (#//.Reference reference)) + (#analysis.Reference reference) + (case reference + (#reference.Constant constant) + (operation/wrap (#//.Reference reference)) - (#reference.Variable var) - (do compiler.Monad<Operation> - [resolver //.resolver] - (case var - (#reference.Local register) - (do @ - [arity //.scope-arity] - (wrap (if (function.nested? arity) - (if (n/= +0 register) - (|> (dec arity) - (list.n/range +1) - (list/map (|>> //.variable/local)) - [(//.variable/local +0)] - //.function/apply) - (#//.Reference (#reference.Variable (function.adjust arity #0 var)))) - (#//.Reference (#reference.Variable var))))) - - (#reference.Foreign register) - (wrap (|> resolver (dict.get var) (maybe.default var) #reference.Variable #//.Reference))))) + (#reference.Variable var) + (do ///.Monad<Operation> + [resolver //.resolver] + (case var + (#reference.Local register) + (do @ + [arity //.scope-arity] + (wrap (if (function.nested? arity) + (if (n/= +0 register) + (|> (dec arity) + (list.n/range +1) + (list/map (|>> //.variable/local)) + [(//.variable/local +0)] + //.function/apply) + (#//.Reference (#reference.Variable (function.adjust arity #0 var)))) + (#//.Reference (#reference.Variable var))))) + + (#reference.Foreign register) + (wrap (|> resolver (dict.get var) (maybe.default var) #reference.Variable #//.Reference))))) - (#analysis.Case inputA branchesAB+) - (case.synthesize (|>> synthesize //.indirectly) inputA branchesAB+) - ))) + (#analysis.Case inputA branchesAB+) + (case.synthesize (|>> synthesize //.indirectly) inputA branchesAB+) + )) diff --git a/stdlib/source/lux/language/compiler/synthesis/function.lux b/stdlib/source/lux/language/compiler/synthesis/function.lux index e73621b5c..0fadbc6d1 100644 --- a/stdlib/source/lux/language/compiler/synthesis/function.lux +++ b/stdlib/source/lux/language/compiler/synthesis/function.lux @@ -11,11 +11,11 @@ [collection [list ("list/" Functor<List> Monoid<List> Fold<List>)] ["dict" dictionary (#+ Dictionary)]]]] - [// (#+ Synthesis Synthesizer) + [// (#+ Synthesis Operation Compiler) [loop] [/// [reference (#+ Variable)] - [compiler (#+ Operation) + ["." compiler [analysis (#+ Environment Arity Analysis)]]]]) (def: #export nested? @@ -45,7 +45,7 @@ [apply args]))) (def: #export (apply synthesize) - (-> Synthesizer Synthesizer) + (-> Compiler Compiler) (.function (_ exprA) (let [[funcA argsA] (unfold exprA)] (do (state.Monad<State'> error.Monad<Error>) @@ -75,7 +75,7 @@ "") (def: return - (All [a] (-> (Maybe a) (Operation //.State a))) + (All [a] (-> (Maybe a) (Operation a))) (|>> (case> (#.Some output) (:: compiler.Monad<Operation> wrap output) @@ -83,7 +83,7 @@ (compiler.throw cannot-prepare-function-body [])))) (def: #export (function synthesize environment body) - (-> Synthesizer Environment Analysis (Operation //.State Synthesis)) + (-> Compiler Environment Analysis (Operation Synthesis)) (do compiler.Monad<Operation> [direct? //.direct? arity //.scope-arity diff --git a/stdlib/source/lux/language/compiler/synthesis/loop.lux b/stdlib/source/lux/language/compiler/synthesis/loop.lux index 95666656b..ea6589f21 100644 --- a/stdlib/source/lux/language/compiler/synthesis/loop.lux +++ b/stdlib/source/lux/language/compiler/synthesis/loop.lux @@ -13,7 +13,8 @@ [/// [reference (#+ Register Variable)] [compiler - [analysis (#+ Environment)]]]]) + [analysis (#+ Environment)] + [extension]]]]) (type: #export (Transform a) (-> a (Maybe a))) @@ -30,8 +31,8 @@ (template: (recursive-apply args) (#//.Apply (self) args)) -(def: proper Bit #1) -(def: improper Bit #0) +(def: improper #0) +(def: proper #1) (def: (proper? exprS) (-> Synthesis Bit) diff --git a/stdlib/test/test/lux/language/compiler/synthesis/case.lux b/stdlib/test/test/lux/language/compiler/synthesis/case.lux index 0f907f310..da8e59fa1 100644 --- a/stdlib/test/test/lux/language/compiler/synthesis/case.lux +++ b/stdlib/test/test/lux/language/compiler/synthesis/case.lux @@ -6,12 +6,13 @@ [data [error ("error/" Functor<Error>)]] [language - ["///." reference] - ["///." compiler - [".L" analysis (#+ Branch Analysis)] + [reference] + ["." compiler + [analysis (#+ Branch Analysis)] ["//" synthesis (#+ Synthesis) - [".S" expression]] - [".L" extension]]] + [expression]] + [extension + [bundle]]]] [math ["r" random]] test] @@ -22,15 +23,15 @@ (do @ [maskedA //primitive.primitive temp (|> r.nat (:: @ map (n/% +100))) - #let [maskA (analysisL.control/case + #let [maskA (analysis.control/case [maskedA - [[(#analysisL.Bind temp) - (#analysisL.Reference (///reference.local temp))] + [[(#analysis.Bind temp) + (#analysis.Reference (reference.local temp))] (list)]])]] (test "Dummy variables created to mask expressions get eliminated during synthesis." (|> maskA - (expressionS.synthesizer extensionL.empty) - (///compiler.run //.init) + expression.synthesize + (compiler.run [bundle.empty //.init]) (error/map (//primitive.corresponds? maskedA)) (error.default #0)))))) @@ -40,15 +41,15 @@ [registerA r.nat inputA //primitive.primitive outputA //primitive.primitive - #let [letA (analysisL.control/case + #let [letA (analysis.control/case [inputA - [[(#analysisL.Bind registerA) + [[(#analysis.Bind registerA) outputA] (list)]])]] (test "Can detect and reify simple 'let' expressions." (|> letA - (expressionS.synthesizer extensionL.empty) - (///compiler.run //.init) + expression.synthesize + (compiler.run [bundle.empty //.init]) (case> (^ (#error.Success (//.branch/let [inputS registerS outputS]))) (and (n/= registerA registerS) (//primitive.corresponds? inputA inputS) @@ -65,18 +66,18 @@ thenA //primitive.primitive elseA //primitive.primitive #let [thenB (: Branch - [(#analysisL.Simple (#analysisL.Bit #1)) + [(#analysis.Simple (#analysis.Bit #1)) thenA]) elseB (: Branch - [(#analysisL.Simple (#analysisL.Bit #0)) + [(#analysis.Simple (#analysis.Bit #0)) elseA]) ifA (if then|else - (analysisL.control/case [inputA [thenB (list elseB)]]) - (analysisL.control/case [inputA [elseB (list thenB)]]))]] + (analysis.control/case [inputA [thenB (list elseB)]]) + (analysis.control/case [inputA [elseB (list thenB)]]))]] (test "Can detect and reify simple 'if' expressions." (|> ifA - (expressionS.synthesizer extensionL.empty) - (///compiler.run //.init) + expression.synthesize + (compiler.run [bundle.empty //.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/language/compiler/synthesis/function.lux b/stdlib/test/test/lux/language/compiler/synthesis/function.lux index 0c55b64fd..8954aafb1 100644 --- a/stdlib/test/test/lux/language/compiler/synthesis/function.lux +++ b/stdlib/test/test/lux/language/compiler/synthesis/function.lux @@ -15,12 +15,13 @@ ["dict" dictionary (#+ Dictionary)] [set]]] [language - ["///." reference (#+ Variable) ("variable/" Equivalence<Variable>)] - ["///." compiler - [".L" analysis (#+ Arity Analysis)] + [reference (#+ Variable) ("variable/" Equivalence<Variable>)] + ["." compiler + [analysis (#+ Arity Analysis)] ["//" synthesis (#+ Synthesis) - [".S" expression]] - [".L" extension]]] + [expression]] + [extension + [bundle]]]] [math ["r" random]] test] [//primitive]) @@ -35,7 +36,7 @@ (do @ [[arity bodyA predictionA] constant-function] (wrap [(inc arity) - (#analysisL.Function (list) bodyA) + (#analysis.Function (list) bodyA) predictionA])) (do @ [predictionA //primitive.primitive] @@ -50,8 +51,8 @@ (do r.Monad<Random> [num-locals (|> r.nat (:: @ map (|>> (n/% +100) (n/max +10)))) #let [indices (list.n/range +0 (dec num-locals)) - local-env (list/map (|>> #///reference.Local) indices) - foreign-env (list/map (|>> #///reference.Foreign) indices)] + local-env (list/map (|>> #reference.Local) indices) + foreign-env (list/map (|>> #reference.Foreign) indices)] [arity bodyA predictionA] (: (r.Random [Arity Analysis Variable]) (loop [arity +1 current-env foreign-env] @@ -72,17 +73,17 @@ (list/map (function (_ pick) (maybe.assume (list.nth pick current-env))) picks)) - #let [picked-env (list/map (|>> #///reference.Foreign) picks)]] + #let [picked-env (list/map (|>> #reference.Foreign) picks)]] (wrap [arity - (#analysisL.Function picked-env bodyA) + (#analysis.Function picked-env bodyA) predictionA])) (do @ [chosen (pick (list.size current-env))] (wrap [arity - (#analysisL.Reference (///reference.foreign chosen)) + (#analysis.Reference (reference.foreign chosen)) (maybe.assume (dict.get chosen resolver))])))))))] (wrap [arity - (#analysisL.Function local-env bodyA) + (#analysis.Function local-env bodyA) predictionA]))) (def: local-function @@ -94,13 +95,13 @@ [nest?' r.bit [arity' bodyA predictionA] (recur (inc arity) nest?')] (wrap [arity' - (#analysisL.Function (list) bodyA) + (#analysis.Function (list) bodyA) predictionA])) (do r.Monad<Random> [chosen (|> r.nat (:: @ map (|>> (n/% +100) (n/max +2))))] (wrap [arity - (#analysisL.Reference (///reference.local chosen)) - (|> chosen (n/+ (dec arity)) #///reference.Local)]))))) + (#analysis.Reference (reference.local chosen)) + (|> chosen (n/+ (dec arity)) #reference.Local)]))))) (context: "Function definition." (<| (seed +13007429814532219492) @@ -112,8 +113,8 @@ ($_ seq (test "Nested functions will get folded together." (|> function//constant - (expressionS.synthesizer extensionL.empty) - (///compiler.run //.init) + expression.synthesize + (compiler.run [bundle.empty //.init]) (case> (^ (#error.Success (//.function/abstraction [environment arity output]))) (and (n/= arity//constant arity) (//primitive.corresponds? prediction//constant output)) @@ -122,9 +123,9 @@ (n/= +0 arity//constant)))) (test "Folded functions provide direct access to environment variables." (|> function//environment - (expressionS.synthesizer extensionL.empty) - (///compiler.run //.init) - (case> (^ (#error.Success (//.function/abstraction [environment arity (#//.Reference (///reference.variable output))]))) + expression.synthesize + (compiler.run [bundle.empty //.init]) + (case> (^ (#error.Success (//.function/abstraction [environment arity (#//.Reference (reference.variable output))]))) (and (n/= arity//environment arity) (variable/= prediction//environment output)) @@ -132,9 +133,9 @@ #0))) (test "Folded functions properly offset local variables." (|> function//local - (expressionS.synthesizer extensionL.empty) - (///compiler.run //.init) - (case> (^ (#error.Success (//.function/abstraction [environment arity (#//.Reference (///reference.variable output))]))) + expression.synthesize + (compiler.run [bundle.empty //.init]) + (case> (^ (#error.Success (//.function/abstraction [environment arity (#//.Reference (reference.variable output))]))) (and (n/= arity//local arity) (variable/= prediction//local output)) @@ -150,9 +151,9 @@ argsA (r.list arity //primitive.primitive)] ($_ seq (test "Can synthesize function application." - (|> (analysisL.apply [funcA argsA]) - (expressionS.synthesizer extensionL.empty) - (///compiler.run //.init) + (|> (analysis.apply [funcA argsA]) + expression.synthesize + (compiler.run [bundle.empty //.init]) (case> (^ (#error.Success (//.function/apply [funcS argsS]))) (and (//primitive.corresponds? funcA funcS) (list.every? (product.uncurry //primitive.corresponds?) @@ -161,9 +162,9 @@ _ #0))) (test "Function application on no arguments just synthesizes to the function itself." - (|> (analysisL.apply [funcA (list)]) - (expressionS.synthesizer extensionL.empty) - (///compiler.run //.init) + (|> (analysis.apply [funcA (list)]) + expression.synthesize + (compiler.run [bundle.empty //.init]) (case> (#error.Success funcS) (//primitive.corresponds? funcA funcS) diff --git a/stdlib/test/test/lux/language/compiler/synthesis/primitive.lux b/stdlib/test/test/lux/language/compiler/synthesis/primitive.lux index 0bf5d9765..86eecb600 100644 --- a/stdlib/test/test/lux/language/compiler/synthesis/primitive.lux +++ b/stdlib/test/test/lux/language/compiler/synthesis/primitive.lux @@ -8,12 +8,13 @@ [error] [text format]] - ["." language - ["///." compiler - [".L" analysis (#+ Analysis)] + [language + ["." compiler + [analysis (#+ Analysis)] ["//" synthesis (#+ Synthesis) - [".S" expression]] - [".L" extension]]] + [expression]] + [extension + [bundle]]]] [math ["r" random]] test]) @@ -21,7 +22,7 @@ (def: #export primitive (r.Random Analysis) (do r.Monad<Random> - [primitive (: (r.Random analysisL.Primitive) + [primitive (: (r.Random analysis.Primitive) ($_ r.alt (wrap []) r.bit @@ -30,37 +31,37 @@ r.rev r.frac (r.unicode +5)))] - (wrap (#analysisL.Primitive primitive)))) + (wrap (#analysis.Primitive primitive)))) (def: #export (corresponds? analysis synthesis) (-> Analysis Synthesis Bit) (case [synthesis analysis] [(#//.Primitive (#//.Text valueS)) - (#analysisL.Primitive (#analysisL.Unit valueA))] + (#analysis.Primitive (#analysis.Unit valueA))] (is? valueS (:coerce Text valueA)) [(#//.Primitive (#//.Bit valueS)) - (#analysisL.Primitive (#analysisL.Bit valueA))] + (#analysis.Primitive (#analysis.Bit valueA))] (is? valueS valueA) [(#//.Primitive (#//.I64 valueS)) - (#analysisL.Primitive (#analysisL.Nat valueA))] + (#analysis.Primitive (#analysis.Nat valueA))] (is? valueS (.i64 valueA)) [(#//.Primitive (#//.I64 valueS)) - (#analysisL.Primitive (#analysisL.Int valueA))] + (#analysis.Primitive (#analysis.Int valueA))] (is? valueS (.i64 valueA)) [(#//.Primitive (#//.I64 valueS)) - (#analysisL.Primitive (#analysisL.Rev valueA))] + (#analysis.Primitive (#analysis.Rev valueA))] (is? valueS (.i64 valueA)) [(#//.Primitive (#//.F64 valueS)) - (#analysisL.Primitive (#analysisL.Frac valueA))] + (#analysis.Primitive (#analysis.Frac valueA))] (is? valueS valueA) [(#//.Primitive (#//.Text valueS)) - (#analysisL.Primitive (#analysisL.Text valueA))] + (#analysis.Primitive (#analysis.Text valueA))] (is? valueS valueA) _ @@ -69,28 +70,28 @@ (context: "Primitives." (<| (times +100) (do @ - [%bit% r.bit - %nat% r.nat - %int% r.int - %rev% r.rev - %frac% r.frac - %text% (r.unicode +5)] + [|bit| r.bit + |nat| r.nat + |int| r.int + |rev| r.rev + |frac| r.frac + |text| (r.unicode +5)] (`` ($_ seq (~~ (do-template [<desc> <analysis> <synthesis> <sample>] [(test (format "Can synthesize " <desc> ".") - (|> (#analysisL.Primitive (<analysis> <sample>)) - (expressionS.synthesizer extensionL.empty) - (///compiler.run //.init) + (|> (#analysis.Primitive (<analysis> <sample>)) + expression.synthesize + (compiler.run [bundle.empty //.init]) (case> (#error.Success (#//.Primitive (<synthesis> value))) (is? <sample> value) _ #0)))] - ["unit" #analysisL.Unit #//.Text //.unit] - ["bit" #analysisL.Bit #//.Bit %bit%] - ["nat" #analysisL.Nat #//.I64 (.i64 %nat%)] - ["int" #analysisL.Int #//.I64 (.i64 %int%)] - ["rev" #analysisL.Rev #//.I64 (.i64 %rev%)] - ["frac" #analysisL.Frac #//.F64 %frac%] - ["text" #analysisL.Text #//.Text %text%]))))))) + ["unit" #analysis.Unit #//.Text //.unit] + ["bit" #analysis.Bit #//.Bit |bit|] + ["nat" #analysis.Nat #//.I64 (.i64 |nat|)] + ["int" #analysis.Int #//.I64 (.i64 |int|)] + ["rev" #analysis.Rev #//.I64 (.i64 |rev|)] + ["frac" #analysis.Frac #//.F64 |frac|] + ["text" #analysis.Text #//.Text |text|]))))))) diff --git a/stdlib/test/test/lux/language/compiler/synthesis/structure.lux b/stdlib/test/test/lux/language/compiler/synthesis/structure.lux index d3845929c..cb82f9131 100644 --- a/stdlib/test/test/lux/language/compiler/synthesis/structure.lux +++ b/stdlib/test/test/lux/language/compiler/synthesis/structure.lux @@ -11,11 +11,12 @@ [collection [list]]] [language - ["///." compiler - [".L" analysis] + ["." compiler + [analysis] ["//" synthesis (#+ Synthesis) - [".S" expression]] - [".L" extension]]] + [expression]] + [extension + [bundle]]]] [math ["r" random]] test] @@ -29,9 +30,9 @@ memberA //primitive.primitive] ($_ seq (test "Can synthesize variants." - (|> (analysisL.sum-analysis size tagA memberA) - (expressionS.synthesizer extensionL.empty) - (///compiler.run //.init) + (|> (analysis.sum-analysis size tagA memberA) + expression.synthesize + (compiler.run [bundle.empty //.init]) (case> (#error.Success (#//.Structure (#//.Variant [leftsS right?S valueS]))) (let [tagS (if right?S (inc leftsS) leftsS)] (and (n/= tagA tagS) @@ -49,9 +50,9 @@ membersA (r.list size //primitive.primitive)] ($_ seq (test "Can synthesize tuple." - (|> (analysisL.product-analysis membersA) - (expressionS.synthesizer extensionL.empty) - (///compiler.run //.init) + (|> (analysis.product-analysis membersA) + expression.synthesize + (compiler.run [bundle.empty //.init]) (case> (#error.Success (#//.Structure (#//.Tuple membersS))) (and (n/= size (list.size membersS)) (list.every? (product.uncurry //primitive.corresponds?) |