(.module:
  [library
   [lux "*"
    [abstract
     [apply {"+" Apply}]
     [equivalence {"+" Equivalence}]
     ["[0]" functor {"+" Functor}]
     ["[0]" monad {"+" Monad do}]]
    [meta
     ["[0]" location]]]])

(type: .public (Try a)
  (Variant
   {#Failure Text}
   {#Success a}))

(implementation: .public functor
  (Functor Try)
  
  (def: (each f ma)
    (case ma
      {#Failure msg}
      {#Failure msg}
      
      {#Success datum}
      {#Success (f datum)})))

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

  (def: (on fa ff)
    (case ff
      {#Success f}
      (case fa
        {#Success a}
        {#Success (f a)}

        {#Failure msg}
        {#Failure msg})

      {#Failure msg}
      {#Failure msg})))

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

  (def: (in a)
    {#Success a})

  (def: (conjoint mma)
    (case mma
      {#Failure msg}
      {#Failure msg}
      
      {#Success ma}
      ma)))

(implementation: .public (with monad)
  ... TODO: Replace (All (_ a) (! (Try a))) with (functor.Then ! Try)
  (All (_ !) (-> (Monad !) (Monad (All (_ a) (! (Try a))))))
  
  (def: &functor
    (functor.composite (value@ monad.&functor monad)
                       ..functor))

  (def: in
    (|>> (# ..monad in)
         (# monad in)))
  
  (def: (conjoint MeMea)
    (do monad
      [eMea MeMea]
      (case eMea
        {#Failure try}
        (in {#Failure try})

        {#Success Mea}
        Mea))))

(def: .public (lifted monad)
  (All (_ ! a) (-> (Monad !) (-> (! a) (! (Try a)))))
  (# monad each (# ..monad in)))

(implementation: .public (equivalence (^open "_#[0]"))
  (All (_ a) (-> (Equivalence a) (Equivalence (Try a))))

  (def: (= reference sample)
    (case [reference sample]
      [{#Success reference} {#Success sample}]
      (_#= reference sample)

      [{#Failure reference} {#Failure sample}]
      ("lux text =" reference sample)

      _
      false
      )))

(def: .public (trusted try)
  (All (_ a)
    (-> (Try a) a))
  (case try
    {#Success value}
    value

    {#Failure message}
    (panic! message)))

(def: .public (maybe try)
  (All (_ a)
    (-> (Try a) (Maybe a)))
  (case try
    {#Success value}
    {.#Some value}

    {#Failure message}
    {.#None}))

(def: .public (of_maybe maybe)
  (All (_ a)
    (-> (Maybe a) (Try a)))
  (case maybe
    {.#Some value}
    {#Success value}

    {.#None}
    {#Failure (`` (("lux in-module" (~~ (static .prelude_module)) .name#encoded)
                   (name_of ..of_maybe)))}))

(macro: .public (else tokens compiler)
  (case tokens
    (^ (list else try))
    {#Success [compiler (list (` (case (~ try)
                                   {..#Success (~' g!temp)}
                                   (~' g!temp)

                                   {..#Failure (~ [location.dummy {.#Identifier ["" ""]}])}
                                   (~ else))))]}

    _
    {#Failure "Wrong syntax for else"}))