1 files changed, 64 insertions, 0 deletions
diff --git a/stdlib/source/test/lux/meta/type/implicit.lux b/stdlib/source/test/lux/meta/type/implicit.lux
new file mode 100644
index 000000000..299ae7464
--- /dev/null
+++ b/stdlib/source/test/lux/meta/type/implicit.lux
@@ -0,0 +1,64 @@
+(.require
+ [library
+  [lux (.except)
+   ["_" test (.only Test)]
+   [abstract
+    [equivalence (.only)]
+    [functor (.only)]
+    [monoid (.only)]
+    [monad (.only do)]
+    ["[0]" enum]]
+   [data
+    ["[0]" bit (.use "[1]#[0]" equivalence)]
+    [collection
+     ["[0]" list]]]
+   [math
+    ["[0]" random (.only Random)]
+    [number
+     ["n" nat]]]]]
+ [\\library
+  ["[0]" /]])
+
+(/.implicitly n.multiplication)
+
+(def .public test
+  Test
+  (<| (_.covering /._)
+      (do [! random.monad]
+        [.let [digit (at ! each (n.% 10) random.nat)]
+         left digit
+         right digit
+         .let [start (n.min left right)
+               end (n.max left right)]
+
+         left random.nat
+         right random.nat]
+        (all _.and
+             (_.coverage [/.a/an]
+               (let [first_order!
+                     (let [(open "list#[0]") (list.equivalence n.equivalence)]
+                       (and (bit#= (at n.equivalence = left right)
+                                   (/.a/an = left right))
+                            (list#= (at list.functor each ++ (enum.range n.enum start end))
+                                    (/.a/an each ++ (enum.range n.enum start end)))))
+
+                     second_order!
+                     (/.a/an =
+                             (enum.range n.enum start end)
+                             (enum.range n.enum start end))
+
+                     third_order!
+                     (let [lln (/.a/an each (enum.range n.enum start)
+                                       (enum.range n.enum start end))]
+                       (/.a/an = lln lln))]
+                 (and first_order!
+                      second_order!
+                      third_order!)))
+             (_.coverage [/.with]
+               (/.with [n.addition]
+                 (n.= (at n.addition composite left right)
+                      (/.a/an composite left right))))
+             (_.coverage [/.implicitly]
+               (n.= (at n.multiplication composite left right)
+                    (/.a/an composite left right)))
+             ))))