#Effect Source

kind Effect

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

#Eff Source

data Eff :: # 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.


#Pure Source

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 Source

runPure :: forall a. Pure a -> a

Run a pure computation and return its result.

#untilE Source

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 Source

whileE :: forall e a. 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 Source

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 Source

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

Loop over an array of values.

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