deepcontrol-0.4.2.1: Provide more deeper level style of programming than the usual Control.xxx modules express

Copyright(c) 2007 Magnus Therning
(c) 2015 KONISHI Yohsuke
LicenseBSD-style (see the file LICENSE)
Maintainerocean0yohsuke@gmail.com
Stabilityexperimental
Portability---
Safe HaskellNone
LanguageHaskell2010

DeepControl.Monad.Trans.Identity

Contents

Description

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

Synopsis

Level-1

Level-2

newtype IdentityT2 f1 f2 a Source #

Constructors

IdentityT2 

Fields

Instances

MonadTransCover2 IdentityT2 Source # 

Methods

(|-*|) :: (Monad m1, Monad2 m2) => Trans2Down IdentityT2 m1 a -> IdentityT2 m1 m2 a Source #

(|*-|) :: (Monad m1, Monad2 m2) => Trans2Down IdentityT2 m2 a -> IdentityT2 m1 m2 a Source #

MonadTransFold2 IdentityT2 Source # 

Methods

transfold2 :: (Monad m1, Monad (t2 m1), MonadTrans_ t2) => IdentityT2 m1 (TransDown t2) a -> T_ IdentityT2 (t2 m1) a Source #

untransfold2 :: (Monad m1, Monad (t2 m1), MonadTrans_ t2) => T_ IdentityT2 (t2 m1) a -> IdentityT2 m1 (TransDown t2) a Source #

MonadTrans2Down IdentityT2 Source # 

Associated Types

type Trans2Down (IdentityT2 :: (* -> *) -> (* -> *) -> * -> *) :: (* -> *) -> * -> * Source #

MonadTrans2 IdentityT2 Source # 

Methods

liftT2 :: (Monad m1, Monad2 m2) => m1 (m2 a) -> IdentityT2 m1 m2 a Source #

(Monad m1, Monad2 m2) => Monad (IdentityT2 m1 m2) Source # 

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) Source # 

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) Source # 

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) Source # 

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) Source # 

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, Monad2 m2) => MonadIO (IdentityT2 m1 m2) Source # 

Methods

liftIO :: IO a -> IdentityT2 m1 m2 a #

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

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, Monad2 m2) => MonadPlus (IdentityT2 m1 m2) Source # 

Methods

mzero :: IdentityT2 m1 m2 a #

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

(Commutative f1, Commutative f2) => Commutative (IdentityT2 f1 f2) Source # 

Methods

commute :: Applicative f => IdentityT2 f1 f2 (f a) -> f (IdentityT2 f1 f2 a) Source #

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

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) Source # 

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) Source # 

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) Source # 

Methods

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

show :: IdentityT2 f1 f2 a -> String #

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

type Trans2Down IdentityT2 Source # 

lift functions

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

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

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

Level-3

newtype IdentityT3 f1 f2 f3 a Source #

Constructors

IdentityT3 

Fields

Instances

MonadTransCover3 IdentityT3 Source # 

Methods

(|--*|) :: (Monad m1, Monad2 m2, Monad3 m3) => Trans3Down IdentityT3 m1 m2 a -> IdentityT3 m1 m2 m3 a Source #

(|-*-|) :: (Monad m1, Monad2 m2, Monad3 m3) => Trans3Down IdentityT3 m1 m3 a -> IdentityT3 m1 m2 m3 a Source #

(|*--|) :: (Monad m1, Monad2 m2, Monad3 m3) => Trans3Down IdentityT3 m2 m3 a -> IdentityT3 m1 m2 m3 a Source #

MonadTransFold3 IdentityT3 Source # 

Methods

transfold3 :: (Monad m1, Monad (t2 m1), Monad (t3 (t2 m1)), MonadTrans t2, MonadTrans_ t2, MonadTrans t3, MonadTrans_ t3) => IdentityT3 m1 (TransDown t2) (TransDown t3) a -> T__ IdentityT3 (t3 (t2 m1)) a Source #

untransfold3 :: (Monad m1, Monad (t2 m1), Monad (t3 (t2 m1)), MonadTrans t2, MonadTrans_ t2, MonadTrans t3, MonadTrans_ t3) => T__ IdentityT3 (t3 (t2 m1)) a -> IdentityT3 m1 (TransDown t2) (TransDown t3) a Source #

MonadTrans3Down IdentityT3 Source # 

Associated Types

type Trans3Down (IdentityT3 :: (* -> *) -> (* -> *) -> (* -> *) -> * -> *) :: (* -> *) -> (* -> *) -> * -> * Source #

MonadTrans3 IdentityT3 Source # 

Methods

liftT3 :: (Monad m1, Monad2 m2, Monad3 m3) => m1 (m2 (m3 a)) -> IdentityT3 m1 m2 m3 a Source #

(Monad m1, Monad2 m2, Monad3 m3) => Monad (IdentityT3 m1 m2 m3) Source # 

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) Source # 

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) Source # 

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) Source # 

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) Source # 

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, Monad2 m2, Monad3 m3) => MonadIO (IdentityT3 m1 m2 m3) Source # 

Methods

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

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

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, Monad2 m2, Alternative m3, Monad3 m3) => MonadPlus (IdentityT3 m1 m2 m3) Source # 

Methods

mzero :: IdentityT3 m1 m2 m3 a #

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

(Commutative f1, Commutative f2, Commutative f3) => Commutative (IdentityT3 f1 f2 f3) Source # 

Methods

commute :: Applicative f => IdentityT3 f1 f2 f3 (f a) -> f (IdentityT3 f1 f2 f3 a) Source #

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

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) Source # 

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) Source # 

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) Source # 

Methods

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

show :: IdentityT3 f1 f2 f3 a -> String #

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

type Trans3Down IdentityT3 Source # 

lift functions

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

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

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

Level-4

newtype IdentityT4 f1 f2 f3 f4 a Source #

Constructors

IdentityT4 

Fields

Instances

MonadTransCover4 IdentityT4 Source # 

Methods

(|---*|) :: (Monad m1, Monad2 m2, Monad3 m3, Monad4 m4) => Trans4Down IdentityT4 m1 m2 m3 a -> IdentityT4 m1 m2 m3 m4 a Source #

(|--*-|) :: (Monad m1, Monad2 m2, Monad3 m3, Monad4 m4) => Trans4Down IdentityT4 m1 m2 m4 a -> IdentityT4 m1 m2 m3 m4 a Source #

(|-*--|) :: (Monad m1, Monad2 m2, Monad3 m3, Monad4 m4) => Trans4Down IdentityT4 m1 m3 m4 a -> IdentityT4 m1 m2 m3 m4 a Source #

(|*---|) :: (Monad m1, Monad2 m2, Monad3 m3, Monad4 m4) => Trans4Down IdentityT4 m2 m3 m4 a -> IdentityT4 m1 m2 m3 m4 a Source #

MonadTransFold4 IdentityT4 Source # 

Methods

transfold4 :: (Monad m1, Monad (t2 m1), Monad (t3 (t2 m1)), Monad (t4 (t3 (t2 m1))), MonadTrans t2, MonadTrans_ t2, MonadTrans t3, MonadTrans_ t3, MonadTrans t4, MonadTrans_ t4) => IdentityT4 m1 (TransDown t2) (TransDown t3) (TransDown t4) a -> T___ IdentityT4 (t4 (t3 (t2 m1))) a Source #

untransfold4 :: (Monad m1, Monad (t2 m1), Monad (t3 (t2 m1)), Monad (t4 (t3 (t2 m1))), MonadTrans t2, MonadTrans_ t2, MonadTrans t3, MonadTrans_ t3, MonadTrans t4, MonadTrans_ t4) => T___ IdentityT4 (t4 (t3 (t2 m1))) a -> IdentityT4 m1 (TransDown t2) (TransDown t3) (TransDown t4) a Source #

MonadTrans4Down IdentityT4 Source # 

Associated Types

type Trans4Down (IdentityT4 :: (* -> *) -> (* -> *) -> (* -> *) -> (* -> *) -> * -> *) :: (* -> *) -> (* -> *) -> (* -> *) -> * -> * Source #

MonadTrans4 IdentityT4 Source # 

Methods

liftT4 :: (Monad m1, Monad2 m2, Monad3 m3, Monad4 m4) => m1 (m2 (m3 (m4 a))) -> IdentityT4 m1 m2 m3 m4 a Source #

(Monad m1, Monad2 m2, Monad3 m3, Monad4 m4) => Monad (IdentityT4 m1 m2 m3 m4) Source # 

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) Source # 

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) Source # 

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) Source # 

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) Source # 

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, Monad2 m2, Monad3 m3, Monad4 m4) => MonadIO (IdentityT4 m1 m2 m3 m4) Source # 

Methods

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

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

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, Monad2 m2, Alternative m3, Monad3 m3, Alternative m4, Monad4 m4) => MonadPlus (IdentityT4 m1 m2 m3 m4) Source # 

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 #

(Commutative f1, Commutative f2, Commutative f3, Commutative f4) => Commutative (IdentityT4 f1 f2 f3 f4) Source # 

Methods

commute :: Applicative f => IdentityT4 f1 f2 f3 f4 (f a) -> f (IdentityT4 f1 f2 f3 f4 a) Source #

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

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) Source # 

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) Source # 

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) Source # 

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 #

type Trans4Down IdentityT4 Source # 

lift functions

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

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

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

Level-5

newtype IdentityT5 f1 f2 f3 f4 f5 a Source #

Constructors

IdentityT5 

Fields

Instances

MonadTransCover5 IdentityT5 Source # 

Methods

(|----*|) :: (Monad m1, Monad2 m2, Monad3 m3, Monad4 m4, Monad5 m5) => Trans5Down IdentityT5 m1 m2 m3 m4 a -> IdentityT5 m1 m2 m3 m4 m5 a Source #

(|---*-|) :: (Monad m1, Monad2 m2, Monad3 m3, Monad4 m4, Monad5 m5) => Trans5Down IdentityT5 m1 m2 m3 m5 a -> IdentityT5 m1 m2 m3 m4 m5 a Source #

(|--*--|) :: (Monad m1, Monad2 m2, Monad3 m3, Monad4 m4, Monad5 m5) => Trans5Down IdentityT5 m1 m2 m4 m5 a -> IdentityT5 m1 m2 m3 m4 m5 a Source #

(|-*---|) :: (Monad m1, Monad2 m2, Monad3 m3, Monad4 m4, Monad5 m5) => Trans5Down IdentityT5 m1 m3 m4 m5 a -> IdentityT5 m1 m2 m3 m4 m5 a Source #

(|*----|) :: (Monad m1, Monad2 m2, Monad3 m3, Monad4 m4, Monad5 m5) => Trans5Down IdentityT5 m2 m3 m4 m5 a -> IdentityT5 m1 m2 m3 m4 m5 a Source #

MonadTransFold5 IdentityT5 Source # 

Methods

transfold5 :: (Monad m1, Monad (t2 m1), Monad (t3 (t2 m1)), Monad (t4 (t3 (t2 m1))), Monad (t5 (t4 (t3 (t2 m1)))), MonadTrans t2, MonadTrans_ t2, MonadTrans t3, MonadTrans_ t3, MonadTrans t4, MonadTrans_ t4, MonadTrans t5, MonadTrans_ t5) => IdentityT5 m1 (TransDown t2) (TransDown t3) (TransDown t4) (TransDown t5) a -> T____ IdentityT5 (t5 (t4 (t3 (t2 m1)))) a Source #

untransfold5 :: (Monad m1, Monad (t2 m1), Monad (t3 (t2 m1)), Monad (t4 (t3 (t2 m1))), Monad (t5 (t4 (t3 (t2 m1)))), MonadTrans t2, MonadTrans_ t2, MonadTrans t3, MonadTrans_ t3, MonadTrans t4, MonadTrans_ t4, MonadTrans t5, MonadTrans_ t5) => T____ IdentityT5 (t5 (t4 (t3 (t2 m1)))) a -> IdentityT5 m1 (TransDown t2) (TransDown t3) (TransDown t4) (TransDown t5) a Source #

MonadTrans5Down IdentityT5 Source # 

Associated Types

type Trans5Down (IdentityT5 :: (* -> *) -> (* -> *) -> (* -> *) -> (* -> *) -> (* -> *) -> * -> *) :: (* -> *) -> (* -> *) -> (* -> *) -> (* -> *) -> * -> * Source #

MonadTrans5 IdentityT5 Source # 

Methods

liftT5 :: (Monad m1, Monad2 m2, Monad3 m3, Monad4 m4, Monad5 m5) => m1 (m2 (m3 (m4 (m5 a)))) -> IdentityT5 m1 m2 m3 m4 m5 a Source #

(Monad m1, Monad2 m2, Monad3 m3, Monad4 m4, Monad5 m5) => Monad (IdentityT5 m1 m2 m3 m4 m5) Source # 

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) Source # 

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) Source # 

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) Source # 

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) Source # 

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, Monad2 m2, Monad3 m3, Monad4 m4, Monad5 m5) => MonadIO (IdentityT5 m1 m2 m3 m4 m5) Source # 

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) Source # 

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, Monad2 m2, Alternative m3, Monad3 m3, Alternative m4, Monad4 m4, Alternative m5, Monad5 m5) => MonadPlus (IdentityT5 m1 m2 m3 m4 m5) Source # 

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 #

(Commutative f1, Commutative f2, Commutative f3, Commutative f4, Commutative f5) => Commutative (IdentityT5 f1 f2 f3 f4 f5) Source # 

Methods

commute :: Applicative f => IdentityT5 f1 f2 f3 f4 f5 (f a) -> f (IdentityT5 f1 f2 f3 f4 f5 a) Source #

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

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) Source # 

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) Source # 

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) Source # 

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 #

type Trans5Down IdentityT5 Source # 

lift functions

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 Source #

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

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

Orphan instances

MonadTransCover (IdentityT *) Source # 

Methods

(|*|) :: Monad m1 => TransDown (IdentityT *) a -> IdentityT * m1 a Source #

MonadTransDown (IdentityT *) Source # 

Associated Types

type TransDown (IdentityT * :: (* -> *) -> * -> *) :: * -> * Source #

Commutative f => Commutative (IdentityT * f) Source # 

Methods

commute :: Applicative f => IdentityT * f (f a) -> f (IdentityT * f a) Source #