Control.Monad.Eff

data Effect :: Type

The kind of all effect types.

Declare new effect types using foreign data declarations, as follows:

import Control.Monad.Eff (kind Effect)

foreign import data MyEffect :: Effect

data Eff :: Row Effect -> Type -> Type

The Eff type constructor is used to represent native effects.

See Handling Native Effects with the Eff Monad for more details.

The first type parameter is a row of effects which represents the contexts in which a computation can be run, and the second type parameter is the return type.

Instances

• (Semigroup a) => Semigroup (Eff e a)
• (Monoid a) => Monoid (Eff e a)
• Functor (Eff e)
• Apply (Eff e)
• Applicative (Eff e)
• Bind (Eff e)
• Monad (Eff e)

type Pure a = Eff () a

The Pure type synonym represents pure computations, i.e. ones in which all effects have been handled.

The runPure function can be used to run pure computations and obtain their result.

runPure :: forall a. Pure a -> a

Run a pure computation and return its result.

untilE :: forall e. Eff e Boolean -> Eff e Unit

Loop until a condition becomes true.

untilE b is an effectful computation which repeatedly runs the effectful computation b, until its return value is true.

whileE :: forall a e. Eff e Boolean -> Eff e a -> Eff e Unit

Loop while a condition is true.

whileE b m is effectful computation which runs the effectful computation b. If its result is true, it runs the effectful computation m and loops. If not, the computation ends.

forE :: forall e. Int -> Int -> (Int -> Eff e Unit) -> Eff e Unit

Loop over a consecutive collection of numbers.

forE lo hi f runs the computation returned by the function f for each of the inputs between lo (inclusive) and hi (exclusive).

foreachE :: forall a e. Array a -> (a -> Eff e Unit) -> Eff e Unit

Loop over an array of values.

foreachE xs f runs the computation returned by the function f for each of the inputs xs.