Safe Haskell | None |
---|---|

Language | Haskell2010 |

- newtype LoopT m a = LoopT {
- runLoopT :: forall r. (a -> m r -> m r -> m r) -> m r -> m r -> m r

- type Loop = LoopT Identity
- loop :: Loop a -> Loop a
- data Unroll n = Unroll
- type family UnTL n :: Nat
- class Unrolling n
- noUnroll :: Unroll 1
- cons :: a -> LoopT m a -> LoopT m a
- continue :: a -> LoopT m a
- continue_ :: LoopT m a
- break_ :: LoopT m a
- exec_ :: Applicative m => LoopT m a -> m ()
- iterate :: Unrolling (UnTL n) => Unroll n -> a -> (a -> a) -> LoopT m a
- forever :: Unrolling (UnTL n) => Unroll n -> LoopT m ()
- for :: Unrolling (UnTL n) => Unroll n -> a -> (a -> Bool) -> (a -> a) -> LoopT m a
- unfoldl :: Unrolling (UnTL n) => Unroll n -> (i -> Maybe (i, a)) -> i -> LoopT m a
- while :: (Unrolling (UnTL n), Monad m) => Unroll n -> m Bool -> LoopT m ()

# Documentation

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

.

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

loop :: Loop a -> Loop a Source

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

.

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.

continue :: a -> LoopT m a Source

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

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

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

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

:: 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 () Source

Loop forever without yielding (interesting) values.

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

-> (a -> a) | Advance the iterator |

-> LoopT m a |

Standard `for`

loop.