GHC.Base

The Eq class defines equality (==) and inequality (/=). All the basic datatypes exported by the Prelude are instances of Eq, and Eq may be derived for any datatype whose constituents are also instances of Eq.

Minimal complete definition: either == or /=.

Methods

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

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

Instances

Eq ThreadId

(Ix ix) => Eq (UArray ix Bool)

(Ix ix) => Eq (UArray ix Char)

(Ix ix) => Eq (UArray ix Int)

(Ix ix) => Eq (UArray ix Word)

(Ix ix) => Eq (UArray ix (Ptr a))

(Ix ix) => Eq (UArray ix (FunPtr a))

(Ix ix) => Eq (UArray ix Float)

(Ix ix) => Eq (UArray ix Double)

(Ix ix) => Eq (UArray ix (StablePtr a))

(Ix ix) => Eq (UArray ix Int8)

(Ix ix) => Eq (UArray ix Int16)

(Ix ix) => Eq (UArray ix Int32)

(Ix ix) => Eq (UArray ix Int64)

(Ix ix) => Eq (UArray ix Word8)

(Ix ix) => Eq (UArray ix Word16)

(Ix ix) => Eq (UArray ix Word32)

(Ix ix) => Eq (UArray ix Word64)

(RealFloat a, Eq a) => Eq (Complex a)

(Eq a, Eq b) => Eq (Either a b)

(Eq key, Eq elt) => Eq (FiniteMap key elt)

(Eq a) => Eq (Maybe a)

Eq PackedString

(Eq a) => Eq (Set a)

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

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

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

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

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

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

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

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

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

(Eq a, Eq b, Eq c, Eq d, Eq e, Eq f, Eq g, Eq h, Eq i, Eq j, Eq k) => Eq (a, b, c, d, e, f, g, h, i, j, k)

(Eq a, Eq b, Eq c, Eq d, Eq e, Eq f, Eq g, Eq h, Eq i, Eq j, Eq k, Eq l) => Eq (a, b, c, d, e, f, g, h, i, j, k, l)

(Eq a, Eq b, Eq c, Eq d, Eq e, Eq f, Eq g, Eq h, Eq i, Eq j, Eq k, Eq l, Eq m) => Eq (a, b, c, d, e, f, g, h, i, j, k, l, m)

(Eq a, Eq b, Eq c, Eq d, Eq e, Eq f, Eq g, Eq h, Eq i, Eq j, Eq k, Eq l, Eq m, Eq n) => Eq (a, b, c, d, e, f, g, h, i, j, k, l, m, n)

(Eq a, Eq b, Eq c, Eq d, Eq e, Eq f, Eq g, Eq h, Eq i, Eq j, Eq k, Eq l, Eq m, Eq n, Eq o) => Eq (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o)

Eq Unique

(Eq a) => Eq (Poly a)

Eq (STArray s i e)

(Ix i, Eq e) => Eq (Array i e)

(Eq a) => Eq [a]

Eq ()

Eq (ForeignPtr a)

Eq (MVar a)

Eq (IORef a)

Eq (IOArray i e)

Eq (Ptr a)

Eq (FunPtr a)

(Integral a, Eq a) => Eq (Ratio a)

Eq (STRef s a)

Eq (StablePtr a)

Eq (StableName a)

class (Eq a) => Ord a where

Methods

compare :: a -> a -> Ordering

(<) :: a -> a -> Bool

(<=) :: a -> a -> Bool

(>) :: a -> a -> Bool

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

max :: a -> a -> a

min :: a -> a -> a

Instances

Ord ThreadId

(Ix ix) => Ord (UArray ix Bool)

(Ix ix) => Ord (UArray ix Char)

(Ix ix) => Ord (UArray ix Int)

(Ix ix) => Ord (UArray ix Word)

(Ix ix) => Ord (UArray ix (Ptr a))

(Ix ix) => Ord (UArray ix (FunPtr a))

(Ix ix) => Ord (UArray ix Float)

(Ix ix) => Ord (UArray ix Double)

(Ix ix) => Ord (UArray ix Int8)

(Ix ix) => Ord (UArray ix Int16)

(Ix ix) => Ord (UArray ix Int32)

(Ix ix) => Ord (UArray ix Int64)

(Ix ix) => Ord (UArray ix Word8)

(Ix ix) => Ord (UArray ix Word16)

(Ix ix) => Ord (UArray ix Word32)

(Ix ix) => Ord (UArray ix Word64)

(Ord a, Ord b) => Ord (Either a b)

(Ord a) => Ord (Maybe a)

Ord PackedString

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

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

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

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

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

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

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

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

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

(Ord a, Ord b, Ord c, Ord d, Ord e, Ord f, Ord g, Ord h, Ord i, Ord j, Ord k) => Ord (a, b, c, d, e, f, g, h, i, j, k)

(Ord a, Ord b, Ord c, Ord d, Ord e, Ord f, Ord g, Ord h, Ord i, Ord j, Ord k, Ord l) => Ord (a, b, c, d, e, f, g, h, i, j, k, l)

(Ord a, Ord b, Ord c, Ord d, Ord e, Ord f, Ord g, Ord h, Ord i, Ord j, Ord k, Ord l, Ord m) => Ord (a, b, c, d, e, f, g, h, i, j, k, l, m)

(Ord a, Ord b, Ord c, Ord d, Ord e, Ord f, Ord g, Ord h, Ord i, Ord j, Ord k, Ord l, Ord m, Ord n) => Ord (a, b, c, d, e, f, g, h, i, j, k, l, m, n)

(Ord a, Ord b, Ord c, Ord d, Ord e, Ord f, Ord g, Ord h, Ord i, Ord j, Ord k, Ord l, Ord m, Ord n, Ord o) => Ord (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o)

Ord Unique

(Ord a) => Ord (Poly a)

(Ix i, Ord e) => Ord (Array i e)

(Ord a) => Ord [a]

Ord ()

Ord (ForeignPtr a)

Ord (Ptr a)

Ord (FunPtr a)

(Integral a) => Ord (Ratio a)

class Functor f where

The Functor class is used for types that can be mapped over. Instances of Functor should satisfy the following laws:

 fmap id  ==  id
 fmap (f . g)  ==  fmap f . fmap g

The instances of Functor for lists, Maybe and IO defined in the Prelude satisfy these laws.

Methods

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

Instances

Functor (Cont r)

(Monad m) => Functor (ContT r m)

Functor (Either e)

(Monad m) => Functor (ErrorT e m)

Functor Identity

(Monad m) => Functor (ListT m)

Functor (RWS r w s)

(Monad m) => Functor (RWST r w s m)

Functor ((->) r)

Functor (Reader r)

(Monad m) => Functor (ReaderT r m)

Functor (ST s)

Functor (State s)

(Monad m) => Functor (StateT s m)

Functor (Writer w)

(Monad m) => Functor (WriterT w m)

Functor Maybe

Functor Gen

(Ix i) => Functor (Array i)

Functor []

Functor IO

Functor (ST s)

Functor (GenParser tok st)

Functor ReadP

Functor ReadPrec

class Monad m where

The Monad class defines the basic operations over a monad. Instances of Monad should satisfy the following laws:

 return a >>= k  ==  k a
 m >>= return  ==  m
 m >>= (\x -> k x >>= h)  ==  (m >>= k) >>= h

Instances of both Monad and Functor should additionally satisfy the law:

 fmap f xs  ==  xs >>= return . f

The instances of Monad for lists, Maybe and IO defined in the Prelude satisfy these laws.

Methods

(>>=) :: m a -> (a -> m b) -> m b

(>>) :: m a -> m b -> m b

return :: a -> m a

fail :: String -> m a

Instances

(ArrowApply a) => Monad (ArrowMonad a)

Monad (Cont r)

(Monad m) => Monad (ContT r m)

(Error e) => Monad (Either e)

(Monad m, Error e) => Monad (ErrorT e m)

Monad Identity

(Monad m) => Monad (ListT m)

(Monoid w) => Monad (RWS r w s)

(Monoid w, Monad m) => Monad (RWST r w s m)

Monad ((->) r)

Monad (Reader r)

(Monad m) => Monad (ReaderT r m)

Monad (ST s)

Monad (State s)

(Monad m) => Monad (StateT s m)

(Monoid w) => Monad (Writer w)

(Monoid w, Monad m) => Monad (WriterT w m)

Monad Maybe

Monad Gen

Monad []

Monad IO

Monad (ST s)

Monad (GenParser tok st)

Monad P

Monad ReadP

Monad ReadPrec

data [] a

Constructors

[]
(:) a [a]

foldr :: (a -> b -> b) -> b -> [a] -> b

build :: forall a . (forall b . (a -> b -> b) -> b -> b) -> [a]

augment :: forall a . (forall b . (a -> b -> b) -> b -> b) -> [a] -> [a]

map :: (a -> b) -> [a] -> [b]

mapFB :: (elt -> lst -> lst) -> (a -> elt) -> a -> lst -> lst

(++) :: [a] -> [a] -> [a]

data Bool

The Bool type is an enumeration. It is defined with False first so that the corresponding Enum instance will give fromEnum False the value zero, and fromEnum True the value 1.

Constructors

False
True

Instances

IArray UArray Bool

(Ix ix) => Eq (UArray ix Bool)

(Ix ix) => Ord (UArray ix Bool)

(Ix ix, Show ix) => Show (UArray ix Bool)

MArray (STUArray s) Bool (ST s)

MArray IOUArray Bool IO

(&&) :: Bool -> Bool -> Bool

Boolean "and"

(||) :: Bool -> Bool -> Bool

Boolean "or"

not :: Bool -> Bool

Boolean "not"

otherwise :: Bool

otherwise is defined as the value True. It helps to make guards more readable. eg.

  f x | x < 0     = ...
      | otherwise = ...

data ()

The unit datatype () has one non-undefined member, the nullary constructor ().

Constructors

()

data Ordering

Represents an ordering relationship between two values: less than, equal to, or greater than. An Ordering is returned by compare.

Constructors

LT
EQ
GT

Instances

type String = [Char]

A String is a list of characters. String constants in Haskell are values of type String.

data Char

The character type Char is an enumeration whose values represent Unicode characters. A character literal in Haskell has type Char.

To convert a Char to or from an Int, use toEnum and fromEnum from the Enum class respectively (equivalently ord and chr also do the trick).

Constructors

C# Char#

Instances

Error [Char]

IArray UArray Char

(Ix ix) => Eq (UArray ix Char)

(Ix ix) => Ord (UArray ix Char)

(Ix ix, Show ix) => Show (UArray ix Char)

MArray (STUArray s) Char (ST s)

(Ix ix, Show ix) => Show (DiffUArray ix Char)

IArray (IOToDiffArray IOUArray) Char

MArray IOUArray Char IO

CCallable Char

CReturnable Char

chr :: Int -> Char

unsafeChr :: Int -> Char

ord :: Char -> Int

eqString :: String -> String -> Bool

data Int

A fixed-precision integer type with at least the range [-2^29 .. 2^29-1]. The exact range for a given implementation can be determined by using minBound and maxBound from the Bounded class.

Constructors

I# Int#

Instances

IArray UArray Int

(Ix ix) => Eq (UArray ix Int)

(Ix ix) => Ord (UArray ix Int)

(Ix ix, Show ix) => Show (UArray ix Int)

MArray (STUArray s) Int (ST s)

(Ix ix, Show ix) => Show (DiffUArray ix Int)

IArray (IOToDiffArray IOUArray) Int

MArray IOUArray Int IO

Bits Int