foldM package:rio

foldM :: (Foldable t, Monad m) => (b -> a -> m b) -> b -> t a -> m b
rio RIO.Prelude
The foldM function is analogous to foldl, except that its result is encapsulated in a monad. Note that foldM works from left-to-right over the list arguments. This could be an issue where (>>) and the `folded function' are not commutative. 
foldM f a1 [x1, x2, ..., xm]

==

do
a2 <- f a1 x1
a3 <- f a2 x2
...
f am xm
If right-to-left evaluation is required, the input list should be reversed. Note: foldM is the same as foldlM
foldM :: (Monad m, Vector v b) => (a -> b -> m a) -> a -> v b -> m a
rio RIO.Vector
O(n) Monadic fold
foldM :: Monad m => (a -> b -> m a) -> a -> Vector b -> m a
rio RIO.Vector.Boxed
O(n) Monadic fold
foldM :: (Monad m, Storable b) => (a -> b -> m a) -> a -> Vector b -> m a
rio RIO.Vector.Storable
O(n) Monadic fold
foldM :: (Monad m, Unbox b) => (a -> b -> m a) -> a -> Vector b -> m a
rio RIO.Vector.Unboxed
O(n) Monadic fold
foldMapWithKey :: Monoid m => (k -> a -> m) -> Map k a -> m
rio RIO.Map
O(n). Fold the keys and values in the map using the given monoid, such that 
foldMapWithKey f = fold . mapWithKey f
This can be an asymptotically faster than foldrWithKey or foldlWithKey for some monoids.
foldM_ :: (Foldable t, Monad m) => (b -> a -> m b) -> b -> t a -> m ()
rio RIO.Prelude
Like foldM, but discards the result.
foldMap :: (Foldable t, Monoid m) => (a -> m) -> t a -> m
rio RIO.Prelude
Map each element of the structure to a monoid, and combine the results.
foldMapM :: (Monad m, Monoid w, Foldable t) => (a -> m w) -> t a -> m w
rio RIO.Prelude
Extend foldMap to allow side effects. Internally, this is implemented using a strict left fold. This is used for performance reasons. It also necessitates that this function has a Monad constraint and not just an Applicative constraint. For more information, see https://github.com/commercialhaskell/rio/pull/99#issuecomment-394179757.
foldMapWithIndex :: Monoid m => (Int -> a -> m) -> Seq a -> m
rio RIO.Seq
foldM' :: (Monad m, Vector v b) => (a -> b -> m a) -> a -> v b -> m a
rio RIO.Vector
O(n) Monadic fold with strict accumulator
foldM'_ :: (Monad m, Vector v b) => (a -> b -> m a) -> a -> v b -> m ()
rio RIO.Vector
O(n) Monadic fold with strict accumulator that discards the result
foldM_ :: (Monad m, Vector v b) => (a -> b -> m a) -> a -> v b -> m ()
rio RIO.Vector
O(n) Monadic fold that discards the result
foldM' :: Monad m => (a -> b -> m a) -> a -> Vector b -> m a
rio RIO.Vector.Boxed
O(n) Monadic fold with strict accumulator
foldM'_ :: Monad m => (a -> b -> m a) -> a -> Vector b -> m ()
rio RIO.Vector.Boxed
O(n) Monadic fold with strict accumulator that discards the result
foldM_ :: Monad m => (a -> b -> m a) -> a -> Vector b -> m ()
rio RIO.Vector.Boxed
O(n) Monadic fold that discards the result
foldM' :: (Monad m, Storable b) => (a -> b -> m a) -> a -> Vector b -> m a
rio RIO.Vector.Storable
O(n) Monadic fold with strict accumulator
foldM'_ :: (Monad m, Storable b) => (a -> b -> m a) -> a -> Vector b -> m ()
rio RIO.Vector.Storable
O(n) Monadic fold with strict accumulator that discards the result
foldM_ :: (Monad m, Storable b) => (a -> b -> m a) -> a -> Vector b -> m ()
rio RIO.Vector.Storable
O(n) Monadic fold that discards the result
foldM' :: (Monad m, Unbox b) => (a -> b -> m a) -> a -> Vector b -> m a
rio RIO.Vector.Unboxed
O(n) Monadic fold with strict accumulator
foldM'_ :: (Monad m, Unbox b) => (a -> b -> m a) -> a -> Vector b -> m ()
rio RIO.Vector.Unboxed
O(n) Monadic fold with strict accumulator that discards the result
foldM_ :: (Monad m, Unbox b) => (a -> b -> m a) -> a -> Vector b -> m ()
rio RIO.Vector.Unboxed
O(n) Monadic fold that discards the result
bifoldMap :: (Bifoldable p, Monoid m) => (a -> m) -> (b -> m) -> p a b -> m
rio RIO.Prelude
Combines the elements of a structure, given ways of mapping them to a common monoid. 
bifoldMap f g
≡ bifoldr (mappend . f) (mappend . g) mempty
ifoldM :: (Monad m, Vector v b) => (a -> Int -> b -> m a) -> a -> v b -> m a
rio RIO.Vector
O(n) Monadic fold (action applied to each element and its index)
ifoldM' :: (Monad m, Vector v b) => (a -> Int -> b -> m a) -> a -> v b -> m a
rio RIO.Vector
O(n) Monadic fold with strict accumulator (action applied to each element and its index)