Haskell Core Libraries (base package)ContentsIndex
Prelude
Portability portable
Stability provisional
Maintainer libraries@haskell.org
Contents
Basic data types
Basic type classes
List operations
Converting to and from String
Simple I/O operations
Monads
Miscellaneous functions
Description
The Prelude: a standard module imported by default into all Haskell modules. For more documentation, see the Haskell 98 Report http://www.haskell.org/onlinereport/.
Synopsis
data Bool
= False
| True
data Maybe a
= Nothing
| Just a
data Either a b
= Left a
| Right b
data Ordering
= LT
| EQ
| GT
data Char
type String = [Char]
data Int
data Integer
data Float
data Double
data IO a
type Rational = Ratio Integer
[]
module Data.Tuple
()
->
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 Enum a where
succ :: a -> a
pred :: a -> a
toEnum :: Int -> a
fromEnum :: a -> Int
enumFrom :: a -> [a]
enumFromThen :: a -> a -> [a]
enumFromTo :: a -> a -> [a]
enumFromThenTo :: a -> a -> a -> [a]
class Bounded a where
minBound :: a
maxBound :: a
class (Eq a, Show a) => Num a where
(+) :: a -> a -> a
(-) :: a -> a -> a
(*) :: a -> a -> a
negate :: a -> a
abs :: a -> a
signum :: a -> a
fromInteger :: Integer -> a
class (Num a, Ord a) => Real a where
toRational :: a -> Rational
class (Real a, Enum a) => Integral a where
quot :: a -> a -> a
rem :: a -> a -> a
div :: a -> a -> a
mod :: a -> a -> a
quotRem :: a -> a -> (a, a)
divMod :: a -> a -> (a, a)
toInteger :: a -> Integer
class Num a => Fractional a where
(/) :: a -> a -> a
recip :: a -> a
fromRational :: Rational -> a
class Fractional a => Floating a where
pi :: a
exp :: a -> a
log :: a -> a
sqrt :: a -> a
(**) :: a -> a -> a
logBase :: a -> a -> a
sin :: a -> a
cos :: a -> a
tan :: a -> a
asin :: a -> a
acos :: a -> a
atan :: a -> a
sinh :: a -> a
cosh :: a -> a
tanh :: a -> a
asinh :: a -> a
acosh :: a -> a
atanh :: a -> a
class (Real a, Fractional a) => RealFrac a where
properFraction :: Integral b => a -> (b, a)
truncate :: Integral b => a -> b
round :: Integral b => a -> b
ceiling :: Integral b => a -> b
floor :: Integral b => a -> b
class (RealFrac a, Floating a) => RealFloat a where
floatRadix :: a -> Integer
floatDigits :: a -> Int
floatRange :: a -> (Int, Int)
decodeFloat :: a -> (Integer, Int)
encodeFloat :: Integer -> Int -> a
exponent :: a -> Int
significand :: a -> a
scaleFloat :: Int -> a -> a
isNaN :: a -> Bool
isInfinite :: a -> Bool
isDenormalized :: a -> Bool
isNegativeZero :: a -> Bool
isIEEE :: a -> Bool
atan2 :: a -> a -> a
map :: (a -> b) -> [a] -> [b]
(++) :: [a] -> [a] -> [a]
filter :: (a -> Bool) -> [a] -> [a]
concat :: [[a]] -> [a]
head :: [a] -> a
last :: [a] -> a
tail :: [a] -> [a]
init :: [a] -> [a]
null :: [a] -> Bool
length :: [a] -> Int
(!!) :: [a] -> Int -> a
foldl :: (a -> b -> a) -> a -> [b] -> a
foldl1 :: (a -> a -> a) -> [a] -> a
scanl :: (a -> b -> a) -> a -> [b] -> [a]
scanl1 :: (a -> a -> a) -> [a] -> [a]
foldr :: (a -> b -> b) -> b -> [a] -> b
foldr1 :: (a -> a -> a) -> [a] -> a
scanr :: (a -> b -> b) -> b -> [a] -> [b]
scanr1 :: (a -> a -> a) -> [a] -> [a]
iterate :: (a -> a) -> a -> [a]
repeat :: a -> [a]
replicate :: Int -> a -> [a]
cycle :: [a] -> [a]
take :: Int -> [b] -> [b]
drop :: Int -> [b] -> [b]
splitAt :: Int -> [b] -> ([b], [b])
takeWhile :: (a -> Bool) -> [a] -> [a]
dropWhile :: (a -> Bool) -> [a] -> [a]
span :: (a -> Bool) -> [a] -> ([a], [a])
break :: (a -> Bool) -> [a] -> ([a], [a])
reverse :: [a] -> [a]
and :: [Bool] -> Bool
or :: [Bool] -> Bool
any :: (a -> Bool) -> [a] -> Bool
all :: (a -> Bool) -> [a] -> Bool
elem :: Eq a => a -> [a] -> Bool
notElem :: Eq a => a -> [a] -> Bool
lookup :: Eq a => a -> [(a, b)] -> Maybe b
maximum :: Ord a => [a] -> a
minimum :: Ord a => [a] -> a
concatMap :: (a -> [b]) -> [a] -> [b]
zip :: [a] -> [b] -> [(a, b)]
zip3 :: [a] -> [b] -> [c] -> [(a, b, c)]
zipWith :: (a -> b -> c) -> [a] -> [b] -> [c]
zipWith3 :: (a -> b -> c -> d) -> [a] -> [b] -> [c] -> [d]
unzip :: [(a, b)] -> ([a], [b])
unzip3 :: [(a, b, c)] -> ([a], [b], [c])
lines :: String -> [String]
words :: String -> [String]
unlines :: [String] -> String
unwords :: [String] -> String
sum :: Num a => [a] -> a
product :: Num a => [a] -> a
type ReadS a = String -> [(a, String)]
type ShowS = String -> String
class Read a where
readsPrec :: Int -> ReadS a
readList :: ReadS [a]
class Show a where
showsPrec :: Int -> a -> ShowS
show :: a -> String
showList :: [a] -> ShowS
reads :: Read a => ReadS a
shows :: Show a => a -> ShowS
read :: Read a => String -> a
lex :: ReadS String
showChar :: Char -> ShowS
showString :: String -> ShowS
readParen :: Bool -> ReadS a -> ReadS a
showParen :: Bool -> ShowS -> ShowS
ioError :: Exception -> IO a
userError :: String -> IOError
catch :: IO a -> (Exception -> IO a) -> IO a
type FilePath = String
type IOError = Exception
putChar :: Char -> IO ()
putStr :: String -> IO ()
putStrLn :: String -> IO ()
print :: Show a => a -> IO ()
getChar :: IO Char
getLine :: IO String
getContents :: IO String
interact :: (String -> String) -> IO ()
readFile :: FilePath -> IO String
writeFile :: FilePath -> String -> IO ()
appendFile :: FilePath -> String -> IO ()
readIO :: Read a => String -> IO a
readLn :: Read a => IO a
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
class Functor f where
fmap :: (a -> b) -> f a -> f b
mapM :: Monad m => (a -> m b) -> [a] -> m [b]
mapM_ :: Monad m => (a -> m b) -> [a] -> m ()
sequence :: Monad m => [m a] -> m [a]
sequence_ :: Monad m => [m a] -> m ()
(=<<) :: Monad m => (a -> m b) -> m a -> m b
maybe :: b -> (a -> b) -> Maybe a -> b
either :: (a -> c) -> (b -> c) -> Either a b -> c
(&&) :: Bool -> Bool -> Bool
(||) :: Bool -> Bool -> Bool
not :: Bool -> Bool
otherwise :: Bool
subtract :: Num a => a -> a -> a
even :: Integral a => a -> Bool
odd :: Integral a => a -> Bool
gcd :: Integral a => a -> a -> a
lcm :: Integral a => a -> a -> a
(^) :: (Num a, Integral b) => a -> b -> a
(^^) :: (Fractional a, Integral b) => a -> b -> a
fromIntegral :: (Integral a, Num b) => a -> b
realToFrac :: (Real a, Fractional b) => a -> b
id :: 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
error :: String -> a
undefined :: a
($!) :: (a -> b) -> a -> b
Basic data types
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
Eq Bool
Ord Bool
Bounded Bool
Enum Bool
Read Bool
Show Bool
Storable Bool
Random Bool
data Maybe a

The Maybe type encapsulates an optional value. A value of type Maybe a either contains a value of type a (represented as Just a), or it is empty (represented as Nothing). Using Maybe is a good way to deal with errors or exceptional cases without resorting to drastic measures such as error.

The Maybe type is also a monad. It is a simple kind of error monad, where all errors are represented by Nothing. A richer error monad can be built using the Either type.

Constructors
Nothing
Just a
Instances
MonadPlus Maybe
MonadFix Maybe
Typeable a => Typeable (Maybe a)
Functor Maybe
Monad Maybe
Eq a => Eq (Maybe a)
Ord a => Ord (Maybe a)
Read a => Read (Maybe a)
Show a => Show (Maybe a)
data Either a b

The Either type represents values with two possibilities: a value of type Either a b is either Left a or Right b.

The Either type is sometimes used to represent a value which is either correct or an error; by convention, the Left constructor is used to hold an error value and the Right constructor is used to hold a correct value (mnemonic: "right" also means "correct").

Constructors
Left a
Right b
Instances
Functor (Either e)
Error e => Monad (Either e)
Error e => MonadPlus (Either e)
Error e => MonadFix (Either e)
Error e => MonadError e (Either e)
(Typeable a, Typeable b) => Typeable (Either a b)
(Eq a, Eq b) => Eq (Either a b)
(Ord a, Ord b) => Ord (Either a b)
(Read a, Read b) => Read (Either a b)
(Show a, Show b) => Show (Either a b)
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
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).

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
type String = [Char]
A String is a list of characters. String constants in Haskell are values of type String.
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.
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
data Integer
Arbitrary-precision integers.
Instances
Bits Integer
Typeable Integer
Arbitrary Integer
Ix Integer
Eq Integer
Ord Integer
Num Integer
Enum Integer
Show Integer
Read Integer
Real Integer
Integral Integer
Random Integer
data Float
Single-precision floating point numbers.
Instances
IArray UArray Float
Ix ix => Eq (UArray ix Float)
Ix ix => Ord (UArray ix Float)
(Ix ix, Show ix) => Show (UArray ix Float)
MArray (STUArray s) Float (ST s)
(Ix ix, Show ix) => Show (DiffUArray ix Float)
IArray (IOToDiffArray IOUArray) Float
MArray IOUArray Float IO
Typeable Float
Arbitrary Float
CCallable Float
CReturnable Float
Eq Float
Ord Float
Num Float
Real Float
Fractional Float
RealFrac Float
Floating Float
RealFloat Float
Show Float
Enum Float
Read Float
Storable Float
Random Float
data Double
Double-precision floating point numbers.
Instances
IArray UArray Double
Ix ix => Eq (UArray ix Double)
Ix ix => Ord (UArray ix Double)
(Ix ix, Show ix) => Show (UArray ix Double)
MArray (STUArray s) Double (ST s)
(Ix ix, Show ix) => Show (DiffUArray ix Double)
IArray (IOToDiffArray IOUArray) Double
MArray IOUArray Double IO
Typeable Double
Arbitrary Double
CCallable Double
CReturnable Double
Eq Double
Ord Double
Num Double
Real Double
Fractional Double
Floating Double
RealFrac Double
RealFloat Double
Show Double
Enum Double
Read Double
Storable Double
Random Double
data IO a

A value of type IO a is a computation which, when performed, does some I/O before returning a value of type a.

There is really only one way to "perform" an I/O action: bind it to Main.main in your program. When your program is run, the I/O will be performed. It isn't possible to perform I/O from an arbitrary function, unless that function is itself in the IO monad and called at some point, directly or indirectly, from Main.main.

IO is a monad, so IO actions can be combined using either the do-notation or the >> and >>= operations from the Monad class.

Instances
MonadPlus IO
MonadError IOError IO
MonadFix IO
MonadIO IO
MArray IOArray e IO
MArray IOUArray Bool IO
MArray IOUArray Char IO
MArray IOUArray Int IO
MArray IOUArray Word IO
MArray IOUArray (Ptr a) IO
MArray IOUArray (FunPtr a) IO
MArray IOUArray Float IO
MArray IOUArray Double IO
MArray IOUArray (StablePtr a) IO
MArray IOUArray Int8 IO
MArray IOUArray Int16 IO
MArray IOUArray Int32 IO
MArray IOUArray Int64 IO
MArray IOUArray Word8 IO
MArray IOUArray Word16 IO
MArray IOUArray Word32 IO
MArray IOUArray Word64 IO
Storable e => MArray StorableArray e IO
Typeable a => Typeable (IO a)
Functor IO
Monad IO
type Rational = Ratio Integer
Arbitrary-precision rational numbers, represented as a ratio of two Integer values. A rational number may be constructed using the % operator.
[]
module Data.Tuple
()
->
Basic type classes
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)
??? e i => Eq (IOArray i e)
??? e i => Eq (IOUArray i e)
(RealFloat a, Eq a) => Eq (Complex a)
Eq TyCon
Eq TypeRep
(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 (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 Bool
Eq Ordering
Eq Float
Eq Double
Eq HandlePosn
Eq IOMode
Eq IOModeEx
Eq SeekMode
Eq (MVar a)
Eq Handle
Eq Exception
Eq IOException
Eq IOErrorType
Eq BufferState
Eq BufferMode
??? a => Eq (IORef a)
Eq ArithException
Eq AsyncException
Eq ArrayException
Eq ExitCode
Eq Int64
Eq Int8
Eq Int16
Eq Int32
Eq Integer
Eq FDType
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 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 IOMode
Ord SeekMode
Ord BufferMode
Ord ArithException
Ord AsyncException
Ord ArrayException
Ord ExitCode
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 Month
Ord Day
Ord ClockTime
Ord CalendarTime
Ord TimeDiff
class Enum a where
Methods
succ :: a -> a
pred :: a -> a
toEnum :: Int -> a
fromEnum :: a -> Int
enumFrom :: a -> [a]
enumFromThen :: a -> a -> [a]
enumFromTo :: a -> a -> [a]
enumFromThenTo :: a -> a -> a -> [a]
Instances
Enum CChar
Enum CSChar
Enum CUChar
Enum CShort
Enum CUShort
Enum CInt
Enum CUInt
Enum CLong
Enum CULong
Enum CLLong
Enum CULLong
Enum CFloat
Enum CDouble
Enum CLDouble
Enum CPtrdiff
Enum CSize
Enum CWchar
Enum CSigAtomic
Enum CClock
Enum CTime
Enum ()
Enum Bool
Enum Ordering
Enum Char
Enum Int
Enum Float
Enum Double
Enum IOMode
Enum SeekMode
Enum Int8
Enum Int16
Enum Int32
Enum Int64
Enum Integer
Integral a => Enum (Ratio a)
Enum Word
Enum Word8
Enum Word16
Enum Word32
Enum Word64
Enum Month
Enum Day
class Bounded a where
Methods
minBound :: a
maxBound :: a
Instances
Bounded CChar
Bounded CSChar
Bounded CUChar
Bounded CShort
Bounded CUShort
Bounded CInt
Bounded CUInt
Bounded CLong
Bounded CULong
Bounded CLLong
Bounded CULLong
Bounded CPtrdiff
Bounded CSize
Bounded CWchar
Bounded CSigAtomic
Bounded CClock
Bounded CTime
Bounded ()
(Bounded a, Bounded b) => Bounded (a, b)
(Bounded a, Bounded b, Bounded c) => Bounded (a, b, c)
(Bounded a, Bounded b, Bounded c, Bounded d) => Bounded (a, b, c, d)
Bounded Bool
Bounded Ordering
Bounded Char
Bounded Int
Bounded Int8
Bounded Int16
Bounded Int32
Bounded Int64
Bounded Word
Bounded Word8
Bounded Word16
Bounded Word32
Bounded Word64
Bounded Month
Bounded Day
class (Eq a, Show a) => Num a where
Methods
(+) :: a -> a -> a
(-) :: a -> a -> a
(*) :: a -> a -> a
negate :: a -> a
abs :: a -> a
signum :: a -> a
fromInteger :: Integer -> a
Instances
RealFloat a => Num (Complex a)
Num CChar
Num CSChar
Num CUChar
Num CShort
Num CUShort
Num CInt
Num CUInt
Num CLong
Num CULong
Num CLLong
Num CULLong
Num CFloat
Num CDouble
Num CLDouble
Num CPtrdiff
Num CSize
Num CWchar
Num CSigAtomic
Num CClock
Num CTime
Num Float
Num Double
Num Int8
Num Int16
Num Int32
Num Int64
Num Int
Num Integer
Integral a => Num (Ratio a)
Num Word
Num Word8
Num Word16
Num Word32
Num Word64
class (Num a, Ord a) => Real a where
Methods
toRational :: a -> Rational
Instances
Real CChar
Real CSChar
Real CUChar
Real CShort
Real CUShort
Real CInt
Real CUInt
Real CLong
Real CULong
Real CLLong
Real CULLong
Real CFloat
Real CDouble
Real CLDouble
Real CPtrdiff
Real CSize
Real CWchar
Real CSigAtomic
Real CClock
Real CTime
Real Float
Real Double
Real Int8
Real Int16
Real Int32
Real Int64
Real Int
Real Integer
Integral a => Real (Ratio a)
Real Word
Real Word8
Real Word16
Real Word32
Real Word64
class (Real a, Enum a) => Integral a where
Methods
quot :: a -> a -> a
rem :: a -> a -> a
div :: a -> a -> a
mod :: a -> a -> a
quotRem :: a -> a -> (a, a)
divMod :: a -> a -> (a, a)
toInteger :: a -> Integer
Instances
Integral CChar
Integral CSChar
Integral CUChar
Integral CShort
Integral CUShort
Integral CInt
Integral CUInt
Integral CLong
Integral CULong
Integral CLLong
Integral CULLong
Integral CPtrdiff
Integral CSize
Integral CWchar
Integral CSigAtomic
Integral CClock
Integral CTime
Integral Int8
Integral Int16
Integral Int32
Integral Int64
Integral Int
Integral Integer
Integral Word
Integral Word8
Integral Word16
Integral Word32
Integral Word64
class Num a => Fractional a where
Methods
(/) :: a -> a -> a
recip :: a -> a
fromRational :: Rational -> a
Instances
RealFloat a => Fractional (Complex a)
Fractional CFloat
Fractional CDouble
Fractional CLDouble
Fractional Float
Fractional Double
Integral a => Fractional (Ratio a)
class Fractional a => Floating a where
Methods
pi :: a
exp :: a -> a
log :: a -> a
sqrt :: a -> a
(**) :: a -> a -> a
logBase :: a -> a -> a
sin :: a -> a
cos :: a -> a
tan :: a -> a
asin :: a -> a
acos :: a -> a
atan :: a -> a
sinh :: a -> a
cosh :: a -> a
tanh :: a -> a
asinh :: a -> a
acosh :: a -> a
atanh :: a -> a
Instances
RealFloat a => Floating (Complex a)
Floating CFloat
Floating CDouble
Floating CLDouble
Floating Float
Floating Double
class (Real a, Fractional a) => RealFrac a where
Methods
properFraction :: Integral b => a -> (b, a)
truncate :: Integral b => a -> b
round :: Integral b => a -> b
ceiling :: Integral b => a -> b
floor :: Integral b => a -> b
Instances
RealFrac CFloat
RealFrac CDouble
RealFrac CLDouble
RealFrac Float
RealFrac Double
Integral a => RealFrac (Ratio a)
class (RealFrac a, Floating a) => RealFloat a where
Methods
floatRadix :: a -> Integer
floatDigits :: a -> Int
floatRange :: a -> (Int, Int)
decodeFloat :: a -> (Integer, Int)
encodeFloat :: Integer -> Int -> a
exponent :: a -> Int
significand :: a -> a
scaleFloat :: Int -> a -> a
isNaN :: a -> Bool
isInfinite :: a -> Bool
isDenormalized :: a -> Bool
isNegativeZero :: a -> Bool
isIEEE :: a -> Bool
atan2 :: a -> a -> a
Instances
RealFloat CFloat
RealFloat CDouble
RealFloat CLDouble
RealFloat Float
RealFloat Double
List operations
map :: (a -> b) -> [a] -> [b]
(++) :: [a] -> [a] -> [a]
filter :: (a -> Bool) -> [a] -> [a]
concat :: [[a]] -> [a]
head :: [a] -> a
last :: [a] -> a
tail :: [a] -> [a]
init :: [a] -> [a]
null :: [a] -> Bool
length :: [a] -> Int
(!!) :: [a] -> Int -> a
foldl :: (a -> b -> a) -> a -> [b] -> a
foldl1 :: (a -> a -> a) -> [a] -> a
scanl :: (a -> b -> a) -> a -> [b] -> [a]
scanl1 :: (a -> a -> a) -> [a] -> [a]
foldr :: (a -> b -> b) -> b -> [a] -> b
foldr1 :: (a -> a -> a) -> [a] -> a
scanr :: (a -> b -> b) -> b -> [a] -> [b]
scanr1 :: (a -> a -> a) -> [a] -> [a]
iterate :: (a -> a) -> a -> [a]
repeat :: a -> [a]
replicate :: Int -> a -> [a]
cycle :: [a] -> [a]
take :: Int -> [b] -> [b]
drop :: Int -> [b] -> [b]
splitAt :: Int -> [b] -> ([b], [b])
takeWhile :: (a -> Bool) -> [a] -> [a]
dropWhile :: (a -> Bool) -> [a] -> [a]
span :: (a -> Bool) -> [a] -> ([a], [a])
break :: (a -> Bool) -> [a] -> ([a], [a])
reverse :: [a] -> [a]
and :: [Bool] -> Bool
or :: [Bool] -> Bool
any :: (a -> Bool) -> [a] -> Bool
all :: (a -> Bool) -> [a] -> Bool
elem :: Eq a => a -> [a] -> Bool
notElem :: Eq a => a -> [a] -> Bool
lookup :: Eq a => a -> [(a, b)] -> Maybe b
maximum :: Ord a => [a] -> a
minimum :: Ord a => [a] -> a
concatMap :: (a -> [b]) -> [a] -> [b]
zip :: [a] -> [b] -> [(a, b)]
zip3 :: [a] -> [b] -> [c] -> [(a, b, c)]
zipWith :: (a -> b -> c) -> [a] -> [b] -> [c]
zipWith3 :: (a -> b -> c -> d) -> [a] -> [b] -> [c] -> [d]
unzip :: [(a, b)] -> ([a], [b])
unzip3 :: [(a, b, c)] -> ([a], [b], [c])
lines :: String -> [String]
words :: String -> [String]
unlines :: [String] -> String
unwords :: [String] -> String
sum :: Num a => [a] -> a
product :: Num a => [a] -> a
Converting to and from String
type ReadS a = String -> [(a, String)]
A parser for a type a, represented as a function that takes a String and returns a list of possible parses (a,String) pairs.
type ShowS = String -> String
class Read a where
Methods
readsPrec :: Int -> ReadS a
readList :: ReadS [a]
Instances
(RealFloat a, Read a) => Read (Complex a)
Read CChar
Read CSChar
Read CUChar
Read CShort
Read CUShort
Read CInt
Read CUInt
Read CLong
Read CULong
Read CLLong
Read CULLong
Read CFloat
Read CDouble
Read CLDouble
Read CPtrdiff
Read CSize
Read CWchar
Read CSigAtomic
Read CClock
Read CTime
Read IOMode
Read IOModeEx
Read SeekMode
Read BufferMode
Read ExitCode
Read Int8
Read Int16
Read Int32
Read Int64
Read Char
Read Bool
Read Ordering
Read a => Read (Maybe a)
(Read a, Read b) => Read (Either a b)
Read a => Read [a]
(Ix a, Read a, Read b) => Read (Array a b)
Read Lexeme
Read Int
Read Integer
Read Float
Read Double
(Integral a, Read a) => Read (Ratio a)
Read ()
(Read a, Read b) => Read (a, b)
(Read a, Read b, Read c) => Read (a, b, c)
(Read a, Read b, Read c, Read d) => Read (a, b, c, d)
(Read a, Read b, Read c, Read d, Read e) => Read (a, b, c, d, e)
Read Word
Read Word8
Read Word16
Read Word32
Read Word64
Read Permissions
Read StdGen
Read Month
Read Day
Read CalendarTime
Read TimeDiff
class Show a where
Methods
showsPrec :: Int -> a -> ShowS
show :: a -> String
showList :: [a] -> ShowS
Instances
Show ThreadId
(Ix ix, Show ix) => Show (UArray ix Bool)
(Ix ix, Show ix) => Show (UArray ix Char)
(Ix ix, Show ix) => Show (UArray ix Int)
(Ix ix, Show ix) => Show (UArray ix Word)
(Ix ix, Show ix) => Show (UArray ix Float)
(Ix ix, Show ix) => Show (UArray ix Double)
(Ix ix, Show ix) => Show (UArray ix Int8)
(Ix ix, Show ix) => Show (UArray ix Int16)
(Ix ix, Show ix) => Show (UArray ix Int32)
(Ix ix, Show ix) => Show (UArray ix Int64)
(Ix ix, Show ix) => Show (UArray ix Word8)
(Ix ix, Show ix) => Show (UArray ix Word16)
(Ix ix, Show ix) => Show (UArray ix Word32)
(Ix ix, Show ix) => Show (UArray ix Word64)
(Ix ix, Show ix, Show e) => Show (DiffArray ix e)
(Ix ix, Show ix) => Show (DiffUArray ix Char)
(Ix ix, Show ix) => Show (DiffUArray ix Int)
(Ix ix, Show ix) => Show (DiffUArray ix Word)
(Ix ix, Show ix) => Show (DiffUArray ix Float)
(Ix ix, Show ix) => Show (DiffUArray ix Double)
(Ix ix, Show ix) => Show (DiffUArray ix Int8)
(Ix ix, Show ix) => Show (DiffUArray ix Int16)
(Ix ix, Show ix) => Show (DiffUArray ix Int32)
(Ix ix, Show ix) => Show (DiffUArray ix Int64)
(Ix ix, Show ix) => Show (DiffUArray ix Word8)
(Ix ix, Show ix) => Show (DiffUArray ix Word16)
(Ix ix, Show ix) => Show (DiffUArray ix Word32)
(Ix ix, Show ix) => Show (DiffUArray ix Word64)
(RealFloat a, Show a) => Show (Complex a)
Show Dynamic
Show TypeRep
Show TyCon
Show PackedString
Show (Poly a)
Show CChar
Show CSChar
Show CUChar
Show CShort
Show CUShort
Show CInt
Show CUInt
Show CLong
Show CULong
Show CLLong
Show CULLong
Show CFloat
Show CDouble
Show CLDouble
Show CPtrdiff
Show CSize
Show CWchar
Show CSigAtomic
Show CClock
Show CTime
Show (ForeignPtr a)
Show (Ptr a)
Show (FunPtr a)
(Ix a, Show a, Show b) => Show (Array a b)
Show Float
Show Double
Show HandlePosn
Show IOMode
Show IOModeEx
Show SeekMode
Show HandleType
Show Handle
Show ArithException
Show AsyncException
Show ArrayException
Show Exception
Show IOErrorType
Show IOException
Show BufferMode
Show ExitCode
Show Int8
Show Int16
Show Int32
Show Int64
Show Integer
Integral a => Show (Ratio a)
Show (ST s a)
Show ()
Show a => Show [a]
Show Bool
Show Ordering
Show Char
Show Int
Show a => Show (Maybe a)
(Show a, Show b) => Show (Either a b)
(Show a, Show b) => Show (a, b)
(Show a, Show b, Show c) => Show (a, b, c)
(Show a, Show b, Show c, Show d) => Show (a, b, c, d)
(Show a, Show b, Show c, Show d, Show e) => Show (a, b, c, d, e)
Show Word
Show Word8
Show Word16
Show Word32
Show Word64
Show Permissions
Show TimeLocale
Show StdGen
Show ClockTime
Show Month
Show Day
Show CalendarTime
Show TimeDiff
Show Html
Show HtmlAttr
Show HtmlTable
Show HotLink
Show a => Show (BlockTable a)
Show ParseError
Show Doc
Show Lexeme
Show (a -> b)
reads :: Read a => ReadS a
shows :: Show a => a -> ShowS
read :: Read a => String -> a
lex :: ReadS String
showChar :: Char -> ShowS
showString :: String -> ShowS
readParen :: Bool -> ReadS a -> ReadS a
showParen :: Bool -> ShowS -> ShowS
Simple I/O operations
ioError :: Exception -> IO a

A variant of throw that can be used within the IO monad.

Although ioError has a type that is an instance of the type of throw, the two functions are subtly different:

 throw e   `seq` return ()  ===> throw e
 ioError e `seq` return ()  ===> return ()

The first example will cause the exception e to be raised, whereas the second one won't. In fact, ioError will only cause an exception to be raised when it is used within the IO monad. The ioError variant should be used in preference to throw to raise an exception within the IO monad because it guarantees ordering with respect to other IO operations, whereas throw does not.

userError :: String -> IOError
catch :: IO a -> (Exception -> IO a) -> IO a
type FilePath = String
type IOError = Exception
putChar :: Char -> IO ()
putStr :: String -> IO ()
putStrLn :: String -> IO ()
print :: Show a => a -> IO ()
getChar :: IO Char
getLine :: IO String
getContents :: IO String
interact :: (String -> String) -> IO ()
readFile :: FilePath -> IO String
writeFile :: FilePath -> String -> IO ()
appendFile :: FilePath -> String -> IO ()
readIO :: Read a => String -> IO a
readLn :: Read a => IO a
Monads
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
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
mapM :: Monad m => (a -> m b) -> [a] -> m [b]
mapM_ :: Monad m => (a -> m b) -> [a] -> m ()
sequence :: Monad m => [m a] -> m [a]
sequence_ :: Monad m => [m a] -> m ()
(=<<) :: Monad m => (a -> m b) -> m a -> m b
Miscellaneous functions
maybe :: b -> (a -> b) -> Maybe a -> b
either :: (a -> c) -> (b -> c) -> Either a b -> c
(&&) :: 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 = ...
subtract :: Num a => a -> a -> a
even :: Integral a => a -> Bool
odd :: Integral a => a -> Bool
gcd :: Integral a => a -> a -> a
lcm :: Integral a => a -> a -> a
(^) :: (Num a, Integral b) => a -> b -> a
(^^) :: (Fractional a, Integral b) => a -> b -> a
fromIntegral :: (Integral a, Num b) => a -> b
realToFrac :: (Real a, Fractional b) => a -> b
id :: 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
error :: String -> a
undefined :: a
($!) :: (a -> b) -> a -> b
Produced by Haddock version 0.6