Control.Monad.Loop

Documentation

newtype LoopT m a

LoopT m a represents a loop over a base type m that yields a value a at each iteration. It can be used as a monad transformer, but there are actually no restrictions on the type m. However, this library only provides functions to execute the loop if m is at least Applicative (for exec_). If m is also Foldable, so is LoopT m. For any other type, you may use runLoopT.

Constructors

LoopT

Fields

runLoopT :: forall r. (a -> m r -> m r -> m r) -> m r -> m r -> m r

Instances

MonadTrans (LoopT *)

Monad (LoopT k m)

Functor (LoopT k m)

Applicative (LoopT k m)

(Applicative m, Foldable m) => Foldable (LoopT * m)

(Applicative m, Foldable m) => Traversable (LoopT * m)

MonadIO m => MonadIO (LoopT * m)

(Monad m, Storable a) => ForEach (LoopT * m) (Vector a)

(Monad m, Prim a) => ForEach (LoopT * m) (Vector a)

(Monad m, Unbox a) => ForEach (LoopT * m) (Vector a)

Monad m => ForEach (LoopT * m) (Vector a)

Monad m => ForEach (LoopT * m) [a]

(Storable a, PrimMonad m, (~) * (PrimState m) s) => ForEach (LoopT * m) (MVector s a)

(PrimMonad m, Prim a, (~) * (PrimState m) s) => ForEach (LoopT * m) (MVector s a)

(PrimMonad m, Unbox a, (~) * (PrimState m) s) => ForEach (LoopT * m) (MVector s a)

(PrimMonad m, (~) * (PrimState m) s) => ForEach (LoopT * m) (MVector s a)

type Loop = LoopT Identity

Loop is a pure loop, without side-effects.

loop :: Loop a -> Loop a

loop is just an aid to type inference. For loops over a base monad, there are usually other constraints that fix the type, but for pure loops, the compiler often has trouble inferring Identity.

cons :: a -> LoopT m a -> LoopT m a

continue :: a -> LoopT m a

Yield a value for this iteration of the loop and skip immediately to the next iteration.

continue_ :: LoopT m a

Skip immediately to the next iteration of the loop without yielding a value.

break_ :: LoopT m a

Skip all the remaining iterations of the immediately-enclosing loop.

exec_ :: Applicative m => LoopT m a -> m ()

Execute a loop, sequencing the effects and discarding the values.

class ForEach m c

Class of containers that can be iterated over. The class is parameterized over a base monad where the values of the container can be read to allow iterating over mutable structures. The associated type families parameterize the value and index types of the container, allowing the class to be instantiated for container types (unboxed or storable vectors, for example) which do not admit all types as values.

Minimal complete definition

forEach, iforEach

Associated Types

type ForEachValue c

type ForEachIx c

Instances

(Monad m, Storable a) => ForEach (LoopT * m) (Vector a)

(Monad m, Prim a) => ForEach (LoopT * m) (Vector a)

(Monad m, Unbox a) => ForEach (LoopT * m) (Vector a)

Monad m => ForEach (LoopT * m) (Vector a)

Monad m => ForEach (LoopT * m) [a]

(Storable a, PrimMonad m, (~) * (PrimState m) s) => ForEach (LoopT * m) (MVector s a)

(PrimMonad m, Prim a, (~) * (PrimState m) s) => ForEach (LoopT * m) (MVector s a)

(PrimMonad m, Unbox a, (~) * (PrimState m) s) => ForEach (LoopT * m) (MVector s a)

(PrimMonad m, (~) * (PrimState m) s) => ForEach (LoopT * m) (MVector s a)

iterate

Arguments

:: a

Starting value of iterator

-> (a -> a)

Advance the iterator

-> LoopT m a

forever :: LoopT m ()

for

Arguments

:: a

Starting value of iterator

-> (a -> Bool)

Termination condition. The loop will terminate the first time this is false. The termination condition is checked at the start of each iteration.

-> (a -> a)

Advance the iterator

-> LoopT m a

unfoldl

Arguments

:: (i -> Maybe (i, a))

Just (i, a) advances the loop, yielding an a. Nothing terminates the loop.

-> i

Starting value

-> LoopT m a

while :: Monad m => m Bool -> LoopT m ()

forEach :: ForEach m c => c -> m (ForEachValue c)

Iterate over the values in the container.

iforEach :: ForEach m c => c -> m (ForEachIx c, ForEachValue c)

Iterate over the indices and the value at each index.