1 files changed, 89 insertions, 28 deletions
diff --git a/stdlib/source/test/lux.lux b/stdlib/source/test/lux.lux
index 8cd7a7695..cd77beb6f 100644
--- a/stdlib/source/test/lux.lux
+++ b/stdlib/source/test/lux.lux
@@ -445,39 +445,100 @@
                    (is? expected (..identity_macro expected)))
           ))))
 
+(/.type: for_type/variant
+  #Case/0
+  (#Case/1 Nat)
+  (#Case/2 Int Text))
+
+(/.type: for_type/record
+  {#slot/0 Bit
+   #slot/1 Rev})
+
+(/.type: (for_type/all parameter)
+  [parameter parameter])
+
 (def: for_type
   Test
-  (do random.monad
+  (do {! random.monad}
     [expected random.nat
 
      expected_left random.nat
-     expected_right random.nat]
-    ($_ _.and
-        (_.cover [/.:]
-                 (|> expected
-                     (/.: Any)
-                     (is? (/.: Any expected))))
-        (_.cover [/.:as]
-                 (|> expected
-                     (/.: Any)
-                     (/.:as /.Nat)
-                     (is? expected)))
-        (_.cover [/.:assume]
-                 (|> expected
-                     (/.: Any)
-                     /.:assume
-                     (/.: /.Nat)
-                     (is? expected)))
-        (_.cover [/.:let]
-                 (let [[actual_left actual_right]
-                       (: (/.:let [side /.Nat]
-                            (& side side))
-                          [expected_left expected_right])]
-                   (and (is? expected_left actual_left)
-                        (is? expected_right actual_right))))
-        (_.cover [/.:of]
-                 (is? /.Nat (/.:of expected)))
-        )))
+     expected_right random.nat
+
+     #let [existential_type (: (Random /.Type)
+                               (\ ! map (|>> #.Ex) random.nat))]
+     expected/0 existential_type
+     expected/1 existential_type]
+    (<| (_.for [/.Type])
+        ($_ _.and
+            (_.cover [/.:]
+                     (|> expected
+                         (/.: Any)
+                         (is? (/.: Any expected))))
+            (_.cover [/.:as]
+                     (|> expected
+                         (/.: Any)
+                         (/.:as /.Nat)
+                         (is? expected)))
+            (_.cover [/.:assume]
+                     (|> expected
+                         (/.: Any)
+                         /.:assume
+                         (/.: /.Nat)
+                         (is? expected)))
+            (_.cover [/.:let]
+                     (let [[actual_left actual_right]
+                           (: (/.:let [side /.Nat]
+                                (& side side))
+                              [expected_left expected_right])]
+                       (and (is? expected_left actual_left)
+                            (is? expected_right actual_right))))
+            (_.cover [/.:of]
+                     (is? /.Nat (/.:of expected)))
+            (_.cover [/.primitive]
+                     (case (/.primitive "foo" [expected/0 expected/1])
+                       (^ (#.Primitive "foo" (list actual/0 actual/1)))
+                       (and (is? expected/0 actual/0)
+                            (is? expected/1 actual/1))
+
+                       _
+                       false))
+            (_.cover [/.type]
+                     (and (case (/.type [expected/0 expected/1])
+                            (#.Product actual/0 actual/1)
+                            (and (is? expected/0 actual/0)
+                                 (is? expected/1 actual/1))
+
+                            _
+                            false)
+                          (case (/.type (| expected/0 expected/1))
+                            (#.Sum actual/0 actual/1)
+                            (and (is? expected/0 actual/0)
+                                 (is? expected/1 actual/1))
+
+                            _
+                            false)
+                          (case (/.type (-> expected/0 expected/1))
+                            (#.Function actual/0 actual/1)
+                            (and (is? expected/0 actual/0)
+                                 (is? expected/1 actual/1))
+
+                            _
+                            false)
+                          (case (/.type (expected/0 expected/1))
+                            (#.Apply actual/1 actual/0)
+                            (and (is? expected/0 actual/0)
+                                 (is? expected/1 actual/1))
+
+                            _
+                            false)))
+            (_.cover [/.type:]
+                     (exec
+                       (: /.Type ..for_type/variant)
+                       (: /.Type ..for_type/record)
+                       (: /.Type ..for_type/all)
+                       true))
+            ))))
 
 (def: for_i64
   Test