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


-- | 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
--   <tt><a>Monad</a></tt>. 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 <tt><a>Monad</a></tt>, we
--   recommend structuring imports like so:
--   
--   <pre>
--   import Control.Monad hiding ((<a>$!</a>))
--   import Constrictor
--   </pre>
--   
--   or
--   
--   <pre>
--   import Control.Monad
--   import Constrictor hiding ((<a>$!</a>))
--   </pre>
--   
--   There should be no side effects (i.e. naming/scoping conflicts)
--   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
foldrMapM' :: forall t b a m. (Foldable t, Monoid b, Monad m) => (a -> m b) -> t a -> m b

-- | A wrapped applicative functor. Please note that base 4.12.0.0 will
--   include this type, and it will be removed from this library at that
--   point.
newtype Ap f a
Ap :: f a -> Ap f a
[getAp] :: Ap f a -> f a
instance Data.Traversable.Traversable f => Data.Traversable.Traversable (Constrictor.Ap f)
instance GHC.Show.Show (f a) => GHC.Show.Show (Constrictor.Ap f a)
instance GHC.Read.Read (f a) => GHC.Read.Read (Constrictor.Ap f a)
instance GHC.Classes.Ord (f a) => GHC.Classes.Ord (Constrictor.Ap f a)
instance GHC.Num.Num (f a) => GHC.Num.Num (Constrictor.Ap f a)
instance GHC.Base.MonadPlus f => GHC.Base.MonadPlus (Constrictor.Ap f)
instance Control.Monad.Fix.MonadFix f => Control.Monad.Fix.MonadFix (Constrictor.Ap f)
instance Control.Monad.Fail.MonadFail f => Control.Monad.Fail.MonadFail (Constrictor.Ap f)
instance GHC.Base.Monad f => GHC.Base.Monad (Constrictor.Ap f)
instance GHC.Generics.Generic1 (Constrictor.Ap f)
instance GHC.Generics.Generic (Constrictor.Ap f a)
instance GHC.Base.Functor f => GHC.Base.Functor (Constrictor.Ap f)
instance Data.Foldable.Foldable f => Data.Foldable.Foldable (Constrictor.Ap f)
instance GHC.Classes.Eq (f a) => GHC.Classes.Eq (Constrictor.Ap f a)
instance GHC.Enum.Enum (f a) => GHC.Enum.Enum (Constrictor.Ap f a)
instance GHC.Base.Applicative f => GHC.Base.Applicative (Constrictor.Ap f)
instance GHC.Base.Alternative f => GHC.Base.Alternative (Constrictor.Ap f)
instance (GHC.Base.Applicative f, Data.Semigroup.Semigroup a) => Data.Semigroup.Semigroup (Constrictor.Ap f a)
instance (GHC.Base.Applicative f, GHC.Base.Monoid a) => GHC.Base.Monoid (Constrictor.Ap f a)