Safe Haskell	Trustworthy
Language	Haskell98

Prelude.Extras

Contents

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

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
Eq1 Ratio Source
Eq1 StablePtr Source
Eq1 Ptr Source
Eq1 FunPtr Source
Eq1 Identity Source
Eq1 Fixed Source
Eq1 Complex Source
Eq1 Chan Source
Eq1 ZipList Source
Eq1 TVar Source
Eq1 ForeignPtr Source
Eq1 IORef Source
Eq1 MVar Source
Eq1 Dual Source
Eq1 Sum Source
Eq1 Product Source
Eq1 First Source
Eq1 Last Source
Eq1 Down Source
Eq1 Maybe Source
Eq a => Eq1 (Either a) Source
Eq a => Eq1 ((,) a) Source
Eq a => Eq1 (Const a) Source
Eq1 (Proxy *) Source
Eq1 f => Eq1 (Lift1 f) Source
(Eq a, Eq b) => Eq1 ((,,) a b) Source
Eq1 f => Eq1 (Alt * f) Source
(Eq2 f, Eq a) => Eq1 (Lift2 f a) Source
(Eq a, Eq b, Eq c) => Eq1 ((,,,) a b c) Source
(Eq a, Eq b, Eq c, Eq d) => Eq1 ((,,,,) a b c d) Source
(Eq a, Eq b, Eq c, Eq d, Eq e) => Eq1 ((,,,,,) a b c d e) Source
(Eq a, Eq b, Eq c, Eq d, Eq e, Eq f) => Eq1 ((,,,,,,) a b c d e f) Source
(Eq a, Eq b, Eq c, Eq d, Eq e, Eq f, Eq g) => Eq1 ((,,,,,,,) a b c d e f g) Source
(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) Source
(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) 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
Ord1 Ptr Source
Ord1 FunPtr Source
Ord1 Identity Source
Ord1 Fixed Source
Ord1 ZipList Source
Ord1 ForeignPtr Source
Ord1 Dual Source
Ord1 Sum Source
Ord1 Product Source
Ord1 First Source
Ord1 Last Source
Ord1 Down Source
Ord1 Maybe Source
Ord a => Ord1 (Either a) Source
Ord a => Ord1 ((,) a) Source
Ord a => Ord1 (Const a) Source
Ord1 (Proxy *) Source
Ord1 f => Ord1 (Lift1 f) Source
(Ord a, Ord b) => Ord1 ((,,) a b) Source
Ord1 f => Ord1 (Alt * f) Source
(Ord2 f, Ord a) => Ord1 (Lift2 f a) Source
(Ord a, Ord b, Ord c) => Ord1 ((,,,) a b c) Source
(Ord a, Ord b, Ord c, Ord d) => Ord1 ((,,,,) a b c d) Source
(Ord a, Ord b, Ord c, Ord d, Ord e) => Ord1 ((,,,,,) a b c d e) Source
(Ord a, Ord b, Ord c, Ord d, Ord e, Ord f) => Ord1 ((,,,,,,) a b c d e f) Source
(Ord a, Ord b, Ord c, Ord d, Ord e, Ord f, Ord g) => Ord1 ((,,,,,,,) a b c d e f g) Source
(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) Source
(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) 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
Show1 Ptr Source
Show1 FunPtr Source
Show1 Identity Source
Show1 Complex Source
Show1 ZipList Source
Show1 ForeignPtr Source
Show1 Dual Source
Show1 Sum Source
Show1 Product Source
Show1 First Source
Show1 Last Source
Show1 Down Source
Show1 Maybe Source
Show a => Show1 (Either a) Source
Show a => Show1 ((,) a) Source
Show a => Show1 (Const a) Source
Show1 (Proxy *) Source
Show1 f => Show1 (Lift1 f) Source
(Show a, Show b) => Show1 ((,,) a b) Source
Show1 f => Show1 (Alt * f) Source
(Show2 f, Show a) => Show1 (Lift2 f a) Source
(Show a, Show b, Show c) => Show1 ((,,,) a b c) Source
(Show a, Show b, Show c, Show d) => Show1 ((,,,,) a b c d) Source
(Show a, Show b, Show c, Show d, Show e) => Show1 ((,,,,,) a b c d e) Source
(Show a, Show b, Show c, Show d, Show e, Show f) => Show1 ((,,,,,,) a b c d e f) Source
(Show a, Show b, Show c, Show d, Show e, Show f, Show g) => Show1 ((,,,,,,,) a b c d e f g) Source
(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) Source
(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) 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
Read1 Identity Source
Read1 Complex Source
Read1 ZipList Source
Read1 Dual Source
Read1 Sum Source
Read1 Product Source
Read1 First Source
Read1 Last Source
Read1 Down Source
Read1 Maybe Source
Read a => Read1 (Either a) Source
Read a => Read1 ((,) a) Source
Read a => Read1 (Const a) Source
Read1 (Proxy *) Source
Read1 f => Read1 (Lift1 f) Source
(Read a, Read b) => Read1 ((,,) a b) Source
Read1 f => Read1 (Alt * f) Source
(Read2 f, Read a) => Read1 (Lift2 f a) Source
(Read a, Read b, Read c) => Read1 ((,,,) a b c) Source
(Read a, Read b, Read c, Read d) => Read1 ((,,,,) a b c d) Source
(Read a, Read b, Read c, Read d, Read e) => Read1 ((,,,,,) a b c d e) Source
(Read a, Read b, Read c, Read d, Read e, Read f) => Read1 ((,,,,,,) a b c d e f) Source
(Read a, Read b, Read c, Read d, Read e, Read f, Read g) => Read1 ((,,,,,,,) a b c d e f g) Source
(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) Source
(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) 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

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

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

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

newtype Lift1 f a Source

Constructors

Lift1
Fields lower1 :: f a

Instances

Functor f => Functor (Lift1 f) Source
Foldable f => Foldable (Lift1 f) Source
Traversable f => Traversable (Lift1 f) Source
Read1 f => Read1 (Lift1 f) Source
Show1 f => Show1 (Lift1 f) Source
Ord1 f => Ord1 (Lift1 f) Source
Eq1 f => Eq1 (Lift1 f) Source
(Eq1 f, Eq a) => Eq (Lift1 f a) Source
(Ord1 f, Ord a) => Ord (Lift1 f a) Source
(Read1 f, Read a) => Read (Lift1 f a) Source
(Show1 f, Show a) => Show (Lift1 f a) Source

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
Eq2 (,) Source
Eq2 Const Source
Eq a => Eq2 ((,,) a) Source
Eq2 f => Eq2 (Lift2 f) Source
(Eq a, Eq b) => Eq2 ((,,,) a b) Source
(Eq a, Eq b, Eq c) => Eq2 ((,,,,) a b c) Source
(Eq a, Eq b, Eq c, Eq d) => Eq2 ((,,,,,) a b c d) Source
(Eq a, Eq b, Eq c, Eq d, Eq e) => Eq2 ((,,,,,,) a b c d e) Source
(Eq a, Eq b, Eq c, Eq d, Eq e, Eq f) => Eq2 ((,,,,,,,) a b c d e f) Source
(Eq a, Eq b, Eq c, Eq d, Eq e, Eq f, Eq g) => Eq2 ((,,,,,,,,) a b c d e f g) Source
(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) 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
Ord2 (,) Source
Ord2 Const Source
Ord a => Ord2 ((,,) a) Source
Ord2 f => Ord2 (Lift2 f) Source
(Ord a, Ord b) => Ord2 ((,,,) a b) Source
(Ord a, Ord b, Ord c) => Ord2 ((,,,,) a b c) Source
(Ord a, Ord b, Ord c, Ord d) => Ord2 ((,,,,,) a b c d) Source
(Ord a, Ord b, Ord c, Ord d, Ord e) => Ord2 ((,,,,,,) a b c d e) Source
(Ord a, Ord b, Ord c, Ord d, Ord e, Ord f) => Ord2 ((,,,,,,,) a b c d e f) Source
(Ord a, Ord b, Ord c, Ord d, Ord e, Ord f, Ord g) => Ord2 ((,,,,,,,,) a b c d e f g) Source
(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) 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
Show2 (,) Source
Show2 Const Source
Show a => Show2 ((,,) a) Source
Show2 f => Show2 (Lift2 f) Source
(Show a, Show b) => Show2 ((,,,) a b) Source
(Show a, Show b, Show c) => Show2 ((,,,,) a b c) Source
(Show a, Show b, Show c, Show d) => Show2 ((,,,,,) a b c d) Source
(Show a, Show b, Show c, Show d, Show e) => Show2 ((,,,,,,) a b c d e) Source
(Show a, Show b, Show c, Show d, Show e, Show f) => Show2 ((,,,,,,,) a b c d e f) Source
(Show a, Show b, Show c, Show d, Show e, Show f, Show g) => Show2 ((,,,,,,,,) a b c d e f g) Source
(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) 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
Read2 (,) Source
Read2 Const Source
Read a => Read2 ((,,) a) Source
Read2 f => Read2 (Lift2 f) Source
(Read a, Read b) => Read2 ((,,,) a b) Source
(Read a, Read b, Read c) => Read2 ((,,,,) a b c) Source
(Read a, Read b, Read c, Read d) => Read2 ((,,,,,) a b c d) Source
(Read a, Read b, Read c, Read d, Read e) => Read2 ((,,,,,,) a b c d e) Source
(Read a, Read b, Read c, Read d, Read e, Read f) => Read2 ((,,,,,,,) a b c d e f) Source
(Read a, Read b, Read c, Read d, Read e, Read f, Read g) => Read2 ((,,,,,,,,) a b c d e f g) Source
(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) 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

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

newtype Lift2 f a b Source

Constructors

Lift2
Fields lower2 :: f a b

Instances

Read2 f => Read2 (Lift2 f) Source
Show2 f => Show2 (Lift2 f) Source
Ord2 f => Ord2 (Lift2 f) Source
Eq2 f => Eq2 (Lift2 f) Source
Functor (f a) => Functor (Lift2 f a) Source
Foldable (f a) => Foldable (Lift2 f a) Source
Traversable (f a) => Traversable (Lift2 f a) Source
(Read2 f, Read a) => Read1 (Lift2 f a) Source
(Show2 f, Show a) => Show1 (Lift2 f a) Source
(Ord2 f, Ord a) => Ord1 (Lift2 f a) Source
(Eq2 f, Eq a) => Eq1 (Lift2 f a) Source
(Eq2 f, Eq a, Eq b) => Eq (Lift2 f a b) Source
(Ord2 f, Ord a, Ord b) => Ord (Lift2 f a b) Source
(Read2 f, Read a, Read b) => Read (Lift2 f a b) Source
(Show2 f, Show a, Show b) => Show (Lift2 f a b) Source