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

Safe HaskellNone
LanguageHaskell98

Prelude.Extras

Contents

Synopsis

Lifted Prelude classes for kind * -> *

class Eq1 f where Source

Minimal complete definition

Nothing

Methods

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

Instances

Eq1 [] Source 

Methods

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

Eq1 Ratio Source 

Methods

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

Eq1 StablePtr Source 

Methods

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

Eq1 Ptr Source 

Methods

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

Eq1 FunPtr Source 

Methods

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

Eq1 Identity Source 

Methods

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

Eq1 Fixed Source 

Methods

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

Eq1 Complex Source 

Methods

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

Eq1 Chan Source 

Methods

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

Eq1 ZipList Source 

Methods

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

Eq1 TVar Source 

Methods

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

Eq1 ForeignPtr Source 

Methods

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

Eq1 IORef Source 

Methods

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

Eq1 MVar Source 

Methods

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

Eq1 Dual Source 

Methods

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

Eq1 Sum Source 

Methods

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

Eq1 Product Source 

Methods

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

Eq1 First Source 

Methods

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

Eq1 Last Source 

Methods

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

Eq1 Down Source 

Methods

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

Eq1 Maybe Source 

Methods

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

Eq a => Eq1 (Either a) Source 

Methods

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

Eq1 (Proxy *) Source 

Methods

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

Eq1 f => Eq1 (Lift1 f) Source 

Methods

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

Eq1 f => Eq1 (Alt * f) Source 

Methods

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

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

Methods

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

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

class Eq1 f => Ord1 f where Source

Minimal complete definition

Nothing

Methods

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

Instances

Ord1 [] Source 

Methods

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

Ord1 Ptr Source 

Methods

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

Ord1 FunPtr Source 

Methods

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

Ord1 Identity Source 

Methods

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

Ord1 Fixed Source 

Methods

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

Ord1 ZipList Source 

Methods

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

Ord1 ForeignPtr Source 

Methods

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

Ord1 Dual Source 

Methods

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

Ord1 Sum Source 

Methods

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

Ord1 Product Source 

Methods

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

Ord1 First Source 

Methods

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

Ord1 Last Source 

Methods

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

Ord1 Down Source 

Methods

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

Ord1 Maybe Source 

Methods

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

Ord a => Ord1 (Either a) Source 

Methods

compare1 :: Ord b => Either a b -> Either a b -> Ordering Source

Ord1 (Proxy *) Source 

Methods

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

Ord1 f => Ord1 (Lift1 f) Source 

Methods

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

Ord1 f => Ord1 (Alt * f) Source 

Methods

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

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

Methods

compare1 :: Ord b => Lift2 f a b -> Lift2 f a b -> Ordering Source

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

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

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

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

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

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

class Show1 f where Source

Minimal complete definition

Nothing

Methods

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

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

Instances

Show1 [] Source 

Methods

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

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

Show1 Ptr Source 

Methods

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

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

Show1 FunPtr Source 

Methods

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

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

Show1 Identity Source 

Methods

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

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

Show1 Complex Source 

Methods

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

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

Show1 ZipList Source 

Methods

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

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

Show1 ForeignPtr Source 
Show1 Dual Source 

Methods

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

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

Show1 Sum Source 

Methods

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

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

Show1 Product Source 

Methods

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

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

Show1 First Source 

Methods

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

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

Show1 Last Source 

Methods

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

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

Show1 Down Source 

Methods

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

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

Show1 Maybe Source 

Methods

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

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

Show a => Show1 (Either a) Source 

Methods

showsPrec1 :: Show b => Int -> Either a b -> ShowS Source

showList1 :: Show b => [Either a b] -> ShowS Source

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

Methods

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

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

Show1 (Proxy *) Source 

Methods

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

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

Show1 f => Show1 (Lift1 f) Source 

Methods

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

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

Show1 f => Show1 (Alt * f) Source 

Methods

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

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

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

Methods

showsPrec1 :: Show b => Int -> Lift2 f a b -> ShowS Source

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

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

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

class Read1 f where Source

Minimal complete definition

Nothing

Methods

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

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

Instances

Read1 [] Source 

Methods

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

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

Read1 Identity Source 
Read1 Complex Source 
Read1 ZipList Source 
Read1 Dual Source 

Methods

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

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

Read1 Sum Source 

Methods

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

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

Read1 Product Source 
Read1 First Source 

Methods

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

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

Read1 Last Source 

Methods

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

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

Read1 Down Source 

Methods

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

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

Read1 Maybe Source 

Methods

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

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

Read a => Read1 (Either a) Source 

Methods

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

readList1 :: Read b => ReadS [Either a b] Source

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

Methods

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

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

Read1 (Proxy *) Source 

Methods

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

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

Read1 f => Read1 (Lift1 f) Source 

Methods

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

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

Read1 f => Read1 (Alt * f) Source 

Methods

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

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

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

Methods

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

readList1 :: Read b => ReadS [Lift2 f a b] Source

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

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

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

newtype Lift1 f a Source

Constructors

Lift1 

Fields

Instances

Functor f => Functor (Lift1 f) Source 

Methods

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

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

Foldable f => Foldable (Lift1 f) Source 

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

Methods

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

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

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

Methods

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

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

Show1 f => Show1 (Lift1 f) Source 

Methods

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

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

Ord1 f => Ord1 (Lift1 f) Source 

Methods

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

Eq1 f => Eq1 (Lift1 f) Source 

Methods

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

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

Methods

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

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

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

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) Source 
(Show1 f, Show a) => Show (Lift1 f a) Source 

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 Source

Minimal complete definition

Nothing

Methods

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

Instances

Eq2 Either Source 

Methods

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

Eq2 f => Eq2 (Lift2 f) Source 

Methods

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

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

class Eq2 f => Ord2 f where Source

Minimal complete definition

Nothing

Methods

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

Instances

Ord2 Either Source 

Methods

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

Ord2 f => Ord2 (Lift2 f) Source 

Methods

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

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

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

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

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

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

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

class Show2 f where Source

Minimal complete definition

Nothing

Methods

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

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

Instances

Show2 Either Source 

Methods

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

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

Show2 (,) Source 

Methods

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

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

Show2 f => Show2 (Lift2 f) Source 

Methods

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

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

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

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

class Read2 f where Source

Minimal complete definition

Nothing

Methods

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

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

Instances

Read2 Either Source 

Methods

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

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

Read2 (,) Source 

Methods

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

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

Read2 f => Read2 (Lift2 f) Source 

Methods

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

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

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

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

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

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

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

newtype Lift2 f a b Source

Constructors

Lift2 

Fields

Instances

Read2 f => Read2 (Lift2 f) Source 

Methods

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

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

Show2 f => Show2 (Lift2 f) Source 

Methods

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

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

Ord2 f => Ord2 (Lift2 f) Source 

Methods

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

Eq2 f => Eq2 (Lift2 f) Source 

Methods

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

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

Methods

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

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

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

Methods

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

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

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

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

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

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

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

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

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

null :: Lift2 f a b -> Bool

length :: Lift2 f a b -> Int

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

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

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

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

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

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

Methods

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

sequenceA :: Applicative b => Lift2 f a (b c) -> b (Lift2 f a c)

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

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

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

Methods

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

readList1 :: Read b => ReadS [Lift2 f a b] Source

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

Methods

showsPrec1 :: Show b => Int -> Lift2 f a b -> ShowS Source

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

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

Methods

compare1 :: Ord b => Lift2 f a b -> Lift2 f a b -> Ordering Source

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

Methods

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

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

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

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

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

Methods

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

show :: Lift2 f a b -> String

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