(.using
 [library
  [lux {"-" list}
   [abstract
    [monoid {"+" Monoid}]
    [equivalence {"+" Equivalence}]
    [hash {"+" Hash}]
    [apply {"+" Apply}]
    ["[0]" functor {"+" Functor}]
    ["[0]" monad {"+" Monad do}]]
   [meta
    ["[0]" 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
      
      _
      mx)))

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

(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
      {.#Some mx}
      mx
      
      ... {.#None}
      it
      (:expected it))))

(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}
      1

      {.#Some value}
      (# super hash value))))

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

  (def: &functor
    (functor.composite (the monad.&functor monad)
                       ..functor))

  (def: in
    (|>> (# ..monad in)
         (# monad in)))
  
  (def: (conjoint MmMma)
    (do monad
      [mMma MmMma]
      (case mMma
        {.#Some Mma}
        Mma

        ... {.#None}
        it
        (in (:expected it))))))

(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 {.#Symbol ["" ""]}])]
      {.#Right [state (.list (` (.case (~ maybe)
                                  {.#Some (~ g!temp)}
                                  (~ g!temp)

                                  ... {.#None}
                                  (~ g!temp)
                                  (~ 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
    {.#Some value}
    {.#Item value {.#End}}

    ... {.#None}
    _
    {.#End}))

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

    _
    {.#Left "Wrong syntax for when"}))