Google

>
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
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
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)
Eq TyCon
(Eq key, Eq elt) => Eq (FiniteMap key elt)
Eq PackedString
(Eq a) => Eq (Set a)
(Eq a) => Eq (Poly a)
Eq Errno
Eq (ForeignPtr a)
Eq (STArray s i e)
(Ix i, Eq e) => Eq (Array i e)
(Eq a) => Eq [a]
Eq ()
Eq Char
Eq Int
Eq Float
Eq Double
Eq HandlePosn
Eq (MVar a)
Eq Handle
Eq Exception
Eq IOException
Eq IOErrorType
Eq Int64
Eq Integer
Eq (STRef s a)
Eq (StablePtr a)
Eq Word64
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 PackedString
(Ord a) => Ord (Poly a)
(Ix i, Ord e) => Ord (Array i e)
(Ord a) => Ord [a]
Ord ()
Ord Char
Ord Int
Ord Float
Ord Double
Ord Int64
Ord Integer
(Integral a) => Ord (Ratio a)
Ord Word64
class Functor f where
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
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 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
Ix Bool
Bounded Bool
Enum Bool
Read Bool
Show Bool
Storable 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
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
Ix Char
Eq Char
Ord Char
CCallable Char
CReturnable Char
Bounded Char
Enum Char
Read Char
Show Char
Storable 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
Ix Int
Eq Int
Ord Int
CCallable Int
CReturnable Int
Bounded Int
Enum Int
Num Int
Read Int
Real Int
Integral Int
Show Int
Storable 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
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
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