(.module:
  [library
   [lux (#- list)
    [abstract
     [monoid (#+ Monoid)]
     [equivalence (#+ Equivalence)]
     [hash (#+ Hash)]
     [apply (#+ Apply)]
     ["." functor (#+ Functor)]
     ["." monad (#+ Monad do)]]
    [meta
     ["." location]]]])

... (type: (Maybe a)
...   #.None
...   (#.Some a))

(implementation: .public monoid
  (All [a] (Monoid (Maybe a)))
  
  (def: identity #.None)
  
  (def: (composite mx my)
    (case mx
      #.None
      my
      
      (#.Some x)
      (#.Some x))))

(implementation: .public functor
  (Functor Maybe)
  
  (def: (each f ma)
    (case ma
      #.None     #.None
      (#.Some a) (#.Some (f a)))))

(implementation: .public apply
  (Apply Maybe)
  
  (def: &functor ..functor)

  (def: (on fa ff)
    (case [ff fa]
      [(#.Some f) (#.Some a)]
      (#.Some (f a))

      _
      #.None)))

(implementation: .public monad
  (Monad Maybe)
  
  (def: &functor ..functor)

  (def: (in x)
    (#.Some x))

  (def: (conjoint mma)
    (case mma
      #.None
      #.None
      
      (#.Some mx)
      mx)))

(implementation: .public (equivalence super)
  (All [a] (-> (Equivalence a) (Equivalence (Maybe a))))
  
  (def: (= mx my)
    (case [mx my]
      [#.None #.None]
      #1

      [(#.Some x) (#.Some y)]
      (\ super = x y)
      
      _
      #0)))

(implementation: .public (hash super)
  (All [a] (-> (Hash a) (Hash (Maybe a))))

  (def: &equivalence
    (..equivalence (\ super &equivalence)))
  
  (def: (hash value)
    (case value
      #.None
      0

      (#.Some value)
      (\ super hash value))))

(implementation: .public (with monad)
  (All [M] (-> (Monad M) (Monad (All [a] (M (Maybe a))))))

  (def: &functor
    (functor.composite (value@ #monad.&functor monad)
                       ..functor))

  (def: in (|>> (\ ..monad in) (\ monad in)))
  
  (def: (conjoint MmMma)
    (do monad
      [mMma MmMma]
      (case mMma
        #.None
        (in #.None)

        (#.Some Mma)
        Mma))))

(def: .public (lifted monad)
  (All [M a] (-> (Monad M) (-> (M a) (M (Maybe a)))))
  (\ monad each (\ ..monad in)))

(macro: .public (else tokens state)
  (case tokens
    (^ (.list else maybe))
    (let [g!temp (: Code [location.dummy (#.Identifier ["" ""])])]
      (#.Right [state (.list (` (case (~ maybe)
                                  (#.Some (~ g!temp))
                                  (~ g!temp)

                                  #.None
                                  (~ else))))]))

    _
    (#.Left "Wrong syntax for else")))

(def: .public trusted
  (All [a] (-> (Maybe a) a))
  (|>> (..else (undefined))))

(def: .public (list value)
  (All [a] (-> (Maybe a) (List a)))
  (case value
    #.None
    #.End

    (#.Some value)
    (#.Item value #.End)))

(macro: .public (when tokens state)
  (case tokens
    (^ (.list test then))
    (#.Right [state (.list (` (.if (~ test)
                                (~ then)
                                #.None)))])

    _
    (#.Left "Wrong syntax for when")))