|
GHC.Base | Portability | non-portable (GHC extensions) | Stability | internal | Maintainer | cvs-ghc@haskell.org |
|
|
|
|
|
Description |
Basic data types and classes.
|
|
Synopsis |
|
|
|
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 | |
|
|
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 | |
|
|
data [] 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 | | Instances | |
|
|
(&&) :: 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 | | 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 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 | | Instances | |
|
|
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 | | Instances | |
|
|
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 |
|
|
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 |