| Safe Haskell | None |
|---|---|
| Language | Haskell2010 |
Control.Monad.Loop
Synopsis
- newtype LoopT (m :: k -> Type) a = LoopT {
- runLoopT :: forall (r :: k). (a -> m r -> m r -> m r) -> m r -> m r -> m r
- type Loop = LoopT Identity
- loop :: Loop a -> Loop a
- cons :: forall {k} a (m :: k -> Type). a -> LoopT m a -> LoopT m a
- continue :: forall {k} a (m :: k -> Type). a -> LoopT m a
- continue_ :: forall {k} (m :: k -> Type) a. LoopT m a
- break_ :: forall {k} (m :: k -> Type) a. LoopT m a
- exec_ :: Applicative m => LoopT m a -> m ()
- class ForEach (m :: Type -> Type) c where
- type ForEachValue c
- type ForEachIx c
- iterate :: forall a (m :: Type -> Type). a -> (a -> a) -> LoopT m a
- forever :: forall (m :: Type -> Type). LoopT m ()
- for :: forall a (m :: Type -> Type). a -> (a -> Bool) -> (a -> a) -> LoopT m a
- unfoldl :: forall i a (m :: Type -> Type). (i -> Maybe (i, a)) -> i -> LoopT m a
- while :: Monad m => m Bool -> LoopT m ()
- forEach :: ForEach m c => c -> m (ForEachValue c)
- iforEach :: ForEach m c => c -> m (ForEachIx c, ForEachValue c)
Documentation
newtype LoopT (m :: k -> Type) a Source #
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.
Instances
| MonadTrans (LoopT :: (Type -> Type) -> Type -> Type) Source # | |||||||||
Defined in Control.Monad.Loop.Internal | |||||||||
| MonadIO m => MonadIO (LoopT m) Source # | |||||||||
Defined in Control.Monad.Loop.Internal | |||||||||
| (Applicative m, Foldable m) => Foldable (LoopT m) Source # | |||||||||
Defined in Control.Monad.Loop.Internal Methods fold :: Monoid m0 => LoopT m m0 -> m0 # foldMap :: Monoid m0 => (a -> m0) -> LoopT m a -> m0 # foldMap' :: Monoid m0 => (a -> m0) -> LoopT m a -> m0 # foldr :: (a -> b -> b) -> b -> LoopT m a -> b # foldr' :: (a -> b -> b) -> b -> LoopT m a -> b # foldl :: (b -> a -> b) -> b -> LoopT m a -> b # foldl' :: (b -> a -> b) -> b -> LoopT m a -> b # foldr1 :: (a -> a -> a) -> LoopT m a -> a # foldl1 :: (a -> a -> a) -> LoopT m a -> a # elem :: Eq a => a -> LoopT m a -> Bool # maximum :: Ord a => LoopT m a -> a # minimum :: Ord a => LoopT m a -> a # | |||||||||
| (Applicative m, Foldable m) => Traversable (LoopT m) Source # | |||||||||
Defined in Control.Monad.Loop.Internal | |||||||||
| Applicative (LoopT m) Source # | |||||||||
| Functor (LoopT m) Source # | |||||||||
| Monad (LoopT m) Source # | |||||||||
| Monad m => ForEach (LoopT m) (Vector a) Source # | |||||||||
Defined in Control.Monad.Loop.ForEach Associated Types
| |||||||||
| (Monad m, Prim a) => ForEach (LoopT m) (Vector a) Source # | |||||||||
Defined in Control.Monad.Loop.ForEach Associated Types
| |||||||||
| (Monad m, Storable a) => ForEach (LoopT m) (Vector a) Source # | |||||||||
Defined in Control.Monad.Loop.ForEach Associated Types
| |||||||||
| (Monad m, Unbox a) => ForEach (LoopT m) (Vector a) Source # | |||||||||
Defined in Control.Monad.Loop.ForEach Associated Types
| |||||||||
| Monad m => ForEach (LoopT m) [a] Source # | |||||||||
Defined in Control.Monad.Loop.ForEach Associated Types
| |||||||||
| (PrimMonad m, PrimState m ~ s) => ForEach (LoopT m) (MVector s a) Source # | |||||||||
Defined in Control.Monad.Loop.ForEach Associated Types
| |||||||||
| (PrimMonad m, Prim a, PrimState m ~ s) => ForEach (LoopT m) (MVector s a) Source # | |||||||||
Defined in Control.Monad.Loop.ForEach Associated Types
| |||||||||
| (Storable a, PrimMonad m, PrimState m ~ s) => ForEach (LoopT m) (MVector s a) Source # | |||||||||
Defined in Control.Monad.Loop.ForEach Associated Types
| |||||||||
| (PrimMonad m, Unbox a, PrimState m ~ s) => ForEach (LoopT m) (MVector s a) Source # | |||||||||
Defined in Control.Monad.Loop.ForEach Associated Types
| |||||||||
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.
continue :: forall {k} a (m :: k -> Type). a -> LoopT m a Source #
Yield a value for this iteration of the loop and skip immediately to the next iteration.
continue_ :: forall {k} (m :: k -> Type) a. LoopT m a Source #
Skip immediately to the next iteration of the loop without yielding a value.
break_ :: forall {k} (m :: k -> Type) a. LoopT m a Source #
Skip all the remaining iterations of the immediately-enclosing loop.
exec_ :: Applicative m => LoopT m a -> m () Source #
Execute a loop, sequencing the effects and discarding the values.
class ForEach (m :: Type -> Type) c Source #
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.
Instances
forEach :: ForEach m c => c -> m (ForEachValue c) Source #
Iterate over the values in the container.