DeepControl.Monad.Trans.Identity

This module enables you to deal with deep monads in any monad-transformer.

Level-1

module Data.Functor.Identity

module Control.Monad.Trans.Identity

Level-1

identity-cover

(*:) :: Monad m => Identity a -> IdentityT m a infixl 3

The level-1 identity-cover function, analogous to '(.*)'

>>> (*:) (Identity 1) :: IdentityT [] Int
IdentityT [1]

>>> (*:) (Identity 1) :: IdentityT Maybe Int
IdentityT (Just 1)

Level-2

newtype IdentityT2 f1 f2 a

Constructors

IdentityT2

Fields

• runIdentityT2 :: f1 (f2 a)

Instances

(Monad m1, Monad m2, Traversable m2) => Monad (IdentityT2 m1 m2)

Methods

(>>=) :: IdentityT2 m1 m2 a -> (a -> IdentityT2 m1 m2 b) -> IdentityT2 m1 m2 b

(>>) :: IdentityT2 m1 m2 a -> IdentityT2 m1 m2 b -> IdentityT2 m1 m2 b

return :: a -> IdentityT2 m1 m2 a

fail :: String -> IdentityT2 m1 m2 a

(Functor f2, Functor f1) => Functor (IdentityT2 f1 f2)

Methods

fmap :: (a -> b) -> IdentityT2 f1 f2 a -> IdentityT2 f1 f2 b

(<$) :: a -> IdentityT2 f1 f2 b -> IdentityT2 f1 f2 a

(Applicative m1, Applicative m2) => Applicative (IdentityT2 m1 m2)

Methods

pure :: a -> IdentityT2 m1 m2 a

(<*>) :: IdentityT2 m1 m2 (a -> b) -> IdentityT2 m1 m2 a -> IdentityT2 m1 m2 b

(*>) :: IdentityT2 m1 m2 a -> IdentityT2 m1 m2 b -> IdentityT2 m1 m2 b

(<*) :: IdentityT2 m1 m2 a -> IdentityT2 m1 m2 b -> IdentityT2 m1 m2 a

(Foldable f2, Foldable f1) => Foldable (IdentityT2 f1 f2)

Methods

fold :: Monoid m => IdentityT2 f1 f2 m -> m

foldMap :: Monoid m => (a -> m) -> IdentityT2 f1 f2 a -> m

foldr :: (a -> b -> b) -> b -> IdentityT2 f1 f2 a -> b

foldr' :: (a -> b -> b) -> b -> IdentityT2 f1 f2 a -> b

foldl :: (b -> a -> b) -> b -> IdentityT2 f1 f2 a -> b

foldl' :: (b -> a -> b) -> b -> IdentityT2 f1 f2 a -> b

foldr1 :: (a -> a -> a) -> IdentityT2 f1 f2 a -> a

foldl1 :: (a -> a -> a) -> IdentityT2 f1 f2 a -> a

toList :: IdentityT2 f1 f2 a -> [a]

null :: IdentityT2 f1 f2 a -> Bool

length :: IdentityT2 f1 f2 a -> Int

elem :: Eq a => a -> IdentityT2 f1 f2 a -> Bool

maximum :: Ord a => IdentityT2 f1 f2 a -> a

minimum :: Ord a => IdentityT2 f1 f2 a -> a

sum :: Num a => IdentityT2 f1 f2 a -> a

product :: Num a => IdentityT2 f1 f2 a -> a

(Traversable f2, Traversable f1) => Traversable (IdentityT2 f1 f2)

Methods

traverse :: Applicative f => (a -> f b) -> IdentityT2 f1 f2 a -> f (IdentityT2 f1 f2 b)

sequenceA :: Applicative f => IdentityT2 f1 f2 (f a) -> f (IdentityT2 f1 f2 a)

mapM :: Monad m => (a -> m b) -> IdentityT2 f1 f2 a -> m (IdentityT2 f1 f2 b)

sequence :: Monad m => IdentityT2 f1 f2 (m a) -> m (IdentityT2 f1 f2 a)

(MonadIO m1, Monad m1, Monad m2, Traversable m2) => MonadIO (IdentityT2 m1 m2)

Methods

liftIO :: IO a -> IdentityT2 m1 m2 a

(Alternative m1, Alternative m2) => Alternative (IdentityT2 m1 m2)

Methods

empty :: IdentityT2 m1 m2 a

(<|>) :: IdentityT2 m1 m2 a -> IdentityT2 m1 m2 a -> IdentityT2 m1 m2 a

some :: IdentityT2 m1 m2 a -> IdentityT2 m1 m2 [a]

many :: IdentityT2 m1 m2 a -> IdentityT2 m1 m2 [a]

(MonadPlus m1, Alternative m2, Monad m2, Traversable m2) => MonadPlus (IdentityT2 m1 m2)

Methods

mzero :: IdentityT2 m1 m2 a

mplus :: IdentityT2 m1 m2 a -> IdentityT2 m1 m2 a -> IdentityT2 m1 m2 a

Eq (f1 (f2 a)) => Eq (IdentityT2 f1 f2 a)

Methods

(==) :: IdentityT2 f1 f2 a -> IdentityT2 f1 f2 a -> Bool

(/=) :: IdentityT2 f1 f2 a -> IdentityT2 f1 f2 a -> Bool

Ord (f1 (f2 a)) => Ord (IdentityT2 f1 f2 a)

Methods

compare :: IdentityT2 f1 f2 a -> IdentityT2 f1 f2 a -> Ordering

(<) :: IdentityT2 f1 f2 a -> IdentityT2 f1 f2 a -> Bool

(<=) :: IdentityT2 f1 f2 a -> IdentityT2 f1 f2 a -> Bool

(>) :: IdentityT2 f1 f2 a -> IdentityT2 f1 f2 a -> Bool

(>=) :: IdentityT2 f1 f2 a -> IdentityT2 f1 f2 a -> Bool

max :: IdentityT2 f1 f2 a -> IdentityT2 f1 f2 a -> IdentityT2 f1 f2 a

min :: IdentityT2 f1 f2 a -> IdentityT2 f1 f2 a -> IdentityT2 f1 f2 a

Read (f1 (f2 a)) => Read (IdentityT2 f1 f2 a)

Methods

readsPrec :: Int -> ReadS (IdentityT2 f1 f2 a)

readList :: ReadS [IdentityT2 f1 f2 a]

readPrec :: ReadPrec (IdentityT2 f1 f2 a)

readListPrec :: ReadPrec [IdentityT2 f1 f2 a]

Show (f1 (f2 a)) => Show (IdentityT2 f1 f2 a)

Methods

showsPrec :: Int -> IdentityT2 f1 f2 a -> ShowS

show :: IdentityT2 f1 f2 a -> String

showList :: [IdentityT2 f1 f2 a] -> ShowS

identity-cover

(**:) :: (Monad m1, Monad m2) => Identity a -> IdentityT2 m1 m2 a infixl 3

The level-2 identity-cover function, analogous to '(**:)'

>>> (**:) (Identity 1) :: IdentityT2 [] Maybe Int
IdentityT2 {runIdentityT2 = [Just 1]}

>>> (**:) (Identity 1) :: IdentityT2 (Except ()) (Writer String) Int
IdentityT2 {runIdentityT2 = ExceptT (Identity (Right (WriterT (Identity (1,"")))))}

(-*:) :: (Monad m1, Monad m2) => IdentityT m1 a -> IdentityT2 m1 m2 a infixl 3

The level-2 identity-cover function, analogous to '(-*)'

>>> (-*:) (IdentityT [1]) :: IdentityT2 [] Maybe Int
IdentityT2 {runIdentityT2 = [Just 1]}

>>> (-*:) (IdentityT (ExceptT (Identity (Right 1)))) :: IdentityT2 (Except ()) (Writer String) Int
IdentityT2 {runIdentityT2 = ExceptT (Identity (Right (WriterT (Identity (1,"")))))}

(*-:) :: (Monad m1, Monad m2) => IdentityT m2 a -> IdentityT2 m1 m2 a infixl 3

The level-2 identity-cover function, analogous to '(.*)'

>>> (*-:) (IdentityT (Just 1)) :: IdentityT2 [] Maybe Int
IdentityT2 {runIdentityT2 = [Just 1]}

>>> (*-:) (IdentityT (WriterT (Identity (1,"")))) :: IdentityT2 (Except ()) (Writer String) Int
IdentityT2 {runIdentityT2 = ExceptT (Identity (Right (WriterT (Identity (1,"")))))}

identity-roll

transfoldI2 :: (Monad m1, MonadTrans_ m2 t2) => IdentityT2 m1 m2 a -> IdentityT (t2 m1) a

untransfoldI2 :: (Monad m1, MonadTrans_ m2 t2) => IdentityT (t2 m1) a -> IdentityT2 m1 m2 a

lift

mapIdentityT2 :: (m1 (m2 a) -> n1 (n2 b)) -> IdentityT2 m1 m2 a -> IdentityT2 n1 n2 b

liftCallCC2 :: CallCC2 m1 m2 a b -> CallCC (IdentityT2 m1 m2) a b

liftCatch2 :: Catch2 e m1 m2 a -> Catch e (IdentityT2 m1 m2) a

Level-3

newtype IdentityT3 f1 f2 f3 a

Constructors

IdentityT3

Fields

• runIdentityT3 :: f1 (f2 (f3 a))

Instances

(Monad m1, Monad m2, Traversable m2, Monad m3, Traversable m3) => Monad (IdentityT3 m1 m2 m3)

Methods

(>>=) :: IdentityT3 m1 m2 m3 a -> (a -> IdentityT3 m1 m2 m3 b) -> IdentityT3 m1 m2 m3 b

(>>) :: IdentityT3 m1 m2 m3 a -> IdentityT3 m1 m2 m3 b -> IdentityT3 m1 m2 m3 b

return :: a -> IdentityT3 m1 m2 m3 a

fail :: String -> IdentityT3 m1 m2 m3 a

(Functor f3, Functor f2, Functor f1) => Functor (IdentityT3 f1 f2 f3)

Methods

fmap :: (a -> b) -> IdentityT3 f1 f2 f3 a -> IdentityT3 f1 f2 f3 b

(<$) :: a -> IdentityT3 f1 f2 f3 b -> IdentityT3 f1 f2 f3 a

(Applicative m1, Applicative m2, Applicative m3) => Applicative (IdentityT3 m1 m2 m3)

Methods

pure :: a -> IdentityT3 m1 m2 m3 a

(<*>) :: IdentityT3 m1 m2 m3 (a -> b) -> IdentityT3 m1 m2 m3 a -> IdentityT3 m1 m2 m3 b

(*>) :: IdentityT3 m1 m2 m3 a -> IdentityT3 m1 m2 m3 b -> IdentityT3 m1 m2 m3 b

(<*) :: IdentityT3 m1 m2 m3 a -> IdentityT3 m1 m2 m3 b -> IdentityT3 m1 m2 m3 a

(Foldable f3, Foldable f2, Foldable f1) => Foldable (IdentityT3 f1 f2 f3)

Methods

fold :: Monoid m => IdentityT3 f1 f2 f3 m -> m

foldMap :: Monoid m => (a -> m) -> IdentityT3 f1 f2 f3 a -> m

foldr :: (a -> b -> b) -> b -> IdentityT3 f1 f2 f3 a -> b

foldr' :: (a -> b -> b) -> b -> IdentityT3 f1 f2 f3 a -> b

foldl :: (b -> a -> b) -> b -> IdentityT3 f1 f2 f3 a -> b

foldl' :: (b -> a -> b) -> b -> IdentityT3 f1 f2 f3 a -> b

foldr1 :: (a -> a -> a) -> IdentityT3 f1 f2 f3 a -> a

foldl1 :: (a -> a -> a) -> IdentityT3 f1 f2 f3 a -> a

toList :: IdentityT3 f1 f2 f3 a -> [a]

null :: IdentityT3 f1 f2 f3 a -> Bool

length :: IdentityT3 f1 f2 f3 a -> Int

elem :: Eq a => a -> IdentityT3 f1 f2 f3 a -> Bool

maximum :: Ord a => IdentityT3 f1 f2 f3 a -> a

minimum :: Ord a => IdentityT3 f1 f2 f3 a -> a

sum :: Num a => IdentityT3 f1 f2 f3 a -> a

product :: Num a => IdentityT3 f1 f2 f3 a -> a

(Traversable f3, Traversable f2, Traversable f1) => Traversable (IdentityT3 f1 f2 f3)

Methods

traverse :: Applicative f => (a -> f b) -> IdentityT3 f1 f2 f3 a -> f (IdentityT3 f1 f2 f3 b)

sequenceA :: Applicative f => IdentityT3 f1 f2 f3 (f a) -> f (IdentityT3 f1 f2 f3 a)

mapM :: Monad m => (a -> m b) -> IdentityT3 f1 f2 f3 a -> m (IdentityT3 f1 f2 f3 b)

sequence :: Monad m => IdentityT3 f1 f2 f3 (m a) -> m (IdentityT3 f1 f2 f3 a)

(MonadIO m1, Monad m1, Monad m2, Traversable m2, Monad m3, Traversable m3) => MonadIO (IdentityT3 m1 m2 m3)

Methods

liftIO :: IO a -> IdentityT3 m1 m2 m3 a

(Alternative m1, Alternative m2, Alternative m3) => Alternative (IdentityT3 m1 m2 m3)

Methods

empty :: IdentityT3 m1 m2 m3 a

(<|>) :: IdentityT3 m1 m2 m3 a -> IdentityT3 m1 m2 m3 a -> IdentityT3 m1 m2 m3 a

some :: IdentityT3 m1 m2 m3 a -> IdentityT3 m1 m2 m3 [a]

many :: IdentityT3 m1 m2 m3 a -> IdentityT3 m1 m2 m3 [a]

(MonadPlus m1, Alternative m2, Monad m2, Traversable m2, Alternative m3, Monad m3, Traversable m3) => MonadPlus (IdentityT3 m1 m2 m3)

Methods

mzero :: IdentityT3 m1 m2 m3 a

mplus :: IdentityT3 m1 m2 m3 a -> IdentityT3 m1 m2 m3 a -> IdentityT3 m1 m2 m3 a

Eq (f1 (f2 (f3 a))) => Eq (IdentityT3 f1 f2 f3 a)

Methods

(==) :: IdentityT3 f1 f2 f3 a -> IdentityT3 f1 f2 f3 a -> Bool

(/=) :: IdentityT3 f1 f2 f3 a -> IdentityT3 f1 f2 f3 a -> Bool

Ord (f1 (f2 (f3 a))) => Ord (IdentityT3 f1 f2 f3 a)

Methods

compare :: IdentityT3 f1 f2 f3 a -> IdentityT3 f1 f2 f3 a -> Ordering

(<) :: IdentityT3 f1 f2 f3 a -> IdentityT3 f1 f2 f3 a -> Bool

(<=) :: IdentityT3 f1 f2 f3 a -> IdentityT3 f1 f2 f3 a -> Bool

(>) :: IdentityT3 f1 f2 f3 a -> IdentityT3 f1 f2 f3 a -> Bool

(>=) :: IdentityT3 f1 f2 f3 a -> IdentityT3 f1 f2 f3 a -> Bool

max :: IdentityT3 f1 f2 f3 a -> IdentityT3 f1 f2 f3 a -> IdentityT3 f1 f2 f3 a

min :: IdentityT3 f1 f2 f3 a -> IdentityT3 f1 f2 f3 a -> IdentityT3 f1 f2 f3 a

Read (f1 (f2 (f3 a))) => Read (IdentityT3 f1 f2 f3 a)

Methods

readsPrec :: Int -> ReadS (IdentityT3 f1 f2 f3 a)

readList :: ReadS [IdentityT3 f1 f2 f3 a]

readPrec :: ReadPrec (IdentityT3 f1 f2 f3 a)

readListPrec :: ReadPrec [IdentityT3 f1 f2 f3 a]

Show (f1 (f2 (f3 a))) => Show (IdentityT3 f1 f2 f3 a)

Methods

showsPrec :: Int -> IdentityT3 f1 f2 f3 a -> ShowS

show :: IdentityT3 f1 f2 f3 a -> String

showList :: [IdentityT3 f1 f2 f3 a] -> ShowS

identity-cover

(***:) :: (Monad m1, Monad m2, Monad m3) => Identity a -> IdentityT3 m1 m2 m3 a infixl 3

(--*:) :: (Monad m1, Monad m2, Monad m3) => IdentityT2 m1 m2 a -> IdentityT3 m1 m2 m3 a infixl 3

(-*-:) :: (Monad m1, Monad m2, Monad m3) => IdentityT2 m1 m3 a -> IdentityT3 m1 m2 m3 a infixl 3

(*--:) :: (Monad m1, Monad m2, Monad m3) => IdentityT2 m2 m3 a -> IdentityT3 m1 m2 m3 a infixl 3

(-**:) :: (Monad m1, Monad m2, Monad m3) => IdentityT m1 a -> IdentityT3 m1 m2 m3 a infixl 3

(*-*:) :: (Monad m1, Monad m2, Monad m3) => IdentityT m2 a -> IdentityT3 m1 m2 m3 a infixl 3

(**-:) :: (Monad m1, Monad m2, Monad m3) => IdentityT m3 a -> IdentityT3 m1 m2 m3 a infixl 3

identity-roll

transfoldI3 :: (Monad m1, Monad (t2 m1), MonadTrans_ m2 t2, MonadTrans_ m3 t3) => IdentityT3 m1 m2 m3 a -> IdentityT (t3 (t2 m1)) a

untransfoldI3 :: (Monad m1, Monad (t2 m1), MonadTrans_ m2 t2, MonadTrans_ m3 t3) => IdentityT (t3 (t2 m1)) a -> IdentityT3 m1 m2 m3 a

lift

mapIdentityT3 :: (m1 (m2 (m3 a)) -> n1 (n2 (n3 b))) -> IdentityT3 m1 m2 m3 a -> IdentityT3 n1 n2 n3 b

liftCallCC3 :: CallCC3 m1 m2 m3 a b -> CallCC (IdentityT3 m1 m2 m3) a b

liftCatch3 :: Catch3 e m1 m2 m3 a -> Catch e (IdentityT3 m1 m2 m3) a

Level-4

newtype IdentityT4 f1 f2 f3 f4 a

Constructors

IdentityT4

Fields

• runIdentityT4 :: f1 (f2 (f3 (f4 a)))

Instances

(Monad m1, Monad m2, Traversable m2, Monad m3, Traversable m3, Monad m4, Traversable m4) => Monad (IdentityT4 m1 m2 m3 m4)

Methods

(>>=) :: IdentityT4 m1 m2 m3 m4 a -> (a -> IdentityT4 m1 m2 m3 m4 b) -> IdentityT4 m1 m2 m3 m4 b

(>>) :: IdentityT4 m1 m2 m3 m4 a -> IdentityT4 m1 m2 m3 m4 b -> IdentityT4 m1 m2 m3 m4 b

return :: a -> IdentityT4 m1 m2 m3 m4 a

fail :: String -> IdentityT4 m1 m2 m3 m4 a

(Functor f4, Functor f3, Functor f2, Functor f1) => Functor (IdentityT4 f1 f2 f3 f4)

Methods

fmap :: (a -> b) -> IdentityT4 f1 f2 f3 f4 a -> IdentityT4 f1 f2 f3 f4 b

(<$) :: a -> IdentityT4 f1 f2 f3 f4 b -> IdentityT4 f1 f2 f3 f4 a

(Applicative m1, Applicative m2, Applicative m3, Applicative m4) => Applicative (IdentityT4 m1 m2 m3 m4)

Methods

pure :: a -> IdentityT4 m1 m2 m3 m4 a

(<*>) :: IdentityT4 m1 m2 m3 m4 (a -> b) -> IdentityT4 m1 m2 m3 m4 a -> IdentityT4 m1 m2 m3 m4 b

(*>) :: IdentityT4 m1 m2 m3 m4 a -> IdentityT4 m1 m2 m3 m4 b -> IdentityT4 m1 m2 m3 m4 b

(<*) :: IdentityT4 m1 m2 m3 m4 a -> IdentityT4 m1 m2 m3 m4 b -> IdentityT4 m1 m2 m3 m4 a

(Foldable f4, Foldable f3, Foldable f2, Foldable f1) => Foldable (IdentityT4 f1 f2 f3 f4)

Methods

fold :: Monoid m => IdentityT4 f1 f2 f3 f4 m -> m

foldMap :: Monoid m => (a -> m) -> IdentityT4 f1 f2 f3 f4 a -> m

foldr :: (a -> b -> b) -> b -> IdentityT4 f1 f2 f3 f4 a -> b

foldr' :: (a -> b -> b) -> b -> IdentityT4 f1 f2 f3 f4 a -> b

foldl :: (b -> a -> b) -> b -> IdentityT4 f1 f2 f3 f4 a -> b

foldl' :: (b -> a -> b) -> b -> IdentityT4 f1 f2 f3 f4 a -> b

foldr1 :: (a -> a -> a) -> IdentityT4 f1 f2 f3 f4 a -> a

foldl1 :: (a -> a -> a) -> IdentityT4 f1 f2 f3 f4 a -> a

toList :: IdentityT4 f1 f2 f3 f4 a -> [a]

null :: IdentityT4 f1 f2 f3 f4 a -> Bool

length :: IdentityT4 f1 f2 f3 f4 a -> Int

elem :: Eq a => a -> IdentityT4 f1 f2 f3 f4 a -> Bool

maximum :: Ord a => IdentityT4 f1 f2 f3 f4 a -> a

minimum :: Ord a => IdentityT4 f1 f2 f3 f4 a -> a

sum :: Num a => IdentityT4 f1 f2 f3 f4 a -> a

product :: Num a => IdentityT4 f1 f2 f3 f4 a -> a

(Traversable f4, Traversable f3, Traversable f2, Traversable f1) => Traversable (IdentityT4 f1 f2 f3 f4)

Methods

traverse :: Applicative f => (a -> f b) -> IdentityT4 f1 f2 f3 f4 a -> f (IdentityT4 f1 f2 f3 f4 b)

sequenceA :: Applicative f => IdentityT4 f1 f2 f3 f4 (f a) -> f (IdentityT4 f1 f2 f3 f4 a)

mapM :: Monad m => (a -> m b) -> IdentityT4 f1 f2 f3 f4 a -> m (IdentityT4 f1 f2 f3 f4 b)

sequence :: Monad m => IdentityT4 f1 f2 f3 f4 (m a) -> m (IdentityT4 f1 f2 f3 f4 a)

(MonadIO m1, Monad m1, Monad m2, Traversable m2, Monad m3, Traversable m3, Monad m4, Traversable m4) => MonadIO (IdentityT4 m1 m2 m3 m4)

Methods

liftIO :: IO a -> IdentityT4 m1 m2 m3 m4 a

(Alternative m1, Alternative m2, Alternative m3, Alternative m4) => Alternative (IdentityT4 m1 m2 m3 m4)

Methods

empty :: IdentityT4 m1 m2 m3 m4 a

(<|>) :: IdentityT4 m1 m2 m3 m4 a -> IdentityT4 m1 m2 m3 m4 a -> IdentityT4 m1 m2 m3 m4 a

some :: IdentityT4 m1 m2 m3 m4 a -> IdentityT4 m1 m2 m3 m4 [a]

many :: IdentityT4 m1 m2 m3 m4 a -> IdentityT4 m1 m2 m3 m4 [a]

(MonadPlus m1, Alternative m2, Monad m2, Traversable m2, Alternative m3, Monad m3, Traversable m3, Alternative m4, Monad m4, Traversable m4) => MonadPlus (IdentityT4 m1 m2 m3 m4)

Methods

mzero :: IdentityT4 m1 m2 m3 m4 a

mplus :: IdentityT4 m1 m2 m3 m4 a -> IdentityT4 m1 m2 m3 m4 a -> IdentityT4 m1 m2 m3 m4 a

Eq (f1 (f2 (f3 (f4 a)))) => Eq (IdentityT4 f1 f2 f3 f4 a)

Methods

(==) :: IdentityT4 f1 f2 f3 f4 a -> IdentityT4 f1 f2 f3 f4 a -> Bool

(/=) :: IdentityT4 f1 f2 f3 f4 a -> IdentityT4 f1 f2 f3 f4 a -> Bool

Ord (f1 (f2 (f3 (f4 a)))) => Ord (IdentityT4 f1 f2 f3 f4 a)

Methods

compare :: IdentityT4 f1 f2 f3 f4 a -> IdentityT4 f1 f2 f3 f4 a -> Ordering

(<) :: IdentityT4 f1 f2 f3 f4 a -> IdentityT4 f1 f2 f3 f4 a -> Bool

(<=) :: IdentityT4 f1 f2 f3 f4 a -> IdentityT4 f1 f2 f3 f4 a -> Bool

(>) :: IdentityT4 f1 f2 f3 f4 a -> IdentityT4 f1 f2 f3 f4 a -> Bool

(>=) :: IdentityT4 f1 f2 f3 f4 a -> IdentityT4 f1 f2 f3 f4 a -> Bool

max :: IdentityT4 f1 f2 f3 f4 a -> IdentityT4 f1 f2 f3 f4 a -> IdentityT4 f1 f2 f3 f4 a

min :: IdentityT4 f1 f2 f3 f4 a -> IdentityT4 f1 f2 f3 f4 a -> IdentityT4 f1 f2 f3 f4 a

Read (f1 (f2 (f3 (f4 a)))) => Read (IdentityT4 f1 f2 f3 f4 a)

Methods

readsPrec :: Int -> ReadS (IdentityT4 f1 f2 f3 f4 a)

readList :: ReadS [IdentityT4 f1 f2 f3 f4 a]

readPrec :: ReadPrec (IdentityT4 f1 f2 f3 f4 a)

readListPrec :: ReadPrec [IdentityT4 f1 f2 f3 f4 a]

Show (f1 (f2 (f3 (f4 a)))) => Show (IdentityT4 f1 f2 f3 f4 a)

Methods

showsPrec :: Int -> IdentityT4 f1 f2 f3 f4 a -> ShowS

show :: IdentityT4 f1 f2 f3 f4 a -> String

showList :: [IdentityT4 f1 f2 f3 f4 a] -> ShowS

identity-cover

(****:) :: (Monad m1, Monad m2, Monad m3, Monad m4) => Identity a -> IdentityT4 m1 m2 m3 m4 a infixl 3

(---*:) :: (Monad m1, Monad m2, Monad m3, Monad m4) => IdentityT3 m1 m2 m3 a -> IdentityT4 m1 m2 m3 m4 a infixl 3

(--*-:) :: (Monad m1, Monad m2, Monad m3, Monad m4) => IdentityT3 m1 m2 m4 a -> IdentityT4 m1 m2 m3 m4 a infixl 3

(-*--:) :: (Monad m1, Monad m2, Monad m3, Monad m4) => IdentityT3 m1 m3 m4 a -> IdentityT4 m1 m2 m3 m4 a infixl 3

(*---:) :: (Monad m1, Monad m2, Monad m3, Monad m4) => IdentityT3 m2 m3 m4 a -> IdentityT4 m1 m2 m3 m4 a infixl 3

(--**:) :: (Monad m1, Monad m2, Monad m3, Monad m4) => IdentityT2 m1 m2 a -> IdentityT4 m1 m2 m3 m4 a infixl 3

(-*-*:) :: (Monad m1, Monad m2, Monad m3, Monad m4) => IdentityT2 m1 m3 a -> IdentityT4 m1 m2 m3 m4 a infixl 3

(*--*:) :: (Monad m1, Monad m2, Monad m3, Monad m4) => IdentityT2 m2 m3 a -> IdentityT4 m1 m2 m3 m4 a infixl 3

(*-*-:) :: (Monad m1, Monad m2, Monad m3, Monad m4) => IdentityT2 m2 m4 a -> IdentityT4 m1 m2 m3 m4 a infixl 3

(-**-:) :: (Monad m1, Monad m2, Monad m3, Monad m4) => IdentityT2 m1 m4 a -> IdentityT4 m1 m2 m3 m4 a infixl 3

(**--:) :: (Monad m1, Monad m2, Monad m3, Monad m4) => IdentityT2 m3 m4 a -> IdentityT4 m1 m2 m3 m4 a infixl 3

(-***:) :: (Monad m1, Monad m2, Monad m3, Monad m4) => IdentityT m1 a -> IdentityT4 m1 m2 m3 m4 a infixl 3

(*-**:) :: (Monad m1, Monad m2, Monad m3, Monad m4) => IdentityT m2 a -> IdentityT4 m1 m2 m3 m4 a infixl 3

(**-*:) :: (Monad m1, Monad m2, Monad m3, Monad m4) => IdentityT m3 a -> IdentityT4 m1 m2 m3 m4 a infixl 3

(***-:) :: (Monad m1, Monad m2, Monad m3, Monad m4) => IdentityT m4 a -> IdentityT4 m1 m2 m3 m4 a infixl 3

identity-roll

transfoldI4 :: (Monad m1, Monad (t2 m1), Monad (t3 (t2 m1)), MonadTrans_ m2 t2, MonadTrans_ m3 t3, MonadTrans_ m4 t4) => IdentityT4 m1 m2 m3 m4 a -> IdentityT (t4 (t3 (t2 m1))) a

untransfoldI4 :: (Monad m1, Monad (t2 m1), Monad (t3 (t2 m1)), MonadTrans_ m2 t2, MonadTrans_ m3 t3, MonadTrans_ m4 t4) => IdentityT (t4 (t3 (t2 m1))) a -> IdentityT4 m1 m2 m3 m4 a

lift

mapIdentityT4 :: (m1 (m2 (m3 (m4 a))) -> n1 (n2 (n3 (n4 b)))) -> IdentityT4 m1 m2 m3 m4 a -> IdentityT4 n1 n2 n3 n4 b

liftCallCC4 :: CallCC4 m1 m2 m3 m4 a b -> CallCC (IdentityT4 m1 m2 m3 m4) a b

liftCatch4 :: Catch4 e m1 m2 m3 m4 a -> Catch e (IdentityT4 m1 m2 m3 m4) a

Level-5

newtype IdentityT5 f1 f2 f3 f4 f5 a

Constructors

IdentityT5

Fields

• runIdentityT5 :: f1 (f2 (f3 (f4 (f5 a))))

Instances

(Monad m1, Monad m2, Traversable m2, Monad m3, Traversable m3, Monad m4, Traversable m4, Monad m5, Traversable m5) => Monad (IdentityT5 m1 m2 m3 m4 m5)

Methods

(>>=) :: IdentityT5 m1 m2 m3 m4 m5 a -> (a -> IdentityT5 m1 m2 m3 m4 m5 b) -> IdentityT5 m1 m2 m3 m4 m5 b

(>>) :: IdentityT5 m1 m2 m3 m4 m5 a -> IdentityT5 m1 m2 m3 m4 m5 b -> IdentityT5 m1 m2 m3 m4 m5 b

return :: a -> IdentityT5 m1 m2 m3 m4 m5 a

fail :: String -> IdentityT5 m1 m2 m3 m4 m5 a

(Functor f5, Functor f4, Functor f3, Functor f2, Functor f1) => Functor (IdentityT5 f1 f2 f3 f4 f5)

Methods

fmap :: (a -> b) -> IdentityT5 f1 f2 f3 f4 f5 a -> IdentityT5 f1 f2 f3 f4 f5 b

(<$) :: a -> IdentityT5 f1 f2 f3 f4 f5 b -> IdentityT5 f1 f2 f3 f4 f5 a

(Applicative m1, Applicative m2, Applicative m3, Applicative m4, Applicative m5) => Applicative (IdentityT5 m1 m2 m3 m4 m5)

Methods

pure :: a -> IdentityT5 m1 m2 m3 m4 m5 a

(<*>) :: IdentityT5 m1 m2 m3 m4 m5 (a -> b) -> IdentityT5 m1 m2 m3 m4 m5 a -> IdentityT5 m1 m2 m3 m4 m5 b

(*>) :: IdentityT5 m1 m2 m3 m4 m5 a -> IdentityT5 m1 m2 m3 m4 m5 b -> IdentityT5 m1 m2 m3 m4 m5 b

(<*) :: IdentityT5 m1 m2 m3 m4 m5 a -> IdentityT5 m1 m2 m3 m4 m5 b -> IdentityT5 m1 m2 m3 m4 m5 a

(Foldable f5, Foldable f4, Foldable f3, Foldable f2, Foldable f1) => Foldable (IdentityT5 f1 f2 f3 f4 f5)

Methods

fold :: Monoid m => IdentityT5 f1 f2 f3 f4 f5 m -> m

foldMap :: Monoid m => (a -> m) -> IdentityT5 f1 f2 f3 f4 f5 a -> m

foldr :: (a -> b -> b) -> b -> IdentityT5 f1 f2 f3 f4 f5 a -> b

foldr' :: (a -> b -> b) -> b -> IdentityT5 f1 f2 f3 f4 f5 a -> b

foldl :: (b -> a -> b) -> b -> IdentityT5 f1 f2 f3 f4 f5 a -> b

foldl' :: (b -> a -> b) -> b -> IdentityT5 f1 f2 f3 f4 f5 a -> b

foldr1 :: (a -> a -> a) -> IdentityT5 f1 f2 f3 f4 f5 a -> a

foldl1 :: (a -> a -> a) -> IdentityT5 f1 f2 f3 f4 f5 a -> a

toList :: IdentityT5 f1 f2 f3 f4 f5 a -> [a]

null :: IdentityT5 f1 f2 f3 f4 f5 a -> Bool

length :: IdentityT5 f1 f2 f3 f4 f5 a -> Int

elem :: Eq a => a -> IdentityT5 f1 f2 f3 f4 f5 a -> Bool

maximum :: Ord a => IdentityT5 f1 f2 f3 f4 f5 a -> a

minimum :: Ord a => IdentityT5 f1 f2 f3 f4 f5 a -> a

sum :: Num a => IdentityT5 f1 f2 f3 f4 f5 a -> a

product :: Num a => IdentityT5 f1 f2 f3 f4 f5 a -> a

(Traversable f5, Traversable f4, Traversable f3, Traversable f2, Traversable f1) => Traversable (IdentityT5 f1 f2 f3 f4 f5)

Methods

traverse :: Applicative f => (a -> f b) -> IdentityT5 f1 f2 f3 f4 f5 a -> f (IdentityT5 f1 f2 f3 f4 f5 b)

sequenceA :: Applicative f => IdentityT5 f1 f2 f3 f4 f5 (f a) -> f (IdentityT5 f1 f2 f3 f4 f5 a)

mapM :: Monad m => (a -> m b) -> IdentityT5 f1 f2 f3 f4 f5 a -> m (IdentityT5 f1 f2 f3 f4 f5 b)

sequence :: Monad m => IdentityT5 f1 f2 f3 f4 f5 (m a) -> m (IdentityT5 f1 f2 f3 f4 f5 a)

(MonadIO m1, Monad m1, Monad m2, Traversable m2, Monad m3, Traversable m3, Monad m4, Traversable m4, Monad m5, Traversable m5) => MonadIO (IdentityT5 m1 m2 m3 m4 m5)

Methods

liftIO :: IO a -> IdentityT5 m1 m2 m3 m4 m5 a

(Alternative m1, Alternative m2, Alternative m3, Alternative m4, Alternative m5) => Alternative (IdentityT5 m1 m2 m3 m4 m5)

Methods

empty :: IdentityT5 m1 m2 m3 m4 m5 a

(<|>) :: IdentityT5 m1 m2 m3 m4 m5 a -> IdentityT5 m1 m2 m3 m4 m5 a -> IdentityT5 m1 m2 m3 m4 m5 a

some :: IdentityT5 m1 m2 m3 m4 m5 a -> IdentityT5 m1 m2 m3 m4 m5 [a]

many :: IdentityT5 m1 m2 m3 m4 m5 a -> IdentityT5 m1 m2 m3 m4 m5 [a]

(MonadPlus m1, Alternative m2, Monad m2, Traversable m2, Alternative m3, Monad m3, Traversable m3, Alternative m4, Monad m4, Traversable m4, Alternative m5, Monad m5, Traversable m5) => MonadPlus (IdentityT5 m1 m2 m3 m4 m5)

Methods

mzero :: IdentityT5 m1 m2 m3 m4 m5 a

mplus :: IdentityT5 m1 m2 m3 m4 m5 a -> IdentityT5 m1 m2 m3 m4 m5 a -> IdentityT5 m1 m2 m3 m4 m5 a

Eq (f1 (f2 (f3 (f4 (f5 a))))) => Eq (IdentityT5 f1 f2 f3 f4 f5 a)

Methods

(==) :: IdentityT5 f1 f2 f3 f4 f5 a -> IdentityT5 f1 f2 f3 f4 f5 a -> Bool

(/=) :: IdentityT5 f1 f2 f3 f4 f5 a -> IdentityT5 f1 f2 f3 f4 f5 a -> Bool

Ord (f1 (f2 (f3 (f4 (f5 a))))) => Ord (IdentityT5 f1 f2 f3 f4 f5 a)

Methods

compare :: IdentityT5 f1 f2 f3 f4 f5 a -> IdentityT5 f1 f2 f3 f4 f5 a -> Ordering

(<) :: IdentityT5 f1 f2 f3 f4 f5 a -> IdentityT5 f1 f2 f3 f4 f5 a -> Bool

(<=) :: IdentityT5 f1 f2 f3 f4 f5 a -> IdentityT5 f1 f2 f3 f4 f5 a -> Bool

(>) :: IdentityT5 f1 f2 f3 f4 f5 a -> IdentityT5 f1 f2 f3 f4 f5 a -> Bool

(>=) :: IdentityT5 f1 f2 f3 f4 f5 a -> IdentityT5 f1 f2 f3 f4 f5 a -> Bool

max :: IdentityT5 f1 f2 f3 f4 f5 a -> IdentityT5 f1 f2 f3 f4 f5 a -> IdentityT5 f1 f2 f3 f4 f5 a

min :: IdentityT5 f1 f2 f3 f4 f5 a -> IdentityT5 f1 f2 f3 f4 f5 a -> IdentityT5 f1 f2 f3 f4 f5 a

Read (f1 (f2 (f3 (f4 (f5 a))))) => Read (IdentityT5 f1 f2 f3 f4 f5 a)

Methods

readsPrec :: Int -> ReadS (IdentityT5 f1 f2 f3 f4 f5 a)

readList :: ReadS [IdentityT5 f1 f2 f3 f4 f5 a]

readPrec :: ReadPrec (IdentityT5 f1 f2 f3 f4 f5 a)

readListPrec :: ReadPrec [IdentityT5 f1 f2 f3 f4 f5 a]

Show (f1 (f2 (f3 (f4 (f5 a))))) => Show (IdentityT5 f1 f2 f3 f4 f5 a)

Methods

showsPrec :: Int -> IdentityT5 f1 f2 f3 f4 f5 a -> ShowS

show :: IdentityT5 f1 f2 f3 f4 f5 a -> String

showList :: [IdentityT5 f1 f2 f3 f4 f5 a] -> ShowS

identity-cover

(*****:) :: (Monad m1, Monad m2, Monad m3, Monad m4, Monad m5) => Identity a -> IdentityT5 m1 m2 m3 m4 m5 a infixl 3

(----*:) :: (Monad m1, Monad m2, Monad m3, Monad m4, Monad m5) => IdentityT4 m1 m2 m3 m4 a -> IdentityT5 m1 m2 m3 m4 m5 a infixl 3

(---*-:) :: (Monad m1, Monad m2, Monad m3, Monad m4, Monad m5) => IdentityT4 m1 m2 m3 m5 a -> IdentityT5 m1 m2 m3 m4 m5 a infixl 3

(--*--:) :: (Monad m1, Monad m2, Monad m3, Monad m4, Monad m5) => IdentityT4 m1 m2 m4 m5 a -> IdentityT5 m1 m2 m3 m4 m5 a infixl 3

(-*---:) :: (Monad m1, Monad m2, Monad m3, Monad m4, Monad m5) => IdentityT4 m1 m3 m4 m5 a -> IdentityT5 m1 m2 m3 m4 m5 a infixl 3

(*----:) :: (Monad m1, Monad m2, Monad m3, Monad m4, Monad m5) => IdentityT4 m2 m3 m4 m5 a -> IdentityT5 m1 m2 m3 m4 m5 a infixl 3

(---**:) :: (Monad m1, Monad m2, Monad m3, Monad m4, Monad m5) => IdentityT3 m1 m2 m3 a -> IdentityT5 m1 m2 m3 m4 m5 a infixl 3

(--*-*:) :: (Monad m1, Monad m2, Monad m3, Monad m4, Monad m5) => IdentityT3 m1 m2 m4 a -> IdentityT5 m1 m2 m3 m4 m5 a infixl 3

(-*--*:) :: (Monad m1, Monad m2, Monad m3, Monad m4, Monad m5) => IdentityT3 m1 m3 m4 a -> IdentityT5 m1 m2 m3 m4 m5 a infixl 3

(*---*:) :: (Monad m1, Monad m2, Monad m3, Monad m4, Monad m5) => IdentityT3 m2 m3 m4 a -> IdentityT5 m1 m2 m3 m4 m5 a infixl 3

(*--*-:) :: (Monad m1, Monad m2, Monad m3, Monad m4, Monad m5) => IdentityT3 m2 m3 m5 a -> IdentityT5 m1 m2 m3 m4 m5 a infixl 3

(-*-*-:) :: (Monad m1, Monad m2, Monad m3, Monad m4, Monad m5) => IdentityT3 m1 m3 m5 a -> IdentityT5 m1 m2 m3 m4 m5 a infixl 3

(--**-:) :: (Monad m1, Monad m2, Monad m3, Monad m4, Monad m5) => IdentityT3 m1 m2 m5 a -> IdentityT5 m1 m2 m3 m4 m5 a infixl 3

(-**--:) :: (Monad m1, Monad m2, Monad m3, Monad m4, Monad m5) => IdentityT3 m1 m4 m5 a -> IdentityT5 m1 m2 m3 m4 m5 a infixl 3

(*-*--:) :: (Monad m1, Monad m2, Monad m3, Monad m4, Monad m5) => IdentityT3 m2 m4 m5 a -> IdentityT5 m1 m2 m3 m4 m5 a infixl 3

(**---:) :: (Monad m1, Monad m2, Monad m3, Monad m4, Monad m5) => IdentityT3 m3 m4 m5 a -> IdentityT5 m1 m2 m3 m4 m5 a infixl 3

(--***:) :: (Monad m1, Monad m2, Monad m3, Monad m4, Monad m5) => IdentityT2 m1 m2 a -> IdentityT5 m1 m2 m3 m4 m5 a infixl 3

(-*-**:) :: (Monad m1, Monad m2, Monad m3, Monad m4, Monad m5) => IdentityT2 m1 m3 a -> IdentityT5 m1 m2 m3 m4 m5 a infixl 3

(*--**:) :: (Monad m1, Monad m2, Monad m3, Monad m4, Monad m5) => IdentityT2 m2 m3 a -> IdentityT5 m1 m2 m3 m4 m5 a infixl 3

(*-*-*:) :: (Monad m1, Monad m2, Monad m3, Monad m4, Monad m5) => IdentityT2 m2 m4 a -> IdentityT5 m1 m2 m3 m4 m5 a infixl 3

(-**-*:) :: (Monad m1, Monad m2, Monad m3, Monad m4, Monad m5) => IdentityT2 m1 m4 a -> IdentityT5 m1 m2 m3 m4 m5 a infixl 3

(**--*:) :: (Monad m1, Monad m2, Monad m3, Monad m4, Monad m5) => IdentityT2 m3 m4 a -> IdentityT5 m1 m2 m3 m4 m5 a infixl 3

(**-*-:) :: (Monad m1, Monad m2, Monad m3, Monad m4, Monad m5) => IdentityT2 m3 m5 a -> IdentityT5 m1 m2 m3 m4 m5 a infixl 3

(*-**-:) :: (Monad m1, Monad m2, Monad m3, Monad m4, Monad m5) => IdentityT2 m2 m5 a -> IdentityT5 m1 m2 m3 m4 m5 a infixl 3

(-***-:) :: (Monad m1, Monad m2, Monad m3, Monad m4, Monad m5) => IdentityT2 m1 m5 a -> IdentityT5 m1 m2 m3 m4 m5 a infixl 3

(***--:) :: (Monad m1, Monad m2, Monad m3, Monad m4, Monad m5) => IdentityT2 m4 m5 a -> IdentityT5 m1 m2 m3 m4 m5 a infixl 3

(-****:) :: (Monad m1, Monad m2, Monad m3, Monad m4, Monad m5) => IdentityT m1 a -> IdentityT5 m1 m2 m3 m4 m5 a infixl 3

(*-***:) :: (Monad m1, Monad m2, Monad m3, Monad m4, Monad m5) => IdentityT m2 a -> IdentityT5 m1 m2 m3 m4 m5 a infixl 3

(**-**:) :: (Monad m1, Monad m2, Monad m3, Monad m4, Monad m5) => IdentityT m3 a -> IdentityT5 m1 m2 m3 m4 m5 a infixl 3

(***-*:) :: (Monad m1, Monad m2, Monad m3, Monad m4, Monad m5) => IdentityT m4 a -> IdentityT5 m1 m2 m3 m4 m5 a infixl 3

(****-:) :: (Monad m1, Monad m2, Monad m3, Monad m4, Monad m5) => IdentityT m5 a -> IdentityT5 m1 m2 m3 m4 m5 a infixl 3

identity-roll

transfoldI5 :: (Monad m1, Monad (t2 m1), Monad (t3 (t2 m1)), Monad (t4 (t3 (t2 m1))), MonadTrans_ m2 t2, MonadTrans_ m3 t3, MonadTrans_ m4 t4, MonadTrans_ m5 t5) => IdentityT5 m1 m2 m3 m4 m5 a -> IdentityT (t5 (t4 (t3 (t2 m1)))) a

untransfoldI5 :: (Monad m1, Monad (t2 m1), Monad (t3 (t2 m1)), Monad (t4 (t3 (t2 m1))), MonadTrans_ m2 t2, MonadTrans_ m3 t3, MonadTrans_ m4 t4, MonadTrans_ m5 t5) => IdentityT (t5 (t4 (t3 (t2 m1)))) a -> IdentityT5 m1 m2 m3 m4 m5 a

lift

mapIdentityT5 :: (m1 (m2 (m3 (m4 (m5 a)))) -> n1 (n2 (n3 (n4 (n5 b))))) -> IdentityT5 m1 m2 m3 m4 m5 a -> IdentityT5 n1 n2 n3 n4 n5 b

liftCallCC5 :: CallCC5 m1 m2 m3 m4 m5 a b -> CallCC (IdentityT5 m1 m2 m3 m4 m5) a b

liftCatch5 :: Catch5 e m1 m2 m3 m4 m5 a -> Catch e (IdentityT5 m1 m2 m3 m4 m5) a

Example: identity-cover

Here is an example showing how to use identity-cover functions

import DeepControl.Applicative ((|$>))
import DeepControl.Monad (Monad)
import DeepControl.Monad.Morph (generalize, (|*|), (|>|))
import DeepControl.Monad.Trans.Identity (IdentityT(..), IdentityT2(..), (-*:), (*-:))
import Control.Monad.Writer
import Control.Monad.State

tick :: State Int ()
tick = modify (+1)

tock                         ::                   StateT Int IO ()
tock = do
    generalize |>| tick      :: (Monad      m) => StateT Int m  ()  -- (|>|) is the level-1 trans-map function, analogous to (|$>)
    (|*|) $ putStrLn "Tock!" :: (MonadTrans t) => t          IO ()  -- (|*|) is the level-1 trans-lift function, alias to 'lift'

-- λ> runStateT tock 0
-- Tock!
-- ((),1)

save :: StateT Int (Writer [Int]) ()
save = do
    n <- get
    (|*|) $ tell [n]

program ::                             StateT Int (IdentityT2 IO (Writer [Int])) () -- StateT-IdentityT2-IO-Writer monad, a level-2 monad-transform
program = replicateM_ 4 $ do
    ((-*:) . IdentityT) |>| tock                                                    -- (-*:) is a level-2 identity-cover function, analogous to (-*)
        :: (Monad m, Traversable m) => StateT Int (IdentityT2 IO m             ) ()
    ((*-:) . IdentityT) |>| save                                                    -- (*-:) is a level-2 identity-cover function, analogous to (.*)
        :: (Monad m               ) => StateT Int (IdentityT2 m  (Writer [Int])) ()

-- λ> execWriter |$> runIdentityT2 (runStateT program 0)
-- Tock!
-- Tock!
-- Tock!
-- Tock!
-- [1,2,3,4]