From b6c3a84b536235a53bdfaf0f96d76413bc222ba7 Mon Sep 17 00:00:00 2001 From: Eduardo Julian Date: Mon, 30 Oct 2017 21:49:35 -0400 Subject: - Migrated the format of synthesis nodes from a custom data-type, to just Code nodes. --- new-luxc/test/test/luxc/generator/case.lux | 58 +-- new-luxc/test/test/luxc/generator/function.lux | 19 +- new-luxc/test/test/luxc/generator/primitive.lux | 15 +- .../test/luxc/generator/procedure/common.jvm.lux | 161 ++++---- .../test/luxc/generator/procedure/host.jvm.lux | 452 ++++++++++----------- new-luxc/test/test/luxc/generator/reference.lux | 7 +- new-luxc/test/test/luxc/generator/structure.lux | 39 +- .../test/test/luxc/synthesizer/case/special.lux | 4 +- new-luxc/test/test/luxc/synthesizer/common.lux | 22 +- new-luxc/test/test/luxc/synthesizer/function.lux | 10 +- new-luxc/test/test/luxc/synthesizer/loop.lux | 46 ++- new-luxc/test/test/luxc/synthesizer/primitive.lux | 38 +- new-luxc/test/test/luxc/synthesizer/procedure.lux | 4 +- new-luxc/test/test/luxc/synthesizer/structure.lux | 4 +- 14 files changed, 433 insertions(+), 446 deletions(-) (limited to 'new-luxc/test') diff --git a/new-luxc/test/test/luxc/generator/case.lux b/new-luxc/test/test/luxc/generator/case.lux index f9e165c03..ff0e017aa 100644 --- a/new-luxc/test/test/luxc/generator/case.lux +++ b/new-luxc/test/test/luxc/generator/case.lux @@ -4,9 +4,11 @@ (control [monad #+ do] pipe) (data ["e" error] + text/format (coll [list])) ["r" math/random "r/" Monad] [meta] + (meta [code]) test) (luxc (lang ["ls" synthesis]) [analyser] @@ -28,46 +30,44 @@ (r;Random [ls;Synthesis ls;Path]) (<| r;rec (function [gen-case]) (`` ($_ r;either - (r/wrap [#ls;Unit #ls;UnitP]) - (~~ (do-template [ ] + (r/wrap [(' []) (' ("lux case pop"))]) + (~~ (do-template [ ] [(do r;Monad [value ] - (wrap [( value) ( value)]))] + (wrap [( value) ( value)]))] - [r;bool #ls;Bool #ls;BoolP] - [r;nat #ls;Nat #ls;NatP] - [r;int #ls;Int #ls;IntP] - [r;deg #ls;Deg #ls;DegP] - [r;frac #ls;Frac #ls;FracP] - [(r;text +5) #ls;Text #ls;TextP])) + [r;bool code;bool] + [r;nat code;nat] + [r;int code;int] + [r;deg code;deg] + [r;frac code;frac] + [(r;text +5) code;text])) (do r;Monad [size (|> r;nat (:: @ map (|>. (n.% struct-limit) (n.max +2)))) idx (|> r;nat (:: @ map (n.% size))) [subS subP] gen-case - #let [caseS (#ls;Tuple (list;concat (list (list;repeat idx #ls;Unit) - (list subS) - (list;repeat (|> size n.dec (n.- idx)) #ls;Unit)))) - caseP (#ls;TupleP (if (tail? size idx) - (#;Right idx) - (#;Left idx)) - subP)]] + #let [caseS (` [(~@ (list;concat (list (list;repeat idx (' [])) + (list subS) + (list;repeat (|> size n.dec (n.- idx)) (' [])))))]) + caseP (if (tail? size idx) + (` ("lux case tuple right" (~ (code;nat idx)) (~ subP))) + (` ("lux case tuple left" (~ (code;nat idx)) (~ subP))))]] (wrap [caseS caseP])) (do r;Monad [size (|> r;nat (:: @ map (|>. (n.% struct-limit) (n.max +2)))) idx (|> r;nat (:: @ map (n.% size))) [subS subP] gen-case - #let [caseS (#ls;Variant idx (tail? idx idx) subS) - caseP (#ls;VariantP (if (tail? idx idx) - (#;Right idx) - (#;Left idx)) - subP)]] + #let [caseS (` ((~ (code;nat idx)) (~ (code;bool (tail? size idx))) (~ subS))) + caseP (if (tail? size idx) + (` ("lux case variant right" (~ (code;nat idx)) (~ subP))) + (` ("lux case variant left" (~ (code;nat idx)) (~ subP))))]] (wrap [caseS caseP])) )))) (context: "Pattern-matching." (<| (times +100) (do @ - [[valueS path] gen-case + [[valueS pathS] gen-case to-bind r;nat] ($_ seq (test "Can generate pattern-matching." @@ -75,21 +75,25 @@ [runtime-bytecode @runtime;generate sampleI (@;generate-case exprG;generate valueS - (#ls;AltP (#ls;SeqP path (#ls;ExecP (#ls;Bool true))) - (#ls;SeqP (#ls;BindP +0) (#ls;ExecP (#ls;Bool false)))))] + (` ("lux case alt" + ("lux case seq" (~ pathS) + ("lux case exec" true)) + ("lux case seq" ("lux case bind" +0) + ("lux case exec" false)))))] (@eval;eval sampleI)) (meta;run (init-compiler [])) (case> (#e;Success valueG) (:! Bool valueG) - _ + (#e;Error error) false))) (test "Can bind values." (|> (do meta;Monad [runtime-bytecode @runtime;generate sampleI (@;generate-case exprG;generate - (#ls;Nat to-bind) - (#ls;SeqP (#ls;BindP +1) (#ls;ExecP (#ls;Variable 1))))] + (code;nat to-bind) + (` ("lux case seq" ("lux case bind" +0) + ("lux case exec" (0)))))] (@eval;eval sampleI)) (meta;run (init-compiler [])) (case> (#e;Success valueG) diff --git a/new-luxc/test/test/luxc/generator/function.lux b/new-luxc/test/test/luxc/generator/function.lux index dfc1230be..1f922706c 100644 --- a/new-luxc/test/test/luxc/generator/function.lux +++ b/new-luxc/test/test/luxc/generator/function.lux @@ -33,7 +33,8 @@ (do r;Monad [arity arity arg (|> r;nat (:: @ map (n.% arity))) - #let [functionS (#ls;Function arity (list) (#ls;Variable (nat-to-int (n.inc arg))))]] + #let [functionS (` ("lux function" (~ (code;nat arity)) [] + ((~ (code;int (nat-to-int (n.inc arg)))))))]] (wrap [arity arg functionS]))) (context: "Function." @@ -43,14 +44,14 @@ cut-off (|> r;nat (:: @ map (n.% arity))) args (r;list arity r;nat) #let [arg-value (maybe;assume (list;nth arg args)) - argsS (list/map (|>. #ls;Nat) args) + argsS (list/map code;nat args) last-arg (n.dec arity) cut-off (|> cut-off (n.min (n.dec last-arg)))]] ($_ seq (test "Can read arguments." (|> (do meta;Monad [runtime-bytecode @runtime;generate - sampleI (@expr;generate (#ls;Call argsS functionS))] + sampleI (@expr;generate (` ("lux call" (~ functionS) (~@ argsS))))] (@eval;eval sampleI)) (meta;run (init-compiler [])) (case> (#e;Success valueG) @@ -65,7 +66,9 @@ preS (list;take partial-arity argsS) postS (list;drop partial-arity argsS)] runtime-bytecode @runtime;generate - sampleI (@expr;generate (|> functionS (#ls;Call preS) (#ls;Call postS)))] + sampleI (@expr;generate (` ("lux call" + ("lux call" (~ functionS) (~@ preS)) + (~@ postS))))] (@eval;eval sampleI)) (meta;run (init-compiler [])) (case> (#e;Success valueG) @@ -83,11 +86,11 @@ (|> arg n.inc nat-to-int (i.* -1)) (|> arg n.inc (n.- super-arity) nat-to-int)) sub-arity (|> arity (n.- super-arity)) - functionS (<| (#ls;Function super-arity (list)) - (#ls;Function sub-arity env) - (#ls;Variable arg-var))] + functionS (` ("lux function" (~ (code;nat super-arity)) [] + ("lux function" (~ (code;nat sub-arity)) [(~@ (list/map code;int env))] + ((~ (code;int arg-var))))))] runtime-bytecode @runtime;generate - sampleI (@expr;generate (#ls;Call argsS functionS))] + sampleI (@expr;generate (` ("lux call" (~ functionS) (~@ argsS))))] (@eval;eval sampleI)) (meta;run (init-compiler [])) (case> (#e;Success valueG) diff --git a/new-luxc/test/test/luxc/generator/primitive.lux b/new-luxc/test/test/luxc/generator/primitive.lux index 66eacca27..37f87829b 100644 --- a/new-luxc/test/test/luxc/generator/primitive.lux +++ b/new-luxc/test/test/luxc/generator/primitive.lux @@ -9,6 +9,7 @@ [text "T/" Eq]) ["r" math/random] [meta] + (meta [code]) test) (luxc [";L" host] (lang ["ls" synthesis]) @@ -42,16 +43,16 @@ _ false)))] - ["bool" Bool #ls;Bool %bool% B/=] - ["nat" Nat #ls;Nat %nat% n.=] - ["int" Int #ls;Int %int% i.=] - ["deg" Deg #ls;Deg %deg% d.=] - ["frac" Frac #ls;Frac %frac% f.=] - ["text" Text #ls;Text %text% T/=])] + ["bool" Bool code;bool %bool% B/=] + ["nat" Nat code;nat %nat% n.=] + ["int" Int code;int %int% i.=] + ["deg" Deg code;deg %deg% d.=] + ["frac" Frac code;frac %frac% f.=] + ["text" Text code;text %text% T/=])] ($_ seq (test "Can generate unit." (|> (do meta;Monad - [sampleI (@;generate #ls;Unit)] + [sampleI (@;generate (' []))] (@eval;eval sampleI)) (meta;run (init-compiler [])) (case> (#e;Success valueG) diff --git a/new-luxc/test/test/luxc/generator/procedure/common.jvm.lux b/new-luxc/test/test/luxc/generator/procedure/common.jvm.lux index dde15b19b..7e36575d8 100644 --- a/new-luxc/test/test/luxc/generator/procedure/common.jvm.lux +++ b/new-luxc/test/test/luxc/generator/procedure/common.jvm.lux @@ -12,7 +12,8 @@ (coll ["a" array] [list])) ["r" math/random] - [meta #+ Monad] + [meta] + (meta [code]) [host] test) (luxc (lang ["ls" synthesis]) @@ -32,9 +33,8 @@ (with-expansions [ (do-template [ ] [(test (|> (do meta;Monad - [sampleI (@;generate (#ls;Procedure - (list (#ls;Nat subject) - (#ls;Nat param))))] + [sampleI (@;generate (` ( (~ (code;nat subject)) + (~ (code;nat param)))))] (@eval;eval sampleI)) (meta;run (init-compiler [])) (case> (#e;Success valueG) @@ -52,7 +52,7 @@ ($_ seq (test "bit count" (|> (do meta;Monad - [sampleI (@;generate (#ls;Procedure "bit count" (list (#ls;Nat subject))))] + [sampleI (@;generate (` ("bit count" (~ (code;nat subject)))))] (@eval;eval sampleI)) (meta;run (init-compiler [])) (case> (#e;Success valueG) @@ -64,9 +64,9 @@ (test "bit shift-right" (|> (do meta;Monad - [sampleI (@;generate (#ls;Procedure "bit shift-right" - (list (#ls;Int (nat-to-int subject)) - (#ls;Nat param))))] + [sampleI (@;generate (` ("bit shift-right" + (~ (code;int (nat-to-int subject))) + (~ (code;nat param)))))] (@eval;eval sampleI)) (meta;run (init-compiler [])) (case> (#e;Success valueG) @@ -82,64 +82,59 @@ (do @ [param (|> r;nat (r;filter (|>. (n.= +0) not))) subject r;nat] - (with-expansions [ (do-template [ ] - [(test - (|> (do meta;Monad - [sampleI (@;generate (#ls;Procedure (list)))] - (@eval;eval sampleI)) - (meta;run (init-compiler [])) - (case> (#e;Success valueG) - (n.= (:! Nat valueG)) + (`` ($_ seq + (~~ (do-template [ ] + [(test + (|> (do meta;Monad + [sampleI (@;generate (` ()))] + (@eval;eval sampleI)) + (meta;run (init-compiler [])) + (case> (#e;Success valueG) + (n.= (:! Nat valueG)) - _ - false)))] + _ + false)))] - ["nat min" nat/bottom] - ["nat max" nat/top] - ) - (do-template [ ] - [(test - (|> (do meta;Monad - [sampleI (@;generate (#ls;Procedure (list (#ls;Nat subject))))] - (@eval;eval sampleI)) - (meta;run (init-compiler [])) - (case> (#e;Success valueG) - ( ( subject) (:! valueG)) + ["nat min" nat/bottom] + ["nat max" nat/top] + )) + (~~ (do-template [ ] + [(test + (|> (do meta;Monad + [sampleI (@;generate (` ( (~ (code;nat subject)))))] + (@eval;eval sampleI)) + (meta;run (init-compiler [])) + (case> (#e;Success valueG) + ( ( subject) (:! valueG)) - _ - false)))] + _ + false)))] - ["nat to-int" Int nat-to-int i.=] - ["nat to-char" Text text;from-code text/=] - ) - (do-template [ ] - [(test - (|> (do Monad - [runtime-bytecode @runtime;generate - sampleI (@;generate (#ls;Procedure - (list (#ls;Nat subject) - (#ls;Nat param))))] - (@eval;eval sampleI)) - (meta;run (init-compiler [])) - (case> (#e;Success valueG) - ( ( param subject) (:! valueG)) + ["nat to-int" Int nat-to-int i.=] + ["nat to-char" Text text;from-code text/=] + )) + (~~ (do-template [ ] + [(test + (|> (do meta;Monad + [runtime-bytecode @runtime;generate + sampleI (@;generate (` ( (~ (code;nat subject)) (~ (code;nat param)))))] + (@eval;eval sampleI)) + (meta;run (init-compiler [])) + (case> (#e;Success valueG) + ( ( param subject) (:! valueG)) - _ - false)))] + _ + false)))] - ["nat +" n.+ Nat n.=] - ["nat -" n.- Nat n.=] - ["nat *" n.* Nat n.=] - ["nat /" n./ Nat n.=] - ["nat %" n.% Nat n.=] - ["nat =" n.= Bool bool/=] - ["nat <" n.< Bool bool/=] - )] - ($_ seq - - - - ))))) + ["nat +" n.+ Nat n.=] + ["nat -" n.- Nat n.=] + ["nat *" n.* Nat n.=] + ["nat /" n./ Nat n.=] + ["nat %" n.% Nat n.=] + ["nat =" n.= Bool bool/=] + ["nat <" n.< Bool bool/=] + )) + ))))) (context: "Int procedures" (<| (times +100) @@ -149,7 +144,7 @@ (with-expansions [ (do-template [ ] [(test (|> (do meta;Monad - [sampleI (@;generate (#ls;Procedure (list)))] + [sampleI (@;generate (` ()))] (@eval;eval sampleI)) (meta;run (init-compiler [])) (case> (#e;Success valueG) @@ -164,7 +159,7 @@ (do-template [ ] [(test (|> (do meta;Monad - [sampleI (@;generate (#ls;Procedure (list (#ls;Int subject))))] + [sampleI (@;generate (` ( (~ (code;int subject)))))] (@eval;eval sampleI)) (meta;run (init-compiler [])) (case> (#e;Success valueG) @@ -178,11 +173,9 @@ ) (do-template [ ] [(test - (|> (do Monad + (|> (do meta;Monad [runtime-bytecode @runtime;generate - sampleI (@;generate (#ls;Procedure - (list (#ls;Int subject) - (#ls;Int param))))] + sampleI (@;generate (` ( (~ (code;int subject)) (~ (code;int param)))))] (@eval;eval sampleI)) (meta;run (init-compiler [])) (case> (#e;Success valueG) @@ -212,11 +205,9 @@ subject r;frac] (with-expansions [ (do-template [ ] [(test - (|> (do Monad + (|> (do meta;Monad [runtime-bytecode @runtime;generate - sampleI (@;generate (#ls;Procedure - (list (#ls;Frac subject) - (#ls;Frac param))))] + sampleI (@;generate (` ( (~ (code;frac subject)) (~ (code;frac param)))))] (@eval;eval sampleI)) (meta;run (init-compiler [])) (case> (#e;Success valueG) @@ -245,7 +236,7 @@ (with-expansions [ (do-template [ ] [(test (|> (do meta;Monad - [sampleI (@;generate (#ls;Procedure (list)))] + [sampleI (@;generate (` ()))] (@eval;eval sampleI)) (meta;run (init-compiler [])) (case> (#e;Success valueG) @@ -263,9 +254,9 @@ ) (do-template [ ] [(test - (|> (do Monad + (|> (do meta;Monad [runtime-bytecode @runtime;generate - sampleI (@;generate (#ls;Procedure (list (#ls;Frac subject))))] + sampleI (@;generate (` ( (~ (code;frac subject)))))] (@eval;eval sampleI)) (meta;run (init-compiler [])) (case> (#e;Success valueG) @@ -281,11 +272,9 @@ (test "frac encode|decode" - (|> (do Monad + (|> (do meta;Monad [runtime-bytecode @runtime;generate - sampleI (@;generate (|> (#ls;Frac subject) - (list) (#ls;Procedure "frac encode") - (list) (#ls;Procedure "frac decode")))] + sampleI (@;generate (` ("frac decode" ("frac encode" (~ (code;frac subject))))))] (@eval;eval sampleI)) (meta;run (init-compiler [])) (case> (^multi (#e;Success valueG) @@ -313,7 +302,7 @@ (~~ (do-template [ ] [(test (|> (do meta;Monad - [sampleI (@;generate (#ls;Procedure (list)))] + [sampleI (@;generate (` ()))] (@eval;eval sampleI)) (meta;run (init-compiler [])) (case> (#e;Success valueG) @@ -327,9 +316,9 @@ )) (~~ (do-template [ ] [(test - (|> (do Monad + (|> (do meta;Monad [runtime-bytecode @runtime;generate - sampleI (@;generate (#ls;Procedure (list (#ls;Deg subject))))] + sampleI (@;generate (` ( (~ (code;deg subject)))))] (@eval;eval sampleI)) (meta;run (init-compiler [])) (case> (#e;Success valueG) @@ -342,11 +331,9 @@ )) (~~ (do-template [ ] [(test - (|> (do Monad + (|> (do meta;Monad [runtime-bytecode @runtime;generate - sampleI (@;generate (#ls;Procedure - (list (#ls;Deg subject) - (#ls;Deg param))))] + sampleI (@;generate (` ( (~ (code;deg subject)) (~ (code;deg param)))))] (@eval;eval sampleI)) (meta;run (init-compiler [])) (case> (#e;Success valueG) @@ -365,11 +352,9 @@ )) (~~ (do-template [ ] [(test - (|> (do Monad + (|> (do meta;Monad [runtime-bytecode @runtime;generate - sampleI (@;generate (#ls;Procedure - (list (#ls;Deg subject) - (#ls;Nat special))))] + sampleI (@;generate (` ( (~ (code;deg subject)) (~ (code;nat special)))))] (@eval;eval sampleI)) (meta;run (init-compiler [])) (case> (#e;Success valueG) diff --git a/new-luxc/test/test/luxc/generator/procedure/host.jvm.lux b/new-luxc/test/test/luxc/generator/procedure/host.jvm.lux index 7a047dff9..153f276cc 100644 --- a/new-luxc/test/test/luxc/generator/procedure/host.jvm.lux +++ b/new-luxc/test/test/luxc/generator/procedure/host.jvm.lux @@ -12,7 +12,8 @@ text/format (coll [list])) ["r" math/random "r/" Monad] - [meta #+ Monad] + [meta] + (meta [code]) [host] test) (luxc [";L" host] @@ -33,9 +34,7 @@ (with-expansions [<2step> (do-template [ ] [(test (format " / " ) (|> (do meta;Monad - [sampleI (@;generate (|> ( ) - (list) (#ls;Procedure ) - (list) (#ls;Procedure )))] + [sampleI (@;generate (|> (~ ( )) (`)))] (@eval;eval sampleI)) (meta;run (init-compiler [])) (case> (#e;Success valueG) @@ -44,14 +43,14 @@ (#e;Error error) false)))] - ["jvm convert double-to-float" "jvm convert float-to-double" #ls;Frac frac-sample Frac f.=] - ["jvm convert double-to-int" "jvm convert int-to-double" #ls;Frac frac-sample Frac f.=] - ["jvm convert double-to-long" "jvm convert long-to-double" #ls;Frac frac-sample Frac f.=] + ["jvm convert double-to-float" "jvm convert float-to-double" code;frac frac-sample Frac f.=] + ["jvm convert double-to-int" "jvm convert int-to-double" code;frac frac-sample Frac f.=] + ["jvm convert double-to-long" "jvm convert long-to-double" code;frac frac-sample Frac f.=] - ["jvm convert long-to-float" "jvm convert float-to-long" #ls;Int int-sample Int i.=] - ["jvm convert long-to-int" "jvm convert int-to-long" #ls;Int int-sample Int i.=] - ["jvm convert long-to-short" "jvm convert short-to-long" #ls;Int int-sample Int i.=] - ["jvm convert long-to-byte" "jvm convert byte-to-long" #ls;Int int-sample Int i.=] + ["jvm convert long-to-float" "jvm convert float-to-long" code;int int-sample Int i.=] + ["jvm convert long-to-int" "jvm convert int-to-long" code;int int-sample Int i.=] + ["jvm convert long-to-short" "jvm convert short-to-long" code;int int-sample Int i.=] + ["jvm convert long-to-byte" "jvm convert byte-to-long" code;int int-sample Int i.=] )] ($_ seq <2step> @@ -62,52 +61,50 @@ (do @ [int-sample (|> r;int (:: @ map (|>. (i.% 128) int/abs))) #let [frac-sample (int-to-frac int-sample)]] - (with-expansions [<3step> (do-template [ ] - [(test (format " / " " / " ) - (|> (do meta;Monad - [sampleI (@;generate (|> ( ) - (list) (#ls;Procedure ) - (list) (#ls;Procedure ) - (list) (#ls;Procedure )))] - (@eval;eval sampleI)) - (meta;run (init-compiler [])) - (case> (#e;Success valueG) - ( (:! valueG)) - - (#e;Error error) - false)))] - - ["jvm convert long-to-int" "jvm convert int-to-char" "jvm convert char-to-long" #ls;Int int-sample Int i.=] - ["jvm convert long-to-int" "jvm convert int-to-byte" "jvm convert byte-to-long" #ls;Int int-sample Int i.=] - ["jvm convert long-to-int" "jvm convert int-to-short" "jvm convert short-to-long" #ls;Int int-sample Int i.=] - ["jvm convert long-to-float" "jvm convert float-to-int" "jvm convert int-to-long" #ls;Int int-sample Int i.=] - ["jvm convert long-to-int" "jvm convert int-to-float" "jvm convert float-to-long" #ls;Int int-sample Int i.=] - ) - <4step> (do-template [ ] - [(test (format " / " " / " ) - (|> (do meta;Monad - [sampleI (@;generate (|> ( ) - (list) (#ls;Procedure ) - (list) (#ls;Procedure ) - (list) (#ls;Procedure ) - (list) (#ls;Procedure )))] - (@eval;eval sampleI)) - (meta;run (init-compiler [])) - (case> (#e;Success valueG) - ( (:! valueG)) - - (#e;Error error) - false)))] - - ["jvm convert long-to-int" "jvm convert int-to-char" "jvm convert char-to-byte" "jvm convert byte-to-long" #ls;Int int-sample Int i.=] - ["jvm convert long-to-int" "jvm convert int-to-char" "jvm convert char-to-short" "jvm convert short-to-long" #ls;Int int-sample Int i.=] - ["jvm convert long-to-int" "jvm convert int-to-char" "jvm convert char-to-int" "jvm convert int-to-long" #ls;Int int-sample Int i.=] - ) - ] - ($_ seq - <3step> - <4step> - ))))) + (`` ($_ seq + (~~ (do-template [ ] + [(test (format " / " " / " ) + (|> (do meta;Monad + [sampleI (@;generate (|> (~ ( )) (`)))] + (@eval;eval sampleI)) + (meta;run (init-compiler [])) + (case> (#e;Success valueG) + ( (:! valueG)) + + (#e;Error error) + false)))] + + ["jvm convert long-to-int" "jvm convert int-to-char" "jvm convert char-to-long" code;int int-sample Int i.=] + ["jvm convert long-to-int" "jvm convert int-to-byte" "jvm convert byte-to-long" code;int int-sample Int i.=] + ["jvm convert long-to-int" "jvm convert int-to-short" "jvm convert short-to-long" code;int int-sample Int i.=] + ["jvm convert long-to-float" "jvm convert float-to-int" "jvm convert int-to-long" code;int int-sample Int i.=] + ["jvm convert long-to-int" "jvm convert int-to-float" "jvm convert float-to-long" code;int int-sample Int i.=] + )) + ))))) + +(context: "Conversions [Part 3]" + (<| (times +100) + (do @ + [int-sample (|> r;int (:: @ map (|>. (i.% 128) int/abs))) + #let [frac-sample (int-to-frac int-sample)]] + (`` ($_ seq + (~~ (do-template [ ] + [(test (format " / " " / " ) + (|> (do meta;Monad + [sampleI (@;generate (|> (~ ( )) (`)))] + (@eval;eval sampleI)) + (meta;run (init-compiler [])) + (case> (#e;Success valueG) + ( (:! valueG)) + + (#e;Error error) + false)))] + + ["jvm convert long-to-int" "jvm convert int-to-char" "jvm convert char-to-byte" "jvm convert byte-to-long" code;int int-sample Int i.=] + ["jvm convert long-to-int" "jvm convert int-to-char" "jvm convert char-to-short" "jvm convert short-to-long" code;int int-sample Int i.=] + ["jvm convert long-to-int" "jvm convert int-to-char" "jvm convert char-to-int" "jvm convert int-to-long" code;int int-sample Int i.=] + )) + ))))) (def: gen-nat (r;Random Nat) @@ -132,8 +129,9 @@ (with-expansions [ (do-template [ ] [(test (|> (do meta;Monad - [sampleI (@;generate ( (#ls;Procedure (list (
 ( subject))
-                                                                                                                  (
 ( param))))))]
+                                                    [sampleI (@;generate (` ( ((~ (code;text ))
+                                                                                     (
 (~ ( subject)))
+                                                                                     (
 (~ ( param)))))))]
                                                     (@eval;eval sampleI))
                                                   (meta;run (init-compiler []))
                                                   (case> (#e;Success valueG)
@@ -153,64 +151,75 @@
                  
                  )))))]
 
-  ["int" gen-int #ls;Int Int i.= (i.* 10) i.+ i.- i.* i./ i.% (|>. (list) (#ls;Procedure "jvm convert long-to-int")) (|>. (list) (#ls;Procedure "jvm convert int-to-long"))]
-  ["long" gen-int #ls;Int Int i.= (i.* 10) i.+ i.- i.* i./ i.% id id]
-  ["float" gen-frac #ls;Frac Frac f.= (f.* 10.0) f.+ f.- f.* f./ f.% (|>. (list) (#ls;Procedure "jvm convert double-to-float")) (|>. (list) (#ls;Procedure "jvm convert float-to-double"))]
-  ["double" gen-frac #ls;Frac Frac f.= (f.* 10.0) f.+ f.- f.* f./ f.% id id]
+  ["int" gen-int code;int Int i.= (i.* 10) i.+ i.- i.* i./ i.% "jvm convert long-to-int" "jvm convert int-to-long"]
+  ["long" gen-int code;int Int i.= (i.* 10) i.+ i.- i.* i./ i.% "lux noop" "lux noop"]
+  ["float" gen-frac code;frac Frac f.= (f.* 10.0) f.+ f.- f.* f./ f.% "jvm convert double-to-float" "jvm convert float-to-double"]
+  ["double" gen-frac code;frac Frac f.= (f.* 10.0) f.+ f.- f.* f./ f.% "lux noop" "lux noop"]
+  )
+
+(do-template [  ]
+  [(context: (format "Bit-wise ["  "] { Combiners ]")
+     (<| (times +100)
+         (do @
+           [param gen-nat
+            subject gen-nat]
+           (`` ($_ seq
+                   (~~ (do-template [ ]
+                         [(test 
+                                (|> (do meta;Monad
+                                      [sampleI (@;generate (` ( ((~ (code;text ))
+                                                                       ( (~ (code;nat subject)))
+                                                                       ( (~ (code;nat param)))))))]
+                                      (@eval;eval sampleI))
+                                    (meta;run (init-compiler []))
+                                    (case> (#e;Success valueG)
+                                           (n.= ( param subject)
+                                                (:! Nat valueG))
+
+                                           (#e;Error error)
+                                           false)))]
+
+                         [(format "jvm "  " and") bit;and]
+                         [(format "jvm "  " or") bit;or]
+                         [(format "jvm "  " xor") bit;xor]
+                         ))
+                   )))))]
+
+  ["int" "jvm convert int-to-long" "jvm convert long-to-int"]
+  ["long" "lux noop" "lux noop"]
   )
 
 (do-template [  ]
-  [(context: (format "Bit-wise ["  "]")
+  [(context: (format "Bit-wise ["  "] { Shifters }")
      (<| (times +100)
          (do @
            [param gen-nat
             subject gen-nat
             #let [shift (n.% +10 param)]]
-           (with-expansions [ (do-template [ ]
-                                           [(test 
-                                                  (|> (do meta;Monad
-                                                        [sampleI (@;generate ( (#ls;Procedure  (list ( (#ls;Nat subject))
-                                                                                                                      ( (#ls;Nat param))))))]
-                                                        (@eval;eval sampleI))
-                                                      (meta;run (init-compiler []))
-                                                      (case> (#e;Success valueG)
-                                                             (n.= ( param subject)
-                                                                  (:! Nat valueG))
-
-                                                             (#e;Error error)
-                                                             false)))]
-
-                                           [(format "jvm "  " and") bit;and]
-                                           [(format "jvm "  " or") bit;or]
-                                           [(format "jvm "  " xor") bit;xor]
-                                           )
-                              (do-template [     
]
-                                          [(test 
-                                                 (|> (do meta;Monad
-                                                       [sampleI (@;generate ( (#ls;Procedure  (list ( (
 subject))
-                                                                                                                     (|> (#ls;Nat shift)
-                                                                                                                         (list)
-                                                                                                                         (#ls;Procedure "jvm convert long-to-int"))))))]
-                                                       (@eval;eval sampleI))
-                                                     (meta;run (init-compiler []))
-                                                     (case> (#e;Success valueG)
-                                                            ( ( shift ( subject))
-                                                                    (:!  valueG))
-
-                                                            (#e;Error error)
-                                                            false)))]
-
-                                          [(format "jvm "  " shl") bit;shift-left Nat n.= id #ls;Nat]
-                                          [(format "jvm "  " shr") bit;signed-shift-right Int i.= nat-to-int (|>. nat-to-int #ls;Int)]
-                                          [(format "jvm "  " ushr") bit;shift-right Nat n.= id #ls;Nat]
-                                          )]
-             ($_ seq
-                 
-                 
-                 )))))]
-
-  ["int" (|>. (list) (#ls;Procedure "jvm convert int-to-long")) (|>. (list) (#ls;Procedure "jvm convert long-to-int"))]
-  ["long" id id]
+           (`` ($_ seq
+                   (~~ (do-template [     
]
+                         [(test 
+                                (|> (do meta;Monad
+                                      [sampleI (@;generate (` ( ((~ (code;text ))
+                                                                       ( (~ (
 subject)))
+                                                                       ("jvm convert long-to-int" (~ (code;nat shift)))))))]
+                                      (@eval;eval sampleI))
+                                    (meta;run (init-compiler []))
+                                    (case> (#e;Success valueG)
+                                           ( ( shift ( subject))
+                                                   (:!  valueG))
+
+                                           (#e;Error error)
+                                           false)))]
+
+                         [(format "jvm "  " shl") bit;shift-left Nat n.= id code;nat]
+                         [(format "jvm "  " shr") bit;signed-shift-right Int i.= nat-to-int (|>. nat-to-int code;int)]
+                         [(format "jvm "  " ushr") bit;shift-right Nat n.= id code;nat]
+                         ))
+                   )))))]
+
+  ["int" "jvm convert int-to-long" "jvm convert long-to-int"]
+  ["long" "lux noop" "lux noop"]
   )
 
 (do-template [   <=> <<> 
]
@@ -222,8 +231,9 @@
            (with-expansions [ (do-template [ ]
                                        [(test 
                                               (|> (do meta;Monad
-                                                    [sampleI (@;generate (#ls;Procedure  (list (
 ( subject))
-                                                                                                          (
 ( param)))))]
+                                                    [sampleI (@;generate (` ((~ (code;text ))
+                                                                             (
 (~ ( subject)))
+                                                                             (
 (~ ( param))))))]
                                                     (@eval;eval sampleI))
                                                   (meta;run (init-compiler []))
                                                   (case> (#e;Success valueG)
@@ -240,14 +250,25 @@
                  
                  )))))]
 
-  ["int" gen-int #ls;Int i.= i.< (|>. (list) (#ls;Procedure "jvm convert long-to-int"))]
-  ["long" gen-int #ls;Int i.= i.< id]
-  ["float" gen-frac #ls;Frac f.= f.< (|>. (list) (#ls;Procedure "jvm convert double-to-float"))]
-  ["double" gen-frac #ls;Frac f.= f.< id]
-  ["char" gen-int #ls;Int i.= i.< (|>. (list) (#ls;Procedure "jvm convert long-to-int")
-                                       (list) (#ls;Procedure "jvm convert int-to-char"))]
+  ["int" gen-int code;int i.= i.< "jvm convert long-to-int"]
+  ["long" gen-int code;int i.= i.< "lux noop"]
+  ["float" gen-frac code;frac f.= f.< "jvm convert double-to-float"]
+  ["double" gen-frac code;frac f.= f.< "lux noop"]
+  ["char" gen-int code;int i.= i.< "jvm convert long-to-char"]
   )
 
+(def: (jvm//array//new dimension class size)
+  (-> Nat Text Nat ls;Synthesis)
+  (` ("jvm array new" (~ (code;nat dimension)) (~ (code;text class)) (~ (code;nat size)))))
+
+(def: (jvm//array//write class idx inputS arrayS)
+  (-> Text Nat ls;Synthesis ls;Synthesis ls;Synthesis)
+  (` ("jvm array write" (~ (code;text class)) (~ (code;nat idx)) (~ inputS) (~ arrayS))))
+
+(def: (jvm//array//read class idx arrayS)
+  (-> Text Nat ls;Synthesis ls;Synthesis)
+  (` ("jvm array read" (~ (code;text class)) (~ (code;nat idx)) (~ arrayS))))
+
 (context: "Array [Part 1]"
   (<| (times +100)
       (do @
@@ -264,10 +285,12 @@
         (with-expansions [ (do-template [     ]
                                     [(test 
                                            (|> (do meta;Monad
-                                                 [sampleI (@;generate (|> (#ls;Procedure "jvm array new" (list (#ls;Nat +0) (#ls;Text ) (#ls;Nat size)))
-                                                                          (list (#ls;Text ) (#ls;Nat idx) ) (#ls;Procedure "jvm array write")
-                                                                          (list (#ls;Text ) (#ls;Nat idx)) (#ls;Procedure "jvm array read")
-                                                                          ))]
+                                                 [sampleI (@;generate (|> (jvm//array//new +0  size)
+                                                                          (jvm//array//write  idx )
+                                                                          (jvm//array//read  idx)
+                                                                          (~)
+                                                                          
+                                                                          (`)))]
                                                  (@eval;eval sampleI))
                                                (meta;run (init-compiler []))
                                                (case> (#e;Success outputZ)
@@ -276,21 +299,20 @@
                                                       (#e;Error error)
                                                       false)))]
 
-                                    ["boolean" Bool valueZ bool/= (#ls;Bool valueZ) id]
-                                    ["byte" Int valueB i.= (|> (#ls;Int valueB)
-                                                               (list) (#ls;Procedure "jvm convert long-to-byte"))
-                                     (<| (#ls;Procedure "jvm convert byte-to-long") (list))]
-                                    ["short" Int valueS i.= (|> (#ls;Int valueS)
-                                                                (list) (#ls;Procedure "jvm convert long-to-short"))
-                                     (<| (#ls;Procedure "jvm convert short-to-long") (list))]
-                                    ["int" Int valueI i.= (|> (#ls;Int valueI)
-                                                              (list) (#ls;Procedure "jvm convert long-to-int"))
-                                     (<| (#ls;Procedure "jvm convert int-to-long") (list))]
-                                    ["long" Int valueL i.= (#ls;Int valueL) id]
-                                    ["float" Frac valueF f.= (|> (#ls;Frac valueF)
-                                                                 (list) (#ls;Procedure "jvm convert double-to-float"))
-                                     (<| (#ls;Procedure "jvm convert float-to-double") (list))]
-                                    ["double" Frac valueD f.= (#ls;Frac valueD) id]
+                                    ["boolean" Bool valueZ bool/= (code;bool valueZ)
+                                     "lux noop"]
+                                    ["byte" Int valueB i.= (|> (code;int valueB) (~) "jvm convert long-to-byte" (`))
+                                     "jvm convert byte-to-long"]
+                                    ["short" Int valueS i.= (|> (code;int valueS) (~) "jvm convert long-to-short" (`))
+                                     "jvm convert short-to-long"]
+                                    ["int" Int valueI i.= (|> (code;int valueI) (~) "jvm convert long-to-int" (`))
+                                     "jvm convert int-to-long"]
+                                    ["long" Int valueL i.= (code;int valueL)
+                                     "lux noop"]
+                                    ["float" Frac valueF f.= (|> (code;frac valueF) (~) "jvm convert double-to-float" (`))
+                                     "jvm convert float-to-double"]
+                                    ["double" Frac valueD f.= (code;frac valueD)
+                                     "lux noop"]
                                     )]
           ($_ seq
               
@@ -312,10 +334,12 @@
         (with-expansions [ (do-template [     ]
                                     [(test 
                                            (|> (do meta;Monad
-                                                 [sampleI (@;generate (|> (#ls;Procedure "jvm array new" (list (#ls;Nat +0) (#ls;Text ) (#ls;Nat size)))
-                                                                          (list (#ls;Text ) (#ls;Nat idx) ) (#ls;Procedure "jvm array write")
-                                                                          (list (#ls;Text ) (#ls;Nat idx)) (#ls;Procedure "jvm array read")
-                                                                          ))]
+                                                 [sampleI (@;generate (|> (jvm//array//new +0  size)
+                                                                          (jvm//array//write  idx )
+                                                                          (jvm//array//read  idx)
+                                                                          (~)
+                                                                          
+                                                                          (`)))]
                                                  (@eval;eval sampleI))
                                                (meta;run (init-compiler []))
                                                (case> (#e;Success outputG)
@@ -324,22 +348,25 @@
                                                       (#e;Error error)
                                                       false)))]
 
-                                    ["char" Int valueC i.= (|> (#ls;Int valueC)
-                                                               (list) (#ls;Procedure "jvm convert long-to-int")
-                                                               (list) (#ls;Procedure "jvm convert int-to-char"))
-                                     (<| (#ls;Procedure "jvm convert char-to-long") (list))]
-                                    ["java.lang.Long" Int valueL i.= (#ls;Int valueL) id]
+                                    ["char" Int valueC i.=
+                                     (|> (code;int valueC) (~) "jvm convert long-to-int" "jvm convert int-to-char" (`))
+                                     "jvm convert char-to-long"]
+                                    ["java.lang.Long" Int valueL i.=
+                                     (code;int valueL)
+                                     "lux noop"]
                                     )]
           ($_ seq
               
               (test "java.lang.Double (level 1)"
                     (|> (do meta;Monad
-                          [#let [inner (|> (#ls;Procedure "jvm array new" (list (#ls;Nat +0) (#ls;Text "java.lang.Double") (#ls;Nat size)))
-                                           (list (#ls;Text "java.lang.Double") (#ls;Nat idx) (#ls;Frac valueD)) (#ls;Procedure "jvm array write"))]
-                           sampleI (@;generate (|> (#ls;Procedure "jvm array new" (list (#ls;Nat +1) (#ls;Text "java.lang.Double") (#ls;Nat size)))
-                                                   (list (#ls;Text "#Array") (#ls;Nat idx) inner) (#ls;Procedure "jvm array write")
-                                                   (list (#ls;Text "#Array") (#ls;Nat idx)) (#ls;Procedure "jvm array read")
-                                                   (list (#ls;Text "java.lang.Double") (#ls;Nat idx)) (#ls;Procedure "jvm array read")))]
+                          [#let [inner (|> ("jvm array new" +0 "java.lang.Double" (~ (code;nat size)))
+                                           ("jvm array write" "java.lang.Double" (~ (code;nat idx)) (~ (code;frac valueD)))
+                                           (`))]
+                           sampleI (@;generate (|> ("jvm array new" +1 "java.lang.Double" (~ (code;nat size)))
+                                                   ("jvm array write" "#Array" (~ (code;nat idx)) (~ inner))
+                                                   ("jvm array read" "#Array" (~ (code;nat idx)))
+                                                   ("jvm array read" "java.lang.Double" (~ (code;nat idx)))
+                                                   (`)))]
                           (@eval;eval sampleI))
                         (meta;run (init-compiler []))
                         (case> (#e;Success outputG)
@@ -349,8 +376,7 @@
                                false)))
               (test "jvm array length"
                     (|> (do meta;Monad
-                          [sampleI (@;generate (|> (#ls;Procedure "jvm array new" (list (#ls;Nat +0) (#ls;Text "java.lang.Object") (#ls;Nat size)))
-                                                   (list) (#ls;Procedure "jvm array length")))]
+                          [sampleI (@;generate (` ("jvm array length" ("jvm array new" +0 "java.lang.Object" (~ (code;nat size))))))]
                           (@eval;eval sampleI))
                         (meta;run (init-compiler []))
                         (case> (#e;Success outputG)
@@ -370,10 +396,10 @@
 
 (def: instances
   (List [Text (r;Random ls;Synthesis)])
-  (let [gen-boolean (|> r;bool (:: r;Functor map (|>. #ls;Bool)))
-        gen-integer (|> r;int (:: r;Functor map (|>. #ls;Int)))
-        gen-double (|> r;frac (:: r;Functor map (|>. #ls;Frac)))
-        gen-string (|> (r;text +5) (:: r;Functor map (|>. #ls;Text)))]
+  (let [gen-boolean (|> r;bool (:: r;Functor map code;bool))
+        gen-integer (|> r;int (:: r;Functor map code;int))
+        gen-double (|> r;frac (:: r;Functor map code;frac))
+        gen-string (|> (r;text +5) (:: r;Functor map code;text))]
     (list ["java.lang.Boolean" gen-boolean]
           ["java.lang.Long" gen-integer]
           ["java.lang.Double" gen-double]
@@ -393,16 +419,14 @@
          exception-message (r;text +5)
          #let [class (maybe;assume (list;nth class-idx classes))
                [instance-class instance-gen] (maybe;assume (list;nth instance-idx instances))
-               exception-message$ (|> (#ls;Text exception-message)
-                                      (list (#ls;Text "java.lang.String")) #ls;Tuple)]
+               exception-message$ (` ["java.lang.String" (~ (code;text exception-message))])]
          sample r;int
          monitor r;int
          instance instance-gen]
         ($_ seq
             (test "jvm object null"
                   (|> (do meta;Monad
-                        [sampleI (@;generate (|> (#ls;Procedure "jvm object null" (list))
-                                                 (list) (#ls;Procedure "jvm object null?")))]
+                        [sampleI (@;generate (` ("jvm object null?" ("jvm object null"))))]
                         (@eval;eval sampleI))
                       (meta;run (init-compiler []))
                       (case> (#e;Success outputG)
@@ -412,8 +436,7 @@
                              false)))
             (test "jvm object null?"
                   (|> (do meta;Monad
-                        [sampleI (@;generate (|> (#ls;Int sample)
-                                                 (list) (#ls;Procedure "jvm object null?")))]
+                        [sampleI (@;generate (` ("jvm object null?" (~ (code;int sample)))))]
                         (@eval;eval sampleI))
                       (meta;run (init-compiler []))
                       (case> (#e;Success outputG)
@@ -423,9 +446,7 @@
                              false)))
             (test "jvm object synchronized"
                   (|> (do meta;Monad
-                        [sampleI (@;generate (#ls;Procedure "jvm object synchronized"
-                                                            (list (#ls;Int monitor)
-                                                                  (#ls;Int sample))))]
+                        [sampleI (@;generate (` ("jvm object synchronized" (~ (code;int monitor)) (~ (code;int sample)))))]
                         (@eval;eval sampleI))
                       (meta;run (init-compiler []))
                       (case> (#e;Success outputG)
@@ -436,11 +457,10 @@
             (test "jvm object throw"
                   (|> (do meta;Monad
                         [_ @runtime;generate
-                         sampleI (@;generate (|> (#ls;Procedure "jvm member invoke constructor" (list (#ls;Text "java.lang.Throwable")
-                                                                                                      exception-message$))
-                                                 (list) (#ls;Procedure "jvm object throw")
-                                                 (#ls;Function +1 (list))
-                                                 (list) (#ls;Procedure "lux try")))]
+                         sampleI (@;generate (` ("lux try" ("lux function" +1 []
+                                                            ("jvm object throw" ("jvm member invoke constructor"
+                                                                                 "java.lang.Throwable"
+                                                                                 (~ exception-message$)))))))]
                         (@eval;eval sampleI))
                       (meta;run (init-compiler []))
                       (case> (#e;Success outputG)
@@ -455,7 +475,7 @@
                              false)))
             (test "jvm object class"
                   (|> (do meta;Monad
-                        [sampleI (@;generate (#ls;Procedure "jvm object class" (list (#ls;Text class))))]
+                        [sampleI (@;generate (` ("jvm object class" (~ (code;text class)))))]
                         (@eval;eval sampleI))
                       (meta;run (init-compiler []))
                       (case> (#e;Success outputG)
@@ -465,8 +485,7 @@
                              false)))
             (test "jvm object instance?"
                   (|> (do meta;Monad
-                        [sampleI (@;generate (#ls;Procedure "jvm object instance?" (list (#ls;Text instance-class)
-                                                                                         instance)))]
+                        [sampleI (@;generate (` ("jvm object instance?" (~ (code;text instance-class)) (~ instance))))]
                         (@eval;eval sampleI))
                       (meta;run (init-compiler []))
                       (case> (#e;Success outputG)
@@ -485,28 +504,18 @@
         [sample-short (|> r;int (:: @ map (|>. int/abs (i.% 100))))
          sample-string (r;text +5)
          other-sample-string (r;text +5)
-         #let [shortS (|> (#ls;Int sample-short)
-                          (list) (#ls;Procedure "jvm convert long-to-short")
-                          (list (#ls;Text "short")) #ls;Tuple)
-               stringS (|> (#ls;Text sample-string)
-                           (list (#ls;Text "java.lang.String")) #ls;Tuple)
-               type-codeS (|> (#ls;Procedure "jvm object null" (list))
-                              (list (#ls;Text "org.omg.CORBA.TypeCode")) #ls;Tuple)
-               idl-typeS (|> (#ls;Procedure "jvm object null" (list))
-                             (list (#ls;Text "org.omg.CORBA.IDLType")) #ls;Tuple)
-               value-member$ (#ls;Procedure "jvm member invoke constructor" (list (#ls;Text "org.omg.CORBA.ValueMember")
-                                                                                  stringS
-                                                                                  stringS
-                                                                                  stringS
-                                                                                  stringS
-                                                                                  type-codeS
-                                                                                  idl-typeS
-                                                                                  shortS))]]
+         #let [shortS (` ["short" ("jvm convert long-to-short" (~ (code;int sample-short)))])
+               stringS (` ["java.lang.String" (~ (code;text sample-string))])
+               type-codeS (` ["org.omg.CORBA.TypeCode" ("jvm object null")])
+               idl-typeS (` ["org.omg.CORBA.IDLType" ("jvm object null")])
+               value-memberS (` ("jvm member invoke constructor"
+                                 "org.omg.CORBA.ValueMember"
+                                 (~ stringS) (~ stringS) (~ stringS) (~ stringS)
+                                 (~ type-codeS) (~ idl-typeS) (~ shortS)))]]
         ($_ seq
             (test "jvm member static get"
                   (|> (do meta;Monad
-                        [sampleI (@;generate (|> (#ls;Procedure "jvm member static get" (list (#ls;Text "java.util.GregorianCalendar") (#ls;Text "AD") (#ls;Text "int")))
-                                                 (list) (#ls;Procedure "jvm convert int-to-long")))]
+                        [sampleI (@;generate (` ("jvm convert int-to-long" ("jvm member static get" "java.util.GregorianCalendar" "AD" "int"))))]
                         (@eval;eval sampleI))
                       (meta;run (init-compiler []))
                       (case> (#e;Success outputG)
@@ -516,8 +525,8 @@
                              false)))
             (test "jvm member static put"
                   (|> (do meta;Monad
-                        [sampleI (@;generate (#ls;Procedure "jvm member static put" (list (#ls;Text "java.awt.datatransfer.DataFlavor") (#ls;Text "allHtmlFlavor") (#ls;Text "java.awt.datatransfer.DataFlavor")
-                                                                                          (#ls;Procedure "jvm member static get" (list (#ls;Text "java.awt.datatransfer.DataFlavor") (#ls;Text "allHtmlFlavor") (#ls;Text "java.awt.datatransfer.DataFlavor"))))))]
+                        [sampleI (@;generate (` ("jvm member static put" "java.awt.datatransfer.DataFlavor" "allHtmlFlavor" "java.awt.datatransfer.DataFlavor"
+                                                 ("jvm member static get" "java.awt.datatransfer.DataFlavor" "allHtmlFlavor" "java.awt.datatransfer.DataFlavor"))))]
                         (@eval;eval sampleI))
                       (meta;run (init-compiler []))
                       (case> (#e;Success outputG)
@@ -527,11 +536,7 @@
                              false)))
             (test "jvm member virtual get"
                   (|> (do meta;Monad
-                        [sampleI (@;generate (|> value-member$
-                                                 (list (#ls;Text "org.omg.CORBA.ValueMember")
-                                                       (#ls;Text "name")
-                                                       (#ls;Text "java.lang.String"))
-                                                 (#ls;Procedure "jvm member virtual get")))]
+                        [sampleI (@;generate (` ("jvm member virtual get" "org.omg.CORBA.ValueMember" "name" "java.lang.String" (~ value-memberS))))]
                         (@eval;eval sampleI))
                       (meta;run (init-compiler []))
                       (case> (#e;Success outputG)
@@ -541,16 +546,9 @@
                              false)))
             (test "jvm member virtual put"
                   (|> (do meta;Monad
-                        [sampleI (@;generate (|> value-member$
-                                                 (list (#ls;Text "org.omg.CORBA.ValueMember")
-                                                       (#ls;Text "name")
-                                                       (#ls;Text "java.lang.String")
-                                                       (#ls;Text other-sample-string))
-                                                 (#ls;Procedure "jvm member virtual put")
-                                                 (list (#ls;Text "org.omg.CORBA.ValueMember")
-                                                       (#ls;Text "name")
-                                                       (#ls;Text "java.lang.String"))
-                                                 (#ls;Procedure "jvm member virtual get")))]
+                        [sampleI (@;generate (` ("jvm member virtual get" "org.omg.CORBA.ValueMember" "name" "java.lang.String"
+                                                 ("jvm member virtual put" "org.omg.CORBA.ValueMember" "name" "java.lang.String"
+                                                  (~ (code;text other-sample-string)) (~ value-memberS)))))]
                         (@eval;eval sampleI))
                       (meta;run (init-compiler []))
                       (case> (#e;Success outputG)
@@ -568,22 +566,14 @@
   (<| (times +100)
       (do @
         [sample (|> r;int (:: @ map (|>. int/abs (i.% 100))))
-         #let [object-longS (|> (#ls;Int sample)
-                                (list (#ls;Text "java.lang.Object")) #ls;Tuple)
-               intS (|> (#ls;Int sample)
-                        (list) (#ls;Procedure "jvm convert long-to-int")
-                        (list (#ls;Text "int")) #ls;Tuple)
-               coded-intS (|> (#ls;Text (int/encode sample))
-                              (list (#ls;Text "java.lang.String")) #ls;Tuple)
-               array-listS (#ls;Procedure "jvm member invoke constructor" (list (#ls;Text "java.util.ArrayList") intS))]]
+         #let [object-longS (` ["java.lang.Object" (~ (code;int sample))])
+               intS (` ["int" ("jvm convert long-to-int" (~ (code;int sample)))])
+               coded-intS (` ["java.lang.String" (~ (code;text (int/encode sample)))])
+               array-listS (` ("jvm member invoke constructor" "java.util.ArrayList" (~ intS)))]]
         ($_ seq
             (test "jvm member invoke static"
                   (|> (do meta;Monad
-                        [sampleI (@;generate (#ls;Procedure "jvm member invoke static"
-                                                            (list (#ls;Text "java.lang.Long")
-                                                                  (#ls;Text "decode")
-                                                                  (#ls;Text "java.lang.Long")
-                                                                  coded-intS)))]
+                        [sampleI (@;generate (` ("jvm member invoke static" "java.lang.Long" "decode" "java.lang.Long" (~ coded-intS))))]
                         (@eval;eval sampleI))
                       (meta;run (init-compiler []))
                       (case> (#e;Success outputG)
@@ -593,12 +583,8 @@
                              false)))
             (test "jvm member invoke virtual"
                   (|> (do meta;Monad
-                        [sampleI (@;generate (|> object-longS
-                                                 (list (#ls;Text "java.lang.Object")
-                                                       (#ls;Text "equals")
-                                                       (#ls;Text "boolean")
-                                                       (#ls;Int sample))
-                                                 (#ls;Procedure "jvm member invoke virtual")))]
+                        [sampleI (@;generate (` ("jvm member invoke virtual" "java.lang.Object" "equals" "boolean"
+                                                 (~ (code;int sample)) (~ object-longS))))]
                         (@eval;eval sampleI))
                       (meta;run (init-compiler []))
                       (case> (#e;Success outputG)
@@ -608,12 +594,8 @@
                              false)))
             (test "jvm member invoke interface"
                   (|> (do meta;Monad
-                        [sampleI (@;generate (#ls;Procedure "jvm member invoke interface"
-                                                            (list (#ls;Text "java.util.Collection")
-                                                                  (#ls;Text "add")
-                                                                  (#ls;Text "boolean")
-                                                                  array-listS
-                                                                  object-longS)))]
+                        [sampleI (@;generate (` ("jvm member invoke interface" "java.util.Collection" "add" "boolean"
+                                                 (~ array-listS) (~ object-longS))))]
                         (@eval;eval sampleI))
                       (meta;run (init-compiler []))
                       (case> (#e;Success outputG)
diff --git a/new-luxc/test/test/luxc/generator/reference.lux b/new-luxc/test/test/luxc/generator/reference.lux
index 32f9c1b80..0e6f9ada5 100644
--- a/new-luxc/test/test/luxc/generator/reference.lux
+++ b/new-luxc/test/test/luxc/generator/reference.lux
@@ -6,6 +6,7 @@
        (data ["e" error])
        ["r" math/random]
        [meta]
+       (meta [code])
        test)
   (luxc (lang ["ls" synthesis])
         ["_;" module]
@@ -46,7 +47,7 @@
                   (|> (do meta;Monad
                         [_ (_module;with-module +0 module-name
                              (statementG;generate-def def-name Int valueI empty-metaI (' {})))
-                         sampleI (exprG;generate (#ls;Definition [module-name def-name]))]
+                         sampleI (exprG;generate (code;symbol [module-name def-name]))]
                         (evalG;eval sampleI))
                       (meta;run (init-compiler []))
                       (case> (#e;Success valueG)
@@ -66,8 +67,8 @@
                   (|> (do meta;Monad
                         [sampleI (caseG;generate-let exprG;generate
                                                      register
-                                                     (#ls;Int value)
-                                                     (#ls;Variable (nat-to-int register)))]
+                                                     (code;int value)
+                                                     (` ((~ (code;int (nat-to-int register))))))]
                         (evalG;eval sampleI))
                       (meta;run (init-compiler []))
                       (case> (#e;Success outputG)
diff --git a/new-luxc/test/test/luxc/generator/structure.lux b/new-luxc/test/test/luxc/generator/structure.lux
index 7a14788b7..3157d85d9 100644
--- a/new-luxc/test/test/luxc/generator/structure.lux
+++ b/new-luxc/test/test/luxc/generator/structure.lux
@@ -11,7 +11,8 @@
              (coll [array]
                    [list]))
        ["r" math/random "r/" Monad]
-       [meta #+ Monad]
+       [meta]
+       (meta [code])
        [host]
        test)
   (luxc [";L" host]
@@ -28,34 +29,34 @@
 
 (def: gen-primitive
   (r;Random ls;Synthesis)
-  (r;either (r;either (r;either (r/wrap #ls;Unit)
-                                (r/map (|>. #ls;Bool) r;bool))
-                      (r;either (r/map (|>. #ls;Nat) r;nat)
-                                (r/map (|>. #ls;Int) r;int)))
-            (r;either (r;either (r/map (|>. #ls;Deg) r;deg)
-                                (r/map (|>. #ls;Frac) r;frac))
-                      (r/map (|>. #ls;Text) (r;text +5)))))
+  (r;either (r;either (r;either (r/wrap (' []))
+                                (r/map code;bool r;bool))
+                      (r;either (r/map code;nat r;nat)
+                                (r/map code;int r;int)))
+            (r;either (r;either (r/map code;deg r;deg)
+                                (r/map code;frac r;frac))
+                      (r/map code;text (r;text +5)))))
 
 (def: (corresponds? [prediction sample])
   (-> [ls;Synthesis Top] Bool)
   (case prediction
-    #ls;Unit
+    [_ (#;Tuple #;Nil)]
     (is hostL;unit (:! Text sample))
 
     (^template [  ]
-      ( prediction')
+      [_ ( prediction')]
       (case (host;try ( prediction' (:!  sample)))
         (#e;Success result)
         result
 
         (#e;Error error)
         false))
-    ([#ls;Bool Bool bool/=]
-     [#ls;Nat  Nat n.=]
-     [#ls;Int  Int i.=]
-     [#ls;Deg  Deg d.=]
-     [#ls;Frac Frac f.=]
-     [#ls;Text Text text/=])
+    ([#;Bool Bool bool/=]
+     [#;Nat  Nat n.=]
+     [#;Int  Int i.=]
+     [#;Deg  Deg d.=]
+     [#;Frac Frac f.=]
+     [#;Text Text text/=])
 
     _
     false
@@ -68,7 +69,7 @@
          members (r;list size gen-primitive)]
         (test "Can generate tuple."
               (|> (do meta;Monad
-                    [sampleI (@;generate (#ls;Tuple members))]
+                    [sampleI (@;generate (code;tuple members))]
                     (@eval;eval sampleI))
                   (meta;run (init-compiler []))
                   (case> (#e;Success valueG)
@@ -87,9 +88,9 @@
          #let [last? (n.= (n.dec num-tags) tag)]
          member gen-primitive]
         (test "Can generate variant."
-              (|> (do Monad
+              (|> (do meta;Monad
                     [runtime-bytecode @runtime;generate
-                     sampleI (@;generate (#ls;Variant tag last? member))]
+                     sampleI (@;generate (` ((~ (code;nat tag)) (~ (code;bool last?)) (~ member))))]
                     (@eval;eval sampleI))
                   (meta;run (init-compiler []))
                   (case> (#e;Success valueG)
diff --git a/new-luxc/test/test/luxc/synthesizer/case/special.lux b/new-luxc/test/test/luxc/synthesizer/case/special.lux
index b369eb532..63a921b68 100644
--- a/new-luxc/test/test/luxc/synthesizer/case/special.lux
+++ b/new-luxc/test/test/luxc/synthesizer/case/special.lux
@@ -39,7 +39,7 @@
                                      outputA]))]]
         (test "Can detect and reify simple 'let' expressions."
               (|> (synthesizer;synthesize letA)
-                  (case> (#ls;Let registerS inputS outputS)
+                  (case> (^ [_ (#;Form (list [_ (#;Text "lux let")] [_ (#;Nat registerS)] inputS outputS))])
                          (and (n.= registerA registerS)
                               (corresponds? inputA inputS)
                               (corresponds? outputA outputS))
@@ -63,7 +63,7 @@
                                      [(#la;BoolP true) thenA])))]]
         (test "Can detect and reify simple 'if' expressions."
               (|> (synthesizer;synthesize ifA)
-                  (case> (#ls;If inputS thenS elseS)
+                  (case> (^ [_ (#;Form (list [_ (#;Text "lux if")] inputS thenS elseS))])
                          (and (corresponds? inputA inputS)
                               (corresponds? thenA thenS)
                               (corresponds? elseA elseS))
diff --git a/new-luxc/test/test/luxc/synthesizer/common.lux b/new-luxc/test/test/luxc/synthesizer/common.lux
index 10b1a88b2..35e7a71ba 100644
--- a/new-luxc/test/test/luxc/synthesizer/common.lux
+++ b/new-luxc/test/test/luxc/synthesizer/common.lux
@@ -1,7 +1,7 @@
 (;module:
   lux
-  (lux (data [bool "B/" Eq]
-             [text "T/" Eq])
+  (lux (data [bool "bool/" Eq]
+             [text "text/" Eq])
        ["r" math/random "r/" Monad])
   (luxc (lang ["la" analysis]
               ["ls" synthesis])))
@@ -19,16 +19,18 @@
 (def: #export (corresponds? analysis synthesis)
   (-> la;Analysis ls;Synthesis Bool)
   (case [analysis synthesis]
+    [#la;Unit [_ (#;Tuple #;Nil)]]
+    true
+    
     (^template [  ]
-      [( valueA) ( valueS)]
+      [( valueA) [_ ( valueS)]]
       ( valueA valueS))
-    ([#la;Unit #ls;Unit is]
-     [#la;Bool #ls;Bool B/=]
-     [#la;Nat  #ls;Nat  n.=]
-     [#la;Int  #ls;Int  i.=]
-     [#la;Deg  #ls;Deg  d.=]
-     [#la;Frac #ls;Frac f.=]
-     [#la;Text #ls;Text T/=])
+    ([#la;Bool #;Bool bool/=]
+     [#la;Nat  #;Nat  n.=]
+     [#la;Int  #;Int  i.=]
+     [#la;Deg  #;Deg  d.=]
+     [#la;Frac #;Frac f.=]
+     [#la;Text #;Text text/=])
 
     _
     false))
diff --git a/new-luxc/test/test/luxc/synthesizer/function.lux b/new-luxc/test/test/luxc/synthesizer/function.lux
index 40aef8c3b..f38a2fab5 100644
--- a/new-luxc/test/test/luxc/synthesizer/function.lux
+++ b/new-luxc/test/test/luxc/synthesizer/function.lux
@@ -114,7 +114,7 @@
         ($_ seq
             (test "Nested functions will get folded together."
                   (|> (synthesizer;synthesize function1)
-                      (case> (#ls;Function args captured output)
+                      (case> (^ [_ (#;Form (list [_ (#;Text "lux function")] [_ (#;Nat args)] [_ (#;Tuple captured)] output))])
                              (and (n.= args1 args)
                                   (corresponds? prediction1 output))
                              
@@ -122,7 +122,8 @@
                              (n.= +0 args1))))
             (test "Folded functions provide direct access to captured variables."
                   (|> (synthesizer;synthesize function2)
-                      (case> (#ls;Function args captured (#ls;Variable output))
+                      (case> (^ [_ (#;Form (list [_ (#;Text "lux function")] [_ (#;Nat args)] [_ (#;Tuple captured)]
+                                                 [_ (#;Form (list [_ (#;Int output)]))]))])
                              (and (n.= args2 args)
                                   (i.= prediction2 output))
                              
@@ -130,7 +131,8 @@
                              false)))
             (test "Folded functions properly offset local variables."
                   (|> (synthesizer;synthesize function3)
-                      (case> (#ls;Function args captured (#ls;Variable output))
+                      (case> (^ [_ (#;Form (list [_ (#;Text "lux function")] [_ (#;Nat args)] [_ (#;Tuple captured)]
+                                                 [_ (#;Form (list [_ (#;Int output)]))]))])
                              (and (n.= args3 args)
                                   (i.= prediction3 output))
                              
@@ -147,7 +149,7 @@
         ($_ seq
             (test "Can synthesize function application."
                   (|> (synthesizer;synthesize (la;apply argsA funcA))
-                      (case> (#ls;Call argsS funcS)
+                      (case> (^ [_ (#;Form (list& [_ (#;Text "lux call")] funcS argsS))])
                              (and (corresponds? funcA funcS)
                                   (list;every? (product;uncurry corresponds?)
                                                (list;zip2 argsA argsS)))
diff --git a/new-luxc/test/test/luxc/synthesizer/loop.lux b/new-luxc/test/test/luxc/synthesizer/loop.lux
index 9b048242d..165408fb6 100644
--- a/new-luxc/test/test/luxc/synthesizer/loop.lux
+++ b/new-luxc/test/test/luxc/synthesizer/loop.lux
@@ -2,9 +2,9 @@
   lux
   (lux [io]
        (control [monad #+ do])
-       (data [bool "B/" Eq]
+       (data [bool "bool/" Eq]
              [number]
-             (coll [list "L/" Functor Fold]
+             (coll [list "list/" Functor Fold]
                    ["s" set])
              text/format)
        ["r" math/random "r/" Monad]
@@ -19,29 +19,29 @@
   (-> ls;Arity ls;Synthesis Bool)
   (loop [exprS exprS]
     (case exprS
-      (#ls;Case inputS pathS)
+      (^ [_ (#;Form (list [_ (#;Text "lux case")] inputS pathS))])
       (loop [pathS pathS]
         (case pathS
-          (#ls;AltP leftS rightS)
+          (^ [_ (#;Form (list [_ (#;Text "lux case alt")] leftS rightS))])
           (or (recur leftS)
               (recur rightS))
 
-          (#ls;SeqP leftS rightS)
+          (^ [_ (#;Form (list [_ (#;Text "lux case seq")] leftS rightS))])
           (recur rightS)
-          
-          (#ls;ExecP bodyS)
+
+          (^ [_ (#;Form (list [_ (#;Text "lux case exec")] bodyS))])
           (does-recursion? arity bodyS)
           
           _
           false))
 
-      (#ls;Recur argsS)
+      (^ [_ (#;Form (list& [_ (#;Text "lux recur")] argsS))])
       (n.= arity (list;size argsS))
 
-      (#ls;Let register inputS bodyS)
+      (^ [_ (#;Form (list [_ (#;Text "lux let")] register inputS bodyS))])
       (recur bodyS)
 
-      (#ls;If inputS thenS elseS)
+      (^ [_ (#;Form (list [_ (#;Text "lux if")] inputS thenS elseS))])
       (or (recur thenS)
           (recur elseS))
 
@@ -56,14 +56,14 @@
                         [inputA (|> r;nat (:: @ map (|>. #la;Nat)))
                          num-cases (|> r;nat (:: @ map (|>. (n.% +10) (n.max +1))))
                          tests (|> (r;set number;Hash num-cases r;nat)
-                                   (:: @ map (|>. s;to-list (L/map (|>. #la;NatP)))))
+                                   (:: @ map (|>. s;to-list (list/map (|>. #la;NatP)))))
                          #let [bad-bodies (list;repeat num-cases #la;Unit)]
                          good-body (gen-body arity output)
                          where-to-set (|> r;nat (:: @ map (n.% num-cases)))
                          #let [bodies (list;concat (list (list;take where-to-set bad-bodies)
                                                          (list good-body)
                                                          (list;drop (n.inc where-to-set) bad-bodies)))]]
-                        (wrap (#ls;Case inputA
+                        (wrap (#la;Case inputA
                                         (list;zip2 tests bodies)))))
             (r;either (do r;Monad
                         [valueS r;bool
@@ -73,8 +73,8 @@
                         [valueS r;bool
                          then|else r;bool
                          output' (gen-body arity output)
-                         #let [thenA (if then|else output' #ls;Unit)
-                               elseA (if (not then|else) output' #ls;Unit)]]
+                         #let [thenA (if then|else output' #la;Unit)
+                               elseA (if (not then|else) output' #la;Unit)]]
                         (wrap (#la;Case (#la;Bool valueS)
                                         (list [(#la;BoolP then|else) thenA]
                                               [(#la;BoolP (not then|else)) elseA])))))
@@ -82,10 +82,10 @@
 
 (def: (make-apply func args)
   (-> la;Analysis (List la;Analysis) la;Analysis)
-  (L/fold (function [arg' func']
-            (#la;Apply arg' func'))
-          func
-          args))
+  (list/fold (function [arg' func']
+               (#la;Apply arg' func'))
+             func
+             args))
 
 (def: (make-function arity body)
   (-> ls;Arity la;Analysis la;Analysis)
@@ -141,10 +141,10 @@
         ($_ seq
             (test "Can accurately identify (and then reify) tail recursion."
                   (case (synthesizer;synthesize analysis)
-                    (#ls;Function _arity _env _body)
+                    (^ [_ (#;Form (list [_ (#;Text "lux function")] [_ (#;Nat _arity)] [_ (#;Tuple _env)] _body))])
                     (|> _body
                         (does-recursion? arity)
-                        (B/= prediction)
+                        (bool/= prediction)
                         (and (n.= arity _arity)))
 
                     _
@@ -157,11 +157,13 @@
         ($_ seq
             (test "Can reify loops."
                   (case (synthesizer;synthesize (make-apply analysis (list;repeat arity #la;Unit)))
-                    (#ls;Loop _register _inits _body)
+                    (^ [_ (#;Form (list [_ (#;Text "lux loop")] [_ (#;Nat in_register)] [_ (#;Tuple _inits)] _body))])
                     (and (n.= arity (list;size _inits))
                          (not (&&loop;contains-self-reference? _body)))
 
-                    (#ls;Call argsS (#ls;Function _arity _env _bodyS))
+                    (^ [_ (#;Form (list& [_ (#;Text "lux call")]
+                                         [_ (#;Form (list [_ (#;Text "lux function")] _arity _env _bodyS))]
+                                         argsS))])
                     (&&loop;contains-self-reference? _bodyS)
 
                     _
diff --git a/new-luxc/test/test/luxc/synthesizer/primitive.lux b/new-luxc/test/test/luxc/synthesizer/primitive.lux
index a7fb6913e..e8484697d 100644
--- a/new-luxc/test/test/luxc/synthesizer/primitive.lux
+++ b/new-luxc/test/test/luxc/synthesizer/primitive.lux
@@ -20,22 +20,26 @@
          %deg% r;deg
          %frac% r;frac
          %text% (r;text +5)]
-        (with-expansions
-          [ (do-template [   ]
-                     [(test (format "Can synthesize "  ".")
-                            (|> (synthesizer;synthesize ( ))
-                                (case> ( value)
-                                       (is  value)
+        (`` ($_ seq
+                (test (format "Can synthesize unit.")
+                      (|> (synthesizer;synthesize (#la;Unit []))
+                          (case> [_ (#;Tuple #;Nil)]
+                                 true
 
-                                       _
-                                       false)))]
+                                 _
+                                 false)))
+                (~~ (do-template [   ]
+                      [(test (format "Can synthesize "  ".")
+                             (|> (synthesizer;synthesize ( ))
+                                 (case> [_ ( value)]
+                                        (is  value)
 
-                     ["unit" #la;Unit #ls;Unit []]
-                     ["bool" #la;Bool #ls;Bool %bool%]
-                     ["nat"  #la;Nat  #ls;Nat  %nat%]
-                     ["int"  #la;Int  #ls;Int  %int%]
-                     ["deg"  #la;Deg  #ls;Deg  %deg%]
-                     ["frac" #la;Frac #ls;Frac %frac%]
-                     ["text" #la;Text #ls;Text %text%])]
-          ($_ seq
-              )))))
+                                        _
+                                        false)))]
+
+                      ["bool" #la;Bool #;Bool %bool%]
+                      ["nat"  #la;Nat  #;Nat  %nat%]
+                      ["int"  #la;Int  #;Int  %int%]
+                      ["deg"  #la;Deg  #;Deg  %deg%]
+                      ["frac" #la;Frac #;Frac %frac%]
+                      ["text" #la;Text #;Text %text%])))))))
diff --git a/new-luxc/test/test/luxc/synthesizer/procedure.lux b/new-luxc/test/test/luxc/synthesizer/procedure.lux
index 54f1b1f27..1753dcc47 100644
--- a/new-luxc/test/test/luxc/synthesizer/procedure.lux
+++ b/new-luxc/test/test/luxc/synthesizer/procedure.lux
@@ -24,8 +24,8 @@
         ($_ seq
             (test "Can synthesize procedure calls."
                   (|> (synthesizer;synthesize (#la;Procedure nameA argsA))
-                      (case> (#ls;Procedure nameS argsS)
-                             (and (T/= nameA nameS)
+                      (case> (^ [_ (#;Form (list& [_ (#;Text procedure)] argsS))])
+                             (and (T/= nameA procedure)
                                   (list;every? (product;uncurry corresponds?)
                                                (list;zip2 argsA argsS)))
                              
diff --git a/new-luxc/test/test/luxc/synthesizer/structure.lux b/new-luxc/test/test/luxc/synthesizer/structure.lux
index 441f422bb..517f087d1 100644
--- a/new-luxc/test/test/luxc/synthesizer/structure.lux
+++ b/new-luxc/test/test/luxc/synthesizer/structure.lux
@@ -22,7 +22,7 @@
         ($_ seq
             (test "Can synthesize variants."
                   (|> (synthesizer;synthesize (la;sum tagA size +0 memberA))
-                      (case> (#ls;Variant tagS last?S memberS)
+                      (case> (^ [_ (#;Form (list [_ (#;Nat tagS)] [_ (#;Bool last?S)] memberS))])
                              (and (n.= tagA tagS)
                                   (B/= (n.= (n.dec size) tagA)
                                        last?S)
@@ -40,7 +40,7 @@
         ($_ seq
             (test "Can synthesize tuple."
                   (|> (synthesizer;synthesize (la;product membersA))
-                      (case> (#ls;Tuple membersS)
+                      (case> [_ (#;Tuple membersS)]
                              (and (n.= size (list;size membersS))
                                   (list;every? (product;uncurry corresponds?) (list;zip2 membersA membersS)))
 
-- 
cgit v1.2.3