Control.Monad.Aff

data Aff :: Row Effect -> Type -> Type

An asynchronous computation with effects e. The computation either errors or produces a value of type a.

This is moral equivalent of ErrorT (ContT Unit (Eff e)) a.

Instances

• (Semigroup a) => Semigroup (Aff e a)
• (Monoid a) => Monoid (Aff e a)
• Functor (Aff e)
• Apply (Aff e)
• Applicative (Aff e)
• Bind (Aff e)
• Monad (Aff e)
• MonadEff e (Aff e)
• MonadThrow Error (Aff e)

  Allows users to throw errors on the error channel of the asynchronous computation. See documentation in purescript-transformers.

• MonadError Error (Aff e)

  Allows users to catch errors on the error channel of the asynchronous computation. See documentation in purescript-transformers.

• Alt (Aff e)
• Plus (Aff e)
• Alternative (Aff e)
• MonadZero (Aff e)
• MonadPlus (Aff e)
• MonadRec (Aff e)
• Parallel (ParAff e) (Aff e)

type PureAff a = forall e. Aff e a

A pure asynchronous computation, having no effects other than asynchronous computation.

newtype Canceler e

A canceler is an asynchronous function that can be used to attempt the cancelation of a computation. Returns a boolean flag indicating whether or not the cancellation was successful. Many computations may be composite, in such cases the flag indicates whether any part of the computation was successfully canceled. The flag should not be used for communication.

Constructors

• Canceler (Error -> Aff e Boolean)

Instances

• Semigroup (Canceler e)
• Monoid (Canceler e)

cancel :: forall e. Canceler e -> Error -> Aff e Boolean

Unwraps the canceler function from the newtype that wraps it.

cancelWith :: forall a e. Aff e a -> Canceler e -> Aff e a

This function allows you to attach a custom canceler to an asynchronous computation. If the computation is canceled, then the custom canceler will be run along side the computation's own canceler.

launchAff :: forall a e. Aff e a -> Eff (exception :: EXCEPTION | e) (Canceler e)

Converts the asynchronous computation into a synchronous one. All values are ignored, and if the computation produces an error, it is thrown.

Catching exceptions by using catchException with the resulting Eff computation is not recommended, as exceptions may end up being thrown asynchronously, in which case they cannot be caught.

If you do need to handle exceptions, you can use runAff instead, or you can handle the exception within the Aff computation, using catchError (or any of the other mechanisms).

runAff :: forall a e. (Error -> Eff e Unit) -> (a -> Eff e Unit) -> Aff e a -> Eff e (Canceler e)

Runs the asynchronous computation. You must supply an error callback and a success callback.

Returns a canceler that can be used to attempt cancellation of the asynchronous computation.

makeAff :: forall a e. ((Error -> Eff e Unit) -> (a -> Eff e Unit) -> Eff e Unit) -> Aff e a

Creates an asynchronous effect from a function that accepts error and success callbacks. This function can be used for asynchronous computations that cannot be canceled.

makeAff' :: forall a e. ((Error -> Eff e Unit) -> (a -> Eff e Unit) -> Eff e (Canceler e)) -> Aff e a

Creates an asynchronous effect from a function that accepts error and success callbacks, and returns a canceler for the computation. This function can be used for asynchronous computations that can be canceled.

delay :: forall e. Milliseconds -> Aff e Unit

Pauses execuation of the current computation for the specified number of milliseconds.

finally :: forall b a e. Aff e a -> Aff e b -> Aff e a

Compute aff1, followed by aff2 regardless of whether aff1 terminated successfully.

forkAff :: forall a e. Aff e a -> Aff e (Canceler e)

Forks the specified asynchronous computation so subsequent computations will not block on the result of the computation.

Returns a canceler that can be used to attempt cancellation of the forked computation.

forkAll :: forall a e f. Foldable f => f (Aff e a) -> Aff e (Canceler e)

Forks many asynchronous computation in a synchronous manner while being stack-safe up to the selected Foldable instance.

Returns a canceler that can be used to attempt cancellation of all forked computations.

attempt :: forall a e. Aff e a -> Aff e (Either Error a)

Promotes any error to the value level of the asynchronous monad.

apathize :: forall a e. Aff e a -> Aff e Unit

Ignores any errors.

liftEff' :: forall a e. Eff (exception :: EXCEPTION | e) a -> Aff e (Either Error a)

Lifts a synchronous computation and makes explicit any failure from exceptions.

nonCanceler :: forall e. Canceler e

A constant canceller that always returns false.

newtype ParAff e a

Constructors

• ParAff (Aff e a)

Instances

• Newtype (ParAff e a) _
• (Semigroup a) => Semigroup (ParAff e a)
• (Monoid a) => Monoid (ParAff e a)
• Functor (ParAff e)
• Apply (ParAff e)
• Applicative (ParAff e)
• Alt (ParAff e)

  Returns the first value, or the first error if both error.

• Plus (ParAff e)
• Alternative (ParAff e)
• Parallel (ParAff e) (Aff e)