Prelude.Extras

Lifted Prelude classes for kind * -> *

class Eq1 f where

Methods

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

Instances

Eq1 []

Eq1 Maybe

Eq a => Eq1 (Either a)

Eq1 f => Eq1 (Lift1 f)

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

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

class Eq1 f => Ord1 f where

Methods

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

Instances

Ord1 []

Ord1 Maybe

Ord a => Ord1 (Either a)

Ord1 f => Ord1 (Lift1 f)

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

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

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

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

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

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

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

Instances

Show1 []

Show1 Maybe

Show a => Show1 (Either a)

Show a => Show1 ((,) a)

Show1 f => Show1 (Lift1 f)

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

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)

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

Instances

Read1 []

Read1 Maybe

Read a => Read1 (Either a)

Read a => Read1 ((,) a)

Read1 f => Read1 (Lift1 f)

(Read2 f, Read a) => Read1 (Lift2 f 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]

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

newtype Lift1 f a

Constructors

Lift1

Fields

lower1 :: f a

Instances

Functor f => Functor (Lift1 f)

Foldable f => Foldable (Lift1 f)

Traversable f => Traversable (Lift1 f)

Read1 f => Read1 (Lift1 f)

Show1 f => Show1 (Lift1 f)

Ord1 f => Ord1 (Lift1 f)

Eq1 f => Eq1 (Lift1 f)

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

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

(Read1 f, Read a) => Read (Lift1 f a)

(Show1 f, Show a) => Show (Lift1 f a)

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

class Eq2 f where

Methods

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

Instances

Eq2 Either

Eq2 f => Eq2 (Lift2 f)

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

class Eq2 f => Ord2 f where

Methods

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

Instances

Ord2 Either

Ord2 f => Ord2 (Lift2 f)

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

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

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

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

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

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

Instances

Show2 Either

Show2 (,)

Show2 f => Show2 (Lift2 f)

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)

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

Instances

Read2 Either

Read2 (,)

Read2 f => Read2 (Lift2 f)

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

lower2 :: f a b

Instances

Read2 f => Read2 (Lift2 f)

Show2 f => Show2 (Lift2 f)

Ord2 f => Ord2 (Lift2 f)

Eq2 f => Eq2 (Lift2 f)

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

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

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

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

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

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

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

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

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

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

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