From cdb310ae9918b7887f3b0c00916e26a30be57e0d Mon Sep 17 00:00:00 2001 From: Eduardo Julian Date: Sun, 28 Jan 2018 20:37:28 -0400 Subject: - Got the tests to build again. --- new-luxc/test/test/luxc/common.lux | 4 +- .../test/luxc/lang/analysis/procedure/host.jvm.lux | 10 +- new-luxc/test/test/luxc/lang/analysis/type.lux | 2 +- .../test/test/luxc/lang/synthesis/case/special.lux | 10 +- .../test/test/luxc/lang/synthesis/function.lux | 11 +- new-luxc/test/test/luxc/lang/synthesis/loop.lux | 9 +- .../test/test/luxc/lang/synthesis/primitive.lux | 5 +- .../test/test/luxc/lang/synthesis/procedure.lux | 6 +- .../test/test/luxc/lang/synthesis/structure.lux | 7 +- new-luxc/test/test/luxc/lang/translation/case.lux | 105 ---- .../test/test/luxc/lang/translation/function.lux | 103 ---- .../test/test/luxc/lang/translation/jvm/case.lux | 105 ++++ .../test/luxc/lang/translation/jvm/function.lux | 103 ++++ .../test/luxc/lang/translation/jvm/primitive.lux | 65 +++ .../lang/translation/jvm/procedure/common.jvm.lux | 385 +++++++++++++ .../lang/translation/jvm/procedure/host.jvm.lux | 640 +++++++++++++++++++++ .../test/luxc/lang/translation/jvm/reference.lux | 76 +++ .../test/luxc/lang/translation/jvm/structure.lux | 113 ++++ .../test/test/luxc/lang/translation/primitive.lux | 65 --- .../luxc/lang/translation/procedure/common.jvm.lux | 385 ------------- .../luxc/lang/translation/procedure/host.jvm.lux | 640 --------------------- .../test/test/luxc/lang/translation/reference.lux | 82 --- .../test/test/luxc/lang/translation/structure.lux | 113 ---- new-luxc/test/tests.lux | 14 +- 24 files changed, 1532 insertions(+), 1526 deletions(-) delete mode 100644 new-luxc/test/test/luxc/lang/translation/case.lux delete mode 100644 new-luxc/test/test/luxc/lang/translation/function.lux create mode 100644 new-luxc/test/test/luxc/lang/translation/jvm/case.lux create mode 100644 new-luxc/test/test/luxc/lang/translation/jvm/function.lux create mode 100644 new-luxc/test/test/luxc/lang/translation/jvm/primitive.lux create mode 100644 new-luxc/test/test/luxc/lang/translation/jvm/procedure/common.jvm.lux create mode 100644 new-luxc/test/test/luxc/lang/translation/jvm/procedure/host.jvm.lux create mode 100644 new-luxc/test/test/luxc/lang/translation/jvm/reference.lux create mode 100644 new-luxc/test/test/luxc/lang/translation/jvm/structure.lux delete mode 100644 new-luxc/test/test/luxc/lang/translation/primitive.lux delete mode 100644 new-luxc/test/test/luxc/lang/translation/procedure/common.jvm.lux delete mode 100644 new-luxc/test/test/luxc/lang/translation/procedure/host.jvm.lux delete mode 100644 new-luxc/test/test/luxc/lang/translation/reference.lux delete mode 100644 new-luxc/test/test/luxc/lang/translation/structure.lux (limited to 'new-luxc/test') diff --git a/new-luxc/test/test/luxc/common.lux b/new-luxc/test/test/luxc/common.lux index 914e31893..5ec4b1259 100644 --- a/new-luxc/test/test/luxc/common.lux +++ b/new-luxc/test/test/luxc/common.lux @@ -2,8 +2,8 @@ lux (lux [io]) (luxc (lang ["&." host] - [".L" translation]))) + [".L" init]))) (def: #export (init-compiler _) (-> Top Compiler) - (translationL.init-compiler (io.run &host.init-host))) + (initL.compiler (io.run &host.init-host))) diff --git a/new-luxc/test/test/luxc/lang/analysis/procedure/host.jvm.lux b/new-luxc/test/test/luxc/lang/analysis/procedure/host.jvm.lux index 41b2dfaa0..382ad87e2 100644 --- a/new-luxc/test/test/luxc/lang/analysis/procedure/host.jvm.lux +++ b/new-luxc/test/test/luxc/lang/analysis/procedure/host.jvm.lux @@ -22,10 +22,9 @@ ["&." module] ["~" analysis] (analysis [".A" expression] - ["@." common] - ["@" procedure] - (procedure ["@." host])) - (translation ["@." runtime]) + ["@." common]) + (translation (jvm ["@." runtime])) + (extension (analysis ["@." host])) [".L" eval])) (/// common) (test/luxc common)) @@ -37,7 +36,8 @@ [runtime-bytecode @runtime.translate] (&.with-scope (&.with-type output-type - (@.analyse-procedure analyse evalL.eval procedure params)))) + ((expressionA.analyser evalL.eval) + (` ((~ (code.text procedure)) (~+ params))))))) (&.with-current-module "") (macro.run (init-compiler [])) (case> (#e.Success _) diff --git a/new-luxc/test/test/luxc/lang/analysis/type.lux b/new-luxc/test/test/luxc/lang/analysis/type.lux index 993cacbdf..4de75b989 100644 --- a/new-luxc/test/test/luxc/lang/analysis/type.lux +++ b/new-luxc/test/test/luxc/lang/analysis/type.lux @@ -22,7 +22,7 @@ (analysis [".A" expression] ["@" type] ["@." common]) - (translation ["@." runtime]) + (translation (jvm ["@." runtime])) [eval])) (// common) (test/luxc common)) diff --git a/new-luxc/test/test/luxc/lang/synthesis/case/special.lux b/new-luxc/test/test/luxc/lang/synthesis/case/special.lux index 4e00163ae..398f98a57 100644 --- a/new-luxc/test/test/luxc/lang/synthesis/case/special.lux +++ b/new-luxc/test/test/luxc/lang/synthesis/case/special.lux @@ -9,6 +9,7 @@ (luxc (lang ["la" analysis] ["ls" synthesis] (synthesis [".S" expression]) + [".L" extension] [".L" variable #+ Variable])) (/// common)) @@ -21,7 +22,8 @@ {("lux case bind" (~ (code.nat temp))) (~ (la.var (variableL.local temp)))}))]] (test "Dummy variables created to mask expressions get eliminated during synthesis." - (|> (expressionS.synthesize maskA) + (|> (expressionS.synthesize extensionL.no-syntheses + maskA) (corresponds? maskedA)))))) (context: "Let expressions." @@ -34,7 +36,8 @@ {("lux case bind" (~ (code.nat registerA))) (~ outputA)}))]] (test "Can detect and reify simple 'let' expressions." - (|> (expressionS.synthesize letA) + (|> (expressionS.synthesize extensionL.no-syntheses + letA) (case> (^ [_ (#.Form (list [_ (#.Text "lux let")] [_ (#.Nat registerS)] inputS outputS))]) (and (n/= registerA registerS) (corresponds? inputA inputS) @@ -58,7 +61,8 @@ {false (~ elseA) true (~ thenA)})))]] (test "Can detect and reify simple 'if' expressions." - (|> (expressionS.synthesize ifA) + (|> (expressionS.synthesize extensionL.no-syntheses + ifA) (case> (^ [_ (#.Form (list [_ (#.Text "lux if")] inputS thenS elseS))]) (and (corresponds? inputA inputS) (corresponds? thenA thenS) diff --git a/new-luxc/test/test/luxc/lang/synthesis/function.lux b/new-luxc/test/test/luxc/lang/synthesis/function.lux index 52a9d78db..bb3aa9204 100644 --- a/new-luxc/test/test/luxc/lang/synthesis/function.lux +++ b/new-luxc/test/test/luxc/lang/synthesis/function.lux @@ -16,6 +16,7 @@ (luxc (lang ["la" analysis] ["ls" synthesis] (synthesis [".S" expression]) + [".L" extension] [".L" variable #+ Variable])) (// common)) @@ -101,7 +102,7 @@ [args3 prediction3 function3] gen-function//local] ($_ seq (test "Nested functions will get folded together." - (|> (expressionS.synthesize function1) + (|> (expressionS.synthesize extensionL.no-syntheses function1) (case> (^ [_ (#.Form (list [_ (#.Text "lux function")] [_ (#.Nat args)] [_ (#.Tuple captured)] output))]) (and (n/= args1 args) (corresponds? prediction1 output)) @@ -109,7 +110,7 @@ _ (n/= +0 args1)))) (test "Folded functions provide direct access to captured variables." - (|> (expressionS.synthesize function2) + (|> (expressionS.synthesize extensionL.no-syntheses function2) (case> (^ [_ (#.Form (list [_ (#.Text "lux function")] [_ (#.Nat args)] [_ (#.Tuple captured)] [_ (#.Form (list [_ (#.Int output)]))]))]) (and (n/= args2 args) @@ -118,7 +119,7 @@ _ false))) (test "Folded functions properly offset local variables." - (|> (expressionS.synthesize function3) + (|> (expressionS.synthesize extensionL.no-syntheses function3) (case> (^ [_ (#.Form (list [_ (#.Text "lux function")] [_ (#.Nat args)] [_ (#.Tuple captured)] [_ (#.Form (list [_ (#.Int output)]))]))]) (and (n/= args3 args) @@ -136,7 +137,7 @@ argsA (r.list num-args gen-primitive)] ($_ seq (test "Can synthesize function application." - (|> (expressionS.synthesize (la.apply argsA funcA)) + (|> (expressionS.synthesize extensionL.no-syntheses (la.apply argsA funcA)) (case> (^ [_ (#.Form (list& [_ (#.Text "lux call")] funcS argsS))]) (and (corresponds? funcA funcS) (list.every? (product.uncurry corresponds?) @@ -145,6 +146,6 @@ _ false))) (test "Function application on no arguments just synthesizes to the function itself." - (|> (expressionS.synthesize (la.apply (list) funcA)) + (|> (expressionS.synthesize extensionL.no-syntheses (la.apply (list) funcA)) (corresponds? funcA))) )))) diff --git a/new-luxc/test/test/luxc/lang/synthesis/loop.lux b/new-luxc/test/test/luxc/lang/synthesis/loop.lux index 805c66190..5d2db50a8 100644 --- a/new-luxc/test/test/luxc/lang/synthesis/loop.lux +++ b/new-luxc/test/test/luxc/lang/synthesis/loop.lux @@ -13,7 +13,8 @@ (luxc (lang ["la" analysis] ["ls" synthesis] (synthesis [".S" expression] - [".S" loop]))) + [".S" loop]) + [".L" extension])) (// common)) (def: (does-recursion? arity exprS) @@ -129,7 +130,8 @@ [[prediction arity analysis] gen-recursion] ($_ seq (test "Can accurately identify (and then reify) tail recursion." - (case (expressionS.synthesize analysis) + (case (expressionS.synthesize extensionL.no-syntheses + analysis) (^ [_ (#.Form (list [_ (#.Text "lux function")] [_ (#.Nat _arity)] [_ (#.Tuple _env)] _body))]) (|> _body (does-recursion? arity) @@ -145,7 +147,8 @@ [[prediction arity analysis] gen-recursion] ($_ seq (test "Can reify loops." - (case (expressionS.synthesize (la.apply (list.repeat arity (' [])) analysis)) + (case (expressionS.synthesize extensionL.no-syntheses + (la.apply (list.repeat arity (' [])) analysis)) (^ [_ (#.Form (list [_ (#.Text "lux loop")] [_ (#.Nat in_register)] [_ (#.Tuple _inits)] _body))]) (and (n/= arity (list.size _inits)) (not (loopS.contains-self-reference? _body))) diff --git a/new-luxc/test/test/luxc/lang/synthesis/primitive.lux b/new-luxc/test/test/luxc/lang/synthesis/primitive.lux index 157a9c1c3..57064afd9 100644 --- a/new-luxc/test/test/luxc/lang/synthesis/primitive.lux +++ b/new-luxc/test/test/luxc/lang/synthesis/primitive.lux @@ -9,6 +9,7 @@ test) (luxc (lang ["la" analysis] ["ls" synthesis] + [".L" extension] (synthesis [".S" expression])))) (context: "Primitives" @@ -22,7 +23,7 @@ %text% (r.text +5)] (`` ($_ seq (test (format "Can synthesize unit.") - (|> (expressionS.synthesize (' [])) + (|> (expressionS.synthesize extensionL.no-syntheses (' [])) (case> (^code []) true @@ -30,7 +31,7 @@ false))) (~~ (do-template [ ] [(test (format "Can synthesize " ".") - (|> (expressionS.synthesize ( )) + (|> (expressionS.synthesize extensionL.no-syntheses ( )) (case> [_ ( value)] (is value) diff --git a/new-luxc/test/test/luxc/lang/synthesis/procedure.lux b/new-luxc/test/test/luxc/lang/synthesis/procedure.lux index 7b8923248..9648e5add 100644 --- a/new-luxc/test/test/luxc/lang/synthesis/procedure.lux +++ b/new-luxc/test/test/luxc/lang/synthesis/procedure.lux @@ -10,7 +10,8 @@ test) (luxc (lang ["la" analysis] ["ls" synthesis] - (synthesis [".S" expression]))) + (synthesis [".S" expression]) + [".L" extension])) (// common)) (context: "Procedures" @@ -21,7 +22,8 @@ argsA (r.list num-args gen-primitive)] ($_ seq (test "Can synthesize procedure calls." - (|> (expressionS.synthesize (la.procedure nameA argsA)) + (|> (expressionS.synthesize extensionL.no-syntheses + (la.procedure nameA argsA)) (case> (^ [_ (#.Form (list& [_ (#.Text procedure)] argsS))]) (and (text/= nameA procedure) (list.every? (product.uncurry corresponds?) diff --git a/new-luxc/test/test/luxc/lang/synthesis/structure.lux b/new-luxc/test/test/luxc/lang/synthesis/structure.lux index e401149ec..46c9bf2a1 100644 --- a/new-luxc/test/test/luxc/lang/synthesis/structure.lux +++ b/new-luxc/test/test/luxc/lang/synthesis/structure.lux @@ -10,7 +10,8 @@ test) (luxc (lang ["la" analysis] ["ls" synthesis] - (synthesis [".S" expression]))) + (synthesis [".S" expression]) + [".L" extension])) (// common)) (context: "Variants" @@ -21,7 +22,7 @@ memberA gen-primitive] ($_ seq (test "Can synthesize variants." - (|> (expressionS.synthesize (la.sum tagA size +0 memberA)) + (|> (expressionS.synthesize extensionL.no-syntheses (la.sum tagA size +0 memberA)) (case> (^ [_ (#.Form (list [_ (#.Nat tagS)] [_ (#.Bool last?S)] memberS))]) (and (n/= tagA tagS) (B/= (n/= (n/dec size) tagA) @@ -39,7 +40,7 @@ membersA (r.list size gen-primitive)] ($_ seq (test "Can synthesize tuple." - (|> (expressionS.synthesize (la.product membersA)) + (|> (expressionS.synthesize extensionL.no-syntheses (la.product membersA)) (case> [_ (#.Tuple membersS)] (and (n/= size (list.size membersS)) (list.every? (product.uncurry corresponds?) (list.zip2 membersA membersS))) diff --git a/new-luxc/test/test/luxc/lang/translation/case.lux b/new-luxc/test/test/luxc/lang/translation/case.lux deleted file mode 100644 index 5b3972835..000000000 --- a/new-luxc/test/test/luxc/lang/translation/case.lux +++ /dev/null @@ -1,105 +0,0 @@ -(.module: - lux - (lux [io] - (control [monad #+ do] - pipe) - (data ["e" error] - text/format - (coll [list])) - ["r" math/random "r/" Monad] - [macro] - (macro [code]) - test) - (luxc [lang] - (lang ["ls" synthesis] - (translation ["@" case] - [".T" expression] - ["@." eval] - ["@." runtime] - ["@." common]))) - (test/luxc common)) - -(def: struct-limit Nat +10) - -(def: (tail? size idx) - (-> Nat Nat Bool) - (n/= (n/dec size) idx)) - -(def: gen-case - (r.Random [ls.Synthesis ls.Path]) - (<| r.rec (function [gen-case]) - (`` ($_ r.either - (r/wrap [(' []) (' ("lux case pop"))]) - (~~ (do-template [ ] - [(do r.Monad - [value ] - (wrap [( value) ( value)]))] - - [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 (` [(~+ (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 (` ((~ (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." - (<| (seed +517905247826) - ## (times +100) - (do @ - [[valueS pathS] gen-case - to-bind r.nat] - ($_ seq - (test "Can translate pattern-matching." - (|> (do macro.Monad - [runtime-bytecode @runtime.translate - sampleI (@.translate-case expressionT.translate - valueS - (` ("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)) - (lang.with-current-module "") - (macro.run (init-compiler [])) - (case> (#e.Success valueT) - (:! Bool valueT) - - (#e.Error error) - false))) - (test "Can bind values." - (|> (do macro.Monad - [runtime-bytecode @runtime.translate - sampleI (@.translate-case expressionT.translate - (code.nat to-bind) - (` ("lux case seq" ("lux case bind" +0) - ("lux case exec" (0)))))] - (@eval.eval sampleI)) - (lang.with-current-module "") - (macro.run (init-compiler [])) - (case> (#e.Success valueT) - (n/= to-bind (:! Nat valueT)) - - _ - false))))))) diff --git a/new-luxc/test/test/luxc/lang/translation/function.lux b/new-luxc/test/test/luxc/lang/translation/function.lux deleted file mode 100644 index 7a87e71a1..000000000 --- a/new-luxc/test/test/luxc/lang/translation/function.lux +++ /dev/null @@ -1,103 +0,0 @@ -(.module: - lux - (lux [io] - (control [monad #+ do] - pipe) - (data [product] - [maybe] - ["e" error] - (coll ["a" array] - [list "list/" Functor])) - ["r" math/random "r/" Monad] - [macro] - (macro [code]) - [host] - test) - (luxc [lang] - (lang ["ls" synthesis] - (translation [".T" expression] - ["@." eval] - ["@." runtime] - ["@." common]))) - (test/luxc common)) - -(def: arity-limit Nat +10) - -(def: arity - (r.Random ls.Arity) - (|> r.nat (r/map (|>> (n/% arity-limit) (n/max +1))))) - -(def: gen-function - (r.Random [ls.Arity Nat ls.Synthesis]) - (do r.Monad - [arity arity - arg (|> r.nat (:: @ map (n/% arity))) - #let [functionS (` ("lux function" (~ (code.nat arity)) [] - ((~ (code.int (nat-to-int (n/inc arg)))))))]] - (wrap [arity arg functionS]))) - -(context: "Function." - (<| (times +100) - (do @ - [[arity arg functionS] gen-function - 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 code.nat args) - last-arg (n/dec arity) - cut-off (|> cut-off (n/min (n/dec last-arg)))]] - ($_ seq - (test "Can read arguments." - (|> (do macro.Monad - [runtime-bytecode @runtime.translate - sampleI (expressionT.translate (` ("lux call" (~ functionS) (~+ argsS))))] - (@eval.eval sampleI)) - (lang.with-current-module "") - (macro.run (init-compiler [])) - (case> (#e.Success valueT) - (n/= arg-value (:! Nat valueT)) - - (#e.Error error) - false))) - (test "Can partially apply functions." - (or (n/= +1 arity) - (|> (do macro.Monad - [#let [partial-arity (n/inc cut-off) - preS (list.take partial-arity argsS) - postS (list.drop partial-arity argsS)] - runtime-bytecode @runtime.translate - sampleI (expressionT.translate (` ("lux call" - ("lux call" (~ functionS) (~+ preS)) - (~+ postS))))] - (@eval.eval sampleI)) - (lang.with-current-module "") - (macro.run (init-compiler [])) - (case> (#e.Success valueT) - (n/= arg-value (:! Nat valueT)) - - (#e.Error error) - false)))) - (test "Can read environment." - (or (n/= +1 arity) - (|> (do macro.Monad - [#let [env (|> (list.n/range +0 cut-off) - (list/map (|>> n/inc nat-to-int))) - super-arity (n/inc cut-off) - arg-var (if (n/<= cut-off arg) - (|> arg n/inc nat-to-int (i/* -1)) - (|> arg n/inc (n/- super-arity) nat-to-int)) - sub-arity (|> arity (n/- super-arity)) - 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.translate - sampleI (expressionT.translate (` ("lux call" (~ functionS) (~+ argsS))))] - (@eval.eval sampleI)) - (lang.with-current-module "") - (macro.run (init-compiler [])) - (case> (#e.Success valueT) - (n/= arg-value (:! Nat valueT)) - - (#e.Error error) - false)))) - )))) diff --git a/new-luxc/test/test/luxc/lang/translation/jvm/case.lux b/new-luxc/test/test/luxc/lang/translation/jvm/case.lux new file mode 100644 index 000000000..91071be6c --- /dev/null +++ b/new-luxc/test/test/luxc/lang/translation/jvm/case.lux @@ -0,0 +1,105 @@ +(.module: + lux + (lux [io] + (control [monad #+ do] + pipe) + (data ["e" error] + text/format + (coll [list])) + ["r" math/random "r/" Monad] + [macro] + (macro [code]) + test) + (luxc [lang] + (lang ["ls" synthesis] + (translation (jvm ["@" case] + [".T" expression] + ["@." eval] + ["@." runtime] + ["@." common])))) + (test/luxc common)) + +(def: struct-limit Nat +10) + +(def: (tail? size idx) + (-> Nat Nat Bool) + (n/= (n/dec size) idx)) + +(def: gen-case + (r.Random [ls.Synthesis ls.Path]) + (<| r.rec (function [gen-case]) + (`` ($_ r.either + (r/wrap [(' []) (' ("lux case pop"))]) + (~~ (do-template [ ] + [(do r.Monad + [value ] + (wrap [( value) ( value)]))] + + [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 (` [(~+ (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 (` ((~ (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." + (<| (seed +517905247826) + ## (times +100) + (do @ + [[valueS pathS] gen-case + to-bind r.nat] + ($_ seq + (test "Can translate pattern-matching." + (|> (do macro.Monad + [runtime-bytecode @runtime.translate + sampleI (@.translate-case expressionT.translate + valueS + (` ("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)) + (lang.with-current-module "") + (macro.run (init-compiler [])) + (case> (#e.Success valueT) + (:! Bool valueT) + + (#e.Error error) + false))) + (test "Can bind values." + (|> (do macro.Monad + [runtime-bytecode @runtime.translate + sampleI (@.translate-case expressionT.translate + (code.nat to-bind) + (` ("lux case seq" ("lux case bind" +0) + ("lux case exec" (0)))))] + (@eval.eval sampleI)) + (lang.with-current-module "") + (macro.run (init-compiler [])) + (case> (#e.Success valueT) + (n/= to-bind (:! Nat valueT)) + + _ + false))))))) diff --git a/new-luxc/test/test/luxc/lang/translation/jvm/function.lux b/new-luxc/test/test/luxc/lang/translation/jvm/function.lux new file mode 100644 index 000000000..d9ee7ac71 --- /dev/null +++ b/new-luxc/test/test/luxc/lang/translation/jvm/function.lux @@ -0,0 +1,103 @@ +(.module: + lux + (lux [io] + (control [monad #+ do] + pipe) + (data [product] + [maybe] + ["e" error] + (coll ["a" array] + [list "list/" Functor])) + ["r" math/random "r/" Monad] + [macro] + (macro [code]) + [host] + test) + (luxc [lang] + (lang ["ls" synthesis] + (translation (jvm [".T" expression] + ["@." eval] + ["@." runtime] + ["@." common])))) + (test/luxc common)) + +(def: arity-limit Nat +10) + +(def: arity + (r.Random ls.Arity) + (|> r.nat (r/map (|>> (n/% arity-limit) (n/max +1))))) + +(def: gen-function + (r.Random [ls.Arity Nat ls.Synthesis]) + (do r.Monad + [arity arity + arg (|> r.nat (:: @ map (n/% arity))) + #let [functionS (` ("lux function" (~ (code.nat arity)) [] + ((~ (code.int (nat-to-int (n/inc arg)))))))]] + (wrap [arity arg functionS]))) + +(context: "Function." + (<| (times +100) + (do @ + [[arity arg functionS] gen-function + 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 code.nat args) + last-arg (n/dec arity) + cut-off (|> cut-off (n/min (n/dec last-arg)))]] + ($_ seq + (test "Can read arguments." + (|> (do macro.Monad + [runtime-bytecode @runtime.translate + sampleI (expressionT.translate (` ("lux call" (~ functionS) (~+ argsS))))] + (@eval.eval sampleI)) + (lang.with-current-module "") + (macro.run (init-compiler [])) + (case> (#e.Success valueT) + (n/= arg-value (:! Nat valueT)) + + (#e.Error error) + false))) + (test "Can partially apply functions." + (or (n/= +1 arity) + (|> (do macro.Monad + [#let [partial-arity (n/inc cut-off) + preS (list.take partial-arity argsS) + postS (list.drop partial-arity argsS)] + runtime-bytecode @runtime.translate + sampleI (expressionT.translate (` ("lux call" + ("lux call" (~ functionS) (~+ preS)) + (~+ postS))))] + (@eval.eval sampleI)) + (lang.with-current-module "") + (macro.run (init-compiler [])) + (case> (#e.Success valueT) + (n/= arg-value (:! Nat valueT)) + + (#e.Error error) + false)))) + (test "Can read environment." + (or (n/= +1 arity) + (|> (do macro.Monad + [#let [env (|> (list.n/range +0 cut-off) + (list/map (|>> n/inc nat-to-int))) + super-arity (n/inc cut-off) + arg-var (if (n/<= cut-off arg) + (|> arg n/inc nat-to-int (i/* -1)) + (|> arg n/inc (n/- super-arity) nat-to-int)) + sub-arity (|> arity (n/- super-arity)) + 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.translate + sampleI (expressionT.translate (` ("lux call" (~ functionS) (~+ argsS))))] + (@eval.eval sampleI)) + (lang.with-current-module "") + (macro.run (init-compiler [])) + (case> (#e.Success valueT) + (n/= arg-value (:! Nat valueT)) + + (#e.Error error) + false)))) + )))) diff --git a/new-luxc/test/test/luxc/lang/translation/jvm/primitive.lux b/new-luxc/test/test/luxc/lang/translation/jvm/primitive.lux new file mode 100644 index 000000000..9d51490e2 --- /dev/null +++ b/new-luxc/test/test/luxc/lang/translation/jvm/primitive.lux @@ -0,0 +1,65 @@ +(.module: + lux + (lux [io] + (control [monad #+ do] + pipe) + (data text/format + ["e" error] + [bool "B/" Eq] + [text "T/" Eq]) + ["r" math/random] + [macro] + (macro [code]) + test) + (luxc [lang] + (lang [".L" host] + ["ls" synthesis] + (translation (jvm [".T" expression] + ["@." runtime] + ["@." eval] + ["@." common])))) + (test/luxc common)) + +(context: "Primitives." + (<| (times +100) + (do @ + [%bool% r.bool + %nat% r.nat + %int% r.int + %deg% r.deg + %frac% r.frac + %text% (r.text +5)] + (with-expansions + [ (do-template [ ] + [(test (format "Can translate " ".") + (|> (do macro.Monad + [sampleI (expressionT.translate ( ))] + (@eval.eval sampleI)) + (lang.with-current-module "") + (macro.run (init-compiler [])) + (case> (#e.Success valueT) + ( (:! valueT)) + + (#e.Error error) + false)))] + + ["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 translate unit." + (|> (do macro.Monad + [sampleI (expressionT.translate (' []))] + (@eval.eval sampleI)) + (lang.with-current-module "") + (macro.run (init-compiler [])) + (case> (#e.Success valueT) + (is hostL.unit (:! Text valueT)) + + _ + false))) + + ))))) diff --git a/new-luxc/test/test/luxc/lang/translation/jvm/procedure/common.jvm.lux b/new-luxc/test/test/luxc/lang/translation/jvm/procedure/common.jvm.lux new file mode 100644 index 000000000..8e4fd362f --- /dev/null +++ b/new-luxc/test/test/luxc/lang/translation/jvm/procedure/common.jvm.lux @@ -0,0 +1,385 @@ +(.module: + lux + (lux [io] + (control [monad #+ do] + pipe) + (data text/format + [bit] + ["e" error] + [bool "bool/" Eq] + [text "text/" Eq] + [number "nat/" Interval "int/" Interval "real/" Interval "deg/" Interval] + (coll ["a" array] + [list])) + ["r" math/random] + [macro] + (macro [code]) + [host] + test) + (luxc [lang] + (lang ["ls" synthesis] + (translation (jvm [".T" expression] + ["@." eval] + ["@." runtime] + ["@." common])))) + (test/luxc common)) + +(context: "Bit procedures" + (<| (times +100) + (do @ + [param r.nat + subject r.nat] + (with-expansions [ (do-template [ ] + [(test + (|> (do macro.Monad + [sampleI (expressionT.translate (` ( (~ (code.nat subject)) + (~ (code.nat param)))))] + (@eval.eval sampleI)) + (lang.with-current-module "") + (macro.run (init-compiler [])) + (case> (#e.Success valueT) + (n/= ( param subject) (:! Nat valueT)) + + _ + false)))] + + ["lux bit and" bit.and] + ["lux bit or" bit.or] + ["lux bit xor" bit.xor] + ["lux bit shift-left" bit.shift-left] + ["lux bit unsigned-shift-right" bit.shift-right] + )] + ($_ seq + (test "bit count" + (|> (do macro.Monad + [sampleI (expressionT.translate (` ("lux bit count" (~ (code.nat subject)))))] + (@eval.eval sampleI)) + (lang.with-current-module "") + (macro.run (init-compiler [])) + (case> (#e.Success valueT) + (n/= (bit.count subject) (:! Nat valueT)) + + _ + false))) + + + (test "bit shift-right" + (|> (do macro.Monad + [sampleI (expressionT.translate (` ("lux bit shift-right" + (~ (code.int (nat-to-int subject))) + (~ (code.nat param)))))] + (@eval.eval sampleI)) + (lang.with-current-module "") + (macro.run (init-compiler [])) + (case> (#e.Success valueT) + (i/= (bit.signed-shift-right param (nat-to-int subject)) + (:! Int valueT)) + + _ + false))) + ))))) + +(context: "Nat procedures" + (<| (times +100) + (do @ + [param (|> r.nat (r.filter (|>> (n/= +0) not))) + subject r.nat] + (`` ($_ seq + (~~ (do-template [ ] + [(test + (|> (do macro.Monad + [sampleI (expressionT.translate (` ()))] + (@eval.eval sampleI)) + (lang.with-current-module "") + (macro.run (init-compiler [])) + (case> (#e.Success valueT) + (n/= (:! Nat valueT)) + + _ + false)))] + + ["lux nat min" nat/bottom] + ["lux nat max" nat/top] + )) + (~~ (do-template [ ] + [(test + (|> (do macro.Monad + [sampleI (expressionT.translate (` ( (~ (code.nat subject)))))] + (@eval.eval sampleI)) + (lang.with-current-module "") + (macro.run (init-compiler [])) + (case> (#e.Success valueT) + ( ( subject) (:! valueT)) + + _ + false)))] + + ["lux nat to-int" Int nat-to-int i/=] + ["lux nat char" Text text.from-code text/=] + )) + (~~ (do-template [ ] + [(test + (|> (do macro.Monad + [runtime-bytecode @runtime.translate + sampleI (expressionT.translate (` ( (~ (code.nat subject)) (~ (code.nat param)))))] + (@eval.eval sampleI)) + (lang.with-current-module "") + (macro.run (init-compiler [])) + (case> (#e.Success valueT) + ( ( param subject) (:! valueT)) + + _ + false)))] + + ["lux nat +" n/+ Nat n/=] + ["lux nat -" n/- Nat n/=] + ["lux nat *" n/* Nat n/=] + ["lux nat /" n// Nat n/=] + ["lux nat %" n/% Nat n/=] + ["lux nat =" n/= Bool bool/=] + ["lux nat <" n/< Bool bool/=] + )) + ))))) + +(context: "Int procedures" + (<| (times +100) + (do @ + [param (|> r.int (r.filter (|>> (i/= 0) not))) + subject r.int] + (with-expansions [ (do-template [ ] + [(test + (|> (do macro.Monad + [sampleI (expressionT.translate (` ()))] + (@eval.eval sampleI)) + (lang.with-current-module "") + (macro.run (init-compiler [])) + (case> (#e.Success valueT) + (i/= (:! Int valueT)) + + _ + false)))] + + ["lux int min" int/bottom] + ["lux int max" int/top] + ) + (do-template [ ] + [(test + (|> (do macro.Monad + [sampleI (expressionT.translate (` ( (~ (code.int subject)))))] + (@eval.eval sampleI)) + (lang.with-current-module "") + (macro.run (init-compiler [])) + (case> (#e.Success valueT) + ( ( subject) (:! valueT)) + + _ + false)))] + + ["lux int to-nat" Nat int-to-nat n/=] + ["lux int to-frac" Frac int-to-frac f/=] + ) + (do-template [ ] + [(test + (|> (do macro.Monad + [runtime-bytecode @runtime.translate + sampleI (expressionT.translate (` ( (~ (code.int subject)) (~ (code.int param)))))] + (@eval.eval sampleI)) + (lang.with-current-module "") + (macro.run (init-compiler [])) + (case> (#e.Success valueT) + ( ( param subject) (:! valueT)) + + _ + false)))] + + ["lux int +" i/+ Int i/=] + ["lux int -" i/- Int i/=] + ["lux int *" i/* Int i/=] + ["lux int /" i// Int i/=] + ["lux int %" i/% Int i/=] + ["lux int =" i/= Bool bool/=] + ["lux int <" i/< Bool bool/=] + )] + ($_ seq + + + + ))))) + +(context: "Frac procedures [Part 1]" + (<| (times +100) + (do @ + [param (|> r.frac (r.filter (|>> (f/= 0.0) not))) + subject r.frac] + (with-expansions [ (do-template [ ] + [(test + (|> (do macro.Monad + [runtime-bytecode @runtime.translate + sampleI (expressionT.translate (` ( (~ (code.frac subject)) (~ (code.frac param)))))] + (@eval.eval sampleI)) + (lang.with-current-module "") + (macro.run (init-compiler [])) + (case> (#e.Success valueT) + ( ( param subject) (:! valueT)) + + _ + false)))] + + ["lux frac +" f/+ Frac f/=] + ["lux frac -" f/- Frac f/=] + ["lux frac *" f/* Frac f/=] + ["lux frac /" f// Frac f/=] + ["lux frac %" f/% Frac f/=] + ["lux frac =" f/= Bool bool/=] + ["lux frac <" f/< Bool bool/=] + )] + ($_ seq + + ))))) + +(context: "Frac procedures [Part 2]" + (<| (times +100) + (do @ + [param (|> r.frac (r.filter (|>> (f/= 0.0) not))) + subject r.frac] + (with-expansions [ (do-template [ ] + [(test + (|> (do macro.Monad + [sampleI (expressionT.translate (` ()))] + (@eval.eval sampleI)) + (lang.with-current-module "") + (macro.run (init-compiler [])) + (case> (#e.Success valueT) + ( (:! Frac valueT)) + + _ + false)))] + + ["lux frac min" (f/= real/bottom)] + ["lux frac max" (f/= real/top)] + ["lux frac not-a-number" number.not-a-number?] + ["lux frac positive-infinity" (f/= number.positive-infinity)] + ["lux frac negative-infinity" (f/= number.negative-infinity)] + ["lux frac smallest" (f/= ("lux frac smallest"))] + ) + (do-template [ ] + [(test + (|> (do macro.Monad + [runtime-bytecode @runtime.translate + sampleI (expressionT.translate (` ( (~ (code.frac subject)))))] + (@eval.eval sampleI)) + (lang.with-current-module "") + (macro.run (init-compiler [])) + (case> (#e.Success valueT) + ( ( subject) (:! valueT)) + + _ + false)))] + + ["lux frac to-int" Int frac-to-int i/=] + ["lux frac to-deg" Deg frac-to-deg d/=] + )] + ($_ seq + + + (test "frac encode|decode" + (|> (do macro.Monad + [runtime-bytecode @runtime.translate + sampleI (expressionT.translate (` ("lux frac decode" ("lux frac encode" (~ (code.frac subject))))))] + (@eval.eval sampleI)) + (lang.with-current-module "") + (macro.run (init-compiler [])) + (case> (^multi (#e.Success valueT) + [(:! (Maybe Frac) valueT) (#.Some value)]) + (f/= subject value) + + _ + false))) + ))))) + +(def: (above-threshold value) + (-> Deg Deg) + (let [threshold .000000001 #( 1/(2^30) )#] + (if (d/< threshold value) + (d/+ threshold value) + value))) + +(context: "Deg procedures" + (<| (times +100) + (do @ + [param (|> r.deg (:: @ map above-threshold)) + special r.nat + subject (|> r.deg (:: @ map above-threshold))] + (`` ($_ seq + (~~ (do-template [ ] + [(test + (|> (do macro.Monad + [sampleI (expressionT.translate (` ()))] + (@eval.eval sampleI)) + (lang.with-current-module "") + (macro.run (init-compiler [])) + (case> (#e.Success valueT) + (d/= (:! Deg valueT)) + + _ + false)))] + + ["lux deg min" deg/bottom] + ["lux deg max" deg/top] + )) + (~~ (do-template [ ] + [(test + (|> (do macro.Monad + [runtime-bytecode @runtime.translate + sampleI (expressionT.translate (` ( (~ (code.deg subject)))))] + (@eval.eval sampleI)) + (lang.with-current-module "") + (macro.run (init-compiler [])) + (case> (#e.Success valueT) + ( ( subject) (:! valueT)) + + _ + false)))] + + ["lux deg to-frac" Frac deg-to-frac f/=] + )) + (~~ (do-template [ ] + [(test + (|> (do macro.Monad + [runtime-bytecode @runtime.translate + sampleI (expressionT.translate (` ( (~ (code.deg subject)) (~ (code.deg param)))))] + (@eval.eval sampleI)) + (lang.with-current-module "") + (macro.run (init-compiler [])) + (case> (#e.Success valueT) + ( ( param subject) (:! valueT)) + + _ + false)))] + + ["lux deg +" d/+ Deg d/=] + ["lux deg -" d/- Deg d/=] + ["lux deg *" d/* Deg d/=] + ["lux deg /" d// Deg d/=] + ["lux deg %" d/% Deg d/=] + ["lux deg =" d/= Bool bool/=] + ["lux deg <" d/< Bool bool/=] + )) + (~~ (do-template [ ] + [(test + (|> (do macro.Monad + [runtime-bytecode @runtime.translate + sampleI (expressionT.translate (` ( (~ (code.deg subject)) (~ (code.nat special)))))] + (@eval.eval sampleI)) + (lang.with-current-module "") + (macro.run (init-compiler [])) + (case> (#e.Success valueT) + ( ( special subject) (:! valueT)) + + _ + false)))] + + ["lux deg scale" d/scale Deg d/=] + ["lux deg reciprocal" d/reciprocal Deg d/=] + )) + ))))) diff --git a/new-luxc/test/test/luxc/lang/translation/jvm/procedure/host.jvm.lux b/new-luxc/test/test/luxc/lang/translation/jvm/procedure/host.jvm.lux new file mode 100644 index 000000000..a8e53e79e --- /dev/null +++ b/new-luxc/test/test/luxc/lang/translation/jvm/procedure/host.jvm.lux @@ -0,0 +1,640 @@ +(.module: + lux + (lux [io] + (control [monad #+ do] + pipe) + (data [maybe] + ["e" error] + [bit] + [bool "bool/" Eq] + [number "int/" Number Codec] + [text "text/" Eq] + text/format + (coll [list])) + ["r" math/random "r/" Monad] + [macro] + (macro [code]) + [host] + test) + (luxc [lang] + (lang [".L" host] + ["ls" synthesis] + (translation (jvm [".T" expression] + ["@." eval] + ["@." runtime] + ["@." common])))) + (test/luxc common)) + +(context: "Conversions [Part 1]" + (<| (times +100) + (do @ + [int-sample (|> r.int (:: @ map (i/% 128))) + #let [frac-sample (int-to-frac int-sample)]] + (with-expansions [<2step> (do-template [ ] + [(test (format " / " ) + (|> (do macro.Monad + [sampleI (expressionT.translate (|> (~ ( )) (`)))] + (@eval.eval sampleI)) + (lang.with-current-module "") + (macro.run (init-compiler [])) + (case> (#e.Success valueT) + ( (:! valueT)) + + (#e.Error error) + false)))] + + ["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" 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> + ))))) + +(context: "Conversions [Part 2]" + (<| (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 macro.Monad + [sampleI (expressionT.translate (|> (~ ( )) (`)))] + (@eval.eval sampleI)) + (lang.with-current-module "") + (macro.run (init-compiler [])) + (case> (#e.Success valueT) + ( (:! valueT)) + + (#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 macro.Monad + [sampleI (expressionT.translate (|> (~ ( )) (`)))] + (@eval.eval sampleI)) + (lang.with-current-module "") + (macro.run (init-compiler [])) + (case> (#e.Success valueT) + ( (:! valueT)) + + (#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) + (|> r.nat + (r/map (n/% +128)) + (r.filter (|>> (n/= +0) not)))) + +(def: gen-int + (r.Random Int) + (|> gen-nat (r/map nat-to-int))) + +(def: gen-frac + (r.Random Frac) + (|> gen-int (r/map int-to-frac))) + +(do-template [ <+> <-> <*> <%> 
 ]
+  [(context: (format "Arithmetic ["  "]")
+     (<| (times +100)
+         (do @
+           [param 
+            #let [subject ( param)]]
+           (with-expansions [ (do-template [ ]
+                                       [(test 
+                                              (|> (do macro.Monad
+                                                    [sampleI (expressionT.translate (` ( ((~ (code.text ))
+                                                                                                (
 (~ ( subject)))
+                                                                                                (
 (~ ( param)))))))]
+                                                    (@eval.eval sampleI))
+                                                  (lang.with-current-module "")
+                                                  (macro.run (init-compiler []))
+                                                  (case> (#e.Success valueT)
+                                                         ( ( param subject)
+                                                                 (:!  valueT))
+
+                                                         (#e.Error error)
+                                                         false)))]
+
+                                       [(format "jvm "  " +") <+>]
+                                       [(format "jvm "  " -") <->]
+                                       [(format "jvm "  " *") <*>]
+                                       [(format "jvm "  " /") ]
+                                       [(format "jvm "  " %") <%>]
+                                       )]
+             ($_ seq
+                 
+                 )))))]
+
+  ["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 macro.Monad
+                                      [sampleI (expressionT.translate (` ( ((~ (code.text ))
+                                                                                  ( (~ (code.nat subject)))
+                                                                                  ( (~ (code.nat param)))))))]
+                                      (@eval.eval sampleI))
+                                    (lang.with-current-module "")
+                                    (macro.run (init-compiler []))
+                                    (case> (#e.Success valueT)
+                                           (n/= ( param subject)
+                                                (:! Nat valueT))
+
+                                           (#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 ["  "] { Shifters }")
+     (<| (times +100)
+         (do @
+           [param gen-nat
+            subject gen-nat
+            #let [shift (n/% +10 param)]]
+           (`` ($_ seq
+                   (~~ (do-template [     
]
+                         [(test 
+                                (|> (do macro.Monad
+                                      [sampleI (expressionT.translate (` ( ((~ (code.text ))
+                                                                                  ( (~ (
 subject)))
+                                                                                  ("jvm convert long-to-int" (~ (code.nat shift)))))))]
+                                      (@eval.eval sampleI))
+                                    (lang.with-current-module "")
+                                    (macro.run (init-compiler []))
+                                    (case> (#e.Success valueT)
+                                           ( ( shift ( subject))
+                                                   (:!  valueT))
+
+                                           (#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 [   <=> <<> 
]
+  [(context: (format "Order ["  "]")
+     (<| (times +100)
+         (do @
+           [param 
+            subject ]
+           (with-expansions [ (do-template [ ]
+                                       [(test 
+                                              (|> (do macro.Monad
+                                                    [sampleI (expressionT.translate (` ((~ (code.text ))
+                                                                                        (
 (~ ( subject)))
+                                                                                        (
 (~ ( param))))))]
+                                                    (@eval.eval sampleI))
+                                                  (lang.with-current-module "")
+                                                  (macro.run (init-compiler []))
+                                                  (case> (#e.Success valueT)
+                                                         (bool/= ( param subject)
+                                                                 (:! Bool valueT))
+
+                                                         (#e.Error error)
+                                                         false)))]
+
+                                       [(format "jvm "  " =") <=>]
+                                       [(format "jvm "  " <") <<>]
+                                       )]
+             ($_ seq
+                 
+                 )))))]
+
+  ["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 @
+        [size (|> r.nat (:: @ map (|>> (n/% +10) (n/max +1))))
+         idx (|> r.nat (:: @ map (n/% size)))
+         valueZ r.bool
+         valueB gen-int
+         valueS gen-int
+         valueI gen-int
+         valueL r.int
+         valueF gen-frac
+         valueD r.frac
+         valueC gen-int]
+        (with-expansions [ (do-template [     ]
+                                    [(test 
+                                           (|> (do macro.Monad
+                                                 [sampleI (expressionT.translate (|> (jvm//array//new +0  size)
+                                                                                     (jvm//array//write  idx )
+                                                                                     (jvm//array//read  idx)
+                                                                                     (~)
+                                                                                     
+                                                                                     (`)))]
+                                                 (@eval.eval sampleI))
+                                               (lang.with-current-module "")
+                                               (macro.run (init-compiler []))
+                                               (case> (#e.Success outputZ)
+                                                      (  (:!  outputZ))
+
+                                                      (#e.Error error)
+                                                      false)))]
+
+                                    ["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
+              
+              )))))
+
+(context: "Array [Part 2]"
+  (<| (times +100)
+      (do @
+        [size (|> r.nat (:: @ map (|>> (n/% +10) (n/max +1))))
+         idx (|> r.nat (:: @ map (n/% size)))
+         valueZ r.bool
+         valueB gen-int
+         valueS gen-int
+         valueI gen-int
+         valueL r.int
+         valueF gen-frac
+         valueD r.frac
+         valueC gen-int]
+        (with-expansions [ (do-template [     ]
+                                    [(test 
+                                           (|> (do macro.Monad
+                                                 [sampleI (expressionT.translate (|> (jvm//array//new +0  size)
+                                                                                     (jvm//array//write  idx )
+                                                                                     (jvm//array//read  idx)
+                                                                                     (~)
+                                                                                     
+                                                                                     (`)))]
+                                                 (@eval.eval sampleI))
+                                               (lang.with-current-module "")
+                                               (macro.run (init-compiler []))
+                                               (case> (#e.Success outputT)
+                                                      (  (:!  outputT))
+
+                                                      (#e.Error error)
+                                                      false)))]
+
+                                    ["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 macro.Monad
+                          [#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 (expressionT.translate (|> ("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))
+                        (lang.with-current-module "")
+                        (macro.run (init-compiler []))
+                        (case> (#e.Success outputT)
+                               (f/= valueD (:! Frac outputT))
+
+                               (#e.Error error)
+                               false)))
+              (test "jvm array length"
+                    (|> (do macro.Monad
+                          [sampleI (expressionT.translate (` ("jvm array length" ("jvm array new" +0 "java.lang.Object" (~ (code.nat size))))))]
+                          (@eval.eval sampleI))
+                        (lang.with-current-module "")
+                        (macro.run (init-compiler []))
+                        (case> (#e.Success outputT)
+                               (n/= size (:! Nat outputT))
+
+                               (#e.Error error)
+                               false)))
+              )))))
+
+(host.import java/lang/Class
+  (getName [] String))
+
+(def: classes
+  (List Text)
+  (list "java.lang.Object" "java.lang.Class"
+        "java.lang.String" "java.lang.Number"))
+
+(def: instances
+  (List [Text (r.Random ls.Synthesis)])
+  (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]
+          ["java.lang.String" gen-string]
+          ["java.lang.Object" (r.either (r.either gen-boolean
+                                                  gen-integer)
+                                        (r.either gen-double
+                                                  gen-string))])))
+
+(context: "Object."
+  (<| (times +100)
+      (do @
+        [#let [num-classes (list.size classes)]
+         #let [num-instances (list.size instances)]
+         class-idx (|> r.nat (:: @ map (n/% num-classes)))
+         instance-idx (|> r.nat (:: @ map (n/% num-instances)))
+         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$ (` ["java.lang.String" (~ (code.text exception-message))])]
+         sample r.int
+         monitor r.int
+         instance instance-gen]
+        ($_ seq
+            (test "jvm object null"
+                  (|> (do macro.Monad
+                        [sampleI (expressionT.translate (` ("jvm object null?" ("jvm object null"))))]
+                        (@eval.eval sampleI))
+                      (lang.with-current-module "")
+                      (macro.run (init-compiler []))
+                      (case> (#e.Success outputT)
+                             (:! Bool outputT)
+
+                             (#e.Error error)
+                             false)))
+            (test "jvm object null?"
+                  (|> (do macro.Monad
+                        [sampleI (expressionT.translate (` ("jvm object null?" (~ (code.int sample)))))]
+                        (@eval.eval sampleI))
+                      (lang.with-current-module "")
+                      (macro.run (init-compiler []))
+                      (case> (#e.Success outputT)
+                             (not (:! Bool outputT))
+
+                             (#e.Error error)
+                             false)))
+            (test "jvm object synchronized"
+                  (|> (do macro.Monad
+                        [sampleI (expressionT.translate (` ("jvm object synchronized" (~ (code.int monitor)) (~ (code.int sample)))))]
+                        (@eval.eval sampleI))
+                      (lang.with-current-module "")
+                      (macro.run (init-compiler []))
+                      (case> (#e.Success outputT)
+                             (i/= sample (:! Int outputT))
+
+                             (#e.Error error)
+                             false)))
+            (test "jvm object throw"
+                  (|> (do macro.Monad
+                        [_ @runtime.translate
+                         sampleI (expressionT.translate (` ("lux try" ("lux function" +1 []
+                                                                       ("jvm object throw" ("jvm member invoke constructor"
+                                                                                            "java.lang.Throwable"
+                                                                                            (~ exception-message$)))))))]
+                        (@eval.eval sampleI))
+                      (lang.with-current-module "")
+                      (macro.run (init-compiler []))
+                      (case> (#e.Success outputT)
+                             (case (:! (e.Error Top) outputT)
+                               (#e.Error error)
+                               (text.contains? exception-message error)
+
+                               (#e.Success outputT)
+                               false)
+
+                             (#e.Error error)
+                             false)))
+            (test "jvm object class"
+                  (|> (do macro.Monad
+                        [sampleI (expressionT.translate (` ("jvm object class" (~ (code.text class)))))]
+                        (@eval.eval sampleI))
+                      (lang.with-current-module "")
+                      (macro.run (init-compiler []))
+                      (case> (#e.Success outputT)
+                             (|> outputT (:! Class) (Class::getName []) (text/= class))
+
+                             (#e.Error error)
+                             false)))
+            (test "jvm object instance?"
+                  (|> (do macro.Monad
+                        [sampleI (expressionT.translate (` ("jvm object instance?" (~ (code.text instance-class)) (~ instance))))]
+                        (@eval.eval sampleI))
+                      (lang.with-current-module "")
+                      (macro.run (init-compiler []))
+                      (case> (#e.Success outputT)
+                             (:! Bool outputT)
+
+                             (#e.Error error)
+                             false)))
+            ))))
+
+(host.import java/util/GregorianCalendar
+  (#static AD int))
+
+(context: "Member [Field]"
+  (<| (times +100)
+      (do @
+        [sample-short (|> r.int (:: @ map (|>> int/abs (i/% 100))))
+         sample-string (r.text +5)
+         other-sample-string (r.text +5)
+         #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 macro.Monad
+                        [sampleI (expressionT.translate (` ("jvm convert int-to-long" ("jvm member static get" "java.util.GregorianCalendar" "AD" "int"))))]
+                        (@eval.eval sampleI))
+                      (lang.with-current-module "")
+                      (macro.run (init-compiler []))
+                      (case> (#e.Success outputT)
+                             (i/= GregorianCalendar::AD (:! Int outputT))
+
+                             (#e.Error error)
+                             false)))
+            (test "jvm member static put"
+                  (|> (do macro.Monad
+                        [sampleI (expressionT.translate (` ("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))
+                      (lang.with-current-module "")
+                      (macro.run (init-compiler []))
+                      (case> (#e.Success outputT)
+                             (is hostL.unit (:! Text outputT))
+
+                             (#e.Error error)
+                             false)))
+            (test "jvm member virtual get"
+                  (|> (do macro.Monad
+                        [sampleI (expressionT.translate (` ("jvm member virtual get" "org.omg.CORBA.ValueMember" "name" "java.lang.String" (~ value-memberS))))]
+                        (@eval.eval sampleI))
+                      (lang.with-current-module "")
+                      (macro.run (init-compiler []))
+                      (case> (#e.Success outputT)
+                             (text/= sample-string (:! Text outputT))
+
+                             (#e.Error error)
+                             false)))
+            (test "jvm member virtual put"
+                  (|> (do macro.Monad
+                        [sampleI (expressionT.translate (` ("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))
+                      (lang.with-current-module "")
+                      (macro.run (init-compiler []))
+                      (case> (#e.Success outputT)
+                             (text/= other-sample-string (:! Text outputT))
+
+                             (#e.Error error)
+                             false)))
+            ))))
+
+(host.import java/lang/Object)
+
+(host.import (java/util/ArrayList a))
+
+(context: "Member [Method]"
+  (<| (times +100)
+      (do @
+        [sample (|> r.int (:: @ map (|>> int/abs (i/% 100))))
+         #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 macro.Monad
+                        [sampleI (expressionT.translate (` ("jvm member invoke static" "java.lang.Long" "decode" "java.lang.Long" (~ coded-intS))))]
+                        (@eval.eval sampleI))
+                      (lang.with-current-module "")
+                      (macro.run (init-compiler []))
+                      (case> (#e.Success outputT)
+                             (i/= sample (:! Int outputT))
+
+                             (#e.Error error)
+                             false)))
+            (test "jvm member invoke virtual"
+                  (|> (do macro.Monad
+                        [sampleI (expressionT.translate (` ("jvm member invoke virtual" "java.lang.Object" "equals" "boolean"
+                                                            (~ (code.int sample)) (~ object-longS))))]
+                        (@eval.eval sampleI))
+                      (lang.with-current-module "")
+                      (macro.run (init-compiler []))
+                      (case> (#e.Success outputT)
+                             (:! Bool outputT)
+
+                             (#e.Error error)
+                             false)))
+            (test "jvm member invoke interface"
+                  (|> (do macro.Monad
+                        [sampleI (expressionT.translate (` ("jvm member invoke interface" "java.util.Collection" "add" "boolean"
+                                                            (~ array-listS) (~ object-longS))))]
+                        (@eval.eval sampleI))
+                      (lang.with-current-module "")
+                      (macro.run (init-compiler []))
+                      (case> (#e.Success outputT)
+                             (:! Bool outputT)
+
+                             (#e.Error error)
+                             false)))
+            (test "jvm member invoke constructor"
+                  (|> (do macro.Monad
+                        [sampleI (expressionT.translate array-listS)]
+                        (@eval.eval sampleI))
+                      (lang.with-current-module "")
+                      (macro.run (init-compiler []))
+                      (case> (#e.Success outputT)
+                             (host.instance? ArrayList (:! Object outputT))
+
+                             (#e.Error error)
+                             false)))
+            ))))
diff --git a/new-luxc/test/test/luxc/lang/translation/jvm/reference.lux b/new-luxc/test/test/luxc/lang/translation/jvm/reference.lux
new file mode 100644
index 000000000..ddbefd8d9
--- /dev/null
+++ b/new-luxc/test/test/luxc/lang/translation/jvm/reference.lux
@@ -0,0 +1,76 @@
+(.module:
+  lux
+  (lux [io]
+       (control [monad #+ do]
+                pipe)
+       (data ["e" error]
+             [text])
+       ["r" math/random]
+       [macro]
+       (macro [code])
+       test)
+  (luxc [lang]
+        (lang ["_." module]
+              (host ["$" jvm]
+                    (jvm ["$i" inst]))
+              ["ls" synthesis]
+              (translation (jvm [".T" statement]
+                                [".T" eval]
+                                [".T" expression]
+                                [".T" case]
+                                [".T" runtime]))))
+  (test/luxc common))
+
+(def: nilI $.Inst runtimeT.noneI)
+
+(def: cursorI
+  $.Inst
+  (|>> ($i.int 3)
+       ($i.array runtimeT.$Tuple)
+       $i.DUP ($i.int 0) ($i.string "") $i.AASTORE
+       $i.DUP ($i.int 1) ($i.long 0) ($i.wrap #$.Long) $i.AASTORE
+       $i.DUP ($i.int 2) ($i.long 0) ($i.wrap #$.Long) $i.AASTORE))
+
+(context: "Definitions."
+  (<| (times +100)
+      (do @
+        [module-name (|> (r.text +5) (r.filter (|>> (text.contains? "/") not)))
+         def-name (r.text +5)
+         def-value r.int
+         #let [valueI (|>> ($i.long def-value) ($i.wrap #$.Long))]]
+        ($_ seq
+            (test "Can refer to definitions."
+                  (|> (do macro.Monad
+                        [_ (_module.with-module +0 module-name
+                             (statementT.translate-def def-name Int valueI (' {})))
+                         sampleI (expressionT.translate (code.symbol [module-name def-name]))]
+                        (evalT.eval sampleI))
+                      (lang.with-current-module "")
+                      (macro.run (init-compiler []))
+                      (case> (#e.Success valueT)
+                             (i/= def-value (:! Int valueT))
+
+                             (#e.Error error)
+                             false)))
+            ))))
+
+(context: "Variables."
+  (<| (times +100)
+      (do @
+        [register (|> r.nat (:: @ map (n/% +100)))
+         value r.int]
+        ($_ seq
+            (test "Can refer to local variables/registers."
+                  (|> (do macro.Monad
+                        [sampleI (caseT.translate-let expressionT.translate
+                                                      register
+                                                      (code.int value)
+                                                      (` ((~ (code.int (nat-to-int register))))))]
+                        (evalT.eval sampleI))
+                      (macro.run (init-compiler []))
+                      (case> (#e.Success outputT)
+                             (i/= value (:! Int outputT))
+
+                             (#e.Error error)
+                             false)))
+            ))))
diff --git a/new-luxc/test/test/luxc/lang/translation/jvm/structure.lux b/new-luxc/test/test/luxc/lang/translation/jvm/structure.lux
new file mode 100644
index 000000000..2fc377bd6
--- /dev/null
+++ b/new-luxc/test/test/luxc/lang/translation/jvm/structure.lux
@@ -0,0 +1,113 @@
+(.module:
+  lux
+  (lux [io]
+       (control [monad #+ do]
+                pipe)
+       (data ["e" error]
+             [maybe]
+             [bool "bool/" Eq]
+             [text "text/" Eq]
+             text/format
+             (coll [array]
+                   [list]))
+       ["r" math/random "r/" Monad]
+       [macro]
+       (macro [code])
+       [host]
+       test)
+  (luxc [lang]
+        (lang [".L" host]
+              ["ls" synthesis]
+              (translation (jvm [".T" expression]
+                                ["@." eval]
+                                ["@." runtime]
+                                ["@." common]))))
+  (test/luxc common))
+
+(host.import java/lang/Integer)
+
+(def: gen-primitive
+  (r.Random ls.Synthesis)
+  (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
+    [_ (#.Tuple #.Nil)]
+    (is hostL.unit (:! Text sample))
+
+    (^template [  ]
+      [_ ( prediction')]
+      (case (host.try ( prediction' (:!  sample)))
+        (#e.Success result)
+        result
+
+        (#e.Error error)
+        false))
+    ([#.Bool Bool bool/=]
+     [#.Nat  Nat n/=]
+     [#.Int  Int i/=]
+     [#.Deg  Deg d/=]
+     [#.Frac Frac f/=]
+     [#.Text Text text/=])
+
+    _
+    false
+    ))
+
+(context: "Tuples."
+  (<| (times +100)
+      (do @
+        [size (|> r.nat (:: @ map (|>> (n/% +10) (n/max +2))))
+         members (r.list size gen-primitive)]
+        (test "Can translate tuple."
+              (|> (do macro.Monad
+                    [sampleI (expressionT.translate (code.tuple members))]
+                    (@eval.eval sampleI))
+                  (lang.with-current-module "")
+                  (macro.run (init-compiler []))
+                  (case> (#e.Success valueT)
+                         (let [valueT (:! (Array Top) valueT)]
+                           (and (n/= size (array.size valueT))
+                                (list.every? corresponds? (list.zip2 members (array.to-list valueT)))))
+
+                         _
+                         false))))))
+
+(context: "Variants."
+  (<| (times +100)
+      (do @
+        [num-tags (|> r.nat (:: @ map (|>> (n/% +10) (n/max +2))))
+         tag (|> r.nat (:: @ map (n/% num-tags)))
+         #let [last? (n/= (n/dec num-tags) tag)]
+         member gen-primitive]
+        (test "Can translate variant."
+              (|> (do macro.Monad
+                    [runtime-bytecode @runtime.translate
+                     sampleI (expressionT.translate (` ((~ (code.nat tag)) (~ (code.bool last?)) (~ member))))]
+                    (@eval.eval sampleI))
+                  (lang.with-current-module "")
+                  (macro.run (init-compiler []))
+                  (case> (#e.Success valueT)
+                         (let [valueT (:! (Array Top) valueT)]
+                           (and (n/= +3 (array.size valueT))
+                                (let [_tag (:! Integer (maybe.assume (array.read +0 valueT)))
+                                      _last? (array.read +1 valueT)
+                                      _value (:! Top (maybe.assume (array.read +2 valueT)))]
+                                  (and (n/= tag (|> _tag host.int-to-long int-to-nat))
+                                       (case _last?
+                                         (#.Some _last?')
+                                         (and last? (text/= "" (:! Text _last?')))
+
+                                         #.None
+                                         (not last?))
+                                       (corresponds? [member _value])))))
+
+                         _
+                         false))))))
diff --git a/new-luxc/test/test/luxc/lang/translation/primitive.lux b/new-luxc/test/test/luxc/lang/translation/primitive.lux
deleted file mode 100644
index d6e316036..000000000
--- a/new-luxc/test/test/luxc/lang/translation/primitive.lux
+++ /dev/null
@@ -1,65 +0,0 @@
-(.module:
-  lux
-  (lux [io]
-       (control [monad #+ do]
-                pipe)
-       (data text/format
-             ["e" error]
-             [bool "B/" Eq]
-             [text "T/" Eq])
-       ["r" math/random]
-       [macro]
-       (macro [code])
-       test)
-  (luxc [lang]
-        (lang [".L" host]
-              ["ls" synthesis]
-              (translation [".T" expression]
-                           ["@." runtime]
-                           ["@." eval]
-                           ["@." common])))
-  (test/luxc common))
-
-(context: "Primitives."
-  (<| (times +100)
-      (do @
-        [%bool% r.bool
-         %nat% r.nat
-         %int% r.int
-         %deg% r.deg
-         %frac% r.frac
-         %text% (r.text +5)]
-        (with-expansions
-          [ (do-template [    ]
-                     [(test (format "Can translate "  ".")
-                            (|> (do macro.Monad
-                                  [sampleI (expressionT.translate ( ))]
-                                  (@eval.eval sampleI))
-                                (lang.with-current-module "")
-                                (macro.run (init-compiler []))
-                                (case> (#e.Success valueT)
-                                       (  (:!  valueT))
-
-                                       (#e.Error error)
-                                       false)))]
-
-                     ["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 translate unit."
-                    (|> (do macro.Monad
-                          [sampleI (expressionT.translate (' []))]
-                          (@eval.eval sampleI))
-                        (lang.with-current-module "")
-                        (macro.run (init-compiler []))
-                        (case> (#e.Success valueT)
-                               (is hostL.unit (:! Text valueT))
-
-                               _
-                               false)))
-              
-              )))))
diff --git a/new-luxc/test/test/luxc/lang/translation/procedure/common.jvm.lux b/new-luxc/test/test/luxc/lang/translation/procedure/common.jvm.lux
deleted file mode 100644
index 96cf8b01e..000000000
--- a/new-luxc/test/test/luxc/lang/translation/procedure/common.jvm.lux
+++ /dev/null
@@ -1,385 +0,0 @@
-(.module:
-  lux
-  (lux [io]
-       (control [monad #+ do]
-                pipe)
-       (data text/format
-             [bit]
-             ["e" error]
-             [bool "bool/" Eq]
-             [text "text/" Eq]
-             [number "nat/" Interval "int/" Interval "real/" Interval "deg/" Interval]
-             (coll ["a" array]
-                   [list]))
-       ["r" math/random]
-       [macro]
-       (macro [code])
-       [host]
-       test)
-  (luxc [lang]
-        (lang ["ls" synthesis]
-              (translation [".T" expression]
-                           ["@." eval]
-                           ["@." runtime]
-                           ["@." common])))
-  (test/luxc common))
-
-(context: "Bit procedures"
-  (<| (times +100)
-      (do @
-        [param r.nat
-         subject r.nat]
-        (with-expansions [ (do-template [ ]
-                                     [(test 
-                                            (|> (do macro.Monad
-                                                  [sampleI (expressionT.translate (` ( (~ (code.nat subject))
-                                                                                             (~ (code.nat param)))))]
-                                                  (@eval.eval sampleI))
-                                                (lang.with-current-module "")
-                                                (macro.run (init-compiler []))
-                                                (case> (#e.Success valueT)
-                                                       (n/= ( param subject) (:! Nat valueT))
-
-                                                       _
-                                                       false)))]
-
-                                     ["lux bit and"                  bit.and]
-                                     ["lux bit or"                   bit.or]
-                                     ["lux bit xor"                  bit.xor]
-                                     ["lux bit shift-left"           bit.shift-left]
-                                     ["lux bit unsigned-shift-right" bit.shift-right]
-                                     )]
-          ($_ seq
-              (test "bit count"
-                    (|> (do macro.Monad
-                          [sampleI (expressionT.translate (` ("lux bit count" (~ (code.nat subject)))))]
-                          (@eval.eval sampleI))
-                        (lang.with-current-module "")
-                        (macro.run (init-compiler []))
-                        (case> (#e.Success valueT)
-                               (n/= (bit.count subject) (:! Nat valueT))
-
-                               _
-                               false)))
-
-              
-              (test "bit shift-right"
-                    (|> (do macro.Monad
-                          [sampleI (expressionT.translate (` ("lux bit shift-right"
-                                                              (~ (code.int (nat-to-int subject)))
-                                                              (~ (code.nat param)))))]
-                          (@eval.eval sampleI))
-                        (lang.with-current-module "")
-                        (macro.run (init-compiler []))
-                        (case> (#e.Success valueT)
-                               (i/= (bit.signed-shift-right param (nat-to-int subject))
-                                    (:! Int valueT))
-
-                               _
-                               false)))
-              )))))
-
-(context: "Nat procedures"
-  (<| (times +100)
-      (do @
-        [param (|> r.nat (r.filter (|>> (n/= +0) not)))
-         subject r.nat]
-        (`` ($_ seq
-                (~~ (do-template [ ]
-                      [(test 
-                             (|> (do macro.Monad
-                                   [sampleI (expressionT.translate (` ()))]
-                                   (@eval.eval sampleI))
-                                 (lang.with-current-module "")
-                                 (macro.run (init-compiler []))
-                                 (case> (#e.Success valueT)
-                                        (n/=  (:! Nat valueT))
-
-                                        _
-                                        false)))]
-
-                      ["lux nat min" nat/bottom]
-                      ["lux nat max" nat/top]
-                      ))
-                (~~ (do-template [   ]
-                      [(test 
-                             (|> (do macro.Monad
-                                   [sampleI (expressionT.translate (` ( (~ (code.nat subject)))))]
-                                   (@eval.eval sampleI))
-                                 (lang.with-current-module "")
-                                 (macro.run (init-compiler []))
-                                 (case> (#e.Success valueT)
-                                        ( ( subject) (:!  valueT))
-
-                                        _
-                                        false)))]
-
-                      ["lux nat to-int" Int  nat-to-int     i/=]
-                      ["lux nat char"   Text text.from-code text/=]
-                      ))
-                (~~ (do-template [   ]
-                      [(test 
-                             (|> (do macro.Monad
-                                   [runtime-bytecode @runtime.translate
-                                    sampleI (expressionT.translate (` ( (~ (code.nat subject)) (~ (code.nat param)))))]
-                                   (@eval.eval sampleI))
-                                 (lang.with-current-module "")
-                                 (macro.run (init-compiler []))
-                                 (case> (#e.Success valueT)
-                                        ( ( param subject) (:!  valueT))
-
-                                        _
-                                        false)))]
-
-                      ["lux nat +" n/+ Nat  n/=]
-                      ["lux nat -" n/- Nat  n/=]
-                      ["lux nat *" n/* Nat  n/=]
-                      ["lux nat /" n// Nat  n/=]
-                      ["lux nat %" n/% Nat  n/=]
-                      ["lux nat =" n/= Bool bool/=]
-                      ["lux nat <" n/< Bool bool/=]
-                      ))
-                )))))
-
-(context: "Int procedures"
-  (<| (times +100)
-      (do @
-        [param (|> r.int (r.filter (|>> (i/= 0) not)))
-         subject r.int]
-        (with-expansions [ (do-template [ ]
-                                      [(test 
-                                             (|> (do macro.Monad
-                                                   [sampleI (expressionT.translate (` ()))]
-                                                   (@eval.eval sampleI))
-                                                 (lang.with-current-module "")
-                                                 (macro.run (init-compiler []))
-                                                 (case> (#e.Success valueT)
-                                                        (i/=  (:! Int valueT))
-
-                                                        _
-                                                        false)))]
-
-                                      ["lux int min" int/bottom]
-                                      ["lux int max" int/top]
-                                      )
-                           (do-template [   ]
-                                    [(test 
-                                           (|> (do macro.Monad
-                                                 [sampleI (expressionT.translate (` ( (~ (code.int subject)))))]
-                                                 (@eval.eval sampleI))
-                                               (lang.with-current-module "")
-                                               (macro.run (init-compiler []))
-                                               (case> (#e.Success valueT)
-                                                      ( ( subject) (:!  valueT))
-
-                                                      _
-                                                      false)))]
-
-                                    ["lux int to-nat"  Nat  int-to-nat  n/=]
-                                    ["lux int to-frac" Frac int-to-frac f/=]
-                                    )
-                           (do-template [   ]
-                                     [(test 
-                                            (|> (do macro.Monad
-                                                  [runtime-bytecode @runtime.translate
-                                                   sampleI (expressionT.translate (` ( (~ (code.int subject)) (~ (code.int param)))))]
-                                                  (@eval.eval sampleI))
-                                                (lang.with-current-module "")
-                                                (macro.run (init-compiler []))
-                                                (case> (#e.Success valueT)
-                                                       ( ( param subject) (:!  valueT))
-
-                                                       _
-                                                       false)))]
-
-                                     ["lux int +" i/+ Int  i/=]
-                                     ["lux int -" i/- Int  i/=]
-                                     ["lux int *" i/* Int  i/=]
-                                     ["lux int /" i// Int  i/=]
-                                     ["lux int %" i/% Int  i/=]
-                                     ["lux int =" i/= Bool bool/=]
-                                     ["lux int <" i/< Bool bool/=]
-                                     )]
-          ($_ seq
-              
-              
-              
-              )))))
-
-(context: "Frac procedures [Part 1]"
-  (<| (times +100)
-      (do @
-        [param (|> r.frac (r.filter (|>> (f/= 0.0) not)))
-         subject r.frac]
-        (with-expansions [ (do-template [   ]
-                                     [(test 
-                                            (|> (do macro.Monad
-                                                  [runtime-bytecode @runtime.translate
-                                                   sampleI (expressionT.translate (` ( (~ (code.frac subject)) (~ (code.frac param)))))]
-                                                  (@eval.eval sampleI))
-                                                (lang.with-current-module "")
-                                                (macro.run (init-compiler []))
-                                                (case> (#e.Success valueT)
-                                                       ( ( param subject) (:!  valueT))
-
-                                                       _
-                                                       false)))]
-
-                                     ["lux frac +" f/+ Frac f/=]
-                                     ["lux frac -" f/- Frac f/=]
-                                     ["lux frac *" f/* Frac f/=]
-                                     ["lux frac /" f// Frac f/=]
-                                     ["lux frac %" f/% Frac f/=]
-                                     ["lux frac =" f/= Bool bool/=]
-                                     ["lux frac <" f/< Bool bool/=]
-                                     )]
-          ($_ seq
-              
-              )))))
-
-(context: "Frac procedures [Part 2]"
-  (<| (times +100)
-      (do @
-        [param (|> r.frac (r.filter (|>> (f/= 0.0) not)))
-         subject r.frac]
-        (with-expansions [ (do-template [ ]
-                                      [(test 
-                                             (|> (do macro.Monad
-                                                   [sampleI (expressionT.translate (` ()))]
-                                                   (@eval.eval sampleI))
-                                                 (lang.with-current-module "")
-                                                 (macro.run (init-compiler []))
-                                                 (case> (#e.Success valueT)
-                                                        ( (:! Frac valueT))
-
-                                                        _
-                                                        false)))]
-
-                                      ["lux frac min" (f/= real/bottom)]
-                                      ["lux frac max" (f/= real/top)]
-                                      ["lux frac not-a-number" number.not-a-number?]
-                                      ["lux frac positive-infinity" (f/= number.positive-infinity)]
-                                      ["lux frac negative-infinity" (f/= number.negative-infinity)]
-                                      ["lux frac smallest" (f/= ("lux frac smallest"))]
-                                      )
-                           (do-template [   ]
-                                    [(test 
-                                           (|> (do macro.Monad
-                                                 [runtime-bytecode @runtime.translate
-                                                  sampleI (expressionT.translate (` ( (~ (code.frac subject)))))]
-                                                 (@eval.eval sampleI))
-                                               (lang.with-current-module "")
-                                               (macro.run (init-compiler []))
-                                               (case> (#e.Success valueT)
-                                                      ( ( subject) (:!  valueT))
-
-                                                      _
-                                                      false)))]
-
-                                    ["lux frac to-int" Int frac-to-int i/=]
-                                    ["lux frac to-deg" Deg frac-to-deg d/=]
-                                    )]
-          ($_ seq
-              
-              
-              (test "frac encode|decode"
-                    (|> (do macro.Monad
-                          [runtime-bytecode @runtime.translate
-                           sampleI (expressionT.translate (` ("lux frac decode" ("lux frac encode" (~ (code.frac subject))))))]
-                          (@eval.eval sampleI))
-                        (lang.with-current-module "")
-                        (macro.run (init-compiler []))
-                        (case> (^multi (#e.Success valueT)
-                                       [(:! (Maybe Frac) valueT) (#.Some value)])
-                               (f/= subject value)
-
-                               _
-                               false)))
-              )))))
-
-(def: (above-threshold value)
-  (-> Deg Deg)
-  (let [threshold .000000001 #( 1/(2^30) )#]
-    (if (d/< threshold value)
-      (d/+ threshold value)
-      value)))
-
-(context: "Deg procedures"
-  (<| (times +100)
-      (do @
-        [param (|> r.deg (:: @ map above-threshold))
-         special r.nat
-         subject (|> r.deg (:: @ map above-threshold))]
-        (`` ($_ seq
-                (~~ (do-template [ ]
-                      [(test 
-                             (|> (do macro.Monad
-                                   [sampleI (expressionT.translate (` ()))]
-                                   (@eval.eval sampleI))
-                                 (lang.with-current-module "")
-                                 (macro.run (init-compiler []))
-                                 (case> (#e.Success valueT)
-                                        (d/=  (:! Deg valueT))
-
-                                        _
-                                        false)))]
-
-                      ["lux deg min" deg/bottom]
-                      ["lux deg max" deg/top]
-                      ))
-                (~~ (do-template [   ]
-                      [(test 
-                             (|> (do macro.Monad
-                                   [runtime-bytecode @runtime.translate
-                                    sampleI (expressionT.translate (` ( (~ (code.deg subject)))))]
-                                   (@eval.eval sampleI))
-                                 (lang.with-current-module "")
-                                 (macro.run (init-compiler []))
-                                 (case> (#e.Success valueT)
-                                        ( ( subject) (:!  valueT))
-
-                                        _
-                                        false)))]
-
-                      ["lux deg to-frac" Frac deg-to-frac f/=]
-                      ))
-                (~~ (do-template [   ]
-                      [(test 
-                             (|> (do macro.Monad
-                                   [runtime-bytecode @runtime.translate
-                                    sampleI (expressionT.translate (` ( (~ (code.deg subject)) (~ (code.deg param)))))]
-                                   (@eval.eval sampleI))
-                                 (lang.with-current-module "")
-                                 (macro.run (init-compiler []))
-                                 (case> (#e.Success valueT)
-                                        ( ( param subject) (:!  valueT))
-
-                                        _
-                                        false)))]
-
-                      ["lux deg +" d/+ Deg  d/=]
-                      ["lux deg -" d/- Deg  d/=]
-                      ["lux deg *" d/* Deg  d/=]
-                      ["lux deg /" d// Deg  d/=]
-                      ["lux deg %" d/% Deg  d/=]
-                      ["lux deg =" d/= Bool bool/=]
-                      ["lux deg <" d/< Bool bool/=]
-                      ))
-                (~~ (do-template [   ]
-                      [(test 
-                             (|> (do macro.Monad
-                                   [runtime-bytecode @runtime.translate
-                                    sampleI (expressionT.translate (` ( (~ (code.deg subject)) (~ (code.nat special)))))]
-                                   (@eval.eval sampleI))
-                                 (lang.with-current-module "")
-                                 (macro.run (init-compiler []))
-                                 (case> (#e.Success valueT)
-                                        ( ( special subject) (:!  valueT))
-
-                                        _
-                                        false)))]
-
-                      ["lux deg scale"      d/scale      Deg d/=]
-                      ["lux deg reciprocal" d/reciprocal Deg d/=]
-                      ))
-                )))))
diff --git a/new-luxc/test/test/luxc/lang/translation/procedure/host.jvm.lux b/new-luxc/test/test/luxc/lang/translation/procedure/host.jvm.lux
deleted file mode 100644
index 4af912b2a..000000000
--- a/new-luxc/test/test/luxc/lang/translation/procedure/host.jvm.lux
+++ /dev/null
@@ -1,640 +0,0 @@
-(.module:
-  lux
-  (lux [io]
-       (control [monad #+ do]
-                pipe)
-       (data [maybe]
-             ["e" error]
-             [bit]
-             [bool "bool/" Eq]
-             [number "int/" Number Codec]
-             [text "text/" Eq]
-             text/format
-             (coll [list]))
-       ["r" math/random "r/" Monad]
-       [macro]
-       (macro [code])
-       [host]
-       test)
-  (luxc [lang]
-        (lang [".L" host]
-              ["ls" synthesis]
-              (translation [".T" expression]
-                           ["@." eval]
-                           ["@." runtime]
-                           ["@." common])))
-  (test/luxc common))
-
-(context: "Conversions [Part 1]"
-  (<| (times +100)
-      (do @
-        [int-sample (|> r.int (:: @ map (i/% 128)))
-         #let [frac-sample (int-to-frac int-sample)]]
-        (with-expansions [<2step> (do-template [     ]
-                                    [(test (format  " / " )
-                                           (|> (do macro.Monad
-                                                 [sampleI (expressionT.translate (|> (~ ( ))   (`)))]
-                                                 (@eval.eval sampleI))
-                                               (lang.with-current-module "")
-                                               (macro.run (init-compiler []))
-                                               (case> (#e.Success valueT)
-                                                      (  (:!  valueT))
-
-                                                      (#e.Error error)
-                                                      false)))]
-
-                                    ["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" 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>
-              )))))
-
-(context: "Conversions [Part 2]"
-  (<| (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 macro.Monad
-                                   [sampleI (expressionT.translate (|> (~ ( ))    (`)))]
-                                   (@eval.eval sampleI))
-                                 (lang.with-current-module "")
-                                 (macro.run (init-compiler []))
-                                 (case> (#e.Success valueT)
-                                        (  (:!  valueT))
-
-                                        (#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 macro.Monad
-                                   [sampleI (expressionT.translate (|> (~ ( ))     (`)))]
-                                   (@eval.eval sampleI))
-                                 (lang.with-current-module "")
-                                 (macro.run (init-compiler []))
-                                 (case> (#e.Success valueT)
-                                        (  (:!  valueT))
-
-                                        (#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)
-  (|> r.nat
-      (r/map (n/% +128))
-      (r.filter (|>> (n/= +0) not))))
-
-(def: gen-int
-  (r.Random Int)
-  (|> gen-nat (r/map nat-to-int)))
-
-(def: gen-frac
-  (r.Random Frac)
-  (|> gen-int (r/map int-to-frac)))
-
-(do-template [      <+> <-> <*>  <%> 
 ]
-  [(context: (format "Arithmetic ["  "]")
-     (<| (times +100)
-         (do @
-           [param 
-            #let [subject ( param)]]
-           (with-expansions [ (do-template [ ]
-                                       [(test 
-                                              (|> (do macro.Monad
-                                                    [sampleI (expressionT.translate (` ( ((~ (code.text ))
-                                                                                                (
 (~ ( subject)))
-                                                                                                (
 (~ ( param)))))))]
-                                                    (@eval.eval sampleI))
-                                                  (lang.with-current-module "")
-                                                  (macro.run (init-compiler []))
-                                                  (case> (#e.Success valueT)
-                                                         ( ( param subject)
-                                                                 (:!  valueT))
-
-                                                         (#e.Error error)
-                                                         false)))]
-
-                                       [(format "jvm "  " +") <+>]
-                                       [(format "jvm "  " -") <->]
-                                       [(format "jvm "  " *") <*>]
-                                       [(format "jvm "  " /") ]
-                                       [(format "jvm "  " %") <%>]
-                                       )]
-             ($_ seq
-                 
-                 )))))]
-
-  ["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 macro.Monad
-                                      [sampleI (expressionT.translate (` ( ((~ (code.text ))
-                                                                                  ( (~ (code.nat subject)))
-                                                                                  ( (~ (code.nat param)))))))]
-                                      (@eval.eval sampleI))
-                                    (lang.with-current-module "")
-                                    (macro.run (init-compiler []))
-                                    (case> (#e.Success valueT)
-                                           (n/= ( param subject)
-                                                (:! Nat valueT))
-
-                                           (#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 ["  "] { Shifters }")
-     (<| (times +100)
-         (do @
-           [param gen-nat
-            subject gen-nat
-            #let [shift (n/% +10 param)]]
-           (`` ($_ seq
-                   (~~ (do-template [     
]
-                         [(test 
-                                (|> (do macro.Monad
-                                      [sampleI (expressionT.translate (` ( ((~ (code.text ))
-                                                                                  ( (~ (
 subject)))
-                                                                                  ("jvm convert long-to-int" (~ (code.nat shift)))))))]
-                                      (@eval.eval sampleI))
-                                    (lang.with-current-module "")
-                                    (macro.run (init-compiler []))
-                                    (case> (#e.Success valueT)
-                                           ( ( shift ( subject))
-                                                   (:!  valueT))
-
-                                           (#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 [   <=> <<> 
]
-  [(context: (format "Order ["  "]")
-     (<| (times +100)
-         (do @
-           [param 
-            subject ]
-           (with-expansions [ (do-template [ ]
-                                       [(test 
-                                              (|> (do macro.Monad
-                                                    [sampleI (expressionT.translate (` ((~ (code.text ))
-                                                                                        (
 (~ ( subject)))
-                                                                                        (
 (~ ( param))))))]
-                                                    (@eval.eval sampleI))
-                                                  (lang.with-current-module "")
-                                                  (macro.run (init-compiler []))
-                                                  (case> (#e.Success valueT)
-                                                         (bool/= ( param subject)
-                                                                 (:! Bool valueT))
-
-                                                         (#e.Error error)
-                                                         false)))]
-
-                                       [(format "jvm "  " =") <=>]
-                                       [(format "jvm "  " <") <<>]
-                                       )]
-             ($_ seq
-                 
-                 )))))]
-
-  ["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 @
-        [size (|> r.nat (:: @ map (|>> (n/% +10) (n/max +1))))
-         idx (|> r.nat (:: @ map (n/% size)))
-         valueZ r.bool
-         valueB gen-int
-         valueS gen-int
-         valueI gen-int
-         valueL r.int
-         valueF gen-frac
-         valueD r.frac
-         valueC gen-int]
-        (with-expansions [ (do-template [     ]
-                                    [(test 
-                                           (|> (do macro.Monad
-                                                 [sampleI (expressionT.translate (|> (jvm//array//new +0  size)
-                                                                                     (jvm//array//write  idx )
-                                                                                     (jvm//array//read  idx)
-                                                                                     (~)
-                                                                                     
-                                                                                     (`)))]
-                                                 (@eval.eval sampleI))
-                                               (lang.with-current-module "")
-                                               (macro.run (init-compiler []))
-                                               (case> (#e.Success outputZ)
-                                                      (  (:!  outputZ))
-
-                                                      (#e.Error error)
-                                                      false)))]
-
-                                    ["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
-              
-              )))))
-
-(context: "Array [Part 2]"
-  (<| (times +100)
-      (do @
-        [size (|> r.nat (:: @ map (|>> (n/% +10) (n/max +1))))
-         idx (|> r.nat (:: @ map (n/% size)))
-         valueZ r.bool
-         valueB gen-int
-         valueS gen-int
-         valueI gen-int
-         valueL r.int
-         valueF gen-frac
-         valueD r.frac
-         valueC gen-int]
-        (with-expansions [ (do-template [     ]
-                                    [(test 
-                                           (|> (do macro.Monad
-                                                 [sampleI (expressionT.translate (|> (jvm//array//new +0  size)
-                                                                                     (jvm//array//write  idx )
-                                                                                     (jvm//array//read  idx)
-                                                                                     (~)
-                                                                                     
-                                                                                     (`)))]
-                                                 (@eval.eval sampleI))
-                                               (lang.with-current-module "")
-                                               (macro.run (init-compiler []))
-                                               (case> (#e.Success outputT)
-                                                      (  (:!  outputT))
-
-                                                      (#e.Error error)
-                                                      false)))]
-
-                                    ["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 macro.Monad
-                          [#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 (expressionT.translate (|> ("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))
-                        (lang.with-current-module "")
-                        (macro.run (init-compiler []))
-                        (case> (#e.Success outputT)
-                               (f/= valueD (:! Frac outputT))
-
-                               (#e.Error error)
-                               false)))
-              (test "jvm array length"
-                    (|> (do macro.Monad
-                          [sampleI (expressionT.translate (` ("jvm array length" ("jvm array new" +0 "java.lang.Object" (~ (code.nat size))))))]
-                          (@eval.eval sampleI))
-                        (lang.with-current-module "")
-                        (macro.run (init-compiler []))
-                        (case> (#e.Success outputT)
-                               (n/= size (:! Nat outputT))
-
-                               (#e.Error error)
-                               false)))
-              )))))
-
-(host.import java/lang/Class
-  (getName [] String))
-
-(def: classes
-  (List Text)
-  (list "java.lang.Object" "java.lang.Class"
-        "java.lang.String" "java.lang.Number"))
-
-(def: instances
-  (List [Text (r.Random ls.Synthesis)])
-  (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]
-          ["java.lang.String" gen-string]
-          ["java.lang.Object" (r.either (r.either gen-boolean
-                                                  gen-integer)
-                                        (r.either gen-double
-                                                  gen-string))])))
-
-(context: "Object."
-  (<| (times +100)
-      (do @
-        [#let [num-classes (list.size classes)]
-         #let [num-instances (list.size instances)]
-         class-idx (|> r.nat (:: @ map (n/% num-classes)))
-         instance-idx (|> r.nat (:: @ map (n/% num-instances)))
-         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$ (` ["java.lang.String" (~ (code.text exception-message))])]
-         sample r.int
-         monitor r.int
-         instance instance-gen]
-        ($_ seq
-            (test "jvm object null"
-                  (|> (do macro.Monad
-                        [sampleI (expressionT.translate (` ("jvm object null?" ("jvm object null"))))]
-                        (@eval.eval sampleI))
-                      (lang.with-current-module "")
-                      (macro.run (init-compiler []))
-                      (case> (#e.Success outputT)
-                             (:! Bool outputT)
-
-                             (#e.Error error)
-                             false)))
-            (test "jvm object null?"
-                  (|> (do macro.Monad
-                        [sampleI (expressionT.translate (` ("jvm object null?" (~ (code.int sample)))))]
-                        (@eval.eval sampleI))
-                      (lang.with-current-module "")
-                      (macro.run (init-compiler []))
-                      (case> (#e.Success outputT)
-                             (not (:! Bool outputT))
-
-                             (#e.Error error)
-                             false)))
-            (test "jvm object synchronized"
-                  (|> (do macro.Monad
-                        [sampleI (expressionT.translate (` ("jvm object synchronized" (~ (code.int monitor)) (~ (code.int sample)))))]
-                        (@eval.eval sampleI))
-                      (lang.with-current-module "")
-                      (macro.run (init-compiler []))
-                      (case> (#e.Success outputT)
-                             (i/= sample (:! Int outputT))
-
-                             (#e.Error error)
-                             false)))
-            (test "jvm object throw"
-                  (|> (do macro.Monad
-                        [_ @runtime.translate
-                         sampleI (expressionT.translate (` ("lux try" ("lux function" +1 []
-                                                                       ("jvm object throw" ("jvm member invoke constructor"
-                                                                                            "java.lang.Throwable"
-                                                                                            (~ exception-message$)))))))]
-                        (@eval.eval sampleI))
-                      (lang.with-current-module "")
-                      (macro.run (init-compiler []))
-                      (case> (#e.Success outputT)
-                             (case (:! (e.Error Top) outputT)
-                               (#e.Error error)
-                               (text.contains? exception-message error)
-
-                               (#e.Success outputT)
-                               false)
-
-                             (#e.Error error)
-                             false)))
-            (test "jvm object class"
-                  (|> (do macro.Monad
-                        [sampleI (expressionT.translate (` ("jvm object class" (~ (code.text class)))))]
-                        (@eval.eval sampleI))
-                      (lang.with-current-module "")
-                      (macro.run (init-compiler []))
-                      (case> (#e.Success outputT)
-                             (|> outputT (:! Class) (Class::getName []) (text/= class))
-
-                             (#e.Error error)
-                             false)))
-            (test "jvm object instance?"
-                  (|> (do macro.Monad
-                        [sampleI (expressionT.translate (` ("jvm object instance?" (~ (code.text instance-class)) (~ instance))))]
-                        (@eval.eval sampleI))
-                      (lang.with-current-module "")
-                      (macro.run (init-compiler []))
-                      (case> (#e.Success outputT)
-                             (:! Bool outputT)
-
-                             (#e.Error error)
-                             false)))
-            ))))
-
-(host.import java/util/GregorianCalendar
-  (#static AD int))
-
-(context: "Member [Field]"
-  (<| (times +100)
-      (do @
-        [sample-short (|> r.int (:: @ map (|>> int/abs (i/% 100))))
-         sample-string (r.text +5)
-         other-sample-string (r.text +5)
-         #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 macro.Monad
-                        [sampleI (expressionT.translate (` ("jvm convert int-to-long" ("jvm member static get" "java.util.GregorianCalendar" "AD" "int"))))]
-                        (@eval.eval sampleI))
-                      (lang.with-current-module "")
-                      (macro.run (init-compiler []))
-                      (case> (#e.Success outputT)
-                             (i/= GregorianCalendar::AD (:! Int outputT))
-
-                             (#e.Error error)
-                             false)))
-            (test "jvm member static put"
-                  (|> (do macro.Monad
-                        [sampleI (expressionT.translate (` ("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))
-                      (lang.with-current-module "")
-                      (macro.run (init-compiler []))
-                      (case> (#e.Success outputT)
-                             (is hostL.unit (:! Text outputT))
-
-                             (#e.Error error)
-                             false)))
-            (test "jvm member virtual get"
-                  (|> (do macro.Monad
-                        [sampleI (expressionT.translate (` ("jvm member virtual get" "org.omg.CORBA.ValueMember" "name" "java.lang.String" (~ value-memberS))))]
-                        (@eval.eval sampleI))
-                      (lang.with-current-module "")
-                      (macro.run (init-compiler []))
-                      (case> (#e.Success outputT)
-                             (text/= sample-string (:! Text outputT))
-
-                             (#e.Error error)
-                             false)))
-            (test "jvm member virtual put"
-                  (|> (do macro.Monad
-                        [sampleI (expressionT.translate (` ("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))
-                      (lang.with-current-module "")
-                      (macro.run (init-compiler []))
-                      (case> (#e.Success outputT)
-                             (text/= other-sample-string (:! Text outputT))
-
-                             (#e.Error error)
-                             false)))
-            ))))
-
-(host.import java/lang/Object)
-
-(host.import (java/util/ArrayList a))
-
-(context: "Member [Method]"
-  (<| (times +100)
-      (do @
-        [sample (|> r.int (:: @ map (|>> int/abs (i/% 100))))
-         #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 macro.Monad
-                        [sampleI (expressionT.translate (` ("jvm member invoke static" "java.lang.Long" "decode" "java.lang.Long" (~ coded-intS))))]
-                        (@eval.eval sampleI))
-                      (lang.with-current-module "")
-                      (macro.run (init-compiler []))
-                      (case> (#e.Success outputT)
-                             (i/= sample (:! Int outputT))
-
-                             (#e.Error error)
-                             false)))
-            (test "jvm member invoke virtual"
-                  (|> (do macro.Monad
-                        [sampleI (expressionT.translate (` ("jvm member invoke virtual" "java.lang.Object" "equals" "boolean"
-                                                            (~ (code.int sample)) (~ object-longS))))]
-                        (@eval.eval sampleI))
-                      (lang.with-current-module "")
-                      (macro.run (init-compiler []))
-                      (case> (#e.Success outputT)
-                             (:! Bool outputT)
-
-                             (#e.Error error)
-                             false)))
-            (test "jvm member invoke interface"
-                  (|> (do macro.Monad
-                        [sampleI (expressionT.translate (` ("jvm member invoke interface" "java.util.Collection" "add" "boolean"
-                                                            (~ array-listS) (~ object-longS))))]
-                        (@eval.eval sampleI))
-                      (lang.with-current-module "")
-                      (macro.run (init-compiler []))
-                      (case> (#e.Success outputT)
-                             (:! Bool outputT)
-
-                             (#e.Error error)
-                             false)))
-            (test "jvm member invoke constructor"
-                  (|> (do macro.Monad
-                        [sampleI (expressionT.translate array-listS)]
-                        (@eval.eval sampleI))
-                      (lang.with-current-module "")
-                      (macro.run (init-compiler []))
-                      (case> (#e.Success outputT)
-                             (host.instance? ArrayList (:! Object outputT))
-
-                             (#e.Error error)
-                             false)))
-            ))))
diff --git a/new-luxc/test/test/luxc/lang/translation/reference.lux b/new-luxc/test/test/luxc/lang/translation/reference.lux
deleted file mode 100644
index bcdef1a8b..000000000
--- a/new-luxc/test/test/luxc/lang/translation/reference.lux
+++ /dev/null
@@ -1,82 +0,0 @@
-(.module:
-  lux
-  (lux [io]
-       (control [monad #+ do]
-                pipe)
-       (data ["e" error]
-             [text])
-       ["r" math/random]
-       [macro]
-       (macro [code])
-       test)
-  (luxc [lang]
-        (lang ["_." module]
-              (host ["$" jvm]
-                    (jvm ["$i" inst]))
-              ["ls" synthesis]
-              (translation [".T" statement]
-                           [".T" eval]
-                           [".T" expression]
-                           [".T" case]
-                           [".T" runtime])))
-  (test/luxc common))
-
-(def: nilI $.Inst runtimeT.noneI)
-
-(def: cursorI
-  $.Inst
-  (|>> ($i.int 3)
-       ($i.array runtimeT.$Tuple)
-       $i.DUP ($i.int 0) ($i.string "") $i.AASTORE
-       $i.DUP ($i.int 1) ($i.long 0) ($i.wrap #$.Long) $i.AASTORE
-       $i.DUP ($i.int 2) ($i.long 0) ($i.wrap #$.Long) $i.AASTORE))
-
-(def: empty-metaI
-  (|>> ($i.int 2)
-       ($i.array runtimeT.$Tuple)
-       $i.DUP ($i.int 0) cursorI $i.AASTORE
-       $i.DUP ($i.int 1) nilI $i.AASTORE))
-
-(context: "Definitions."
-  (<| (times +100)
-      (do @
-        [module-name (|> (r.text +5) (r.filter (|>> (text.contains? "/") not)))
-         def-name (r.text +5)
-         def-value r.int
-         #let [valueI (|>> ($i.long def-value) ($i.wrap #$.Long))]]
-        ($_ seq
-            (test "Can refer to definitions."
-                  (|> (do macro.Monad
-                        [_ (_module.with-module +0 module-name
-                             (statementT.translate-def def-name Int valueI empty-metaI (' {})))
-                         sampleI (expressionT.translate (code.symbol [module-name def-name]))]
-                        (evalT.eval sampleI))
-                      (lang.with-current-module "")
-                      (macro.run (init-compiler []))
-                      (case> (#e.Success valueT)
-                             (i/= def-value (:! Int valueT))
-
-                             (#e.Error error)
-                             false)))
-            ))))
-
-(context: "Variables."
-  (<| (times +100)
-      (do @
-        [register (|> r.nat (:: @ map (n/% +100)))
-         value r.int]
-        ($_ seq
-            (test "Can refer to local variables/registers."
-                  (|> (do macro.Monad
-                        [sampleI (caseT.translate-let expressionT.translate
-                                                      register
-                                                      (code.int value)
-                                                      (` ((~ (code.int (nat-to-int register))))))]
-                        (evalT.eval sampleI))
-                      (macro.run (init-compiler []))
-                      (case> (#e.Success outputT)
-                             (i/= value (:! Int outputT))
-
-                             (#e.Error error)
-                             false)))
-            ))))
diff --git a/new-luxc/test/test/luxc/lang/translation/structure.lux b/new-luxc/test/test/luxc/lang/translation/structure.lux
deleted file mode 100644
index 078079b6b..000000000
--- a/new-luxc/test/test/luxc/lang/translation/structure.lux
+++ /dev/null
@@ -1,113 +0,0 @@
-(.module:
-  lux
-  (lux [io]
-       (control [monad #+ do]
-                pipe)
-       (data ["e" error]
-             [maybe]
-             [bool "bool/" Eq]
-             [text "text/" Eq]
-             text/format
-             (coll [array]
-                   [list]))
-       ["r" math/random "r/" Monad]
-       [macro]
-       (macro [code])
-       [host]
-       test)
-  (luxc [lang]
-        (lang [".L" host]
-              ["ls" synthesis]
-              (translation [".T" expression]
-                           ["@." eval]
-                           ["@." runtime]
-                           ["@." common])))
-  (test/luxc common))
-
-(host.import java/lang/Integer)
-
-(def: gen-primitive
-  (r.Random ls.Synthesis)
-  (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
-    [_ (#.Tuple #.Nil)]
-    (is hostL.unit (:! Text sample))
-
-    (^template [  ]
-      [_ ( prediction')]
-      (case (host.try ( prediction' (:!  sample)))
-        (#e.Success result)
-        result
-
-        (#e.Error error)
-        false))
-    ([#.Bool Bool bool/=]
-     [#.Nat  Nat n/=]
-     [#.Int  Int i/=]
-     [#.Deg  Deg d/=]
-     [#.Frac Frac f/=]
-     [#.Text Text text/=])
-
-    _
-    false
-    ))
-
-(context: "Tuples."
-  (<| (times +100)
-      (do @
-        [size (|> r.nat (:: @ map (|>> (n/% +10) (n/max +2))))
-         members (r.list size gen-primitive)]
-        (test "Can translate tuple."
-              (|> (do macro.Monad
-                    [sampleI (expressionT.translate (code.tuple members))]
-                    (@eval.eval sampleI))
-                  (lang.with-current-module "")
-                  (macro.run (init-compiler []))
-                  (case> (#e.Success valueT)
-                         (let [valueT (:! (Array Top) valueT)]
-                           (and (n/= size (array.size valueT))
-                                (list.every? corresponds? (list.zip2 members (array.to-list valueT)))))
-
-                         _
-                         false))))))
-
-(context: "Variants."
-  (<| (times +100)
-      (do @
-        [num-tags (|> r.nat (:: @ map (|>> (n/% +10) (n/max +2))))
-         tag (|> r.nat (:: @ map (n/% num-tags)))
-         #let [last? (n/= (n/dec num-tags) tag)]
-         member gen-primitive]
-        (test "Can translate variant."
-              (|> (do macro.Monad
-                    [runtime-bytecode @runtime.translate
-                     sampleI (expressionT.translate (` ((~ (code.nat tag)) (~ (code.bool last?)) (~ member))))]
-                    (@eval.eval sampleI))
-                  (lang.with-current-module "")
-                  (macro.run (init-compiler []))
-                  (case> (#e.Success valueT)
-                         (let [valueT (:! (Array Top) valueT)]
-                           (and (n/= +3 (array.size valueT))
-                                (let [_tag (:! Integer (maybe.assume (array.read +0 valueT)))
-                                      _last? (array.read +1 valueT)
-                                      _value (:! Top (maybe.assume (array.read +2 valueT)))]
-                                  (and (n/= tag (|> _tag host.int-to-long int-to-nat))
-                                       (case _last?
-                                         (#.Some _last?')
-                                         (and last? (text/= "" (:! Text _last?')))
-
-                                         #.None
-                                         (not last?))
-                                       (corresponds? [member _value])))))
-
-                         _
-                         false))))))
diff --git a/new-luxc/test/tests.lux b/new-luxc/test/tests.lux
index 98043260b..ce15be88f 100644
--- a/new-luxc/test/tests.lux
+++ b/new-luxc/test/tests.lux
@@ -19,13 +19,13 @@
                                ["_.S" function]
                                ["_.S" procedure]
                                ["_.S" loop])
-                    (translation ["_.T" primitive]
-                                 ["_.T" structure]
-                                 ["_.T" case]
-                                 ["_.T" function]
-                                 ["_.T" reference]
-                                 (procedure ["_.T" common]
-                                            ["_.T" host])))
+                    (translation (jvm ["_.T" primitive]
+                                      ["_.T" structure]
+                                      ["_.T" case]
+                                      ["_.T" function]
+                                      ["_.T" reference]
+                                      (procedure ["_.T" common]
+                                                 ["_.T" host]))))
               )))
 
 (program: args
-- 
cgit v1.2.3