GHC.Base

| Haskell Hierarchical Libraries (base package) | Contents | Index
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]
data RealWorld
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 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 TypeRep
Eq TyCon
Eq Key
Eq KeyPr
Eq Unique
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 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 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
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 Maybe
Monad []
Monad IO
Monad (ST s)
Monad P
Monad ReadP
Monad ReadPrec
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
Data Bool
Typeable 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 (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
Data Char
Typeable Char
Storable Char
Ix Char
Eq Char
Ord Char
Bounded Char
Enum Char
Read Char
Show Char
Random Char
HTML Char
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
Data Int
Typeable Int
Storable Int
Ix Int
Eq Int
Ord 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]
data RealWorld
A special argument for the `ST` type constructor, indexing a state embedded in the `IO` monad by `stToIO`.
module GHC.Err
Produced by Haddock version 0.6