Data.Constraint.Lifting

Documentation

class Lifting p f where

Methods

lifting :: p a :- p (f a)

Instances

Lifting * Eq []

Lifting * Eq Ratio

Lifting * Eq Identity

Lifting * Eq Complex

Lifting * Eq Maybe

Lifting * Ord []

Lifting * Ord Identity

Lifting * Ord Maybe

Lifting * Read []

Lifting * Read Identity

Lifting * Read Complex

Lifting * Read Maybe

Lifting * Show []

Lifting * Show Identity

Lifting * Show Complex

Lifting * Show Maybe

Lifting * Monoid Maybe

Lifting * Binary []

Lifting * Binary Maybe

Lifting * NFData []

Lifting * NFData Maybe

Lifting * Hashable []

Lifting * Hashable Maybe

Bounded a => Lifting * Bounded ((,) a)

Eq a => Lifting * Eq (Either a)

Eq a => Lifting * Eq ((,) a)

Eq1 m => Lifting * Eq (ListT m)

Eq1 f => Lifting * Eq (Reverse f)

Eq1 f => Lifting * Eq (Backwards f)

Eq1 m => Lifting * Eq (MaybeT m)

Eq1 m => Lifting * Eq (IdentityT m)

Eq1 f => Lifting * Eq (Lift f)

Ord a => Lifting * Ord (Either a)

Ord a => Lifting * Ord ((,) a)

Ord1 m => Lifting * Ord (ListT m)

Ord1 f => Lifting * Ord (Reverse f)

Ord1 f => Lifting * Ord (Backwards f)

Ord1 m => Lifting * Ord (MaybeT m)

Ord1 m => Lifting * Ord (IdentityT m)

Ord1 f => Lifting * Ord (Lift f)

Read a => Lifting * Read (Either a)

Read a => Lifting * Read ((,) a)

Read1 m => Lifting * Read (ListT m)

Read1 f => Lifting * Read (Reverse f)

Read1 f => Lifting * Read (Backwards f)

Read1 m => Lifting * Read (MaybeT m)

Read1 m => Lifting * Read (IdentityT m)

Read1 f => Lifting * Read (Lift f)

Show a => Lifting * Show (Either a)

Show a => Lifting * Show ((,) a)

Show1 m => Lifting * Show (ListT m)

Show1 f => Lifting * Show (Reverse f)

Show1 f => Lifting * Show (Backwards f)

Show1 m => Lifting * Show (MaybeT m)

Show1 m => Lifting * Show (IdentityT m)

Show1 f => Lifting * Show (Lift f)

Ix a => Lifting * Ix ((,) a)

Lifting * Monoid ((->) a)

Monoid a => Lifting * Monoid ((,) a)

Binary a => Lifting * Binary (Either a)

Binary a => Lifting * Binary ((,) a)

NFData a => Lifting * NFData (Either a)

NFData a => Lifting * NFData ((,) a)

Hashable a => Lifting * Hashable (Either a)

Hashable a => Lifting * Hashable ((,) a)

(Eq e, Eq1 m) => Lifting * Eq (ExceptT e m)

(Eq e, Eq1 m) => Lifting * Eq (ErrorT e m)

(Eq w, Eq1 m) => Lifting * Eq (WriterT w m)

(Eq w, Eq1 m) => Lifting * Eq (WriterT w m)

(Eq1 f, Eq1 g) => Lifting * Eq (Sum f g)

(Eq1 f, Eq1 g) => Lifting * Eq (Product f g)

(Functor f, Eq1 f, Eq1 g) => Lifting * Eq (Compose f g)

(Ord e, Ord1 m) => Lifting * Ord (ExceptT e m)

(Ord e, Ord1 m) => Lifting * Ord (ErrorT e m)

(Ord w, Ord1 m) => Lifting * Ord (WriterT w m)

(Ord w, Ord1 m) => Lifting * Ord (WriterT w m)

(Ord1 f, Ord1 g) => Lifting * Ord (Sum f g)

(Ord1 f, Ord1 g) => Lifting * Ord (Product f g)

(Functor f, Ord1 f, Ord1 g) => Lifting * Ord (Compose f g)

(Read e, Read1 m) => Lifting * Read (ExceptT e m)

(Read e, Read1 m) => Lifting * Read (ErrorT e m)

(Read w, Read1 m) => Lifting * Read (WriterT w m)

(Read w, Read1 m) => Lifting * Read (WriterT w m)

(Read1 f, Read1 g) => Lifting * Read (Sum f g)

(Read1 f, Read1 g) => Lifting * Read (Product f g)

(Functor f, Read1 f, Read1 g) => Lifting * Read (Compose f g)

(Show e, Show1 m) => Lifting * Show (ExceptT e m)

(Show e, Show1 m) => Lifting * Show (ErrorT e m)

(Show w, Show1 m) => Lifting * Show (WriterT w m)

(Show w, Show1 m) => Lifting * Show (WriterT w m)

(Show1 f, Show1 g) => Lifting * Show (Sum f g)

(Show1 f, Show1 g) => Lifting * Show (Product f g)

(Functor f, Show1 f, Show1 g) => Lifting * Show (Compose f g)

Lifting (* -> *) Monad ListT

Lifting (* -> *) Monad MaybeT

Lifting (* -> *) Monad IdentityT

Lifting (* -> *) Functor ListT

Lifting (* -> *) Functor Reverse

Lifting (* -> *) Functor Backwards

Lifting (* -> *) Functor MaybeT

Lifting (* -> *) Functor IdentityT

Lifting (* -> *) Functor Lift

Lifting (* -> *) MonadFix IdentityT

Lifting (* -> *) Applicative ListT

Lifting (* -> *) Applicative Reverse

Lifting (* -> *) Applicative Backwards

Lifting (* -> *) Applicative IdentityT

Lifting (* -> *) Applicative Lift

Lifting (* -> *) Foldable ListT

Lifting (* -> *) Foldable Reverse

Lifting (* -> *) Foldable Backwards

Lifting (* -> *) Foldable MaybeT

Lifting (* -> *) Foldable IdentityT

Lifting (* -> *) Foldable Lift

Lifting (* -> *) Traversable ListT

Lifting (* -> *) Traversable Reverse

Lifting (* -> *) Traversable Backwards

Lifting (* -> *) Traversable MaybeT

Lifting (* -> *) Traversable IdentityT

Lifting (* -> *) Traversable Lift

Lifting (* -> *) Alternative ListT

Lifting (* -> *) Alternative Reverse

Lifting (* -> *) Alternative Backwards

Lifting (* -> *) Alternative IdentityT

Lifting (* -> *) Alternative Lift

Lifting (* -> *) MonadPlus ListT

Lifting (* -> *) MonadPlus MaybeT

Lifting (* -> *) MonadPlus IdentityT

Lifting (* -> *) MonadIO ListT

Lifting (* -> *) MonadIO MaybeT

Lifting (* -> *) MonadIO IdentityT

Lifting (* -> *) MonadCont ListT

Lifting (* -> *) MonadCont MaybeT

Lifting (* -> *) MonadCont IdentityT

Lifting (* -> *) Eq1 ListT

Lifting (* -> *) Eq1 Reverse

Lifting (* -> *) Eq1 Backwards

Lifting (* -> *) Eq1 MaybeT

Lifting (* -> *) Eq1 IdentityT

Lifting (* -> *) Eq1 Lift

Lifting (* -> *) Ord1 ListT

Lifting (* -> *) Ord1 Reverse

Lifting (* -> *) Ord1 Backwards

Lifting (* -> *) Ord1 MaybeT

Lifting (* -> *) Ord1 IdentityT

Lifting (* -> *) Ord1 Lift

Lifting (* -> *) Read1 ListT

Lifting (* -> *) Read1 Reverse

Lifting (* -> *) Read1 Backwards

Lifting (* -> *) Read1 MaybeT

Lifting (* -> *) Read1 IdentityT

Lifting (* -> *) Read1 Lift

Lifting (* -> *) Show1 ListT

Lifting (* -> *) Show1 Reverse

Lifting (* -> *) Show1 Backwards

Lifting (* -> *) Show1 MaybeT

Lifting (* -> *) Show1 IdentityT

Lifting (* -> *) Show1 Lift

Lifting (* -> *) Monad (ContT r)

Lifting (* -> *) Monad (ReaderT e)

Lifting (* -> *) Monad (StateT s)

Lifting (* -> *) Monad (StateT s)

Lifting (* -> *) Monad (ExceptT e)

Error e => Lifting (* -> *) Monad (ErrorT e)

Monoid w => Lifting (* -> *) Monad (WriterT w)

Monoid w => Lifting (* -> *) Monad (WriterT w)

Monad f => Lifting (* -> *) Monad (Product f)

Lifting (* -> *) Functor (ContT r)

Lifting (* -> *) Functor (ReaderT e)

Lifting (* -> *) Functor (StateT s)

Lifting (* -> *) Functor (StateT s)

Lifting (* -> *) Functor (ExceptT e)

Lifting (* -> *) Functor (ErrorT e)

Lifting (* -> *) Functor (WriterT w)

Lifting (* -> *) Functor (WriterT w)

Functor f => Lifting (* -> *) Functor (Sum f)

Functor f => Lifting (* -> *) Functor (Product f)

Functor f => Lifting (* -> *) Functor (Compose f)

Lifting (* -> *) MonadFix (ReaderT e)

Lifting (* -> *) MonadFix (StateT s)

Lifting (* -> *) MonadFix (StateT s)

Lifting (* -> *) MonadFix (ExceptT e)

Error e => Lifting (* -> *) MonadFix (ErrorT e)

Monoid w => Lifting (* -> *) MonadFix (WriterT w)

Monoid w => Lifting (* -> *) MonadFix (WriterT w)

MonadFix f => Lifting (* -> *) MonadFix (Product f)

Lifting (* -> *) Applicative (ContT r)

Lifting (* -> *) Applicative (ReaderT e)

Monoid w => Lifting (* -> *) Applicative (WriterT w)

Monoid w => Lifting (* -> *) Applicative (WriterT w)

Applicative f => Lifting (* -> *) Applicative (Product f)

Applicative f => Lifting (* -> *) Applicative (Compose f)

Lifting (* -> *) Foldable (ExceptT e)

Lifting (* -> *) Foldable (ErrorT e)

Lifting (* -> *) Foldable (WriterT w)

Lifting (* -> *) Foldable (WriterT w)

Foldable f => Lifting (* -> *) Foldable (Sum f)

Foldable f => Lifting (* -> *) Foldable (Product f)

Foldable f => Lifting (* -> *) Foldable (Compose f)

Lifting (* -> *) Traversable (ExceptT e)

Lifting (* -> *) Traversable (ErrorT e)

Lifting (* -> *) Traversable (WriterT w)

Lifting (* -> *) Traversable (WriterT w)

Traversable f => Lifting (* -> *) Traversable (Sum f)

Traversable f => Lifting (* -> *) Traversable (Product f)

Traversable f => Lifting (* -> *) Traversable (Compose f)

Lifting (* -> *) Alternative (ReaderT e)

Monoid w => Lifting (* -> *) Alternative (WriterT w)

Monoid w => Lifting (* -> *) Alternative (WriterT w)

Alternative f => Lifting (* -> *) Alternative (Product f)

Alternative f => Lifting (* -> *) Alternative (Compose f)

Lifting (* -> *) MonadPlus (ReaderT e)

Lifting (* -> *) MonadPlus (StateT s)

Lifting (* -> *) MonadPlus (StateT s)

Monoid e => Lifting (* -> *) MonadPlus (ExceptT e)

Error e => Lifting (* -> *) MonadPlus (ErrorT e)

Monoid w => Lifting (* -> *) MonadPlus (WriterT w)

Monoid w => Lifting (* -> *) MonadPlus (WriterT w)

MonadPlus f => Lifting (* -> *) MonadPlus (Product f)

Lifting (* -> *) MonadIO (ContT r)

Lifting (* -> *) MonadIO (ReaderT e)

Lifting (* -> *) MonadIO (StateT s)

Lifting (* -> *) MonadIO (StateT s)

Lifting (* -> *) MonadIO (ExceptT e)

Error e => Lifting (* -> *) MonadIO (ErrorT e)

Monoid w => Lifting (* -> *) MonadIO (WriterT w)

Monoid w => Lifting (* -> *) MonadIO (WriterT w)

Lifting (* -> *) MonadCont (ReaderT e)

Lifting (* -> *) MonadCont (StateT s)

Lifting (* -> *) MonadCont (StateT s)

Lifting (* -> *) MonadCont (ExceptT w)

Error e => Lifting (* -> *) MonadCont (ErrorT e)

Monoid w => Lifting (* -> *) MonadCont (WriterT w)

Monoid w => Lifting (* -> *) MonadCont (WriterT w)

Eq e => Lifting (* -> *) Eq1 (ExceptT e)

Eq e => Lifting (* -> *) Eq1 (ErrorT e)

Eq w => Lifting (* -> *) Eq1 (WriterT w)

Eq w => Lifting (* -> *) Eq1 (WriterT w)

Eq1 f => Lifting (* -> *) Eq1 (Sum f)

Eq1 f => Lifting (* -> *) Eq1 (Product f)

(Functor f, Eq1 f) => Lifting (* -> *) Eq1 (Compose f)

Ord e => Lifting (* -> *) Ord1 (ExceptT e)

Ord e => Lifting (* -> *) Ord1 (ErrorT e)

Ord w => Lifting (* -> *) Ord1 (WriterT w)

Ord w => Lifting (* -> *) Ord1 (WriterT w)

Ord1 f => Lifting (* -> *) Ord1 (Sum f)

Ord1 f => Lifting (* -> *) Ord1 (Product f)

(Functor f, Ord1 f) => Lifting (* -> *) Ord1 (Compose f)

Read e => Lifting (* -> *) Read1 (ExceptT e)

Read e => Lifting (* -> *) Read1 (ErrorT e)

Read w => Lifting (* -> *) Read1 (WriterT w)

Read w => Lifting (* -> *) Read1 (WriterT w)

Read1 f => Lifting (* -> *) Read1 (Sum f)

Read1 f => Lifting (* -> *) Read1 (Product f)

(Functor f, Read1 f) => Lifting (* -> *) Read1 (Compose f)

Show e => Lifting (* -> *) Show1 (ExceptT e)

Show e => Lifting (* -> *) Show1 (ErrorT e)

Show w => Lifting (* -> *) Show1 (WriterT w)

Show w => Lifting (* -> *) Show1 (WriterT w)

Show1 f => Lifting (* -> *) Show1 (Sum f)

Show1 f => Lifting (* -> *) Show1 (Product f)

(Functor f, Show1 f) => Lifting (* -> *) Show1 (Compose f)

Monoid w => Lifting (* -> *) Monad (RWST r w s)

Monoid w => Lifting (* -> *) Monad (RWST r w s)

Lifting (* -> *) Functor (RWST r w s)

Lifting (* -> *) Functor (RWST r w s)

Monoid w => Lifting (* -> *) MonadFix (RWST r w s)

Monoid w => Lifting (* -> *) MonadFix (RWST r w s)

Monoid w => Lifting (* -> *) MonadPlus (RWST r w s)

Monoid w => Lifting (* -> *) MonadPlus (RWST r w s)

Monoid w => Lifting (* -> *) MonadIO (RWST r w s)

Monoid w => Lifting (* -> *) MonadIO (RWST r w s)

Monoid w => Lifting (* -> *) MonadCont (RWST r w s)

Monoid w => Lifting (* -> *) MonadCont (RWST r w s)

Lifting (* -> *) (MonadError e) IdentityT

Lifting (* -> *) (MonadError e) ListT

Lifting (* -> *) (MonadError e) MaybeT

Lifting (* -> *) (MonadReader r) IdentityT

Lifting (* -> *) (MonadReader r) ListT

Lifting (* -> *) (MonadReader r) MaybeT

Lifting (* -> *) (MonadState s) IdentityT

Lifting (* -> *) (MonadState s) ListT

Lifting (* -> *) (MonadState s) MaybeT

Lifting (* -> *) (MonadError e) (ReaderT r)

Lifting (* -> *) (MonadError e) (StateT s)

Lifting (* -> *) (MonadError e) (StateT s)

Monoid w => Lifting (* -> *) (MonadError e) (WriterT w)

Monoid w => Lifting (* -> *) (MonadError e) (WriterT w)

Lifting (* -> *) (MonadReader r) (ContT r')

Error e => Lifting (* -> *) (MonadReader r) (ErrorT e)

Lifting (* -> *) (MonadReader r) (ExceptT e)

Lifting (* -> *) (MonadReader r) (StateT s)

Lifting (* -> *) (MonadReader r) (StateT s)

Monoid w => Lifting (* -> *) (MonadReader r) (WriterT w)

Monoid w => Lifting (* -> *) (MonadReader r) (WriterT w)

Lifting (* -> *) (MonadState s) (ContT r')

Error e => Lifting (* -> *) (MonadState s) (ErrorT e)

Lifting (* -> *) (MonadState s) (ExceptT e)

Lifting (* -> *) (MonadState s) (ReaderT r)

Monoid w => Lifting (* -> *) (MonadState s) (WriterT w)

Monoid w => Lifting (* -> *) (MonadState s) (WriterT w)

Monoid w => Lifting (* -> *) (MonadError e) (RWST r w s)

Monoid w => Lifting (* -> *) (MonadError e) (RWST r w s)

Lifting (* -> *) (MonadRWS r w s) IdentityT

Lifting (* -> *) (MonadRWS r w s) MaybeT

Lifting (* -> *) (MonadRWS r w s) (ExceptT e)

Error e => Lifting (* -> *) (MonadRWS r w s) (ErrorT e)

class Lifting2 p f where

Methods

lifting2 :: p a :- Lifting p (f a)

Instances

Lifting2 * Bounded (,)

Lifting2 * Eq Either

Lifting2 * Eq (,)

Lifting2 * Ord Either

Lifting2 * Ord (,)

Lifting2 * Read Either

Lifting2 * Read (,)

Lifting2 * Show Either

Lifting2 * Show (,)

Lifting2 * Ix (,)

Lifting2 * Monoid (,)

Lifting2 * Binary Either

Lifting2 * Binary (,)

Lifting2 * NFData Either

Lifting2 * NFData (,)

Lifting2 * Hashable Either

Lifting2 * Hashable (,)

Lifting2 (* -> *) Monad Product

Lifting2 (* -> *) Functor Sum

Lifting2 (* -> *) Functor Product

Lifting2 (* -> *) Functor Compose

Lifting2 (* -> *) MonadFix Product

Lifting2 (* -> *) Applicative Product

Lifting2 (* -> *) Applicative Compose

Lifting2 (* -> *) Foldable Sum

Lifting2 (* -> *) Foldable Product

Lifting2 (* -> *) Foldable Compose

Lifting2 (* -> *) Traversable Sum

Lifting2 (* -> *) Traversable Product

Lifting2 (* -> *) Traversable Compose

Lifting2 (* -> *) Alternative Product

Lifting2 (* -> *) Alternative Compose

Lifting2 (* -> *) MonadPlus Product

Lifting2 (* -> *) Eq1 Sum

Lifting2 (* -> *) Eq1 Product

Lifting2 (* -> *) Ord1 Sum

Lifting2 (* -> *) Ord1 Product

Lifting2 (* -> *) Read1 Sum

Lifting2 (* -> *) Read1 Product

Lifting2 (* -> *) Show1 Sum

Lifting2 (* -> *) Show1 Product