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


-- | Parameterized/indexed monoids and monads using only a single parameter type variable.
--   
--   Parameterized/indexed monoids and monads using only a single parameter
--   type variable.
@package parameterized
@version 0.4.0.0

module Parameterized.TypeLevel

-- | Get the first type of a value level tuple This is useful for defining
--   a newtype wrapper with a single "parameterized" type, around a type
--   with many "parameterized" type variables.

-- | Get the second type of a value level tuple

-- | Get the third type of a value level tuple

-- | Get the fourth type of a value level tuple

-- | Get the fifth type of a value level tuple

-- | Get the sixth type of a value level tuple

-- | Get the seventh type of a value level tuple

-- | Get the eigth type of a value level tuple

-- | Get the nineth type of a value level tuple

-- | Get the tenth type of a value level tuple

module Parameterized.Data.Semigroup

-- | Parameterized version of (<>) in Semigroup If used in
--   conjunction with <a>Empty</a>, ie as a parameterized Monoid, then the
--   instance should follow the following laws: * <tt>pmempty'
--   <tt>pmappend'</tt> x = x</tt> * <tt>x <tt>pmappend'</tt> pempty' =
--   x</tt> * <tt>x <tt>pmappend'</tt> (y <tt>pmappend'</tt> z) = (x
--   <tt>pmappend'</tt> y) <tt>pmappend'</tt> z</tt>
class PSemigroup (n :: k -> Type) (t :: k) (u :: k) (v :: k) | t u -> v
pmappend :: PSemigroup n t u v => PNullary n t -> PNullary n u -> PNullary n v
(&<>) :: (PSemigroup n t u v) => PNullary n t -> PNullary n u -> PNullary n v
infixr 6 &<>

module Parameterized.Data.Monoid

-- | Parameterized version of mempty in Monoid.
class PMEmpty (n :: k -> Type) (id :: k) | n -> id
pmempty :: PMEmpty n id => PNullary n id

-- | Parameterized version of Monoid.
class (PSemigroup n t u v, PMEmpty n id) => PMonoid n id t u v
instance forall k (n :: k -> GHC.Types.Type) (t :: k) (u :: k) (v :: k) (id :: k). (Parameterized.Data.Semigroup.PSemigroup n t u v, Parameterized.Data.Monoid.PMEmpty n id) => Parameterized.Data.Monoid.PMonoid n id t u v

module Parameterized.Control.Applicative

-- | Parameterized version of <a>pure</a> in <a>Applicative</a> An instance
--   of this should create a parameterized unary type where the parameter
--   is an identity in respect to <a>papply</a> NB. For
--   <a>ChangingState</a>, the id <tt>s</tt> "parameter" cannot be purely
--   determined from <tt>m</tt>, so unlike <a>pappend</a> there is not
--   functional dependency to help type inference. Hint: use <tt>ppure @_
--   @_ </tt>id@ to specify the id type to avoid ambiguity.
class PPointed (m :: k -> Type -> Type) (id :: k)

-- | lift a value.
ppure :: PPointed m id => a -> PUnary m id a

-- | Parameterized version of <tt>ap</tt> in <a>Applicative</a> NB.
--   <a>PPointed</a> cannot be made a superclass because type variable
--   <tt>id</tt> is not in scope.
class (Functor (PUnary m t), Functor (PUnary m u), Functor (PUnary m v)) => PApplicative (m :: k -> Type -> Type) (t :: k) (u :: k) (v :: k) | t u -> v

-- | Sequential application.
papply :: PApplicative m t u v => PUnary m t (a -> b) -> PUnary m u a -> PUnary m v b

-- | Sequential application.
(&<*>) :: (PApplicative m t u v) => PUnary m t (a -> b) -> PUnary m u a -> PUnary m v b
infixl 4 &<*>

-- | Sequence actions, discarding the value of the first argument.
(&*>) :: (PApplicative m t u v) => PUnary m t a -> PUnary m u b -> PUnary m v b
infixl 4 &*>

-- | Sequence actions, discarding the value of the second argument.
(&<*) :: (PApplicative m t u v) => PUnary m t a -> PUnary m u b -> PUnary m v a
infixl 4 &<*

-- | Lift a function to actions.
pliftA :: (Functor (PUnary m t)) => (a -> b) -> PUnary m t a -> PUnary m t b

-- | Lift a binary function to actions.
pliftA2 :: (PApplicative m t u v) => (a -> b -> c) -> PUnary m t a -> PUnary m u b -> PUnary m v c

-- | Lift a ternary function to actions.
pliftA3 :: (PApplicative m t u v, PApplicative m v w x) => (a -> b -> c -> d) -> PUnary m t a -> PUnary m u b -> PUnary m w c -> PUnary m x d

-- | Parameterized version of empty in <tt>Alternative</tt>. An instance of
--   this should create a parameterized unary type where the parameter is
--   an identity in respect to <a>pappend</a>
class PEmpty (m :: k -> Type -> Type) (id :: k) | m -> id

-- | The identity of <a>&amp;&lt;|&gt;</a>
pempty :: PEmpty m id => PUnary m id a

-- | Parameterized version of <tt>Alternative</tt> NB. <a>PEmpty</a> cannot
--   be made a superclass because type variable <tt>id</tt> will be
--   ambiguous. NB. PAlternative doensn't require <a>PApplicative</a> as a
--   superclass, because Some things can be made instances of
--   <a>PAlternative</a> but not <a>PApplicative</a>.
class PAlternative (m :: k -> Type -> Type) (t :: k) (u :: k) (v :: k) | t u -> v

-- | An associative binary operation
pappend :: PAlternative m t u v => PUnary m t a -> PUnary m u a -> PUnary m v a
(&<|>) :: (PAlternative m t u v) => PUnary m t a -> PUnary m u a -> PUnary m v a
infixl 3 &<|>

module Parameterized.Control.Monad

-- | Parameterized version of Monad.
class PApplicative m t u v => PMonad (m :: k -> Type -> Type) (t :: k) (u :: k) (v :: k)

-- | Sequentially compose two actions, passing any value produced by the
--   first as an argument to the second.
pbind :: PMonad m t u v => PUnary m t a -> (a -> PUnary m u b) -> PUnary m v b

-- | Sequentially compose two actions, passing any value produced by the
--   first as an argument to the second.
(&>>=) :: PMonad m t u v => PUnary m t a -> (a -> PUnary m u b) -> PUnary m v b
infixl 1 &>>=
(&>>) :: PMonad m t u v => PUnary m t a -> PUnary m u b -> PUnary m v b
infixl 1 &>>

-- | Same as <a>&amp;&gt;&gt;=</a>, but with the arguments interchanged.
(&=<<) :: PMonad m t u v => (a -> PUnary m u b) -> PUnary m t a -> PUnary m v b
infixr 1 &=<<

-- | Left-to-right Kleisli composition of monads.
(&>=>) :: (PMonad m t u v) => (a -> PUnary m t b) -> (b -> PUnary m u c) -> (a -> PUnary m v c)
infixr 1 &>=>

-- | Right-to-left Kleisli composition of monads.
--   <tt>(<tt>&gt;=&gt;</tt>)</tt>, with the arguments flipped.
(&<=<) :: (PMonad m t u v) => (b -> PUnary m u c) -> (a -> PUnary m t b) -> (a -> PUnary m v c)
infixr 1 &<=<

module Parameterized.Control.Monad.Trans.Reader

-- | Given a Reader that accepts <tt>Which a</tt>, and another Reader that
--   accepts <tt>Which b</tt> make a reader that accepts <tt>Which
--   (AppendUnique a b)</tt> and runs both readers if possible, where the
--   types in <tt>Which a</tt> and <tt>Which b</tt> may overlap, but with
--   the compile time constraint that all the types in (AppendUnique a b)
--   are distinct.
newtype OverlappingWhichReader m r a
OverlappingWhichReader :: ReaderT r m a -> OverlappingWhichReader m r a
[runOverlappingWhichReader] :: OverlappingWhichReader m r a -> ReaderT r m a

-- | Given a Reader that accepts <tt>Which a</tt>, and another Reader that
--   accepts <tt>Which b</tt> make a reader that accepts <tt>Which (Append
--   a b)</tt> and only run one of the readers for the correct Which type,
--   with a compile-time contraint that the types in <tt>Which a</tt> are
--   distinct from the type in <tt>Which b</tt> The advantage of
--   <a>DistinctWhichReader</a> over <a>OverlappingWhichReader</a> is that
--   <a>pappend</a> doesn't require the inner monad <tt>m</tt> to be an
--   <a>Alternative</a>. NB. <a>PEmpty</a> still requires
--   <a>Alternative</a> but you don't need to be an instance of
--   <a>PEmpty</a> (analogous to Semigroup)
newtype DistinctWhichReader m r a
DistinctWhichReader :: ReaderT r m a -> DistinctWhichReader m r a
[runDistinctWhichReader] :: DistinctWhichReader m r a -> ReaderT r m a

-- | Given a Reader that accepts <tt>Many a</tt>, and another Reader that
--   accepts <tt>Many b</tt> make a reader that accepts <tt>Many
--   (AppendUnique a b)</tt> with the compile time constraint that all the
--   types in (AppendUnique a b) are distinct.
newtype ManyReader m r a
ManyReader :: ReaderT r m a -> ManyReader m r a
[runManyReader] :: ManyReader m r a -> ReaderT r m a
instance Control.Monad.IO.Class.MonadIO m => Control.Monad.IO.Class.MonadIO (Parameterized.Control.Monad.Trans.Reader.ManyReader m r)
instance Control.Monad.Fail.MonadFail m => Control.Monad.Fail.MonadFail (Parameterized.Control.Monad.Trans.Reader.ManyReader m r)
instance Control.Monad.Fix.MonadFix m => Control.Monad.Fix.MonadFix (Parameterized.Control.Monad.Trans.Reader.ManyReader m r)
instance Control.Monad.Zip.MonadZip m => Control.Monad.Zip.MonadZip (Parameterized.Control.Monad.Trans.Reader.ManyReader m r)
instance GHC.Base.MonadPlus m => GHC.Base.MonadPlus (Parameterized.Control.Monad.Trans.Reader.ManyReader m r)
instance GHC.Base.Alternative m => GHC.Base.Alternative (Parameterized.Control.Monad.Trans.Reader.ManyReader m r)
instance GHC.Base.Monad m => GHC.Base.Monad (Parameterized.Control.Monad.Trans.Reader.ManyReader m r)
instance GHC.Base.Applicative m => GHC.Base.Applicative (Parameterized.Control.Monad.Trans.Reader.ManyReader m r)
instance GHC.Base.Functor m => GHC.Base.Functor (Parameterized.Control.Monad.Trans.Reader.ManyReader m r)
instance GHC.Generics.Generic (Parameterized.Control.Monad.Trans.Reader.ManyReader m r a)
instance Control.Monad.IO.Class.MonadIO m => Control.Monad.IO.Class.MonadIO (Parameterized.Control.Monad.Trans.Reader.DistinctWhichReader m r)
instance Control.Monad.Fail.MonadFail m => Control.Monad.Fail.MonadFail (Parameterized.Control.Monad.Trans.Reader.DistinctWhichReader m r)
instance Control.Monad.Fix.MonadFix m => Control.Monad.Fix.MonadFix (Parameterized.Control.Monad.Trans.Reader.DistinctWhichReader m r)
instance Control.Monad.Zip.MonadZip m => Control.Monad.Zip.MonadZip (Parameterized.Control.Monad.Trans.Reader.DistinctWhichReader m r)
instance GHC.Base.MonadPlus m => GHC.Base.MonadPlus (Parameterized.Control.Monad.Trans.Reader.DistinctWhichReader m r)
instance GHC.Base.Alternative m => GHC.Base.Alternative (Parameterized.Control.Monad.Trans.Reader.DistinctWhichReader m r)
instance GHC.Base.Monad m => GHC.Base.Monad (Parameterized.Control.Monad.Trans.Reader.DistinctWhichReader m r)
instance GHC.Base.Applicative m => GHC.Base.Applicative (Parameterized.Control.Monad.Trans.Reader.DistinctWhichReader m r)
instance GHC.Base.Functor m => GHC.Base.Functor (Parameterized.Control.Monad.Trans.Reader.DistinctWhichReader m r)
instance GHC.Generics.Generic (Parameterized.Control.Monad.Trans.Reader.DistinctWhichReader m r a)
instance Control.Monad.IO.Class.MonadIO m => Control.Monad.IO.Class.MonadIO (Parameterized.Control.Monad.Trans.Reader.OverlappingWhichReader m r)
instance Control.Monad.Fail.MonadFail m => Control.Monad.Fail.MonadFail (Parameterized.Control.Monad.Trans.Reader.OverlappingWhichReader m r)
instance Control.Monad.Fix.MonadFix m => Control.Monad.Fix.MonadFix (Parameterized.Control.Monad.Trans.Reader.OverlappingWhichReader m r)
instance Control.Monad.Zip.MonadZip m => Control.Monad.Zip.MonadZip (Parameterized.Control.Monad.Trans.Reader.OverlappingWhichReader m r)
instance GHC.Base.MonadPlus m => GHC.Base.MonadPlus (Parameterized.Control.Monad.Trans.Reader.OverlappingWhichReader m r)
instance GHC.Base.Alternative m => GHC.Base.Alternative (Parameterized.Control.Monad.Trans.Reader.OverlappingWhichReader m r)
instance GHC.Base.Monad m => GHC.Base.Monad (Parameterized.Control.Monad.Trans.Reader.OverlappingWhichReader m r)
instance GHC.Base.Applicative m => GHC.Base.Applicative (Parameterized.Control.Monad.Trans.Reader.OverlappingWhichReader m r)
instance GHC.Base.Functor m => GHC.Base.Functor (Parameterized.Control.Monad.Trans.Reader.OverlappingWhichReader m r)
instance GHC.Generics.Generic (Parameterized.Control.Monad.Trans.Reader.OverlappingWhichReader m r a)
instance GHC.Base.Applicative m => Parameterized.Control.Applicative.PPointed (Parameterized.Control.Monad.Trans.Reader.OverlappingWhichReader m) (Data.Diverse.Which.Internal.Which '[])
instance GHC.Base.Alternative m => Parameterized.Control.Applicative.PEmpty (Parameterized.Control.Monad.Trans.Reader.OverlappingWhichReader m) (Data.Diverse.Which.Internal.Which '[])
instance (GHC.Base.Alternative m, Data.Diverse.Which.Internal.Reinterpret b c, Data.Diverse.Which.Internal.Reinterpret a c, c ~ Data.Diverse.TypeLevel.AppendUnique a b) => Parameterized.Control.Applicative.PAlternative (Parameterized.Control.Monad.Trans.Reader.OverlappingWhichReader m) (Data.Diverse.Which.Internal.Which a) (Data.Diverse.Which.Internal.Which b) (Data.Diverse.Which.Internal.Which c)
instance GHC.Base.Applicative m => Parameterized.Control.Applicative.PPointed (Parameterized.Control.Monad.Trans.Reader.DistinctWhichReader m) (Data.Diverse.Which.Internal.Which '[])
instance GHC.Base.Alternative m => Parameterized.Control.Applicative.PEmpty (Parameterized.Control.Monad.Trans.Reader.DistinctWhichReader m) (Data.Diverse.Which.Internal.Which '[])
instance (Data.Diverse.Which.Internal.Reinterpret b c, Data.Diverse.TypeLevel.Complement c b ~ a, Data.Diverse.TypeLevel.Complement c a ~ b, c ~ Data.Diverse.TypeLevel.Append a b) => Parameterized.Control.Applicative.PAlternative (Parameterized.Control.Monad.Trans.Reader.DistinctWhichReader m) (Data.Diverse.Which.Internal.Which a) (Data.Diverse.Which.Internal.Which b) (Data.Diverse.Which.Internal.Which c)
instance GHC.Base.Applicative m => Parameterized.Control.Applicative.PPointed (Parameterized.Control.Monad.Trans.Reader.ManyReader m) (Data.Diverse.Many.Internal.Many '[])
instance GHC.Base.Alternative m => Parameterized.Control.Applicative.PEmpty (Parameterized.Control.Monad.Trans.Reader.ManyReader m) (Data.Diverse.Many.Internal.Many '[])
instance (GHC.Base.Functor (Parameterized.Control.Monad.Trans.Reader.ManyReader m (Data.Diverse.Many.Internal.Many c)), GHC.Base.Applicative m, Data.Diverse.Many.Internal.Select a c, Data.Diverse.Many.Internal.Select b c, c ~ Data.Diverse.TypeLevel.AppendUnique a b) => Parameterized.Control.Applicative.PApplicative (Parameterized.Control.Monad.Trans.Reader.ManyReader m) (Data.Diverse.Many.Internal.Many a) (Data.Diverse.Many.Internal.Many b) (Data.Diverse.Many.Internal.Many c)
instance (GHC.Base.Alternative m, Data.Diverse.Many.Internal.Select a c, Data.Diverse.Many.Internal.Select b c, c ~ Data.Diverse.TypeLevel.AppendUnique a b) => Parameterized.Control.Applicative.PAlternative (Parameterized.Control.Monad.Trans.Reader.ManyReader m) (Data.Diverse.Many.Internal.Many a) (Data.Diverse.Many.Internal.Many b) (Data.Diverse.Many.Internal.Many c)
instance (GHC.Base.Functor (Parameterized.Control.Monad.Trans.Reader.ManyReader m (Data.Diverse.Many.Internal.Many c)), GHC.Base.Monad m, Data.Diverse.Many.Internal.Select a c, Data.Diverse.Many.Internal.Select b c, c ~ Data.Diverse.TypeLevel.AppendUnique a b) => Parameterized.Control.Monad.PMonad (Parameterized.Control.Monad.Trans.Reader.ManyReader m) (Data.Diverse.Many.Internal.Many a) (Data.Diverse.Many.Internal.Many b) (Data.Diverse.Many.Internal.Many c)

module Parameterized.Control.Monad.Trans.State.Strict

-- | Given a ManyState that modifies <tt>Many a</tt>, and another ManyState
--   that modifes <tt>Many b</tt> make a State that accepts <tt>Many
--   (AppendUnique a b)</tt> with the compile time constraint that all the
--   types in (AppendUnique a b) are distinct.
newtype ManyState m s a
ManyState :: StateT s m a -> ManyState m s a
[runManyState] :: ManyState m s a -> StateT s m a

-- | Given a ChangingState that changes state from <tt>s</tt> to
--   <tt>t</tt>, and another ChangingState that changes state from
--   <tt>t</tt> to <tt>u</tt> make a State that changes from <tt>s</tt> to
--   <tt>u</tt> with the compile time constraint that all the types in
--   (AppendUnique a b) are distinct. NB. The state is in the snd position
--   to be consistent with StateT.
newtype ChangingState m st a
ChangingState :: (At0 st -> m (a, At1 st)) -> ChangingState m st a
[runChangingState] :: ChangingState m st a -> At0 st -> m (a, At1 st)

-- | Prefer this to using ChangingState to construct as it results in
--   better type inference as it avoids ambiguous type variable <tt>st</tt>
changingState :: (s -> m (a, t)) -> ChangingState m (s, t) a
instance GHC.Generics.Generic (Parameterized.Control.Monad.Trans.State.Strict.ChangingState m st a)
instance Control.Monad.IO.Class.MonadIO m => Control.Monad.IO.Class.MonadIO (Parameterized.Control.Monad.Trans.State.Strict.ManyState m s)
instance Control.Monad.Fail.MonadFail m => Control.Monad.Fail.MonadFail (Parameterized.Control.Monad.Trans.State.Strict.ManyState m s)
instance Control.Monad.Fix.MonadFix m => Control.Monad.Fix.MonadFix (Parameterized.Control.Monad.Trans.State.Strict.ManyState m s)
instance GHC.Base.MonadPlus m => GHC.Base.MonadPlus (Parameterized.Control.Monad.Trans.State.Strict.ManyState m s)
instance GHC.Base.MonadPlus m => GHC.Base.Alternative (Parameterized.Control.Monad.Trans.State.Strict.ManyState m s)
instance GHC.Base.Monad m => GHC.Base.Monad (Parameterized.Control.Monad.Trans.State.Strict.ManyState m s)
instance GHC.Base.Monad m => GHC.Base.Applicative (Parameterized.Control.Monad.Trans.State.Strict.ManyState m s)
instance GHC.Base.Functor m => GHC.Base.Functor (Parameterized.Control.Monad.Trans.State.Strict.ManyState m s)
instance GHC.Generics.Generic (Parameterized.Control.Monad.Trans.State.Strict.ManyState m s a)
instance GHC.Base.Monad m => Parameterized.Control.Applicative.PPointed (Parameterized.Control.Monad.Trans.State.Strict.ManyState m) (Data.Diverse.Many.Internal.Many '[])
instance GHC.Base.Alternative m => Parameterized.Control.Applicative.PEmpty (Parameterized.Control.Monad.Trans.State.Strict.ManyState m) (Data.Diverse.Many.Internal.Many '[])
instance (GHC.Base.Monad m, Data.Diverse.Many.Internal.Select a c, Data.Diverse.Many.Internal.Select b c, Data.Diverse.Many.Internal.Amend a c, Data.Diverse.Many.Internal.Amend b c, c ~ Data.Diverse.TypeLevel.AppendUnique a b) => Parameterized.Control.Applicative.PApplicative (Parameterized.Control.Monad.Trans.State.Strict.ManyState m) (Data.Diverse.Many.Internal.Many a) (Data.Diverse.Many.Internal.Many b) (Data.Diverse.Many.Internal.Many c)
instance (GHC.Base.Monad m, GHC.Base.Alternative m, Data.Diverse.Many.Internal.Select a c, Data.Diverse.Many.Internal.Select b c, Data.Diverse.Many.Internal.Amend a c, Data.Diverse.Many.Internal.Amend b c, c ~ Data.Diverse.TypeLevel.AppendUnique a b) => Parameterized.Control.Applicative.PAlternative (Parameterized.Control.Monad.Trans.State.Strict.ManyState m) (Data.Diverse.Many.Internal.Many a) (Data.Diverse.Many.Internal.Many b) (Data.Diverse.Many.Internal.Many c)
instance (GHC.Base.Monad m, Data.Diverse.Many.Internal.Select a c, Data.Diverse.Many.Internal.Select b c, Data.Diverse.Many.Internal.Amend a c, Data.Diverse.Many.Internal.Amend b c, c ~ Data.Diverse.TypeLevel.AppendUnique a b) => Parameterized.Control.Monad.PMonad (Parameterized.Control.Monad.Trans.State.Strict.ManyState m) (Data.Diverse.Many.Internal.Many a) (Data.Diverse.Many.Internal.Many b) (Data.Diverse.Many.Internal.Many c)
instance GHC.Base.Functor m => GHC.Base.Functor (Parameterized.Control.Monad.Trans.State.Strict.ChangingState m st)
instance GHC.Base.Applicative m => Parameterized.Control.Applicative.PPointed (Parameterized.Control.Monad.Trans.State.Strict.ChangingState m) (s, s)
instance GHC.Base.Monad m => Parameterized.Control.Applicative.PApplicative (Parameterized.Control.Monad.Trans.State.Strict.ChangingState m) (s, t) (t, u) (s, u)
instance GHC.Base.Monad m => Parameterized.Control.Monad.PMonad (Parameterized.Control.Monad.Trans.State.Strict.ChangingState m) (s, t) (t, u) (s, u)