Control.Monad.Loop.Internal

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.

data Unroll n

Proxy type for GHC's type level literal natural numbers. n is the number of times the loop will be unrolled into its own body.

Constructors

Unroll

type family UnTL n :: Nat

Equations

UnTL 1 = S Z

UnTL n = S (UnTL ((-) n 1))

class Unrolling n

Minimal complete definition

unrollFor, unrollIterate

noUnroll :: Unroll 1

Do not unroll the loop at all.

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.

iterate

Arguments

:: Unrolling (UnTL n)

=> Unroll n

Unrolling factor

-> a

Starting value of iterator

-> (a -> a)

Advance the iterator

-> LoopT m a

Iterate forever (or until break is used).

forever :: Unrolling (UnTL n) => Unroll n -> LoopT m ()

Loop forever without yielding (interesting) values.

for

Arguments

:: Unrolling (UnTL n)

=> Unroll n

Unrolling factor

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

Standard for loop.

unfoldl

Arguments

:: Unrolling (UnTL n)

=> Unroll n

Unrolling factor

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

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

-> i

Starting value

-> LoopT m a

Unfold a loop from the left.

while :: (Unrolling (UnTL n), Monad m) => Unroll n -> m Bool -> LoopT m ()