(.module:
  [library
   [lux #*
    ["_" test (#+ Test)]
    [abstract
     [monad (#+ do)]]
    [control
     ["." try]]
    [data
     ["." bit ("#\." equivalence)]
     ["." text ("#\." equivalence)]]
    [math
     ["." random (#+ Random)]
     [number
      ["." nat]
      ["." frac]]]]]
  [\\library
   ["." /]])

(/.import: Uint8Array)

... On Nashorn
(/.import: java/lang/String
  ["#::."
   (new [Uint8Array /.String])
   (getBytes [/.String] Uint8Array)])

... On Node
(/.import: Buffer
  ["#::."
   (#static from [/.String /.String] Buffer)
   (toString [/.String] /.String)])

... On the browser
(/.import: TextEncoder
  ["#::."
   (new [/.String])
   (encode [/.String] Uint8Array)])

(/.import: TextDecoder
  ["#::."
   (new [/.String])
   (decode [Uint8Array] /.String)])

(def: .public test
  Test
  (do {! random.monad}
    [boolean random.bit
     number (\ ! map (|>> (nat.% 100) nat.frac) random.nat)
     string (random.ascii 5)
     function (\ ! map (function (_ shift)
                         (: (-> Nat Nat)
                            (nat.+ shift)))
                 random.nat)
     ... I64s get compiled as JavaScript objects with a specific structure.
     object random.nat]
    (<| (_.covering /._)
        (`` ($_ _.and
                (~~ (template [<type> <value>]
                      [(_.cover [<type>]
                                (exec
                                  (: <type> <value>)
                                  true))]

                      [/.Boolean boolean]
                      [/.Number number]
                      [/.String string]
                      ))
                (_.for [/.Object]
                       ($_ _.and
                           (~~ (template [<type>]
                                 [(_.cover [<type>]
                                           (exec
                                             (: (Ex [a] (/.Object a))
                                                (: <type>
                                                   (:assume [])))
                                             true))]

                                 [/.Function]
                                 [/.Symbol]
                                 [/.Null]
                                 [/.Undefined]
                                 ))
                           ))
                (_.cover [/.null]
                         (exec
                           (: Nat (/.null []))
                           (: Text (/.null []))
                           (: (All [a] (-> a a)) (/.null []))
                           true))
                (_.cover [/.null?]
                         (and (/.null? (/.null []))
                              (not (/.null? 0))
                              (not (/.null? "0"))
                              (not (/.null? (|>>)))))
                (_.cover [/.constant]
                         (|> (/.constant /.Function [parseFloat])
                             "js object null?"
                             not))
                (_.cover [/.closure]
                         (|> (/.closure [input/0] input/0)
                             "js object null?"
                             not))
                (_.cover [/.on_browser? /.on_node_js? /.on_nashorn?]
                         (and (or /.on_nashorn?
                                  /.on_node_js?
                                  /.on_browser?)
                              (bit\= /.on_nashorn?
                                     (not (or /.on_node_js?
                                              /.on_browser?)))
                              (bit\= /.on_node_js?
                                     (not (or /.on_nashorn?
                                              /.on_browser?)))
                              (bit\= /.on_browser?
                                     (not (or /.on_nashorn?
                                              /.on_node_js?)))))
                (_.cover [/.type_of]
                         (and (text\= "boolean" (/.type_of boolean))
                              (text\= "number" (/.type_of number))
                              (text\= "string" (/.type_of string))
                              (text\= "function" (/.type_of function))
                              (text\= "object" (/.type_of object))))
                (_.cover [/.import:]
                         (let [encoding "utf8"]
                           (text\= string
                                   (cond /.on_nashorn?
                                         (let [binary (java/lang/String::getBytes [encoding] (:as java/lang/String string))]
                                           (|> (java/lang/String::new [binary encoding])
                                               (:as Text)))
                                         
                                         /.on_node_js?
                                         (|> (Buffer::from [string encoding])
                                             (Buffer::toString [encoding]))
                                         
                                         ... On the browser
                                         (let [binary (|> (TextEncoder::new [encoding])
                                                          (TextEncoder::encode [string]))]
                                           (|> (TextDecoder::new [encoding])
                                               (TextDecoder::decode [binary])))
                                         ))))
                )))))