prelude-extras-0.4.0.3: Higher order versions of Prelude classes

Safe HaskellTrustworthy
LanguageHaskell98

Prelude.Extras

Contents

Synopsis

Lifted Prelude classes for kind * -> *

class Eq1 f where #

Methods

(==#) :: Eq a => f a -> f a -> Bool infixr 4 #

(==#) :: Eq (f a) => f a -> f a -> Bool infixr 4 #

Instances

Eq1 [] # 

Methods

(==#) :: Eq a => [a] -> [a] -> Bool #

Eq1 Maybe # 

Methods

(==#) :: Eq a => Maybe a -> Maybe a -> Bool #

Eq1 Ratio # 

Methods

(==#) :: Eq a => Ratio a -> Ratio a -> Bool #

Eq1 StablePtr # 

Methods

(==#) :: Eq a => StablePtr a -> StablePtr a -> Bool #

Eq1 Ptr # 

Methods

(==#) :: Eq a => Ptr a -> Ptr a -> Bool #

Eq1 FunPtr # 

Methods

(==#) :: Eq a => FunPtr a -> FunPtr a -> Bool #

Eq1 Identity # 

Methods

(==#) :: Eq a => Identity a -> Identity a -> Bool #

Eq1 Fixed # 

Methods

(==#) :: Eq a => Fixed a -> Fixed a -> Bool #

Eq1 Complex # 

Methods

(==#) :: Eq a => Complex a -> Complex a -> Bool #

Eq1 Chan # 

Methods

(==#) :: Eq a => Chan a -> Chan a -> Bool #

Eq1 ZipList # 

Methods

(==#) :: Eq a => ZipList a -> ZipList a -> Bool #

Eq1 TVar # 

Methods

(==#) :: Eq a => TVar a -> TVar a -> Bool #

Eq1 ForeignPtr # 

Methods

(==#) :: Eq a => ForeignPtr a -> ForeignPtr a -> Bool #

Eq1 Dual # 

Methods

(==#) :: Eq a => Dual a -> Dual a -> Bool #

Eq1 Sum # 

Methods

(==#) :: Eq a => Sum a -> Sum a -> Bool #

Eq1 Product # 

Methods

(==#) :: Eq a => Product a -> Product a -> Bool #

Eq1 First # 

Methods

(==#) :: Eq a => First a -> First a -> Bool #

Eq1 Last # 

Methods

(==#) :: Eq a => Last a -> Last a -> Bool #

Eq1 IORef # 

Methods

(==#) :: Eq a => IORef a -> IORef a -> Bool #

Eq1 Down # 

Methods

(==#) :: Eq a => Down a -> Down a -> Bool #

Eq1 MVar # 

Methods

(==#) :: Eq a => MVar a -> MVar a -> Bool #

Eq a => Eq1 (Either a) # 

Methods

(==#) :: Eq a => Either a a -> Either a a -> Bool #

Eq a => Eq1 ((,) a) # 

Methods

(==#) :: Eq a => (a, a) -> (a, a) -> Bool #

Eq1 (Proxy *) # 

Methods

(==#) :: Eq a => Proxy * a -> Proxy * a -> Bool #

Eq1 f => Eq1 (Lift1 f) # 

Methods

(==#) :: Eq a => Lift1 f a -> Lift1 f a -> Bool #

(Eq a, Eq b) => Eq1 ((,,) a b) # 

Methods

(==#) :: Eq a => (a, b, a) -> (a, b, a) -> Bool #

Eq a => Eq1 (Const * a) # 

Methods

(==#) :: Eq a => Const * a a -> Const * a a -> Bool #

Eq1 f => Eq1 (Alt * f) # 

Methods

(==#) :: Eq a => Alt * f a -> Alt * f a -> Bool #

(Eq2 f, Eq a) => Eq1 (Lift2 f a) # 

Methods

(==#) :: Eq a => Lift2 f a a -> Lift2 f a a -> Bool #

(Eq a, Eq b, Eq c) => Eq1 ((,,,) a b c) # 

Methods

(==#) :: Eq a => (a, b, c, a) -> (a, b, c, a) -> Bool #

(Eq a, Eq b, Eq c, Eq d) => Eq1 ((,,,,) a b c d) # 

Methods

(==#) :: Eq a => (a, b, c, d, a) -> (a, b, c, d, a) -> Bool #

(Eq a, Eq b, Eq c, Eq d, Eq e) => Eq1 ((,,,,,) a b c d e) # 

Methods

(==#) :: Eq a => (a, b, c, d, e, a) -> (a, b, c, d, e, a) -> Bool #

(Eq a, Eq b, Eq c, Eq d, Eq e, Eq f) => Eq1 ((,,,,,,) a b c d e f) # 

Methods

(==#) :: Eq a => (a, b, c, d, e, f, a) -> (a, b, c, d, e, f, a) -> Bool #

(Eq a, Eq b, Eq c, Eq d, Eq e, Eq f, Eq g) => Eq1 ((,,,,,,,) a b c d e f g) # 

Methods

(==#) :: Eq a => (a, b, c, d, e, f, g, a) -> (a, b, c, d, e, f, g, a) -> Bool #

(Eq a, Eq b, Eq c, Eq d, Eq e, Eq f, Eq g, Eq h) => Eq1 ((,,,,,,,,) a b c d e f g h) # 

Methods

(==#) :: Eq a => (a, b, c, d, e, f, g, h, a) -> (a, b, c, d, e, f, g, h, a) -> Bool #

(Eq a, Eq b, Eq c, Eq d, Eq e, Eq f, Eq g, Eq h, Eq i) => Eq1 ((,,,,,,,,,) a b c d e f g h i) # 

Methods

(==#) :: Eq a => (a, b, c, d, e, f, g, h, i, a) -> (a, b, c, d, e, f, g, h, i, a) -> Bool #

(/=#) :: (Eq1 f, Eq a) => f a -> f a -> Bool infixr 4 #

class Eq1 f => Ord1 f where #

Methods

compare1 :: Ord a => f a -> f a -> Ordering #

compare1 :: Ord (f a) => f a -> f a -> Ordering #

Instances

Ord1 [] # 

Methods

compare1 :: Ord a => [a] -> [a] -> Ordering #

Ord1 Maybe # 

Methods

compare1 :: Ord a => Maybe a -> Maybe a -> Ordering #

Ord1 Ptr # 

Methods

compare1 :: Ord a => Ptr a -> Ptr a -> Ordering #

Ord1 FunPtr # 

Methods

compare1 :: Ord a => FunPtr a -> FunPtr a -> Ordering #

Ord1 Identity # 

Methods

compare1 :: Ord a => Identity a -> Identity a -> Ordering #

Ord1 Fixed # 

Methods

compare1 :: Ord a => Fixed a -> Fixed a -> Ordering #

Ord1 ZipList # 

Methods

compare1 :: Ord a => ZipList a -> ZipList a -> Ordering #

Ord1 ForeignPtr # 

Methods

compare1 :: Ord a => ForeignPtr a -> ForeignPtr a -> Ordering #

Ord1 Dual # 

Methods

compare1 :: Ord a => Dual a -> Dual a -> Ordering #

Ord1 Sum # 

Methods

compare1 :: Ord a => Sum a -> Sum a -> Ordering #

Ord1 Product # 

Methods

compare1 :: Ord a => Product a -> Product a -> Ordering #

Ord1 First # 

Methods

compare1 :: Ord a => First a -> First a -> Ordering #

Ord1 Last # 

Methods

compare1 :: Ord a => Last a -> Last a -> Ordering #

Ord1 Down # 

Methods

compare1 :: Ord a => Down a -> Down a -> Ordering #

Ord a => Ord1 (Either a) # 

Methods

compare1 :: Ord a => Either a a -> Either a a -> Ordering #

Ord a => Ord1 ((,) a) # 

Methods

compare1 :: Ord a => (a, a) -> (a, a) -> Ordering #

Ord1 (Proxy *) # 

Methods

compare1 :: Ord a => Proxy * a -> Proxy * a -> Ordering #

Ord1 f => Ord1 (Lift1 f) # 

Methods

compare1 :: Ord a => Lift1 f a -> Lift1 f a -> Ordering #

(Ord a, Ord b) => Ord1 ((,,) a b) # 

Methods

compare1 :: Ord a => (a, b, a) -> (a, b, a) -> Ordering #

Ord a => Ord1 (Const * a) # 

Methods

compare1 :: Ord a => Const * a a -> Const * a a -> Ordering #

Ord1 f => Ord1 (Alt * f) # 

Methods

compare1 :: Ord a => Alt * f a -> Alt * f a -> Ordering #

(Ord2 f, Ord a) => Ord1 (Lift2 f a) # 

Methods

compare1 :: Ord a => Lift2 f a a -> Lift2 f a a -> Ordering #

(Ord a, Ord b, Ord c) => Ord1 ((,,,) a b c) # 

Methods

compare1 :: Ord a => (a, b, c, a) -> (a, b, c, a) -> Ordering #

(Ord a, Ord b, Ord c, Ord d) => Ord1 ((,,,,) a b c d) # 

Methods

compare1 :: Ord a => (a, b, c, d, a) -> (a, b, c, d, a) -> Ordering #

(Ord a, Ord b, Ord c, Ord d, Ord e) => Ord1 ((,,,,,) a b c d e) # 

Methods

compare1 :: Ord a => (a, b, c, d, e, a) -> (a, b, c, d, e, a) -> Ordering #

(Ord a, Ord b, Ord c, Ord d, Ord e, Ord f) => Ord1 ((,,,,,,) a b c d e f) # 

Methods

compare1 :: Ord a => (a, b, c, d, e, f, a) -> (a, b, c, d, e, f, a) -> Ordering #

(Ord a, Ord b, Ord c, Ord d, Ord e, Ord f, Ord g) => Ord1 ((,,,,,,,) a b c d e f g) # 

Methods

compare1 :: Ord a => (a, b, c, d, e, f, g, a) -> (a, b, c, d, e, f, g, a) -> Ordering #

(Ord a, Ord b, Ord c, Ord d, Ord e, Ord f, Ord g, Ord h) => Ord1 ((,,,,,,,,) a b c d e f g h) # 

Methods

compare1 :: Ord a => (a, b, c, d, e, f, g, h, a) -> (a, b, c, d, e, f, g, h, a) -> Ordering #

(Ord a, Ord b, Ord c, Ord d, Ord e, Ord f, Ord g, Ord h, Ord i) => Ord1 ((,,,,,,,,,) a b c d e f g h i) # 

Methods

compare1 :: Ord a => (a, b, c, d, e, f, g, h, i, a) -> (a, b, c, d, e, f, g, h, i, a) -> Ordering #

(<#) :: (Ord1 f, Ord a) => f a -> f a -> Bool infixr 4 #

(<=#) :: (Ord1 f, Ord a) => f a -> f a -> Bool infixr 4 #

(>=#) :: (Ord1 f, Ord a) => f a -> f a -> Bool infixr 4 #

(>#) :: (Ord1 f, Ord a) => f a -> f a -> Bool infixr 4 #

max1 :: (Ord1 f, Ord a) => f a -> f a -> f a #

min1 :: (Ord1 f, Ord a) => f a -> f a -> f a #

class Show1 f where #

Methods

showsPrec1 :: Show a => Int -> f a -> ShowS #

showsPrec1 :: Show (f a) => Int -> f a -> ShowS #

showList1 :: Show a => [f a] -> ShowS #

Instances

Show1 [] # 

Methods

showsPrec1 :: Show a => Int -> [a] -> ShowS #

showList1 :: Show a => [[a]] -> ShowS #

Show1 Maybe # 

Methods

showsPrec1 :: Show a => Int -> Maybe a -> ShowS #

showList1 :: Show a => [Maybe a] -> ShowS #

Show1 Ptr # 

Methods

showsPrec1 :: Show a => Int -> Ptr a -> ShowS #

showList1 :: Show a => [Ptr a] -> ShowS #

Show1 FunPtr # 

Methods

showsPrec1 :: Show a => Int -> FunPtr a -> ShowS #

showList1 :: Show a => [FunPtr a] -> ShowS #

Show1 Identity # 

Methods

showsPrec1 :: Show a => Int -> Identity a -> ShowS #

showList1 :: Show a => [Identity a] -> ShowS #

Show1 Complex # 

Methods

showsPrec1 :: Show a => Int -> Complex a -> ShowS #

showList1 :: Show a => [Complex a] -> ShowS #

Show1 ZipList # 

Methods

showsPrec1 :: Show a => Int -> ZipList a -> ShowS #

showList1 :: Show a => [ZipList a] -> ShowS #

Show1 ForeignPtr # 

Methods

showsPrec1 :: Show a => Int -> ForeignPtr a -> ShowS #

showList1 :: Show a => [ForeignPtr a] -> ShowS #

Show1 Dual # 

Methods

showsPrec1 :: Show a => Int -> Dual a -> ShowS #

showList1 :: Show a => [Dual a] -> ShowS #

Show1 Sum # 

Methods

showsPrec1 :: Show a => Int -> Sum a -> ShowS #

showList1 :: Show a => [Sum a] -> ShowS #

Show1 Product # 

Methods

showsPrec1 :: Show a => Int -> Product a -> ShowS #

showList1 :: Show a => [Product a] -> ShowS #

Show1 First # 

Methods

showsPrec1 :: Show a => Int -> First a -> ShowS #

showList1 :: Show a => [First a] -> ShowS #

Show1 Last # 

Methods

showsPrec1 :: Show a => Int -> Last a -> ShowS #

showList1 :: Show a => [Last a] -> ShowS #

Show1 Down # 

Methods

showsPrec1 :: Show a => Int -> Down a -> ShowS #

showList1 :: Show a => [Down a] -> ShowS #

Show a => Show1 (Either a) # 

Methods

showsPrec1 :: Show a => Int -> Either a a -> ShowS #

showList1 :: Show a => [Either a a] -> ShowS #

Show a => Show1 ((,) a) # 

Methods

showsPrec1 :: Show a => Int -> (a, a) -> ShowS #

showList1 :: Show a => [(a, a)] -> ShowS #

Show1 (Proxy *) # 

Methods

showsPrec1 :: Show a => Int -> Proxy * a -> ShowS #

showList1 :: Show a => [Proxy * a] -> ShowS #

Show1 f => Show1 (Lift1 f) # 

Methods

showsPrec1 :: Show a => Int -> Lift1 f a -> ShowS #

showList1 :: Show a => [Lift1 f a] -> ShowS #

(Show a, Show b) => Show1 ((,,) a b) # 

Methods

showsPrec1 :: Show a => Int -> (a, b, a) -> ShowS #

showList1 :: Show a => [(a, b, a)] -> ShowS #

Show a => Show1 (Const * a) # 

Methods

showsPrec1 :: Show a => Int -> Const * a a -> ShowS #

showList1 :: Show a => [Const * a a] -> ShowS #

Show1 f => Show1 (Alt * f) # 

Methods

showsPrec1 :: Show a => Int -> Alt * f a -> ShowS #

showList1 :: Show a => [Alt * f a] -> ShowS #

(Show2 f, Show a) => Show1 (Lift2 f a) # 

Methods

showsPrec1 :: Show a => Int -> Lift2 f a a -> ShowS #

showList1 :: Show a => [Lift2 f a a] -> ShowS #

(Show a, Show b, Show c) => Show1 ((,,,) a b c) # 

Methods

showsPrec1 :: Show a => Int -> (a, b, c, a) -> ShowS #

showList1 :: Show a => [(a, b, c, a)] -> ShowS #

(Show a, Show b, Show c, Show d) => Show1 ((,,,,) a b c d) # 

Methods

showsPrec1 :: Show a => Int -> (a, b, c, d, a) -> ShowS #

showList1 :: Show a => [(a, b, c, d, a)] -> ShowS #

(Show a, Show b, Show c, Show d, Show e) => Show1 ((,,,,,) a b c d e) # 

Methods

showsPrec1 :: Show a => Int -> (a, b, c, d, e, a) -> ShowS #

showList1 :: Show a => [(a, b, c, d, e, a)] -> ShowS #

(Show a, Show b, Show c, Show d, Show e, Show f) => Show1 ((,,,,,,) a b c d e f) # 

Methods

showsPrec1 :: Show a => Int -> (a, b, c, d, e, f, a) -> ShowS #

showList1 :: Show a => [(a, b, c, d, e, f, a)] -> ShowS #

(Show a, Show b, Show c, Show d, Show e, Show f, Show g) => Show1 ((,,,,,,,) a b c d e f g) # 

Methods

showsPrec1 :: Show a => Int -> (a, b, c, d, e, f, g, a) -> ShowS #

showList1 :: Show a => [(a, b, c, d, e, f, g, a)] -> ShowS #

(Show a, Show b, Show c, Show d, Show e, Show f, Show g, Show h) => Show1 ((,,,,,,,,) a b c d e f g h) # 

Methods

showsPrec1 :: Show a => Int -> (a, b, c, d, e, f, g, h, a) -> ShowS #

showList1 :: Show a => [(a, b, c, d, e, f, g, h, a)] -> ShowS #

(Show a, Show b, Show c, Show d, Show e, Show f, Show g, Show h, Show i) => Show1 ((,,,,,,,,,) a b c d e f g h i) # 

Methods

showsPrec1 :: Show a => Int -> (a, b, c, d, e, f, g, h, i, a) -> ShowS #

showList1 :: Show a => [(a, b, c, d, e, f, g, h, i, a)] -> ShowS #

show1 :: (Show1 f, Show a) => f a -> String #

shows1 :: (Show1 f, Show a) => f a -> ShowS #

class Read1 f where #

Methods

readsPrec1 :: Read a => Int -> ReadS (f a) #

readsPrec1 :: Read (f a) => Int -> ReadS (f a) #

readList1 :: Read a => ReadS [f a] #

Instances

Read1 [] # 

Methods

readsPrec1 :: Read a => Int -> ReadS [a] #

readList1 :: Read a => ReadS [[a]] #

Read1 Maybe # 

Methods

readsPrec1 :: Read a => Int -> ReadS (Maybe a) #

readList1 :: Read a => ReadS [Maybe a] #

Read1 Identity # 

Methods

readsPrec1 :: Read a => Int -> ReadS (Identity a) #

readList1 :: Read a => ReadS [Identity a] #

Read1 Complex # 

Methods

readsPrec1 :: Read a => Int -> ReadS (Complex a) #

readList1 :: Read a => ReadS [Complex a] #

Read1 ZipList # 

Methods

readsPrec1 :: Read a => Int -> ReadS (ZipList a) #

readList1 :: Read a => ReadS [ZipList a] #

Read1 Dual # 

Methods

readsPrec1 :: Read a => Int -> ReadS (Dual a) #

readList1 :: Read a => ReadS [Dual a] #

Read1 Sum # 

Methods

readsPrec1 :: Read a => Int -> ReadS (Sum a) #

readList1 :: Read a => ReadS [Sum a] #

Read1 Product # 

Methods

readsPrec1 :: Read a => Int -> ReadS (Product a) #

readList1 :: Read a => ReadS [Product a] #

Read1 First # 

Methods

readsPrec1 :: Read a => Int -> ReadS (First a) #

readList1 :: Read a => ReadS [First a] #

Read1 Last # 

Methods

readsPrec1 :: Read a => Int -> ReadS (Last a) #

readList1 :: Read a => ReadS [Last a] #

Read1 Down # 

Methods

readsPrec1 :: Read a => Int -> ReadS (Down a) #

readList1 :: Read a => ReadS [Down a] #

Read a => Read1 (Either a) # 

Methods

readsPrec1 :: Read a => Int -> ReadS (Either a a) #

readList1 :: Read a => ReadS [Either a a] #

Read a => Read1 ((,) a) # 

Methods

readsPrec1 :: Read a => Int -> ReadS (a, a) #

readList1 :: Read a => ReadS [(a, a)] #

Read1 (Proxy *) # 

Methods

readsPrec1 :: Read a => Int -> ReadS (Proxy * a) #

readList1 :: Read a => ReadS [Proxy * a] #

Read1 f => Read1 (Lift1 f) # 

Methods

readsPrec1 :: Read a => Int -> ReadS (Lift1 f a) #

readList1 :: Read a => ReadS [Lift1 f a] #

(Read a, Read b) => Read1 ((,,) a b) # 

Methods

readsPrec1 :: Read a => Int -> ReadS (a, b, a) #

readList1 :: Read a => ReadS [(a, b, a)] #

Read a => Read1 (Const * a) # 

Methods

readsPrec1 :: Read a => Int -> ReadS (Const * a a) #

readList1 :: Read a => ReadS [Const * a a] #

Read1 f => Read1 (Alt * f) # 

Methods

readsPrec1 :: Read a => Int -> ReadS (Alt * f a) #

readList1 :: Read a => ReadS [Alt * f a] #

(Read2 f, Read a) => Read1 (Lift2 f a) # 

Methods

readsPrec1 :: Read a => Int -> ReadS (Lift2 f a a) #

readList1 :: Read a => ReadS [Lift2 f a a] #

(Read a, Read b, Read c) => Read1 ((,,,) a b c) # 

Methods

readsPrec1 :: Read a => Int -> ReadS (a, b, c, a) #

readList1 :: Read a => ReadS [(a, b, c, a)] #

(Read a, Read b, Read c, Read d) => Read1 ((,,,,) a b c d) # 

Methods

readsPrec1 :: Read a => Int -> ReadS (a, b, c, d, a) #

readList1 :: Read a => ReadS [(a, b, c, d, a)] #

(Read a, Read b, Read c, Read d, Read e) => Read1 ((,,,,,) a b c d e) # 

Methods

readsPrec1 :: Read a => Int -> ReadS (a, b, c, d, e, a) #

readList1 :: Read a => ReadS [(a, b, c, d, e, a)] #

(Read a, Read b, Read c, Read d, Read e, Read f) => Read1 ((,,,,,,) a b c d e f) # 

Methods

readsPrec1 :: Read a => Int -> ReadS (a, b, c, d, e, f, a) #

readList1 :: Read a => ReadS [(a, b, c, d, e, f, a)] #

(Read a, Read b, Read c, Read d, Read e, Read f, Read g) => Read1 ((,,,,,,,) a b c d e f g) # 

Methods

readsPrec1 :: Read a => Int -> ReadS (a, b, c, d, e, f, g, a) #

readList1 :: Read a => ReadS [(a, b, c, d, e, f, g, a)] #

(Read a, Read b, Read c, Read d, Read e, Read f, Read g, Read h) => Read1 ((,,,,,,,,) a b c d e f g h) # 

Methods

readsPrec1 :: Read a => Int -> ReadS (a, b, c, d, e, f, g, h, a) #

readList1 :: Read a => ReadS [(a, b, c, d, e, f, g, h, a)] #

(Read a, Read b, Read c, Read d, Read e, Read f, Read g, Read h, Read i) => Read1 ((,,,,,,,,,) a b c d e f g h i) # 

Methods

readsPrec1 :: Read a => Int -> ReadS (a, b, c, d, e, f, g, h, i, a) #

readList1 :: Read a => ReadS [(a, b, c, d, e, f, g, h, i, a)] #

read1 :: (Read1 f, Read a) => String -> f a #

reads1 :: (Read1 f, Read a) => ReadS (f a) #

readPrec1 :: (Read1 f, Read a) => ReadPrec (f a) #

readListPrec1 :: (Read1 f, Read a) => ReadPrec [f a] #

readList1Default :: (Read1 f, Read a) => ReadS [f a] #

newtype Lift1 f a #

Constructors

Lift1 

Fields

Instances

Functor f => Functor (Lift1 f) # 

Methods

fmap :: (a -> b) -> Lift1 f a -> Lift1 f b #

(<$) :: a -> Lift1 f b -> Lift1 f a #

Foldable f => Foldable (Lift1 f) # 

Methods

fold :: Monoid m => Lift1 f m -> m #

foldMap :: Monoid m => (a -> m) -> Lift1 f a -> m #

foldr :: (a -> b -> b) -> b -> Lift1 f a -> b #

foldr' :: (a -> b -> b) -> b -> Lift1 f a -> b #

foldl :: (b -> a -> b) -> b -> Lift1 f a -> b #

foldl' :: (b -> a -> b) -> b -> Lift1 f a -> b #

foldr1 :: (a -> a -> a) -> Lift1 f a -> a #

foldl1 :: (a -> a -> a) -> Lift1 f a -> a #

toList :: Lift1 f a -> [a] #

null :: Lift1 f a -> Bool #

length :: Lift1 f a -> Int #

elem :: Eq a => a -> Lift1 f a -> Bool #

maximum :: Ord a => Lift1 f a -> a #

minimum :: Ord a => Lift1 f a -> a #

sum :: Num a => Lift1 f a -> a #

product :: Num a => Lift1 f a -> a #

Traversable f => Traversable (Lift1 f) # 

Methods

traverse :: Applicative f => (a -> f b) -> Lift1 f a -> f (Lift1 f b) #

sequenceA :: Applicative f => Lift1 f (f a) -> f (Lift1 f a) #

mapM :: Monad m => (a -> m b) -> Lift1 f a -> m (Lift1 f b) #

sequence :: Monad m => Lift1 f (m a) -> m (Lift1 f a) #

Read1 f => Read1 (Lift1 f) # 

Methods

readsPrec1 :: Read a => Int -> ReadS (Lift1 f a) #

readList1 :: Read a => ReadS [Lift1 f a] #

Show1 f => Show1 (Lift1 f) # 

Methods

showsPrec1 :: Show a => Int -> Lift1 f a -> ShowS #

showList1 :: Show a => [Lift1 f a] -> ShowS #

Ord1 f => Ord1 (Lift1 f) # 

Methods

compare1 :: Ord a => Lift1 f a -> Lift1 f a -> Ordering #

Eq1 f => Eq1 (Lift1 f) # 

Methods

(==#) :: Eq a => Lift1 f a -> Lift1 f a -> Bool #

(Eq1 f, Eq a) => Eq (Lift1 f a) # 

Methods

(==) :: Lift1 f a -> Lift1 f a -> Bool #

(/=) :: Lift1 f a -> Lift1 f a -> Bool #

(Ord1 f, Ord a) => Ord (Lift1 f a) # 

Methods

compare :: Lift1 f a -> Lift1 f a -> Ordering #

(<) :: Lift1 f a -> Lift1 f a -> Bool #

(<=) :: Lift1 f a -> Lift1 f a -> Bool #

(>) :: Lift1 f a -> Lift1 f a -> Bool #

(>=) :: Lift1 f a -> Lift1 f a -> Bool #

max :: Lift1 f a -> Lift1 f a -> Lift1 f a #

min :: Lift1 f a -> Lift1 f a -> Lift1 f a #

(Read1 f, Read a) => Read (Lift1 f a) # 
(Show1 f, Show a) => Show (Lift1 f a) # 

Methods

showsPrec :: Int -> Lift1 f a -> ShowS #

show :: Lift1 f a -> String #

showList :: [Lift1 f a] -> ShowS #

Lifted Prelude classes for kind * -> * -> *

class Eq2 f where #

Methods

(==##) :: (Eq a, Eq b) => f a b -> f a b -> Bool infixr 4 #

(==##) :: Eq (f a b) => f a b -> f a b -> Bool infixr 4 #

Instances

Eq2 Either # 

Methods

(==##) :: (Eq a, Eq b) => Either a b -> Either a b -> Bool #

Eq2 (,) # 

Methods

(==##) :: (Eq a, Eq b) => (a, b) -> (a, b) -> Bool #

Eq a => Eq2 ((,,) a) # 

Methods

(==##) :: (Eq a, Eq b) => (a, a, b) -> (a, a, b) -> Bool #

Eq2 (Const *) # 

Methods

(==##) :: (Eq a, Eq b) => Const * a b -> Const * a b -> Bool #

Eq2 f => Eq2 (Lift2 f) # 

Methods

(==##) :: (Eq a, Eq b) => Lift2 f a b -> Lift2 f a b -> Bool #

(Eq a, Eq b) => Eq2 ((,,,) a b) # 

Methods

(==##) :: (Eq a, Eq b) => (a, b, a, b) -> (a, b, a, b) -> Bool #

(Eq a, Eq b, Eq c) => Eq2 ((,,,,) a b c) # 

Methods

(==##) :: (Eq a, Eq b) => (a, b, c, a, b) -> (a, b, c, a, b) -> Bool #

(Eq a, Eq b, Eq c, Eq d) => Eq2 ((,,,,,) a b c d) # 

Methods

(==##) :: (Eq a, Eq b) => (a, b, c, d, a, b) -> (a, b, c, d, a, b) -> Bool #

(Eq a, Eq b, Eq c, Eq d, Eq e) => Eq2 ((,,,,,,) a b c d e) # 

Methods

(==##) :: (Eq a, Eq b) => (a, b, c, d, e, a, b) -> (a, b, c, d, e, a, b) -> Bool #

(Eq a, Eq b, Eq c, Eq d, Eq e, Eq f) => Eq2 ((,,,,,,,) a b c d e f) # 

Methods

(==##) :: (Eq a, Eq b) => (a, b, c, d, e, f, a, b) -> (a, b, c, d, e, f, a, b) -> Bool #

(Eq a, Eq b, Eq c, Eq d, Eq e, Eq f, Eq g) => Eq2 ((,,,,,,,,) a b c d e f g) # 

Methods

(==##) :: (Eq a, Eq b) => (a, b, c, d, e, f, g, a, b) -> (a, b, c, d, e, f, g, a, b) -> Bool #

(Eq a, Eq b, Eq c, Eq d, Eq e, Eq f, Eq g, Eq h) => Eq2 ((,,,,,,,,,) a b c d e f g h) # 

Methods

(==##) :: (Eq a, Eq b) => (a, b, c, d, e, f, g, h, a, b) -> (a, b, c, d, e, f, g, h, a, b) -> Bool #

(/=##) :: (Eq2 f, Eq a, Eq b) => f a b -> f a b -> Bool infixr 4 #

class Eq2 f => Ord2 f where #

Methods

compare2 :: (Ord a, Ord b) => f a b -> f a b -> Ordering #

compare2 :: Ord (f a b) => f a b -> f a b -> Ordering #

Instances

Ord2 Either # 

Methods

compare2 :: (Ord a, Ord b) => Either a b -> Either a b -> Ordering #

Ord2 (,) # 

Methods

compare2 :: (Ord a, Ord b) => (a, b) -> (a, b) -> Ordering #

Ord a => Ord2 ((,,) a) # 

Methods

compare2 :: (Ord a, Ord b) => (a, a, b) -> (a, a, b) -> Ordering #

Ord2 (Const *) # 

Methods

compare2 :: (Ord a, Ord b) => Const * a b -> Const * a b -> Ordering #

Ord2 f => Ord2 (Lift2 f) # 

Methods

compare2 :: (Ord a, Ord b) => Lift2 f a b -> Lift2 f a b -> Ordering #

(Ord a, Ord b) => Ord2 ((,,,) a b) # 

Methods

compare2 :: (Ord a, Ord b) => (a, b, a, b) -> (a, b, a, b) -> Ordering #

(Ord a, Ord b, Ord c) => Ord2 ((,,,,) a b c) # 

Methods

compare2 :: (Ord a, Ord b) => (a, b, c, a, b) -> (a, b, c, a, b) -> Ordering #

(Ord a, Ord b, Ord c, Ord d) => Ord2 ((,,,,,) a b c d) # 

Methods

compare2 :: (Ord a, Ord b) => (a, b, c, d, a, b) -> (a, b, c, d, a, b) -> Ordering #

(Ord a, Ord b, Ord c, Ord d, Ord e) => Ord2 ((,,,,,,) a b c d e) # 

Methods

compare2 :: (Ord a, Ord b) => (a, b, c, d, e, a, b) -> (a, b, c, d, e, a, b) -> Ordering #

(Ord a, Ord b, Ord c, Ord d, Ord e, Ord f) => Ord2 ((,,,,,,,) a b c d e f) # 

Methods

compare2 :: (Ord a, Ord b) => (a, b, c, d, e, f, a, b) -> (a, b, c, d, e, f, a, b) -> Ordering #

(Ord a, Ord b, Ord c, Ord d, Ord e, Ord f, Ord g) => Ord2 ((,,,,,,,,) a b c d e f g) # 

Methods

compare2 :: (Ord a, Ord b) => (a, b, c, d, e, f, g, a, b) -> (a, b, c, d, e, f, g, a, b) -> Ordering #

(Ord a, Ord b, Ord c, Ord d, Ord e, Ord f, Ord g, Ord h) => Ord2 ((,,,,,,,,,) a b c d e f g h) # 

Methods

compare2 :: (Ord a, Ord b) => (a, b, c, d, e, f, g, h, a, b) -> (a, b, c, d, e, f, g, h, a, b) -> Ordering #

(<##) :: (Ord2 f, Ord a, Ord b) => f a b -> f a b -> Bool infixr 4 #

(<=##) :: (Ord2 f, Ord a, Ord b) => f a b -> f a b -> Bool infixr 4 #

(>=##) :: (Ord2 f, Ord a, Ord b) => f a b -> f a b -> Bool infixr 4 #

(>##) :: (Ord2 f, Ord a, Ord b) => f a b -> f a b -> Bool infixr 4 #

max2 :: (Ord2 f, Ord a, Ord b) => f a b -> f a b -> f a b #

min2 :: (Ord2 f, Ord a, Ord b) => f a b -> f a b -> f a b #

class Show2 f where #

Methods

showsPrec2 :: (Show a, Show b) => Int -> f a b -> ShowS #

showsPrec2 :: Show (f a b) => Int -> f a b -> ShowS #

showList2 :: (Show a, Show b) => [f a b] -> ShowS #

Instances

Show2 Either # 

Methods

showsPrec2 :: (Show a, Show b) => Int -> Either a b -> ShowS #

showList2 :: (Show a, Show b) => [Either a b] -> ShowS #

Show2 (,) # 

Methods

showsPrec2 :: (Show a, Show b) => Int -> (a, b) -> ShowS #

showList2 :: (Show a, Show b) => [(a, b)] -> ShowS #

Show a => Show2 ((,,) a) # 

Methods

showsPrec2 :: (Show a, Show b) => Int -> (a, a, b) -> ShowS #

showList2 :: (Show a, Show b) => [(a, a, b)] -> ShowS #

Show2 (Const *) # 

Methods

showsPrec2 :: (Show a, Show b) => Int -> Const * a b -> ShowS #

showList2 :: (Show a, Show b) => [Const * a b] -> ShowS #

Show2 f => Show2 (Lift2 f) # 

Methods

showsPrec2 :: (Show a, Show b) => Int -> Lift2 f a b -> ShowS #

showList2 :: (Show a, Show b) => [Lift2 f a b] -> ShowS #

(Show a, Show b) => Show2 ((,,,) a b) # 

Methods

showsPrec2 :: (Show a, Show b) => Int -> (a, b, a, b) -> ShowS #

showList2 :: (Show a, Show b) => [(a, b, a, b)] -> ShowS #

(Show a, Show b, Show c) => Show2 ((,,,,) a b c) # 

Methods

showsPrec2 :: (Show a, Show b) => Int -> (a, b, c, a, b) -> ShowS #

showList2 :: (Show a, Show b) => [(a, b, c, a, b)] -> ShowS #

(Show a, Show b, Show c, Show d) => Show2 ((,,,,,) a b c d) # 

Methods

showsPrec2 :: (Show a, Show b) => Int -> (a, b, c, d, a, b) -> ShowS #

showList2 :: (Show a, Show b) => [(a, b, c, d, a, b)] -> ShowS #

(Show a, Show b, Show c, Show d, Show e) => Show2 ((,,,,,,) a b c d e) # 

Methods

showsPrec2 :: (Show a, Show b) => Int -> (a, b, c, d, e, a, b) -> ShowS #

showList2 :: (Show a, Show b) => [(a, b, c, d, e, a, b)] -> ShowS #

(Show a, Show b, Show c, Show d, Show e, Show f) => Show2 ((,,,,,,,) a b c d e f) # 

Methods

showsPrec2 :: (Show a, Show b) => Int -> (a, b, c, d, e, f, a, b) -> ShowS #

showList2 :: (Show a, Show b) => [(a, b, c, d, e, f, a, b)] -> ShowS #

(Show a, Show b, Show c, Show d, Show e, Show f, Show g) => Show2 ((,,,,,,,,) a b c d e f g) # 

Methods

showsPrec2 :: (Show a, Show b) => Int -> (a, b, c, d, e, f, g, a, b) -> ShowS #

showList2 :: (Show a, Show b) => [(a, b, c, d, e, f, g, a, b)] -> ShowS #

(Show a, Show b, Show c, Show d, Show e, Show f, Show g, Show h) => Show2 ((,,,,,,,,,) a b c d e f g h) # 

Methods

showsPrec2 :: (Show a, Show b) => Int -> (a, b, c, d, e, f, g, h, a, b) -> ShowS #

showList2 :: (Show a, Show b) => [(a, b, c, d, e, f, g, h, a, b)] -> ShowS #

show2 :: (Show2 f, Show a, Show b) => f a b -> String #

shows2 :: (Show2 f, Show a, Show b) => f a b -> ShowS #

class Read2 f where #

Methods

readsPrec2 :: (Read a, Read b) => Int -> ReadS (f a b) #

readsPrec2 :: Read (f a b) => Int -> ReadS (f a b) #

readList2 :: (Read a, Read b) => ReadS [f a b] #

Instances

Read2 Either # 

Methods

readsPrec2 :: (Read a, Read b) => Int -> ReadS (Either a b) #

readList2 :: (Read a, Read b) => ReadS [Either a b] #

Read2 (,) # 

Methods

readsPrec2 :: (Read a, Read b) => Int -> ReadS (a, b) #

readList2 :: (Read a, Read b) => ReadS [(a, b)] #

Read a => Read2 ((,,) a) # 

Methods

readsPrec2 :: (Read a, Read b) => Int -> ReadS (a, a, b) #

readList2 :: (Read a, Read b) => ReadS [(a, a, b)] #

Read2 (Const *) # 

Methods

readsPrec2 :: (Read a, Read b) => Int -> ReadS (Const * a b) #

readList2 :: (Read a, Read b) => ReadS [Const * a b] #

Read2 f => Read2 (Lift2 f) # 

Methods

readsPrec2 :: (Read a, Read b) => Int -> ReadS (Lift2 f a b) #

readList2 :: (Read a, Read b) => ReadS [Lift2 f a b] #

(Read a, Read b) => Read2 ((,,,) a b) # 

Methods

readsPrec2 :: (Read a, Read b) => Int -> ReadS (a, b, a, b) #

readList2 :: (Read a, Read b) => ReadS [(a, b, a, b)] #

(Read a, Read b, Read c) => Read2 ((,,,,) a b c) # 

Methods

readsPrec2 :: (Read a, Read b) => Int -> ReadS (a, b, c, a, b) #

readList2 :: (Read a, Read b) => ReadS [(a, b, c, a, b)] #

(Read a, Read b, Read c, Read d) => Read2 ((,,,,,) a b c d) # 

Methods

readsPrec2 :: (Read a, Read b) => Int -> ReadS (a, b, c, d, a, b) #

readList2 :: (Read a, Read b) => ReadS [(a, b, c, d, a, b)] #

(Read a, Read b, Read c, Read d, Read e) => Read2 ((,,,,,,) a b c d e) # 

Methods

readsPrec2 :: (Read a, Read b) => Int -> ReadS (a, b, c, d, e, a, b) #

readList2 :: (Read a, Read b) => ReadS [(a, b, c, d, e, a, b)] #

(Read a, Read b, Read c, Read d, Read e, Read f) => Read2 ((,,,,,,,) a b c d e f) # 

Methods

readsPrec2 :: (Read a, Read b) => Int -> ReadS (a, b, c, d, e, f, a, b) #

readList2 :: (Read a, Read b) => ReadS [(a, b, c, d, e, f, a, b)] #

(Read a, Read b, Read c, Read d, Read e, Read f, Read g) => Read2 ((,,,,,,,,) a b c d e f g) # 

Methods

readsPrec2 :: (Read a, Read b) => Int -> ReadS (a, b, c, d, e, f, g, a, b) #

readList2 :: (Read a, Read b) => ReadS [(a, b, c, d, e, f, g, a, b)] #

(Read a, Read b, Read c, Read d, Read e, Read f, Read g, Read h) => Read2 ((,,,,,,,,,) a b c d e f g h) # 

Methods

readsPrec2 :: (Read a, Read b) => Int -> ReadS (a, b, c, d, e, f, g, h, a, b) #

readList2 :: (Read a, Read b) => ReadS [(a, b, c, d, e, f, g, h, a, b)] #

read2 :: (Read2 f, Read a, Read b) => String -> f a b #

reads2 :: (Read2 f, Read a, Read b) => ReadS (f a b) #

readPrec2 :: (Read2 f, Read a, Read b) => ReadPrec (f a b) #

readListPrec2 :: (Read2 f, Read a, Read b) => ReadPrec [f a b] #

readList2Default :: (Read2 f, Read a, Read b) => ReadS [f a b] #

readListPrec2Default :: (Read2 f, Read a, Read b) => ReadPrec [f a b] #

newtype Lift2 f a b #

Constructors

Lift2 

Fields

Instances

Read2 f => Read2 (Lift2 f) # 

Methods

readsPrec2 :: (Read a, Read b) => Int -> ReadS (Lift2 f a b) #

readList2 :: (Read a, Read b) => ReadS [Lift2 f a b] #

Show2 f => Show2 (Lift2 f) # 

Methods

showsPrec2 :: (Show a, Show b) => Int -> Lift2 f a b -> ShowS #

showList2 :: (Show a, Show b) => [Lift2 f a b] -> ShowS #

Ord2 f => Ord2 (Lift2 f) # 

Methods

compare2 :: (Ord a, Ord b) => Lift2 f a b -> Lift2 f a b -> Ordering #

Eq2 f => Eq2 (Lift2 f) # 

Methods

(==##) :: (Eq a, Eq b) => Lift2 f a b -> Lift2 f a b -> Bool #

Functor (f a) => Functor (Lift2 f a) # 

Methods

fmap :: (a -> b) -> Lift2 f a a -> Lift2 f a b #

(<$) :: a -> Lift2 f a b -> Lift2 f a a #

Foldable (f a) => Foldable (Lift2 f a) # 

Methods

fold :: Monoid m => Lift2 f a m -> m #

foldMap :: Monoid m => (a -> m) -> Lift2 f a a -> m #

foldr :: (a -> b -> b) -> b -> Lift2 f a a -> b #

foldr' :: (a -> b -> b) -> b -> Lift2 f a a -> b #

foldl :: (b -> a -> b) -> b -> Lift2 f a a -> b #

foldl' :: (b -> a -> b) -> b -> Lift2 f a a -> b #

foldr1 :: (a -> a -> a) -> Lift2 f a a -> a #

foldl1 :: (a -> a -> a) -> Lift2 f a a -> a #

toList :: Lift2 f a a -> [a] #

null :: Lift2 f a a -> Bool #

length :: Lift2 f a a -> Int #

elem :: Eq a => a -> Lift2 f a a -> Bool #

maximum :: Ord a => Lift2 f a a -> a #

minimum :: Ord a => Lift2 f a a -> a #

sum :: Num a => Lift2 f a a -> a #

product :: Num a => Lift2 f a a -> a #

Traversable (f a) => Traversable (Lift2 f a) # 

Methods

traverse :: Applicative f => (a -> f b) -> Lift2 f a a -> f (Lift2 f a b) #

sequenceA :: Applicative f => Lift2 f a (f a) -> f (Lift2 f a a) #

mapM :: Monad m => (a -> m b) -> Lift2 f a a -> m (Lift2 f a b) #

sequence :: Monad m => Lift2 f a (m a) -> m (Lift2 f a a) #

(Read2 f, Read a) => Read1 (Lift2 f a) # 

Methods

readsPrec1 :: Read a => Int -> ReadS (Lift2 f a a) #

readList1 :: Read a => ReadS [Lift2 f a a] #

(Show2 f, Show a) => Show1 (Lift2 f a) # 

Methods

showsPrec1 :: Show a => Int -> Lift2 f a a -> ShowS #

showList1 :: Show a => [Lift2 f a a] -> ShowS #

(Ord2 f, Ord a) => Ord1 (Lift2 f a) # 

Methods

compare1 :: Ord a => Lift2 f a a -> Lift2 f a a -> Ordering #

(Eq2 f, Eq a) => Eq1 (Lift2 f a) # 

Methods

(==#) :: Eq a => Lift2 f a a -> Lift2 f a a -> Bool #

(Eq2 f, Eq a, Eq b) => Eq (Lift2 f a b) # 

Methods

(==) :: Lift2 f a b -> Lift2 f a b -> Bool #

(/=) :: Lift2 f a b -> Lift2 f a b -> Bool #

(Ord2 f, Ord a, Ord b) => Ord (Lift2 f a b) # 

Methods

compare :: Lift2 f a b -> Lift2 f a b -> Ordering #

(<) :: Lift2 f a b -> Lift2 f a b -> Bool #

(<=) :: Lift2 f a b -> Lift2 f a b -> Bool #

(>) :: Lift2 f a b -> Lift2 f a b -> Bool #

(>=) :: Lift2 f a b -> Lift2 f a b -> Bool #

max :: Lift2 f a b -> Lift2 f a b -> Lift2 f a b #

min :: Lift2 f a b -> Lift2 f a b -> Lift2 f a b #

(Read2 f, Read a, Read b) => Read (Lift2 f a b) # 

Methods

readsPrec :: Int -> ReadS (Lift2 f a b) #

readList :: ReadS [Lift2 f a b] #

readPrec :: ReadPrec (Lift2 f a b) #

readListPrec :: ReadPrec [Lift2 f a b] #

(Show2 f, Show a, Show b) => Show (Lift2 f a b) # 

Methods

showsPrec :: Int -> Lift2 f a b -> ShowS #

show :: Lift2 f a b -> String #

showList :: [Lift2 f a b] -> ShowS #