Prelude

| Haskell Core Libraries (base package) | Contents | Index
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
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
(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)
(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
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)
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 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 ()
Enum Bool
Enum Ordering
Enum Char
Enum Int
Enum Float
Enum Double
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
class Bounded a where
Methods
minBound :: a
maxBound :: a
Instances
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
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 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 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 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 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 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 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 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
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 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 StdGen
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)
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 HandleType
Show Handle
Show ArithException
Show AsyncException
Show ArrayException
Show Exception
Show IOErrorType
Show IOException
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 StdGen
Show ClockTime
Show Html
Show HtmlAttr
Show HtmlTable
(Show a) => Show (BlockTable a)
Show ParseError
Show Doc
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.4