Prelude.Type

Syntax emulation

class Lambda1 a c a'

class Lambda2 a b c a' b'

class Lambda3 a b d c a' b' d'

class Lambda4 a b d e c a' b' d' e'

type family Lambda :: k

class If p a b

class Case a c

class Case' p b a cs

data Alternative a b

Type Classes

Show

class Show a b

class Shows a b c

Kind

class Kind a k'

Eq

class (a (==) b) p

class (a (/=) b) p

Ord

class Compare a b o

class (a (<) b) p

class (a (<=) b) p

class (a (>=) b) p

class (a (>) b) p

class Max a b max

class Min a b min

Enum

class ToEnum i a

class FromEnum a i

class Succ a b

class Pred a b

class EnumFromTo a b l

class EnumFromThenTo a c b l

class EnumFromToBy a b c l

Bounded

class MinBound a

class MaxBound a

Primitive kinds

Unit

Maybe

Bool

class Not a b

class (a (||) b) c

class (a (&&) b) c

Ordering

Either

Tuples

class Fst p x

class Snd p x

Type Literals

Star

data StarKind

Predicates/Constraints

class Compose1 f g x z

class Compose2 f g x z a

class Compose3 f g x z a b

class Compose4 f g x z a b c

type O

type family Compose :: k

class Partial1 f x y

class Partial2 f x m y

class Partial3 f x m n y

class Partial4 f x m n o y

type family Partial :: k

class Apply1 f x

class Apply2 f x e

class Apply3 f x e g

class Apply4 f x e h g

type family a ($) b :: k

class Id a b

class Flip1 f x y

class Flip2 f x y m

class Flip3 f x y m n

class Flip4 f x y m n o

type family Flip :: (x -> y -> k) -> y -> x -> k

class Const1 a b c

class Const2 a b c d

class Const3 a b c d e

class Const4 a b c d e f

type family Const :: k

class Until p f x y

Lists

class ShowsTail a x y

class Map f l j

class FoldR f nil list ret

class FoldL f accum list ret

class Head l x

class Tail l x

class Last l x

class Init l x

class Null l p

class Length l i

class (l (!!) n) x

class Drop i l k

class (a (++) b) c

type Concat

class ConcatMap f a b

class ScanL f x l k

class ScanR f x l k

class ScanFold1 c x y z

type ScanL1

type ScanR1

type FoldL1

type FoldR1

class Replicate i a l

class Take i a b

class SplitAt i a b

class TakeWhile f x y

class DropWhile f x y

class Span f x y

class Break f x y

type And

type Or

type Any

type All

class Elem a b p

type NotElem

type Maximum

Integer

class ShowsInteger i x y

class (a (+) b) sum

class AddWithCarry carry a b sum

class Minus a b dif

class Negate a b

class (a (*) b) prod

class Signum a b

class Signum' a b

class Abs a b

class Subtract a b dif

class Even a p

class Odd a p

class Gcd a b c

class Gcd' x y z

Misc functions from the Prelude

class Error a

class ERROR a

class AsKindOf a b

Bits

class Xor a b c

class (a (.&.) b) c

class Complement a b

Integral

class QuotRem a b c

class QuotRem' a b q r

class Rem a b c

class Quot a b c

Miscellanous

class TypeEq x y b

class TypeEq' q x y b

class TypeEq'' q x y b