- Migrated special-form analysis to stdlib.

2 files changed, 0 insertions, 870 deletions

diff --git a/new-luxc/test/test/luxc/lang/analysis/procedure/common.lux b/new-luxc/test/test/luxc/lang/analysis/procedure/common.lux
deleted file mode 100644
index fba355a79..000000000
--- a/new-luxc/test/test/luxc/lang/analysis/procedure/common.lux
+++ /dev/null
@@ -1,324 +0,0 @@
-(.module:
-  lux
-  (lux [io]
-       (control [monad #+ do]
-                pipe)
-       (concurrency [atom])
-       (data text/format
-             ["e" error]
-             [product]
-             (coll [array]))
-       ["r" math/random "r/" Monad<Random>]
-       [macro #+ Monad<Meta>]
-       (macro [code])
-       (lang [type "type/" Eq<Type>])
-       test)
-  (luxc ["&" lang]
-        (lang ["&." scope]
-              ["&." module]
-              ["~" analysis]
-              (analysis [".A" expression]
-                        ["@." common])
-              [".L" eval]))
-  (/// common)
-  (test/luxc common))
-
-(do-template [<name> <success> <failure>]
-  [(def: (<name> procedure params output-type)
-     (-> Text (List Code) Type Bool)
-     (|> (&.with-scope
-           (&.with-type output-type
-             (analyse (` ((~ (code.text procedure)) (~+ params))))))
-         (macro.run (io.run init-jvm))
-         (case> (#e.Success _)
-                <success>
-
-                (#e.Error error)
-                <failure>)))]
-
-  [check-success+ true false]
-  [check-failure+ false true]
-  )
-
-(context: "Lux procedures"
-  (<| (times +100)
-      (do @
-        [[primT primC] gen-primitive
-         [antiT antiC] (|> gen-primitive
-                           (r.filter (|>> product.left (type/= primT) not)))]
-        ($_ seq
-            (test "Can test for reference equality."
-                  (check-success+ "lux is" (list primC primC) Bool))
-            (test "Reference equality must be done with elements of the same type."
-                  (check-failure+ "lux is" (list primC antiC) Bool))
-            (test "Can 'try' risky IO computations."
-                  (check-success+ "lux try"
-                                  (list (` ("lux function" (~' _) (~' _) (~ primC))))
-                                  (type (Either Text primT))))
-            ))))
-
-(context: "Bit procedures"
-  (<| (times +100)
-      (do @
-        [subjectC (|> r.nat (:: @ map code.nat))
-         signedC (|> r.int (:: @ map code.int))
-         paramC (|> r.nat (:: @ map code.nat))]
-        ($_ seq
-            (test "Can count the number of 1 bits in a bit pattern."
-                  (check-success+ "lux bit count" (list subjectC) Nat))
-            (test "Can perform bit 'and'."
-                  (check-success+ "lux bit and" (list subjectC paramC) Nat))
-            (test "Can perform bit 'or'."
-                  (check-success+ "lux bit or" (list subjectC paramC) Nat))
-            (test "Can perform bit 'xor'."
-                  (check-success+ "lux bit xor" (list subjectC paramC) Nat))
-            (test "Can shift bit pattern to the left."
-                  (check-success+ "lux bit left-shift" (list subjectC paramC) Nat))
-            (test "Can shift bit pattern to the right."
-                  (check-success+ "lux bit logical-right-shift" (list subjectC paramC) Nat))
-            (test "Can shift signed bit pattern to the right."
-                  (check-success+ "lux bit arithmetic-right-shift" (list signedC paramC) Int))
-            ))))
-
-(context: "Int procedures"
-  (<| (times +100)
-      (do @
-        [subjectC (|> r.int (:: @ map code.int))
-         paramC (|> r.int (:: @ map code.int))]
-        ($_ seq
-            (test "Can add integers."
-                  (check-success+ "lux int +" (list subjectC paramC) Int))
-            (test "Can subtract integers."
-                  (check-success+ "lux int -" (list subjectC paramC) Int))
-            (test "Can multiply integers."
-                  (check-success+ "lux int *" (list subjectC paramC) Int))
-            (test "Can divide integers."
-                  (check-success+ "lux int /" (list subjectC paramC) Int))
-            (test "Can calculate remainder of integers."
-                  (check-success+ "lux int %" (list subjectC paramC) Int))
-            (test "Can test equality of integers."
-                  (check-success+ "lux int =" (list subjectC paramC) Bool))
-            (test "Can compare integers."
-                  (check-success+ "lux int <" (list subjectC paramC) Bool))
-            (test "Can obtain minimum integer."
-                  (check-success+ "lux int min" (list) Int))
-            (test "Can obtain maximum integer."
-                  (check-success+ "lux int max" (list) Int))
-            (test "Can convert integer to natural number."
-                  (check-success+ "lux int to-nat" (list subjectC) Nat))
-            (test "Can convert integer to frac number."
-                  (check-success+ "lux int to-frac" (list subjectC) Frac))
-            (test "Can convert integer to text."
-                  (check-success+ "lux int char" (list subjectC) Text))
-            ))))
-
-(context: "Frac procedures"
-  (<| (times +100)
-      (do @
-        [subjectC (|> r.frac (:: @ map code.frac))
-         paramC (|> r.frac (:: @ map code.frac))
-         encodedC (|> (r.text +5) (:: @ map code.text))]
-        ($_ seq
-            (test "Can add frac numbers."
-                  (check-success+ "lux frac +" (list subjectC paramC) Frac))
-            (test "Can subtract frac numbers."
-                  (check-success+ "lux frac -" (list subjectC paramC) Frac))
-            (test "Can multiply frac numbers."
-                  (check-success+ "lux frac *" (list subjectC paramC) Frac))
-            (test "Can divide frac numbers."
-                  (check-success+ "lux frac /" (list subjectC paramC) Frac))
-            (test "Can calculate remainder of frac numbers."
-                  (check-success+ "lux frac %" (list subjectC paramC) Frac))
-            (test "Can test equality of frac numbers."
-                  (check-success+ "lux frac =" (list subjectC paramC) Bool))
-            (test "Can compare frac numbers."
-                  (check-success+ "lux frac <" (list subjectC paramC) Bool))
-            (test "Can obtain minimum frac number."
-                  (check-success+ "lux frac min" (list) Frac))
-            (test "Can obtain maximum frac number."
-                  (check-success+ "lux frac max" (list) Frac))
-            (test "Can obtain smallest frac number."
-                  (check-success+ "lux frac smallest" (list) Frac))
-            (test "Can obtain not-a-number."
-                  (check-success+ "lux frac not-a-number" (list) Frac))
-            (test "Can obtain positive infinity."
-                  (check-success+ "lux frac positive-infinity" (list) Frac))
-            (test "Can obtain negative infinity."
-                  (check-success+ "lux frac negative-infinity" (list) Frac))
-            (test "Can convert frac number to integer."
-                  (check-success+ "lux frac to-int" (list subjectC) Int))
-            (test "Can convert frac number to text."
-                  (check-success+ "lux frac encode" (list subjectC) Text))
-            (test "Can convert text to frac number."
-                  (check-success+ "lux frac decode" (list encodedC) (type (Maybe Frac))))
-            ))))
-
-(context: "Text procedures"
-  (<| (times +100)
-      (do @
-        [subjectC (|> (r.text +5) (:: @ map code.text))
-         paramC (|> (r.text +5) (:: @ map code.text))
-         replacementC (|> (r.text +5) (:: @ map code.text))
-         fromC (|> r.nat (:: @ map code.nat))
-         toC (|> r.nat (:: @ map code.nat))]
-        ($_ seq
-            (test "Can test text equality."
-                  (check-success+ "lux text =" (list subjectC paramC) Bool))
-            (test "Compare texts in lexicographical order."
-                  (check-success+ "lux text <" (list subjectC paramC) Bool))
-            (test "Can concatenate one text to another."
-                  (check-success+ "lux text concat" (list subjectC paramC) Text))
-            (test "Can find the index of a piece of text inside a larger one that (may) contain it."
-                  (check-success+ "lux text index" (list subjectC paramC fromC) (type (Maybe Nat))))
-            (test "Can query the size/length of a text."
-                  (check-success+ "lux text size" (list subjectC) Nat))
-            (test "Can calculate a hash code for text."
-                  (check-success+ "lux text hash" (list subjectC) Nat))
-            (test "Can replace a text inside of a larger one (once)."
-                  (check-success+ "lux text replace-once" (list subjectC paramC replacementC) Text))
-            (test "Can replace a text inside of a larger one (all times)."
-                  (check-success+ "lux text replace-all" (list subjectC paramC replacementC) Text))
-            (test "Can obtain the character code of a text at a given index."
-                  (check-success+ "lux text char" (list subjectC fromC) (type (Maybe Nat))))
-            (test "Can clip a piece of text between 2 indices."
-                  (check-success+ "lux text clip" (list subjectC fromC toC) (type (Maybe Text))))
-            ))))
-
-(context: "Array procedures"
-  (<| (times +100)
-      (do @
-        [[elemT elemC] gen-primitive
-         sizeC (|> r.nat (:: @ map code.nat))
-         idxC (|> r.nat (:: @ map code.nat))
-         var-name (r.text +5)
-         #let [arrayT (type (Array elemT))
-               g!array (code.local-symbol var-name)
-               array-operation (function (_ output-type code)
-                                 (|> (&scope.with-scope ""
-                                       (&scope.with-local [var-name arrayT]
-                                         (&.with-type output-type
-                                           (analyse code))))
-                                     (macro.run (io.run init-jvm))
-                                     (case> (#e.Success _)
-                                            true
-
-                                            (#e.Error error)
-                                            false)))]]
-        ($_ seq
-            (test "Can create arrays."
-                  (check-success+ "lux array new" (list sizeC) arrayT))
-            (test "Can get a value inside an array."
-                  (array-operation (type (Maybe elemT))
-                                   (` ("lux array get" (~ g!array) (~ idxC)))))
-            (test "Can put a value inside an array."
-                  (array-operation arrayT
-                                   (` ("lux array put" (~ g!array) (~ idxC) (~ elemC)))))
-            (test "Can remove a value from an array."
-                  (array-operation arrayT
-                                   (` ("lux array remove" (~ g!array) (~ idxC)))))
-            (test "Can query the size of an array."
-                  (array-operation Nat
-                                   (` ("lux array size" (~ g!array)))))
-            ))))
-
-(context: "Math procedures"
-  (<| (times +100)
-      (do @
-        [subjectC (|> r.frac (:: @ map code.frac))
-         paramC (|> r.frac (:: @ map code.frac))]
-        (with-expansions [<unary> (do-template [<proc> <desc>]
-                                    [(test (format "Can calculate " <desc> ".")
-                                           (check-success+ <proc> (list subjectC) Frac))]
-
-                                    ["lux math cos" "cosine"]
-                                    ["lux math sin" "sine"]
-                                    ["lux math tan" "tangent"]
-                                    ["lux math acos" "inverse/arc cosine"]
-                                    ["lux math asin" "inverse/arc sine"]
-                                    ["lux math atan" "inverse/arc tangent"]
-                                    ["lux math cosh" "hyperbolic cosine"]
-                                    ["lux math sinh" "hyperbolic sine"]
-                                    ["lux math tanh" "hyperbolic tangent"]
-                                    ["lux math exp" "exponentiation"]
-                                    ["lux math log" "logarithm"]
-                                    ["lux math ceil" "ceiling"]
-                                    ["lux math floor" "floor"]
-                                    ["lux math round" "rounding"])
-                          <binary> (do-template [<proc> <desc>]
-                                     [(test (format "Can calculate " <desc> ".")
-                                            (check-success+ <proc> (list subjectC paramC) Frac))]
-
-                                     ["lux math atan2" "inverse/arc tangent (with 2 arguments)"]
-                                     ["lux math pow" "power"])]
-          ($_ seq
-              <unary>
-              <binary>)))))
-
-(context: "Atom procedures"
-  (<| (times +100)
-      (do @
-        [[elemT elemC] gen-primitive
-         sizeC (|> r.nat (:: @ map code.nat))
-         idxC (|> r.nat (:: @ map code.nat))
-         var-name (r.text +5)
-         #let [atomT (type (atom.Atom elemT))]]
-        ($_ seq
-            (test "Can create atomic reference."
-                  (check-success+ "lux atom new" (list elemC) atomT))
-            (test "Can read the value of an atomic reference."
-                  (|> (&scope.with-scope ""
-                        (&scope.with-local [var-name atomT]
-                          (&.with-type elemT
-                            (analyse (` ("lux atom read" (~ (code.symbol ["" var-name]))))))))
-                      (macro.run (io.run init-jvm))
-                      (case> (#e.Success _)
-                             true
-
-                             (#e.Error _)
-                             false)))
-            (test "Can swap the value of an atomic reference."
-                  (|> (&scope.with-scope ""
-                        (&scope.with-local [var-name atomT]
-                          (&.with-type Bool
-                            (analyse (` ("lux atom compare-and-swap"
-                                         (~ (code.symbol ["" var-name]))
-                                         (~ elemC)
-                                         (~ elemC)))))))
-                      (macro.run (io.run init-jvm))
-                      (case> (#e.Success _)
-                             true
-
-                             (#e.Error _)
-                             false)))
-            ))))
-
-(context: "Process procedures"
-  (<| (times +100)
-      (do @
-        [[primT primC] gen-primitive
-         timeC (|> r.nat (:: @ map code.nat))]
-        ($_ seq
-            (test "Can query the level of concurrency."
-                  (check-success+ "lux process parallelism-level" (list) Nat))
-            (test "Can schedule an IO computation to run concurrently at some future time."
-                  (check-success+ "lux process schedule"
-                                  (list timeC
-                                        (` ("lux function" (~' _) (~' _) (~ primC))))
-                                  Any))
-            ))))
-
-(context: "IO procedures"
-  (<| (times +100)
-      (do @
-        [logC (|> (r.text +5) (:: @ map code.text))
-         exitC (|> r.int (:: @ map code.int))]
-        ($_ seq
-            (test "Can log messages to standard output."
-                  (check-success+ "lux io log" (list logC) Any))
-            (test "Can throw a run-time error."
-                  (check-success+ "lux io error" (list logC) Nothing))
-            (test "Can exit the program."
-                  (check-success+ "lux io exit" (list exitC) Nothing))
-            (test "Can query the current time (as milliseconds since epoch)."
-                  (check-success+ "lux io current-time" (list) Int))
-            ))))
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
deleted file mode 100644
index 3d0c76777..000000000
--- a/new-luxc/test/test/luxc/lang/analysis/procedure/host.jvm.lux
+++ /dev/null
@@ -1,546 +0,0 @@
-(.module:
-  lux
-  (lux [io]
-       (control [monad #+ do]
-                pipe)
-       (concurrency [atom])
-       (data ["e" error]
-             [product]
-             [maybe]
-             [text "text/" Eq<Text>]
-             text/format
-             (coll [array]
-                   [list "list/" Fold<List>]
-                   (dictionary ["dict" unordered])))
-       ["r" math/random "r/" Monad<Random>]
-       [macro #+ Monad<Meta>]
-       (macro [code])
-       (lang [type])
-       test)
-  (luxc ["&" lang]
-        (lang ["&." scope]
-              ["&." module]
-              ["~" analysis]
-              (analysis [".A" expression]
-                        ["@." common])
-              (translation (jvm ["@." runtime]))
-              (extension (analysis ["@." host]))
-              [".L" eval]))
-  (/// common)
-  (test/luxc common))
-
-(do-template [<name> <success> <failure>]
-  [(def: (<name> procedure params output-type)
-     (-> Text (List Code) Type Bool)
-     (|> (do Monad<Meta>
-           [runtime-bytecode @runtime.translate]
-           (&.with-scope
-             (&.with-type output-type
-               ((expressionA.analyser evalL.eval)
-                (` ((~ (code.text procedure)) (~+ params)))))))
-         (&.with-current-module "")
-         (macro.run (io.run init-jvm))
-         (case> (#e.Success _)
-                <success>
-
-                (#e.Error error)
-                <failure>)))]
-
-  [success true false]
-  [failure false true]
-  )
-
-(do-template [<name> <success> <failure>]
-  [(def: (<name> syntax output-type)
-     (-> Code Type Bool)
-     (|> (do Monad<Meta>
-           [runtime-bytecode @runtime.translate]
-           (&.with-scope
-             (&.with-type output-type
-               (expressionA.analyser evalL.eval syntax))))
-         (&.with-current-module "")
-         (macro.run (io.run init-jvm))
-         (case> (#e.Success _)
-                <success>
-
-                (#e.Error error)
-                <failure>)))]
-
-  [success' true false]
-  [failure' false true]
-  )
-
-(context: "Conversions [double + float]."
-  (with-expansions [<conversions> (do-template [<procedure> <from> <to>]
-                                    [(test (format <procedure> " SUCCESS")
-                                           (success <procedure> (list (' ("lux coerce" (+0 <from> (+0)) []))) <to>))
-                                     (test (format <procedure> " FAILURE")
-                                           (failure <procedure> (list (' [])) <to>))]
-
-                                    ["jvm convert double-to-float" "java.lang.Double" @host.Float]
-                                    ["jvm convert double-to-int" "java.lang.Double" @host.Integer]
-                                    ["jvm convert double-to-long" "java.lang.Double" @host.Long]
-                                    ["jvm convert float-to-double" "java.lang.Float" @host.Double]
-                                    ["jvm convert float-to-int" "java.lang.Float" @host.Integer]
-                                    ["jvm convert float-to-long" "java.lang.Float" @host.Long]
-                                    )]
-    ($_ seq
-        <conversions>
-        )))
-
-(context: "Conversions [int]."
-  (with-expansions [<conversions> (do-template [<procedure> <from> <to>]
-                                    [(test (format <procedure> " SUCCESS")
-                                           (success <procedure> (list (' ("lux coerce" (+0 <from> (+0)) []))) <to>))
-                                     (test (format <procedure> " FAILURE")
-                                           (failure <procedure> (list (' [])) <to>))]
-
-                                    ["jvm convert int-to-byte" "java.lang.Integer" @host.Byte]
-                                    ["jvm convert int-to-char" "java.lang.Integer" @host.Character]
-                                    ["jvm convert int-to-double" "java.lang.Integer" @host.Double]
-                                    ["jvm convert int-to-float" "java.lang.Integer" @host.Float]
-                                    ["jvm convert int-to-long" "java.lang.Integer" @host.Long]
-                                    ["jvm convert int-to-short" "java.lang.Integer" @host.Short]
-                                    )]
-    ($_ seq
-        <conversions>
-        )))
-
-(context: "Conversions [long]."
-  (with-expansions [<conversions> (do-template [<procedure> <from> <to>]
-                                    [(test (format <procedure> " SUCCESS")
-                                           (success <procedure> (list (' ("lux coerce" (+0 <from> (+0)) []))) <to>))
-                                     (test (format <procedure> " FAILURE")
-                                           (failure <procedure> (list (' [])) <to>))]
-
-                                    ["jvm convert long-to-double" "java.lang.Long" @host.Double]
-                                    ["jvm convert long-to-float" "java.lang.Long" @host.Float]
-                                    ["jvm convert long-to-int" "java.lang.Long" @host.Integer]
-                                    ["jvm convert long-to-short" "java.lang.Long" @host.Short]
-                                    ["jvm convert long-to-byte" "java.lang.Long" @host.Byte]
-                                    )]
-    ($_ seq
-        <conversions>
-        )))
-
-(context: "Conversions [char + byte + short]."
-  (with-expansions [<conversions> (do-template [<procedure> <from> <to>]
-                                    [(test (format <procedure> " SUCCESS")
-                                           (success <procedure> (list (' ("lux coerce" (+0 <from> (+0)) []))) <to>))
-                                     (test (format <procedure> " FAILURE")
-                                           (failure <procedure> (list (' [])) <to>))]
-
-                                    ["jvm convert char-to-byte" "java.lang.Character" @host.Byte]
-                                    ["jvm convert char-to-short" "java.lang.Character" @host.Short]
-                                    ["jvm convert char-to-int" "java.lang.Character" @host.Integer]
-                                    ["jvm convert char-to-long" "java.lang.Character" @host.Long]
-                                    ["jvm convert byte-to-long" "java.lang.Byte" @host.Long]
-                                    ["jvm convert short-to-long" "java.lang.Short" @host.Long]
-                                    )]
-    ($_ seq
-        <conversions>
-        )))
-
-(do-template [<domain> <boxed> <type>]
-  [(context: (format "Arithmetic " "[" <domain> "].")
-     (with-expansions [<instructions> (do-template [<procedure> <subject> <param> <output>]
-                                        [(test <procedure>
-                                               (success <procedure>
-                                                        (list (' ("lux coerce" (+0 <subject> (+0)) []))
-                                                              (' ("lux coerce" (+0 <param> (+0)) [])))
-                                                        <output>))]
-
-                                        [(format "jvm " <domain> " +") <boxed> <boxed> <type>]
-                                        [(format "jvm " <domain> " -") <boxed> <boxed> <type>]
-                                        [(format "jvm " <domain> " *") <boxed> <boxed> <type>]
-                                        [(format "jvm " <domain> " /") <boxed> <boxed> <type>]
-                                        [(format "jvm " <domain> " %") <boxed> <boxed> <type>]
-                                        )]
-       ($_ seq
-           <instructions>
-           )))
-
-   (context: (format "Order " "[" <domain> "].")
-     (with-expansions [<instructions> (do-template [<procedure> <subject> <param> <output>]
-                                        [(test <procedure>
-                                               (success <procedure>
-                                                        (list (' ("lux coerce" (+0 <subject> (+0)) []))
-                                                              (' ("lux coerce" (+0 <param> (+0)) [])))
-                                                        <output>))]
-
-                                        [(format "jvm " <domain> " =") <boxed> <boxed> @host.Boolean]
-                                        [(format "jvm " <domain> " <") <boxed> <boxed> @host.Boolean]
-                                        )]
-       ($_ seq
-           <instructions>
-           )))
-
-   (context: (format "Bitwise " "[" <domain> "].")
-     (with-expansions [<instructions> (do-template [<procedure> <subject> <param> <output>]
-                                        [(test <procedure>
-                                               (success <procedure>
-                                                        (list (' ("lux coerce" (+0 <subject> (+0)) []))
-                                                              (' ("lux coerce" (+0 <param> (+0)) [])))
-                                                        <output>))]
-
-                                        [(format "jvm " <domain> " and") <boxed> <boxed> <type>]
-                                        [(format "jvm " <domain> " or") <boxed> <boxed> <type>]
-                                        [(format "jvm " <domain> " xor") <boxed> <boxed> <type>]
-                                        [(format "jvm " <domain> " shl") <boxed> "java.lang.Integer" <type>]
-                                        [(format "jvm " <domain> " shr") <boxed> "java.lang.Integer" <type>]
-                                        [(format "jvm " <domain> " ushr") <boxed> "java.lang.Integer" <type>]
-                                        )]
-       ($_ seq
-           <instructions>
-           )))]
-
-
-  ["int" "java.lang.Integer" @host.Integer]
-  ["long" "java.lang.Long" @host.Long]
-  )
-
-(do-template [<domain> <boxed> <type>]
-  [(context: (format "Arithmetic " "[" <domain> "].")
-     (with-expansions [<instructions> (do-template [<procedure> <subject> <param> <output>]
-                                        [(test <procedure>
-                                               (success <procedure>
-                                                        (list (' ("lux coerce" (+0 <subject> (+0)) []))
-                                                              (' ("lux coerce" (+0 <param> (+0)) [])))
-                                                        <output>))]
-
-                                        [(format "jvm " <domain> " +") <boxed> <boxed> <type>]
-                                        [(format "jvm " <domain> " -") <boxed> <boxed> <type>]
-                                        [(format "jvm " <domain> " *") <boxed> <boxed> <type>]
-                                        [(format "jvm " <domain> " /") <boxed> <boxed> <type>]
-                                        [(format "jvm " <domain> " %") <boxed> <boxed> <type>]
-                                        )]
-       ($_ seq
-           <instructions>
-           )))
-
-   (context: (format "Order " "[" <domain> "].")
-     (with-expansions [<instructions> (do-template [<procedure> <subject> <param> <output>]
-                                        [(test <procedure>
-                                               (success <procedure>
-                                                        (list (' ("lux coerce" (+0 <subject> (+0)) []))
-                                                              (' ("lux coerce" (+0 <param> (+0)) [])))
-                                                        <output>))]
-
-                                        [(format "jvm " <domain> " =") <boxed> <boxed> @host.Boolean]
-                                        [(format "jvm " <domain> " <") <boxed> <boxed> @host.Boolean]
-                                        )]
-       ($_ seq
-           <instructions>
-           )))]
-
-
-  ["float" "java.lang.Float" @host.Float]
-  ["double" "java.lang.Double" @host.Double]
-  )
-
-(do-template [<domain> <boxed> <type>]
-  [(context: (format "Order " "[" <domain> "].")
-     (with-expansions [<instructions> (do-template [<procedure> <subject> <param> <output>]
-                                        [(test <procedure>
-                                               (success <procedure>
-                                                        (list (' ("lux coerce" (+0 <subject> (+0)) []))
-                                                              (' ("lux coerce" (+0 <param> (+0)) [])))
-                                                        <output>))]
-
-                                        [(format "jvm " <domain> " =") <boxed> <boxed> @host.Boolean]
-                                        [(format "jvm " <domain> " <") <boxed> <boxed> @host.Boolean]
-                                        )]
-       ($_ seq
-           <instructions>
-           )))]
-
-
-  ["char" "java.lang.Character" @host.Character]
-  )
-
-(def: array-type
-  (r.Random [Text Text])
-  (let [entries (dict.entries @host.boxes)
-        num-entries (list.size entries)]
-    (do r.Monad<Random>
-      [choice (|> r.nat (:: @ map (n/% (n/inc num-entries))))
-       #let [[unboxed boxed] (: [Text Text]
-                                (|> entries
-                                    (list.nth choice)
-                                    (maybe.default ["java.lang.Object" "java.lang.Object"])))]]
-      (wrap [unboxed boxed]))))
-
-(context: "Array."
-  (<| (times +100)
-      (do @
-        [#let [cap (|>> (n/% +10) (n/max +1))]
-         [unboxed boxed] array-type
-         size (|> r.nat (:: @ map cap))
-         idx (|> r.nat (:: @ map (n/% size)))
-         level (|> r.nat (:: @ map cap))
-         #let [unboxedT (#.Primitive unboxed (list))
-               arrayT (#.Primitive "#Array" (list unboxedT))
-               arrayC (`' ("lux check" (+0 "#Array" (+1 (+0 (~ (code.text unboxed)) (+0)) (+0)))
-                           ("jvm array new" (~ (code.nat size)))))
-               boxedT (#.Primitive boxed (list))
-               boxedTC (` (+0 (~ (code.text boxed)) (+0)))
-               multi-arrayT (list/fold (function (_ _ innerT)
-                                         (|> innerT (list) (#.Primitive "#Array")))
-                                       boxedT
-                                       (list.n/range +1 level))]]
-        ($_ seq
-            (test "jvm array new"
-                  (success "jvm array new"
-                           (list (code.nat size))
-                           arrayT))
-            (test "jvm array new (no nesting)"
-                  (failure "jvm array new"
-                           (list (code.nat size))
-                           unboxedT))
-            (test "jvm array new (nested/multi-level)"
-                  (success "jvm array new"
-                           (list (code.nat size))
-                           multi-arrayT))
-            (test "jvm array length"
-                  (success "jvm array length"
-                           (list arrayC)
-                           Nat))
-            (test "jvm array read"
-                  (success' (` ("jvm object cast"
-                                ("jvm array read" (~ arrayC) (~ (code.nat idx)))))
-                            boxedT))
-            (test "jvm array write"
-                  (success "jvm array write"
-                           (list arrayC (code.nat idx) (`' ("lux coerce" (~ boxedTC) [])))
-                           arrayT))
-            ))))
-
-(def: throwables
-  (List Text)
-  (list "java.lang.Throwable"
-        "java.lang.Error"
-        "java.io.IOError"
-        "java.lang.VirtualMachineError"
-        "java.lang.Exception"
-        "java.io.IOException"
-        "java.lang.RuntimeException"))
-
-(context: "Object."
-  (<| (times +100)
-      (do @
-        [[unboxed boxed] array-type
-         [!unboxed !boxed] (|> array-type
-                               (r.filter (function (_ [!unboxed !boxed])
-                                           (not (text/= boxed !boxed)))))
-         #let [boxedT (#.Primitive boxed (list))
-               boxedC (`' ("lux check" (+0 (~ (code.text boxed)) (+0))
-                           ("jvm object null")))
-               !boxedC (`' ("lux check" (+0 (~ (code.text !boxed)) (+0))
-                            ("jvm object null")))
-               unboxedC (`' ("lux check" (+0 (~ (code.text unboxed)) (+0))
-                             ("jvm object null")))]
-         throwable (|> r.nat
-                       (:: @ map (n/% (n/inc (list.size throwables))))
-                       (:: @ map (function (_ idx)
-                                   (|> throwables
-                                       (list.nth idx)
-                                       (maybe.default "java.lang.Object")))))
-         #let [throwableC (`' ("lux check" (+0 (~ (code.text throwable)) (+0))
-                               ("jvm object null")))]]
-        ($_ seq
-            (test "jvm object null"
-                  (success "jvm object null"
-                           (list)
-                           (#.Primitive boxed (list))))
-            (test "jvm object null (no primitives)"
-                  (or (text/= "java.lang.Object" boxed)
-                      (failure "jvm object null"
-                               (list)
-                               (#.Primitive unboxed (list)))))
-            (test "jvm object null?"
-                  (success "jvm object null?"
-                           (list boxedC)
-                           Bool))
-            (test "jvm object synchronized"
-                  (success "jvm object synchronized"
-                           (list boxedC boxedC)
-                           boxedT))
-            (test "jvm object synchronized (no primitives)"
-                  (or (text/= "java.lang.Object" boxed)
-                      (failure "jvm object synchronized"
-                               (list unboxedC boxedC)
-                               boxedT)))
-            (test "jvm object throw"
-                  (or (text/= "java.lang.Object" throwable)
-                      (success "jvm object throw"
-                               (list throwableC)
-                               Nothing)))
-            (test "jvm object class"
-                  (success "jvm object class"
-                           (list (code.text boxed))
-                           (#.Primitive "java.lang.Class" (list boxedT))))
-            (test "jvm object instance?"
-                  (success "jvm object instance?"
-                           (list (code.text boxed)
-                                 boxedC)
-                           Bool))
-            (test "jvm object instance? (lineage)"
-                  (success "jvm object instance?"
-                           (list (' "java.lang.Object")
-                                 boxedC)
-                           Bool))
-            (test "jvm object instance? (no lineage)"
-                  (or (text/= "java.lang.Object" boxed)
-                      (failure "jvm object instance?"
-                               (list (code.text boxed)
-                                     !boxedC)
-                               Bool)))
-            ))))
-
-(context: "Member [Static Field]."
-  ($_ seq
-      (test "jvm member static get"
-            (success "jvm member static get"
-                     (list (code.text "java.lang.System")
-                           (code.text "out"))
-                     (#.Primitive "java.io.PrintStream" (list))))
-      (test "jvm member static get (inheritance out)"
-            (success "jvm member static get"
-                     (list (code.text "java.lang.System")
-                           (code.text "out"))
-                     (#.Primitive "java.lang.Object" (list))))
-      (test "jvm member static put"
-            (success "jvm member static put"
-                     (list (code.text "java.awt.datatransfer.DataFlavor")
-                           (code.text "allHtmlFlavor")
-                           (`' ("lux check" (+0 "java.awt.datatransfer.DataFlavor" (+0))
-                                ("jvm object null"))))
-                     Any))
-      (test "jvm member static put (final)"
-            (failure "jvm member static put"
-                     (list (code.text "java.lang.System")
-                           (code.text "out")
-                           (`' ("lux check" (+0 "java.io.PrintStream" (+0))
-                                ("jvm object null"))))
-                     Any))
-      (test "jvm member static put (inheritance in)"
-            (success "jvm member static put"
-                     (list (code.text "java.awt.datatransfer.DataFlavor")
-                           (code.text "allHtmlFlavor")
-                           (`' ("jvm object cast"
-                                ("lux check" (+0 "javax.activation.ActivationDataFlavor" (+0))
-                                 ("jvm object null")))))
-                     Any))
-      ))
-
-(context: "Member [Virtual Field]."
-  ($_ seq
-      (test "jvm member virtual get"
-            (success "jvm member virtual get"
-                     (list (code.text "org.omg.CORBA.ValueMember")
-                           (code.text "id")
-                           (`' ("lux check" (+0 "org.omg.CORBA.ValueMember" (+0))
-                                ("jvm object null"))))
-                     (#.Primitive "java.lang.String" (list))))
-      (test "jvm member virtual get (inheritance out)"
-            (success "jvm member virtual get"
-                     (list (code.text "org.omg.CORBA.ValueMember")
-                           (code.text "id")
-                           (`' ("lux check" (+0 "org.omg.CORBA.ValueMember" (+0))
-                                ("jvm object null"))))
-                     (#.Primitive "java.lang.Object" (list))))
-      (test "jvm member virtual put"
-            (success "jvm member virtual put"
-                     (list (code.text "org.omg.CORBA.ValueMember")
-                           (code.text "id")
-                           (`' ("lux check" (+0 "java.lang.String" (+0))
-                                ("jvm object null")))
-                           (`' ("lux check" (+0 "org.omg.CORBA.ValueMember" (+0))
-                                ("jvm object null"))))
-                     (primitive "org.omg.CORBA.ValueMember")))
-      (test "jvm member virtual put (final)"
-            (failure "jvm member virtual put"
-                     (list (code.text "javax.swing.text.html.parser.DTD")
-                           (code.text "applet")
-                           (`' ("lux check" (+0 "javax.swing.text.html.parser.Element" (+0))
-                                ("jvm object null")))
-                           (`' ("lux check" (+0 "javax.swing.text.html.parser.DTD" (+0))
-                                ("jvm object null"))))
-                     (primitive "javax.swing.text.html.parser.DTD")))
-      (test "jvm member virtual put (inheritance in)"
-            (success "jvm member virtual put"
-                     (list (code.text "java.awt.GridBagConstraints")
-                           (code.text "insets")
-                           (`' ("jvm object cast"
-                                ("lux check" (+0 "javax.swing.plaf.InsetsUIResource" (+0))
-                                 ("jvm object null"))))
-                           (`' ("lux check" (+0 "java.awt.GridBagConstraints" (+0))
-                                ("jvm object null"))))
-                     (primitive "java.awt.GridBagConstraints")))
-      ))
-
-(context: "Boxing/Unboxing."
-  ($_ seq
-      (test "jvm member static get"
-            (success "jvm member static get"
-                     (list (code.text "java.util.GregorianCalendar")
-                           (code.text "AD"))
-                     (#.Primitive "java.lang.Integer" (list))))
-      (test "jvm member virtual get"
-            (success "jvm member virtual get"
-                     (list (code.text "javax.accessibility.AccessibleAttributeSequence")
-                           (code.text "startIndex")
-                           (`' ("lux check" (+0 "javax.accessibility.AccessibleAttributeSequence" (+0))
-                                ("jvm object null"))))
-                     (#.Primitive "java.lang.Integer" (list))))
-      (test "jvm member virtual put"
-            (success "jvm member virtual put"
-                     (list (code.text "javax.accessibility.AccessibleAttributeSequence")
-                           (code.text "startIndex")
-                           (`' ("jvm object cast"
-                                ("lux check" (+0 "java.lang.Integer" (+0))
-                                 ("jvm object null"))))
-                           (`' ("lux check" (+0 "javax.accessibility.AccessibleAttributeSequence" (+0))
-                                ("jvm object null"))))
-                     (primitive "javax.accessibility.AccessibleAttributeSequence")))
-      ))
-
-(context: "Member [Method]."
-  (let [longC (' ("lux coerce" (+0 "java.lang.Long" (+0))
-                  +123))
-        intC (`' ("jvm convert long-to-int" (~ longC)))
-        stringC (' ("lux coerce" (+0 "java.lang.String" (+0))
-                    "YOLO"))
-        objectC (`' ("lux check" (+0 "java.util.ArrayList" (+1 (+0 "java.lang.Long" (+0)) (+0)))
-                     ("jvm member invoke constructor" "java.util.ArrayList"
-                      ["int" ("jvm object cast" (~ intC))])))]
-    ($_ seq
-        (test "jvm member invoke static"
-              (success' (` ("jvm member invoke static"
-                            "java.lang.Long" "decode"
-                            ["java.lang.String" (~ stringC)]))
-                        (#.Primitive "java.lang.Long" (list))))
-        (test "jvm member invoke virtual"
-              (success' (` ("jvm object cast"
-                            ("jvm member invoke virtual"
-                             "java.lang.Object" "equals"
-                             ("jvm object cast" (~ longC)) ["java.lang.Object" ("jvm object cast" (~ longC))])))
-                        (#.Primitive "java.lang.Boolean" (list))))
-        (test "jvm member invoke special"
-              (success' (` ("jvm object cast"
-                            ("jvm member invoke special"
-                             "java.lang.Long" "equals"
-                             ("jvm object cast" (~ longC)) ["java.lang.Object" ("jvm object cast" (~ longC))])))
-                        (#.Primitive "java.lang.Boolean" (list))))
-        (test "jvm member invoke interface"
-              (success' (` ("jvm object cast"
-                            ("jvm member invoke interface"
-                             "java.util.Collection" "add"
-                             ("jvm object cast" (~ objectC)) ["java.lang.Object" ("jvm object cast" (~ longC))])))
-                        (#.Primitive "java.lang.Boolean" (list))))
-        (test "jvm member invoke constructor"
-              (success' (` ("jvm member invoke constructor"
-                            "java.util.ArrayList"
-                            ["int" ("jvm object cast" (~ intC))]))
-                        (All [a] (#.Primitive "java.util.ArrayList" (list a)))))
-        )))