(;module:
  lux
  (lux (data ["R" result])
       (control functor
                applicative
                monad
                ["ex" exception #+ Exception])
       (concurrency ["P" promise])
       [macro]
       (macro ["s" syntax #+ syntax: Syntax])
       ))

(type: #export (Task a)
  (P;Promise (R;Result a)))

(def: #export (fail error)
  (All [a] (-> Text (Task a)))
  (:: P;Applicative<Promise> wrap (#R;Error error)))

(def: #export (throw exception message)
  (All [a] (-> Exception Text (Task a)))
  (fail (exception message)))

(def: #export (return value)
  (All [a] (-> a (Task a)))
  (:: P;Applicative<Promise> wrap (#R;Success value)))

(struct: #export _ (Functor Task)
  (def: (map f fa)
    (:: P;Functor<Promise> map
        (function [fa']
          (case fa'
            (#R;Error error)
            (#R;Error error)

            (#R;Success a)
            (#R;Success (f a))))
        fa)))

(struct: #export _ (Applicative Task)
  (def: functor Functor<Task>)

  (def: wrap return)

  (def: (apply ff fa)
    (do P;Monad<Promise>
      [ff' ff
       fa' fa]
      (wrap (do R;Monad<Result>
              [f ff'
               a fa']
              (wrap (f a)))))))

(struct: #export _ (Monad Task)
  (def: applicative Applicative<Task>)

  (def: (join mma)
    (do P;Monad<Promise>
      [mma' mma]
      (case mma'
        (#R;Error error)
        (wrap (#R;Error error))

        (#R;Success ma)
        ma))))

(syntax: #export (task [type s;any])
  {#;doc (doc "Makes an uninitialized Task (in this example, of Unit)."
              (task Unit))}
  (wrap (list (` (: (;;Task (~ type))
                    (P;promise' #;None))))))