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 Constr

Eq Fixity

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

(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

Ix i => Functor (Array i)

Functor []

Functor IO

Functor (ST s)

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 []

Monad (ST s)

data [] a

Constructors

[]
(:) a [a]

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

foldr, applied to a binary operator, a starting value (typically the right-identity of the operator), and a list, reduces the list using the binary operator, from right to left:

 foldr f z [x1, x2, ..., xn] == x1 `f` (x2 `f` ... (xn `f` z)...)

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]

map f xs is the list obtained by applying f to each element of xs, i.e.,

 map f [x1, x2, ..., xn] == [f x1, f x2, ..., f xn]
 map f [x1, x2, ...] == [f x1, f x2, ...]

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

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

Append two lists, i.e.,

 [x1, ..., xm] ++ [y1, ..., yn] == [x1, ..., xm, y1, ..., yn]
 [x1, ..., xm] ++ [y1, ...] == [x1, ..., xm, y1, ...]

If the first list is not finite, the result is the first list.

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 (or equivalently ISO 10646) characters. This set extends the ISO 8859-1 (Latin-1) character set (the first 256 charachers), which is itself an extension of the ASCII character set (the first 128 characters). A character literal in Haskell has type Char.

To convert a Char to or from the corresponding Int value defined by Unicode, use toEnum and fromEnum from the Enum class respectively (or equivalently ord and chr).

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

chr :: Int -> Char

The toEnum method restricted to the type Char.

unsafeChr :: Int -> Char

ord :: Char -> Int

The fromEnum method restricted to the type Char.

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