GHC.Base

| Haskell Core Libraries (base package) | Parent | Contents | Index
GHC.Base |
Portability | non-portable (GHC extensions)
Stability | internal
Maintainer | cvs-ghc@haskell.org
Description
Basic data types and classes.
Synopsis
data Bool
= False
| True
data Char = C# Char#
class Eq a where
(==) :: a -> a -> Bool
(/=) :: a -> a -> Bool
class Functor f where
fmap :: (a -> b) -> f a -> f b
data Int = I# Int#
class Monad m where
fail :: String -> m a
return :: a -> m a
(>>) :: m a -> m b -> m b
(>>=) :: m a -> (a -> m b) -> m b
class (Eq a) => Ord a where
max :: a -> a -> a
min :: a -> a -> a
(<) :: a -> a -> Bool
(<=) :: a -> a -> Bool
(>) :: a -> a -> Bool
(>=) :: a -> a -> Bool
compare :: a -> a -> Ordering
data Ordering
= LT
| EQ
| GT
type String = [Char]
data Unit = Unit
data () = ()
data [] a
= []
| (:) a [a]
data Char = C# Char#
data Ordering
= LT
| EQ
| GT
data Bool
= False
| True
data Ordering
= LT
| EQ
| GT
data Int = I# Int#
data Ordering
= LT
| EQ
| GT
data Bool
= False
| True
data Unit = Unit
asTypeOf :: a -> a -> a
augment :: forall a . (forall b . (a -> b -> b) -> b -> b) -> [a] -> [a]
build :: forall a . (forall b . (a -> b -> b) -> b -> b) -> [a]
chr :: Int -> Char
class (Eq a) => Ord a where
max :: a -> a -> a
min :: a -> a -> a
(<) :: a -> a -> Bool
(<=) :: a -> a -> Bool
(>) :: a -> a -> Bool
(>=) :: a -> a -> Bool
compare :: a -> a -> Ordering
compareInt :: Int -> Int -> Ordering
compareInt# :: Int# -> Int# -> Ordering
const :: a -> b -> a
divInt :: Int -> Int -> Int
divInt# :: Int# -> Int# -> Int#
eqInt :: Int -> Int -> Bool
eqString :: String -> String -> Bool
class Monad m where
fail :: String -> m a
return :: a -> m a
(>>) :: m a -> m b -> m b
(>>=) :: m a -> (a -> m b) -> m b
flip :: (a -> b -> c) -> b -> a -> c
class Functor f where
fmap :: (a -> b) -> f a -> f b
foldr :: (a -> b -> b) -> b -> [a] -> b
gcdInt :: Int -> Int -> Int
geInt :: Int -> Int -> Bool
gtInt :: Int -> Int -> Bool
iShiftL# :: Int# -> Int# -> Int#
iShiftRA# :: Int# -> Int# -> Int#
iShiftRL# :: Int# -> Int# -> Int#
id :: a -> a
lazy :: a -> a
leInt :: Int -> Int -> Bool
ltInt :: Int -> Int -> Bool
map :: (a -> b) -> [a] -> [b]
mapFB :: (elt -> lst -> lst) -> (a -> elt) -> a -> lst -> lst
class (Eq a) => Ord a where
max :: a -> a -> a
min :: a -> a -> a
(<) :: a -> a -> Bool
(<=) :: a -> a -> Bool
(>) :: a -> a -> Bool
(>=) :: a -> a -> Bool
compare :: a -> a -> Ordering
maxInt :: Int
class (Eq a) => Ord a where
max :: a -> a -> a
min :: a -> a -> a
(<) :: a -> a -> Bool
(<=) :: a -> a -> Bool
(>) :: a -> a -> Bool
(>=) :: a -> a -> Bool
compare :: a -> a -> Ordering
minInt :: Int
minusInt :: Int -> Int -> Int
modInt :: Int -> Int -> Int
modInt# :: Int# -> Int# -> Int#
neInt :: Int -> Int -> Bool
negateInt :: Int -> Int
not :: Bool -> Bool
oneInt :: Int
ord :: Char -> Int
otherwise :: Bool
plusInt :: Int -> Int -> Int
quotInt :: Int -> Int -> Int
remInt :: Int -> Int -> Int
class Monad m where
fail :: String -> m a
return :: a -> m a
(>>) :: m a -> m b -> m b
(>>=) :: m a -> (a -> m b) -> m b
shiftL# :: Word# -> Int# -> Word#
shiftRL# :: Word# -> Int# -> Word#
timesInt :: Int -> Int -> Int
twoInt :: Int
unpackAppendCString# :: Addr# -> [Char] -> [Char]
unpackCString# :: Addr# -> [Char]
unpackCStringUtf8# :: Addr# -> [Char]
unpackFoldrCString# :: Addr# -> (Char -> a -> a) -> a -> a
unpackNBytes# :: Addr# -> Int# -> [Char]
unsafeChr :: Int -> Char
until :: (a -> Bool) -> (a -> a) -> a -> a
zeroInt :: Int
($) :: (a -> b) -> a -> b
(&&) :: Bool -> Bool -> Bool
(++) :: [a] -> [a] -> [a]
(.) :: (b -> c) -> (a -> b) -> a -> c
class Eq a where
(==) :: a -> a -> Bool
(/=) :: a -> a -> Bool
data [] a
= []
| (:) a [a]
class (Eq a) => Ord a where
max :: a -> a -> a
min :: a -> a -> a
(<) :: a -> a -> Bool
(<=) :: a -> a -> Bool
(>) :: a -> a -> Bool
(>=) :: a -> a -> Bool
compare :: a -> a -> Ordering
class (Eq a) => Ord a where
max :: a -> a -> a
min :: a -> a -> a
(<) :: a -> a -> Bool
(<=) :: a -> a -> Bool
(>) :: a -> a -> Bool
(>=) :: a -> a -> Bool
compare :: a -> a -> Ordering
class Eq a where
(==) :: a -> a -> Bool
(/=) :: a -> a -> Bool
class (Eq a) => Ord a where
max :: a -> a -> a
min :: a -> a -> a
(<) :: a -> a -> Bool
(<=) :: a -> a -> Bool
(>) :: a -> a -> Bool
(>=) :: a -> a -> Bool
compare :: a -> a -> Ordering
class (Eq a) => Ord a where
max :: a -> a -> a
min :: a -> a -> a
(<) :: a -> a -> Bool
(<=) :: a -> a -> Bool
(>) :: a -> a -> Bool
(>=) :: a -> a -> Bool
compare :: a -> a -> Ordering
class Monad m where
fail :: String -> m a
return :: a -> m a
(>>) :: m a -> m b -> m b
(>>=) :: m a -> (a -> m b) -> m b
class Monad m where
fail :: String -> m a
return :: a -> m a
(>>) :: m a -> m b -> m b
(>>=) :: m a -> (a -> m b) -> m b
(||) :: Bool -> Bool -> Bool
data () = ()
data [] a
= []
| (:) a [a]
module GHC.Err
Documentation
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
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
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 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
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
class Monad m where
Methods
fail :: String -> m a
return :: a -> m a
(>>) :: m a -> m b -> m b
(>>=) :: m a -> (a -> m b) -> m b
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
class (Eq a) => Ord a where
Methods
max :: a -> a -> a
min :: a -> a -> a
(<) :: a -> a -> Bool
(<=) :: a -> a -> Bool
(>) :: a -> a -> Bool
(>=) :: a -> a -> Bool
compare :: a -> a -> Ordering
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
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 Unit
Constructors
Unit |
data ()
The unit datatype `()` has one non-undefined member, the nullary constructor `()`.
Constructors
() |
data [] a
Constructors
[] |
(:) a [a] |
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# |
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 |
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 |
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 |
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# |
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 |
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 |
data Unit
Constructors
Unit |
asTypeOf :: a -> a -> a
augment :: forall a . (forall b . (a -> b -> b) -> b -> b) -> [a] -> [a]
build :: forall a . (forall b . (a -> b -> b) -> b -> b) -> [a]
chr :: Int -> Char
class (Eq a) => Ord a where
Methods
max :: a -> a -> a
min :: a -> a -> a
(<) :: a -> a -> Bool
(<=) :: a -> a -> Bool
(>) :: a -> a -> Bool
(>=) :: a -> a -> Bool
compare :: a -> a -> Ordering
compareInt :: Int -> Int -> Ordering
compareInt# :: Int# -> Int# -> Ordering
const :: a -> b -> a
divInt :: Int -> Int -> Int
divInt# :: Int# -> Int# -> Int#
eqInt :: Int -> Int -> Bool
eqString :: String -> String -> Bool
class Monad m where
Methods
fail :: String -> m a
return :: a -> m a
(>>) :: m a -> m b -> m b
(>>=) :: m a -> (a -> m b) -> m b
flip :: (a -> b -> c) -> b -> a -> c
class Functor f where
Methods
fmap :: (a -> b) -> f a -> f b
foldr :: (a -> b -> b) -> b -> [a] -> b
gcdInt :: Int -> Int -> Int
geInt :: Int -> Int -> Bool
gtInt :: Int -> Int -> Bool
iShiftL# :: Int# -> Int# -> Int#
iShiftRA# :: Int# -> Int# -> Int#
iShiftRL# :: Int# -> Int# -> Int#
id :: a -> a
lazy :: a -> a
leInt :: Int -> Int -> Bool
ltInt :: Int -> Int -> Bool
map :: (a -> b) -> [a] -> [b]
mapFB :: (elt -> lst -> lst) -> (a -> elt) -> a -> lst -> lst
class (Eq a) => Ord a where
Methods
max :: a -> a -> a
min :: a -> a -> a
(<) :: a -> a -> Bool
(<=) :: a -> a -> Bool
(>) :: a -> a -> Bool
(>=) :: a -> a -> Bool
compare :: a -> a -> Ordering
maxInt :: Int
class (Eq a) => Ord a where
Methods
max :: a -> a -> a
min :: a -> a -> a
(<) :: a -> a -> Bool
(<=) :: a -> a -> Bool
(>) :: a -> a -> Bool
(>=) :: a -> a -> Bool
compare :: a -> a -> Ordering
minInt :: Int
minusInt :: Int -> Int -> Int
modInt :: Int -> Int -> Int
modInt# :: Int# -> Int# -> Int#
neInt :: Int -> Int -> Bool
negateInt :: Int -> Int
not :: Bool -> Bool
Boolean "not"
oneInt :: Int
ord :: Char -> Int
otherwise :: Bool
`otherwise` is defined as the value `True`; it helps to make guards more readable. eg.
      f x | x \< 0     = ...
          | otherwise = ...
plusInt :: Int -> Int -> Int
quotInt :: Int -> Int -> Int
remInt :: Int -> Int -> Int
class Monad m where
Methods
fail :: String -> m a
return :: a -> m a
(>>) :: m a -> m b -> m b
(>>=) :: m a -> (a -> m b) -> m b
shiftL# :: Word# -> Int# -> Word#
shiftRL# :: Word# -> Int# -> Word#
timesInt :: Int -> Int -> Int
twoInt :: Int
unpackAppendCString# :: Addr# -> [Char] -> [Char]
unpackCString# :: Addr# -> [Char]
unpackCStringUtf8# :: Addr# -> [Char]
unpackFoldrCString# :: Addr# -> (Char -> a -> a) -> a -> a
unpackNBytes# :: Addr# -> Int# -> [Char]
unsafeChr :: Int -> Char
until :: (a -> Bool) -> (a -> a) -> a -> a
zeroInt :: Int
($) :: (a -> b) -> a -> b
(&&) :: Bool -> Bool -> Bool
Boolean "and"
(++) :: [a] -> [a] -> [a]
(.) :: (b -> c) -> (a -> b) -> a -> c
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
data [] a
Constructors
[] |
(:) a [a] |
class (Eq a) => Ord a where
Methods
max :: a -> a -> a
min :: a -> a -> a
(<) :: a -> a -> Bool
(<=) :: a -> a -> Bool
(>) :: a -> a -> Bool
(>=) :: a -> a -> Bool
compare :: a -> a -> Ordering
class (Eq a) => Ord a where
Methods
max :: a -> a -> a
min :: a -> a -> a
(<) :: a -> a -> Bool
(<=) :: a -> a -> Bool
(>) :: a -> a -> Bool
(>=) :: a -> a -> Bool
compare :: a -> a -> Ordering
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
class (Eq a) => Ord a where
Methods
max :: a -> a -> a
min :: a -> a -> a
(<) :: a -> a -> Bool
(<=) :: a -> a -> Bool
(>) :: a -> a -> Bool
(>=) :: a -> a -> Bool
compare :: a -> a -> Ordering
class (Eq a) => Ord a where
Methods
max :: a -> a -> a
min :: a -> a -> a
(<) :: a -> a -> Bool
(<=) :: a -> a -> Bool
(>) :: a -> a -> Bool
(>=) :: a -> a -> Bool
compare :: a -> a -> Ordering
class Monad m where
Methods
fail :: String -> m a
return :: a -> m a
(>>) :: m a -> m b -> m b
(>>=) :: m a -> (a -> m b) -> m b
class Monad m where
Methods
fail :: String -> m a
return :: a -> m a
(>>) :: m a -> m b -> m b
(>>=) :: m a -> (a -> m b) -> m b
(||) :: Bool -> Bool -> Bool
Boolean "or"
data ()
The unit datatype `()` has one non-undefined member, the nullary constructor `()`.
Constructors
() |
data [] a
Constructors
[] |
(:) a [a] |
module GHC.Err
Produced by Haddock version 0.3