Haskell Core Libraries (base package)ParentContentsIndex
GHC.Base
Portability non-portable (GHC extensions)
Stability internal
Maintainer cvs-ghc@haskell.org
Description
Basic data types and classes.
Synopsis
class Eq a where
(==) :: a -> a -> Bool
(/=) :: a -> a -> Bool
class (Eq a) => Ord a where
compare :: a -> a -> Ordering
(<) :: a -> a -> Bool
(<=) :: a -> a -> Bool
(>) :: a -> a -> Bool
(>=) :: a -> a -> Bool
max :: a -> a -> a
min :: a -> a -> a
class Functor f where
fmap :: (a -> b) -> f a -> f b
class Monad m where
(>>=) :: m a -> (a -> m b) -> m b
(>>) :: m a -> m b -> m b
return :: a -> m a
fail :: String -> m a
data [] a
= []
| (:) 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
= False
| True
(&&) :: Bool -> Bool -> Bool
(||) :: Bool -> Bool -> Bool
not :: Bool -> Bool
otherwise :: Bool
data () = ()
data Ordering
= LT
| EQ
| GT
type String = [Char]
data Char = C# Char#
chr :: Int -> Char
unsafeChr :: Int -> Char
ord :: Char -> Int
eqString :: String -> String -> Bool
data Int = I# Int#
zeroInt :: Int
oneInt :: Int
twoInt :: Int
maxInt :: Int
minInt :: Int
compareInt :: Int -> Int -> Ordering
compareInt# :: Int# -> Int# -> Ordering
id :: a -> a
lazy :: a -> a
assert :: Bool -> a -> a
const :: a -> b -> a
(.) :: (b -> c) -> (a -> b) -> a -> c
flip :: (a -> b -> c) -> b -> a -> c
($) :: (a -> b) -> a -> b
until :: (a -> Bool) -> (a -> a) -> a -> a
asTypeOf :: a -> a -> a
data Unit = Unit
getTag :: a -> Int#
divInt# :: Int# -> Int# -> Int#
modInt# :: Int# -> Int# -> Int#
plusInt :: Int -> Int -> Int
minusInt :: Int -> Int -> Int
timesInt :: Int -> Int -> Int
quotInt :: Int -> Int -> Int
remInt :: Int -> Int -> Int
divInt :: Int -> Int -> Int
modInt :: Int -> Int -> Int
gcdInt :: Int -> Int -> Int
negateInt :: Int -> Int
gtInt :: Int -> Int -> Bool
geInt :: Int -> Int -> Bool
eqInt :: Int -> Int -> Bool
neInt :: Int -> Int -> Bool
ltInt :: Int -> Int -> Bool
leInt :: Int -> Int -> Bool
shiftL# :: Word# -> Int# -> Word#
shiftRL# :: Word# -> Int# -> Word#
iShiftL# :: Int# -> Int# -> Int#
iShiftRA# :: Int# -> Int# -> Int#
iShiftRL# :: Int# -> Int# -> Int#
unpackCString# :: Addr# -> [Char]
unpackAppendCString# :: Addr# -> [Char] -> [Char]
unpackFoldrCString# :: Addr# -> (Char -> a -> a) -> a -> a
unpackCStringUtf8# :: Addr# -> [Char]
unpackNBytes# :: Addr# -> Int# -> [Char]
module GHC.Err
Documentation
class Eq a where

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 TypeRep
Eq TyCon
Eq Key
Eq KeyPr
(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 ALPHA_
Eq BETA_
Eq GAMMA_
Eq OrdALPHA_
Eq OrdBETA_
Eq OrdGAMMA_
Eq Errno
Eq CChar
Eq CSChar
Eq CUChar
Eq CShort
Eq CUShort
Eq CInt
Eq CUInt
Eq CLong
Eq CULong
Eq CLLong
Eq CULLong
Eq CFloat
Eq CDouble
Eq CLDouble
Eq CPtrdiff
Eq CSize
Eq CWchar
Eq CSigAtomic
Eq CClock
Eq CTime
Eq (STArray s i e)
(Ix i, Eq e) => Eq (Array i e)
(Eq a) => Eq [a]
Eq ()
Eq Char
Eq Int
Eq Bool
Eq Ordering
Eq Float
Eq Double
Eq (ForeignPtr a)
Eq HandlePosn
Eq IOModeEx
Eq SeekMode
Eq (MVar a)
Eq Handle
Eq (IORef a)
Eq (IOArray i e)
Eq Exception
Eq IOException
Eq IOErrorType
Eq BufferState
Eq BufferMode
Eq ArithException
Eq AsyncException
Eq ArrayException
Eq ExitCode
Eq IOMode
Eq Int64
Eq Int8
Eq Int16
Eq Int32
Eq Integer
Eq (Ptr a)
Eq (FunPtr a)
(Integral a, Eq a) => Eq (Ratio a)
Eq (STRef s a)
Eq (StablePtr a)
Eq Word64
Eq Word
Eq Word8
Eq Word16
Eq Word32
Eq Permissions
Eq TimeLocale
Eq (StableName a)
Eq FDType
Eq CDev
Eq CIno
Eq CMode
Eq COff
Eq CPid
Eq CSsize
Eq CGid
Eq CNlink
Eq CUid
Eq CCc
Eq CSpeed
Eq CTcflag
Eq CRLim
Eq Fd
Eq Month
Eq Day
Eq ClockTime
Eq CalendarTime
Eq TimeDiff
Eq Lexeme
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)
Ord OrdALPHA_
Ord OrdBETA_
Ord OrdGAMMA_
Ord CChar
Ord CSChar
Ord CUChar
Ord CShort
Ord CUShort
Ord CInt
Ord CUInt
Ord CLong
Ord CULong
Ord CLLong
Ord CULLong
Ord CFloat
Ord CDouble
Ord CLDouble
Ord CPtrdiff
Ord CSize
Ord CWchar
Ord CSigAtomic
Ord CClock
Ord CTime
(Ix i, Ord e) => Ord (Array i e)
(Ord a) => Ord [a]
Ord ()
Ord Char
Ord Int
Ord Bool
Ord Ordering
Ord Float
Ord Double
Ord (ForeignPtr a)
Ord SeekMode
Ord BufferMode
Ord ArithException
Ord AsyncException
Ord ArrayException
Ord ExitCode
Ord IOMode
Ord Int64
Ord Int8
Ord Int16
Ord Int32
Ord Integer
Ord (Ptr a)
Ord (FunPtr a)
(Integral a) => Ord (Ratio a)
Ord Word64
Ord Word
Ord Word8
Ord Word16
Ord Word32
Ord Permissions
Ord TimeLocale
Ord CDev
Ord CIno
Ord CMode
Ord COff
Ord CPid
Ord CSsize
Ord CGid
Ord CNlink
Ord CUid
Ord CCc
Ord CSpeed
Ord CTcflag
Ord CRLim
Ord Fd
Ord Month
Ord Day
Ord ClockTime
Ord CalendarTime
Ord TimeDiff
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
Typeable Bool
Arbitrary Bool
Testable Bool
Storable Bool
Ix Bool
Eq Bool
Ord Bool
Bounded Bool
Enum Bool
Read Bool
Show Bool
Random Bool
(&&) :: 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
Typeable Ordering
Ix Ordering
Eq Ordering
Ord Ordering
Bounded Ordering
Enum Ordering
Read Ordering
Show Ordering
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
Typeable Char
Storable Char
Ix Char
Eq Char
Ord Char
CCallable Char
CReturnable Char
Bounded Char
Enum Char
Read Char
Show Char
Random Char
HTML 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
Typeable Int
Arbitrary Int
Storable Int
Ix Int
Eq Int
Ord Int
CCallable Int
CReturnable Int
Bounded Int
Enum Int
Num Int
Read Int
Real Int
Integral Int
Show Int
Random Int
zeroInt :: Int
oneInt :: Int
twoInt :: Int
maxInt :: Int
minInt :: Int
compareInt :: Int -> Int -> Ordering
compareInt# :: Int# -> Int# -> Ordering
id :: a -> a
lazy :: a -> a
assert :: Bool -> a -> a
const :: a -> b -> a
(.) :: (b -> c) -> (a -> b) -> a -> c
flip :: (a -> b -> c) -> b -> a -> c
($) :: (a -> b) -> a -> b
until :: (a -> Bool) -> (a -> a) -> a -> a
asTypeOf :: a -> a -> a
data Unit
Constructors
Unit
getTag :: a -> Int#
divInt# :: Int# -> Int# -> Int#
modInt# :: Int# -> Int# -> Int#
plusInt :: Int -> Int -> Int
minusInt :: Int -> Int -> Int
timesInt :: Int -> Int -> Int
quotInt :: Int -> Int -> Int
remInt :: Int -> Int -> Int
divInt :: Int -> Int -> Int
modInt :: Int -> Int -> Int
gcdInt :: Int -> Int -> Int
negateInt :: Int -> Int
gtInt :: Int -> Int -> Bool
geInt :: Int -> Int -> Bool
eqInt :: Int -> Int -> Bool
neInt :: Int -> Int -> Bool
ltInt :: Int -> Int -> Bool
leInt :: Int -> Int -> Bool
shiftL# :: Word# -> Int# -> Word#
shiftRL# :: Word# -> Int# -> Word#
iShiftL# :: Int# -> Int# -> Int#
iShiftRA# :: Int# -> Int# -> Int#
iShiftRL# :: Int# -> Int# -> Int#
unpackCString# :: Addr# -> [Char]
unpackAppendCString# :: Addr# -> [Char] -> [Char]
unpackFoldrCString# :: Addr# -> (Char -> a -> a) -> a -> a
unpackCStringUtf8# :: Addr# -> [Char]
unpackNBytes# :: Addr# -> Int# -> [Char]
module GHC.Err
Produced by Haddock version 0.4