(.require
 [library
  [lux (.except)
   ["_" test (.only Test)]
   [data
    ["[0]" identity (.only Identity)]
    [collection
     ["[0]" list (.use "[1]#[0]" functor mix)]]]
   [math
    ["[0]" random]
    [number
     ["n" nat]]]]]
 [\\library
  ["[0]" / (.only Monad do)]])

(def .public test
  Test
  (do random.monad
    [mono random.nat
     poly (random.list 10 random.nat)]
    (<| (_.covering /._)
        (all _.and
             (_.coverage [/.do]
               (n.= (++ mono)
                    (is (Identity Nat)
                        (/.do identity.monad
                          [sample (in mono)]
                          (in (++ sample))))))
             (_.coverage [/.then]
               (n.= (++ mono)
                    (is (Identity Nat)
                        (/.then identity.monad
                                (|>> ++ (at identity.monad in))
                                (at identity.monad in mono)))))
             (_.coverage [/.all]
               (at (list.equivalence n.equivalence) =
                   (list#each ++ poly)
                   (|> poly
                       (list#each (|>> ++ (at identity.monad in)))
                       (is (List (Identity Nat)))
                       (/.all identity.monad)
                       (is (Identity (List Nat))))))
             (_.coverage [/.each]
               (at (list.equivalence n.equivalence) =
                   (list#each ++ poly)
                   (|> poly
                       (/.each identity.monad (|>> ++ (at identity.monad in)))
                       (is (Identity (List Nat))))))
             (_.coverage [/.only]
               (at (list.equivalence n.equivalence) =
                   (list.only n.even? poly)
                   (|> poly
                       (/.only identity.monad (|>> n.even? (at identity.monad in)))
                       (is (Identity (List Nat))))))
             (_.coverage [/.mix]
               (n.= (list#mix n.+ 0 poly)
                    (|> poly
                        (/.mix identity.monad
                               (function (_ part whole)
                                 (at identity.monad in
                                     (n.+ part whole)))
                               0)
                        (is (Identity Nat)))))
             ))))