-- | This module provides the `Effect` type, which is used to represent

-- | _native_ effects. The `Effect` type provides a typed API for effectful

-- | computations, while at the same time generating efficient JavaScript.

module Effect

( Effect

, untilE

, whileE

, forE

, foreachE

) where

import Prelude

import Control.Apply (lift2)

-- | A native effect. The type parameter denotes the return type of running the

-- | effect, that is, an `Effect Int` is a possibly-effectful computation which

-- | eventually produces a value of the type `Int` when it finishes.

foreign import data Effect :: Type -> Type

type role Effect representational

instance functorEffect :: Functor Effect where

map = liftA1

instance applyEffect :: Apply Effect where

apply = ap

instance applicativeEffect :: Applicative Effect where

pure = pureE

foreign import pureE :: forall a. a -> Effect a

instance bindEffect :: Bind Effect where

bind = bindE

foreign import bindE :: forall a b. Effect a -> (a -> Effect b) -> Effect b

instance monadEffect :: Monad Effect

-- | The `Semigroup` instance for effects allows you to run two effects, one

-- | after the other, and then combine their results using the result type's

-- | `Semigroup` instance.

instance semigroupEffect :: Semigroup a => Semigroup (Effect a) where

append = lift2 append

-- | If you have a `Monoid a` instance, then `mempty :: Effect a` is defined as

-- | `pure mempty`.

instance monoidEffect :: Monoid a => Monoid (Effect a) where

mempty = pureE mempty

-- | 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`.

foreign import untilE :: Effect Boolean -> Effect 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.

foreign import whileE :: forall a. Effect Boolean -> Effect a -> Effect 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).

foreign import forE :: Int -> Int -> (Int -> Effect Unit) -> Effect Unit

-- | Loop over an array of values.

-- |

-- | `foreachE xs f` runs the computation returned by the function `f` for each

-- | of the inputs `xs`.

foreign import foreachE

:: forall a. Array a -> (a -> Effect Unit) -> Effect Unit