-- Hoogle documentation, generated by Haddock
-- See Hoogle, http://www.haskell.org/hoogle/


-- | strict versions of many things in base
--   
--   This package provides strict versions of many functions in base,
--   including many folding functions not present in there.
@package constrictor
@version 0.1.2.0


-- | This library provides strict versions of many functions in base, as
--   well as a few functions that do not have lazy versions that exist in
--   base (see the section on Folds).
--   
--   Many functions in this library have an increased constraint from
--   Functor/Applicative to Monad in order to achieve strictness in their
--   arguments and/or result.
module Constrictor

-- | This is <a>&lt;$&gt;</a>, but strict in its argument and result.
--   
--   This is re-defined in this module, and not just re-exported from
--   <i>Control.Monad</i>. The reason for this is that there is no way to
--   hide the docs for re-exports with Haddocks.
--   
--   In the common case that one might import <i>Control.Monad</i>, we
--   recommend structuring imports like so:
--   
--   <pre>
--   import Control.Monad hiding ((&lt;$!&gt;))
--   import Constrictor
--   </pre>
--   
--   or
--   
--   <pre>
--   import Control.Monad
--   import Constrictor hiding ((&lt;$!&gt;))
--   </pre>
--   
--   There should be no unintended side effects introduced as a result of
--   structuring one's imports in this way.
(<$!>) :: Monad m => (a -> b) -> m a -> m b
infixl 4 <$!>

-- | This is <a>fmap</a>, but strict in its argument and result.
--   
--   Note this is equivalent to <a>&lt;$!&gt;</a>, and is provided for
--   convenience.
fmap' :: Monad m => (a -> b) -> m a -> m b
infixl 4 `fmap'`

-- | This is <a>liftM</a>, but strict in its argument and result.
--   
--   Note this is equivalent to <a>&lt;$!&gt;</a>, and is provided for
--   convenience.
liftM' :: Monad m => (a -> b) -> m a -> m b
infixl 4 `liftM'`

-- | This is <a>liftM2</a>, but strict in its arguments and result.
liftM2' :: Monad m => (a -> b -> c) -> m a -> m b -> m c

-- | This is <a>liftM3</a>, but strict in its arguments and result.
liftM3' :: Monad m => (a -> b -> c -> d) -> m a -> m b -> m c -> m d

-- | This is <a>liftM4</a>, but strict in its arguments and result.
liftM4' :: Monad m => (a -> b -> c -> d -> e) -> m a -> m b -> m c -> m d -> m e

-- | This is <a>liftM5</a>, but strict in its arguments and result.
liftM5' :: Monad m => (a -> b -> c -> d -> e -> f) -> m a -> m b -> m c -> m d -> m e -> m f

-- | This is <a>ap</a>, but strict in its arguments and result.
ap' :: Monad m => m (a -> b) -> m a -> m b

-- | Strict version of <a>traverse</a>.
traverse' :: (Traversable t, Applicative f) => (a -> f b) -> t a -> f (t b)

-- | Stricter version of <a>traverse</a>.
traverse'' :: (Traversable t, Monad m) => (a -> m b) -> t a -> m (t b)

-- | Strict version of <a>mapM</a>.
--   
--   This is just <a>traverse'</a> specialised to <a>Monad</a>.
mapM' :: (Traversable t, Monad m) => (a -> m b) -> t a -> m (t b)

-- | Map each element of a foldable structure to a monoid, and combine the
--   results. This function is right-associative.
--   
--   Note that this is equivalent to <a>foldMap</a>.
foldrMap :: (Monoid m, Foldable t) => (a -> m) -> t a -> m

-- | Map each element of a foldable structure to a monoid, and combine the
--   results. This function is left-associative.
--   
--   The operator is applied lazily. For a strict version, see
--   <a>foldlMap'</a>.
foldlMap :: (Monoid m, Foldable t) => (a -> m) -> t a -> m

-- | Map each element of a foldable structure to a monoid, and combine the
--   results. This function is right-associative.
--   
--   Note that this is equivalent to <a>foldMap</a>, but is strict.
foldrMap' :: (Monoid m, Foldable t) => (a -> m) -> t a -> m

-- | Map each element of a foldable structure to a monoid, and combine the
--   results. This function is left-associative.
--   
--   The operator is applied strictly. For a lazy version, see
--   <a>foldlMap</a>.
foldlMap' :: (Monoid m, Foldable t) => (a -> m) -> t a -> m

-- | Lazy in the monoidal accumulator. Monoidal accumulation happens from
--   left to right.
foldlMapA :: forall t b a f. (Foldable t, Monoid b, Applicative f) => (a -> f b) -> t a -> f b

-- | Lazy in the monoidal accumulator. Monoidal accumulation happens from
--   left to right.
foldrMapA :: forall t b a f. (Foldable t, Monoid b, Applicative f) => (a -> f b) -> t a -> f b

-- | Strict in the monoidal accumulator. For monads strict in the left
--   argument of bind, this will run in constant space. Monoidal
--   accumulation happens from left to right.
foldlMapM' :: forall t b a m. (Foldable t, Monoid b, Monad m) => (a -> m b) -> t a -> m b

-- | Strict in the monoidal accumulator. Monoidal accumulation happens from
--   left to right.
foldrMapM' :: forall t b a m. (Foldable t, Monoid b, Monad m) => (a -> m b) -> t a -> m b