Effect.Promise

data Promise :: Type -> Type

A JavaScript promise.

Instances

• (Deferred) => Functor Promise
• (Deferred) => Apply Promise
• (Deferred) => Applicative Promise
• (Deferred) => Bind Promise
• (Deferred) => Monad Promise
• (Deferred) => MonadThrow Error Promise
• (Deferred) => MonadError Error Promise
• (Deferred, Semigroup a) => Semigroup (Promise a)
• (Deferred, Monoid a) => Monoid (Promise a)
• (Deferred) => MonadEffect Promise

promise :: forall a. Deferred => ((a -> Effect Unit) -> (Error -> Effect Unit) -> Effect Unit) -> Promise a

Create a promise by supplying a function which takes a success callback and error callback as arguments, returning an Effect.

then_ :: forall b a. Deferred => (a -> Promise b) -> (Error -> Promise b) -> Promise a -> Promise b

Useful for when you need to transform an error and a resolved value into the same type.

then' :: forall b a. Deferred => (a -> Promise b) -> Promise a -> Promise b

Given a promise and a function which uses that promise's resolved value, create a new promise that resolves to the function's output.

resolve :: forall a. a -> Promise a

Create a promise from a value.

catch :: forall a. Deferred => Promise a -> (Error -> Promise a) -> Promise a

Deals with any errors that may be thrown by the given promise.

reject :: forall b. Deferred => Error -> Promise b

Throw an error into a promise.

race :: forall a f. Deferred => Foldable f => f (Promise a) -> Promise a

Note that while promise semantics say that race xs resolves to the first x in xs to resolve, race xs won't terminate until each promise is settled. In addition, if Array.fromFoldable xs is [], race xs will never settle.

all :: forall a g f. Deferred => Foldable f => Unfoldable g => f (Promise a) -> Promise (g a)

Run all promises in the given Foldable, returning a new promise which either resolves to a collection of all the given promises' results, or rejects with the first promise to reject.

delay :: forall a. Deferred => Milliseconds -> a -> Promise a

Cause a delay in execution, then resolve with the given value.

runPromise :: forall b a. (a -> Effect b) -> (Error -> Effect b) -> (Deferred => Promise a) -> Effect Unit

Consume a promise. Note that this is the only standard way to safely discharge the Deferred constraints you are likely to have.

class Deferred 

A class for side-effecting promises which don't prematurely execute.