| Haskell Hierarchical Libraries (base package) | Contents | Index

Prelude

Portability | portable
Stability | stable
Maintainer | libraries@haskell.org

Contents

Standard types, classes and related functions
  Basic data types
    Tuples
  Basic type classes
  Numbers
    Numeric types
    Numeric type classes
    Numeric functions
  Monads and functors
  Miscellaneous functions
List operations
  Reducing lists (folds)
    Special folds
  Building lists
    Scans
    Infinite lists
  Sublists
  Searching lists
  Zipping and unzipping lists
  Functions on strings
Converting to and from `String`
Basic Input and output
  Simple I/O operations
    Output functions
    Input functions
    Files
  Exception handling in the I/O monad

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

(&&) :: Bool -> Bool -> Bool
(||) :: Bool -> Bool -> Bool
not :: Bool -> Bool
otherwise :: Bool

data Maybe a

= Nothing
| Just a

maybe :: b -> (a -> b) -> Maybe a -> b

data Either a b

= Left a
| Right b

either :: (a -> c) -> (b -> c) -> Either a b -> c

data Ordering

= LT
| EQ
| GT

data Char
type String = [Char]
fst :: (a, b) -> a
snd :: (a, b) -> b
curry :: ((a, b) -> c) -> a -> b -> c
uncurry :: (a -> b -> c) -> (a, b) -> c
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

data Int
data Integer
data Float
data Double
type Rational = Ratio Integer
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

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
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
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
map :: (a -> b) -> [a] -> [b]
(++) :: [a] -> [a] -> [a]
filter :: (a -> Bool) -> [a] -> [a]
head :: [a] -> a
last :: [a] -> a
tail :: [a] -> [a]
init :: [a] -> [a]
null :: [a] -> Bool
length :: [a] -> Int
(!!) :: [a] -> Int -> a
reverse :: [a] -> [a]
foldl :: (a -> b -> a) -> a -> [b] -> a
foldl1 :: (a -> a -> a) -> [a] -> a
foldr :: (a -> b -> b) -> b -> [a] -> b
foldr1 :: (a -> a -> a) -> [a] -> a
and :: [Bool] -> Bool
or :: [Bool] -> Bool
any :: (a -> Bool) -> [a] -> Bool
all :: (a -> Bool) -> [a] -> Bool
sum :: Num a => [a] -> a
product :: Num a => [a] -> a
concat :: [[a]] -> [a]
concatMap :: (a -> [b]) -> [a] -> [b]
maximum :: Ord a => [a] -> a
minimum :: Ord a => [a] -> a
scanl :: (a -> b -> a) -> a -> [b] -> [a]
scanl1 :: (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 -> [a] -> [a]
drop :: Int -> [a] -> [a]
splitAt :: Int -> [a] -> ([a], [a])
takeWhile :: (a -> Bool) -> [a] -> [a]
dropWhile :: (a -> Bool) -> [a] -> [a]
span :: (a -> Bool) -> [a] -> ([a], [a])
break :: (a -> Bool) -> [a] -> ([a], [a])
elem :: Eq a => a -> [a] -> Bool
notElem :: Eq a => a -> [a] -> Bool
lookup :: Eq a => a -> [(a, b)] -> Maybe 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
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
data IO a
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 ()
type FilePath = String
readFile :: FilePath -> IO String
writeFile :: FilePath -> String -> IO ()
appendFile :: FilePath -> String -> IO ()
readIO :: Read a => String -> IO a
readLn :: Read a => IO a
type IOError = IOException
ioError :: IOError -> IO a
userError :: String -> IOError
catch :: IO a -> (IOError -> IO a) -> IO a

Standard types, classes and related functions
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
Storable Bool
Ix Bool
Eq Bool
Ord Bool
Bounded Bool
Enum Bool
Read Bool
Show 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 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
Data a => Data (Maybe a)
Functor Maybe
Monad Maybe
Eq a => Eq (Maybe a)
Ord a => Ord (Maybe a)
Typeable a => Typeable (Maybe a)
Read a => Read (Maybe a)
Show a => Show (Maybe a)

maybe :: b -> (a -> b) -> Maybe a -> b
The `maybe` function takes a default value, a function, and a `Maybe` value. If the `Maybe` value is `Nothing`, the function returns the default value. Otherwise, it applies the function to the value inside the `Just` and returns that.
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)
(Eq a, Eq b) => Eq (Either a b)
(Ord a, Ord b) => Ord (Either a b)
(Typeable a, Typeable b) => Typeable (Either a b)
(Read a, Read b) => Read (Either a b)
(Show a, Show b) => Show (Either a b)

either :: (a -> c) -> (b -> c) -> Either a b -> c
Case analysis for the `Either` type. If the value is ``Left` a`, apply the first function to `a`; if it is ``Right` b`, apply the second function to `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 (or equivalently ISO 10646) characters. This set extends the ISO 8859-1 (Latin-1) character set (the first 256 charachers), which is itself an extension of the ASCII character set (the first 128 characters). A character literal in Haskell has type `Char`.

To convert a `Char` to or from the corresponding `Int` value defined by Unicode, use `toEnum` and `fromEnum` from the `Enum` class respectively (or equivalently `ord` and `chr`).

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
Storable Char
Ix Char
Eq Char
Ord Char
Bounded Char
Enum Char
Read Char
Show Char
Random Char
HTML Char

type String = [Char]
A `String` is a list of characters. String constants in Haskell are values of type `String`.
Tuples
fst :: (a, b) -> a
snd :: (a, b) -> b
curry :: ((a, b) -> c) -> a -> b -> c
uncurry :: (a -> b -> c) -> (a, b) -> c
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)
(RealFloat a, Eq a) => Eq (Complex a)
(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 TypeRep
Eq TyCon
Eq Key
Eq KeyPr
Eq Unique
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 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 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 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 Fd
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 SeekMode
Enum IOMode
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 CDev
Enum CIno
Enum CMode
Enum COff
Enum CPid
Enum CSsize
Enum CGid
Enum CNlink
Enum CUid
Enum CCc
Enum CSpeed
Enum CTcflag
Enum Fd
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 CIno
Bounded CMode
Bounded COff
Bounded CPid
Bounded CSsize
Bounded CGid
Bounded CNlink
Bounded CUid
Bounded CTcflag
Bounded Fd
Bounded Month
Bounded Day

Numbers
Numeric types
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
Storable Int
Ix Int
Eq Int
Ord Int
Bounded Int
Enum Int
Num Int
Read Int
Real Int
Integral Int
Show Int
Random Int

data Integer

Arbitrary-precision integers.
Instances

Bits Integer
Typeable 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
Storable Float
Eq Float
Ord Float
Num Float
Real Float
Fractional Float
RealFrac Float
Floating Float
RealFloat Float
Show Float
Enum Float
Read 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
Storable Double
Eq Double
Ord Double
Num Double
Real Double
Fractional Double
Floating Double
RealFrac Double
RealFloat Double
Show Double
Enum Double
Read Double
Random Double

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.
Numeric type classes
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
Num CDev
Num CIno
Num CMode
Num COff
Num CPid
Num CSsize
Num CGid
Num CNlink
Num CUid
Num CCc
Num CSpeed
Num CTcflag
Num Fd

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
Real CIno
Real CMode
Real COff
Real CPid
Real CSsize
Real CGid
Real CNlink
Real CUid
Real CTcflag
Real Fd

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
Integral CIno
Integral CMode
Integral COff
Integral CPid
Integral CSsize
Integral CGid
Integral CNlink
Integral CUid
Integral CTcflag
Integral Fd

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

Numeric functions
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
Monads and functors
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

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 []
Monad IO
Monad (ST s)
Monad P
Monad ReadP
Monad ReadPrec

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

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
Ix i => Functor (Array i)
Functor []
Functor IO
Functor (ST s)
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
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
List operations
map :: (a -> b) -> [a] -> [b]

`map` `f xs` is the list obtained by applying `f` to each element of `xs`, i.e.,

     map f [x1, x2, ..., xn] == [f x1, f x2, ..., f xn]
     map f [x1, x2, ...] == [f x1, f x2, ...]

(++) :: [a] -> [a] -> [a]

Append two lists, i.e.,

     [x1, ..., xm] ++ [y1, ..., yn] == [x1, ..., xm, y1, ..., yn]
     [x1, ..., xm] ++ [y1, ...] == [x1, ..., xm, y1, ...]

If the first list is not finite, the result is the first list.

filter :: (a -> Bool) -> [a] -> [a]

`filter`, applied to a predicate and a list, returns the list of those elements that satisfy the predicate; i.e.,

     filter p xs = [ x | x <- xs, p x]

head :: [a] -> a
Extract the first element of a list, which must be non-empty.
last :: [a] -> a
Extract the last element of a list, which must be finite and non-empty.
tail :: [a] -> [a]
Extract the elements after the head of a list, which must be non-empty.
init :: [a] -> [a]
Return all the elements of a list except the last one. The list must be finite and non-empty.
null :: [a] -> Bool
Test whether a list is empty.
length :: [a] -> Int
`length` returns the length of a finite list as an `Int`. It is an instance of the more general `genericLength`, the result type of which may be any kind of number.
(!!) :: [a] -> Int -> a
List index (subscript) operator, starting from 0. It is an instance of the more general `genericIndex`, which takes an index of any integral type.
reverse :: [a] -> [a]
`reverse` `xs` returns the elements of `xs` in reverse order. `xs` must be finite.
Reducing lists (folds)
foldl :: (a -> b -> a) -> a -> [b] -> a

`foldl`, applied to a binary operator, a starting value (typically the left-identity of the operator), and a list, reduces the list using the binary operator, from left to right:

     foldl f z [x1, x2, ..., xn] == (...((z `f` x1) `f` x2) `f`...) `f` xn

The list must be finite.

foldl1 :: (a -> a -> a) -> [a] -> a
`foldl1` is a variant of `foldl` that has no starting value argument, and thus must be applied to non-empty lists.
foldr :: (a -> b -> b) -> b -> [a] -> b

`foldr`, applied to a binary operator, a starting value (typically the right-identity of the operator), and a list, reduces the list using the binary operator, from right to left:

     foldr f z [x1, x2, ..., xn] == x1 `f` (x2 `f` ... (xn `f` z)...)

foldr1 :: (a -> a -> a) -> [a] -> a
`foldr1` is a variant of `foldr` that has no starting value argument, and thus must be applied to non-empty lists.
Special folds
and :: [Bool] -> Bool
`and` returns the conjunction of a Boolean list. For the result to be `True`, the list must be finite; `False`, however, results from a `False` value at a finite index of a finite or infinite list.
or :: [Bool] -> Bool
`or` returns the disjunction of a Boolean list. For the result to be `False`, the list must be finite; `True`, however, results from a `True` value at a finite index of a finite or infinite list.
any :: (a -> Bool) -> [a] -> Bool
Applied to a predicate and a list, `any` determines if any element of the list satisfies the predicate.
all :: (a -> Bool) -> [a] -> Bool
Applied to a predicate and a list, `all` determines if all elements of the list satisfy the predicate.
sum :: Num a => [a] -> a
The `sum` function computes the sum of a finite list of numbers.
product :: Num a => [a] -> a
The `product` function computes the product of a finite list of numbers.
concat :: [[a]] -> [a]
Concatenate a list of lists.
concatMap :: (a -> [b]) -> [a] -> [b]
Map a function over a list and concatenate the results.
maximum :: Ord a => [a] -> a
`maximum` returns the maximum value from a list, which must be non-empty, finite, and of an ordered type. It is a special case of `maximumBy`, which allows the programmer to supply their own comparison function.
minimum :: Ord a => [a] -> a
`minimum` returns the minimum value from a list, which must be non-empty, finite, and of an ordered type. It is a special case of `minimumBy`, which allows the programmer to supply their own comparison function.
Building lists
Scans
scanl :: (a -> b -> a) -> a -> [b] -> [a]

`scanl` is similar to `foldl`, but returns a list of successive reduced values from the left:

     scanl f z [x1, x2, ...] == [z, z `f` x1, (z `f` x1) `f` x2, ...]

Note that

     last (scanl f z xs) == foldl f z xs.

scanl1 :: (a -> a -> a) -> [a] -> [a]

`scanl1` is a variant of `scanl` that has no starting value argument:

     scanl1 f [x1, x2, ...] == [x1, x1 `f` x2, ...]

scanr :: (a -> b -> b) -> b -> [a] -> [b]

`scanr` is the right-to-left dual of `scanl`. Note that

     head (scanr f z xs) == foldr f z xs.

scanr1 :: (a -> a -> a) -> [a] -> [a]
`scanr1` is a variant of `scanr` that has no starting value argument.
Infinite lists
iterate :: (a -> a) -> a -> [a]

`iterate` `f x` returns an infinite list of repeated applications of `f` to `x`:

     iterate f x == [x, f x, f (f x), ...]

repeat :: a -> [a]
`repeat` `x` is an infinite list, with `x` the value of every element.
replicate :: Int -> a -> [a]
`replicate` `n x` is a list of length `n` with `x` the value of every element. It is an instance of the more general `genericReplicate`, in which `n` may be of any integral type.
cycle :: [a] -> [a]
`cycle` ties a finite list into a circular one, or equivalently, the infinite repetition of the original list. It is the identity on infinite lists.
Sublists
take :: Int -> [a] -> [a]
`take` `n`, applied to a list `xs`, returns the prefix of `xs` of length `n`, or `xs` itself if `n > `length` xs`. It is an instance of the more general `genericTake`, in which `n` may be of any integral type.
drop :: Int -> [a] -> [a]
`drop` `n xs` returns the suffix of `xs` after the first `n` elements, or `[]` if `n > `length` xs`. It is an instance of the more general `genericDrop`, in which `n` may be of any integral type.
splitAt :: Int -> [a] -> ([a], [a])
`splitAt` `n xs` is equivalent to `(`take` n xs, `drop` n xs)`. It is an instance of the more general `genericSplitAt`, in which `n` may be of any integral type.
takeWhile :: (a -> Bool) -> [a] -> [a]
`takeWhile`, applied to a predicate `p` and a list `xs`, returns the longest prefix (possibly empty) of `xs` of elements that satisfy `p`.
dropWhile :: (a -> Bool) -> [a] -> [a]
`dropWhile` `p xs` returns the suffix remaining after `takeWhile` `p xs`.
span :: (a -> Bool) -> [a] -> ([a], [a])
`span` `p xs` is equivalent to `(`takeWhile` p xs, `dropWhile` p xs)`
break :: (a -> Bool) -> [a] -> ([a], [a])
`break` `p` is equivalent to ``span` (`not` . p)`.
Searching lists
elem :: Eq a => a -> [a] -> Bool
`elem` is the list membership predicate, usually written in infix form, e.g., `x `elem` xs`.
notElem :: Eq a => a -> [a] -> Bool
`notElem` is the negation of `elem`.
lookup :: Eq a => a -> [(a, b)] -> Maybe b
`lookup` `key assocs` looks up a key in an association list.
Zipping and unzipping lists
zip :: [a] -> [b] -> [(a, b)]
`zip` takes two lists and returns a list of corresponding pairs. If one input list is short, excess elements of the longer list are discarded.
zip3 :: [a] -> [b] -> [c] -> [(a, b, c)]
`zip3` takes three lists and returns a list of triples, analogous to `zip`.
zipWith :: (a -> b -> c) -> [a] -> [b] -> [c]
`zipWith` generalises `zip` by zipping with the function given as the first argument, instead of a tupling function. For example, ``zipWith` (+)` is applied to two lists to produce the list of corresponding sums.
zipWith3 :: (a -> b -> c -> d) -> [a] -> [b] -> [c] -> [d]
The `zipWith3` function takes a function which combines three elements, as well as three lists and returns a list of their point-wise combination, analogous to `zipWith`.
unzip :: [(a, b)] -> ([a], [b])
`unzip` transforms a list of pairs into a list of first components and a list of second components.
unzip3 :: [(a, b, c)] -> ([a], [b], [c])
The `unzip3` function takes a list of triples and returns three lists, analogous to `unzip`.
Functions on strings
lines :: String -> [String]
`lines` breaks a string up into a list of strings at newline characters. The resulting strings do not contain newlines.
words :: String -> [String]
`words` breaks a string up into a list of words, which were delimited by white space.
unlines :: [String] -> String
`unlines` is an inverse operation to `lines`. It joins lines, after appending a terminating newline to each.
unwords :: [String] -> String
`unwords` is an inverse operation to `words`. It joins words with separating spaces.
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 SeekMode
Read BufferMode
Read ExitCode
Read IOMode
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 CDev
Read CIno
Read CMode
Read COff
Read CPid
Read CSsize
Read CGid
Read CNlink
Read CUid
Read CCc
Read CSpeed
Read CTcflag
Read Fd
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 PackedString
Show TypeRep
Show TyCon
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 (Ptr a)
Show (FunPtr a)
(Ix a, Show a, Show b) => Show (Array a b)
Show Float
Show Double
Show (ForeignPtr a)
Show HandlePosn
Show SeekMode
Show HandleType
Show Handle
Show ArithException
Show AsyncException
Show ArrayException
Show Exception
Show IOErrorType
Show IOException
Show BufferMode
Show ExitCode
Show IOMode
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 CDev
Show CIno
Show CMode
Show COff
Show CPid
Show CSsize
Show CGid
Show CNlink
Show CUid
Show CCc
Show CSpeed
Show CTcflag
Show Fd
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 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
Basic Input and output
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

Simple I/O operations
Output functions
putChar :: Char -> IO ()
Write a character to the standard output device (same as `hPutChar` `stdout`).
putStr :: String -> IO ()
Write a string to the standard output device (same as `hPutStr` `stdout`).
putStrLn :: String -> IO ()
The same as `putStrLn`, but adds a newline character.
print :: Show a => a -> IO ()

The `print` function outputs a value of any printable type to the standard output device. Printable types are those that are instances of class `Show`; `print` converts values to strings for output using the `show` operation and adds a newline.

For example, a program to print the first 20 integers and their powers of 2 could be written as:

     main = print ([(n, 2^n) | n <- [0..19]])

Input functions
getChar :: IO Char
Read a character from the standard input device (same as `hGetChar` `stdin`).
getLine :: IO String
Read a line from the standard input device (same as `hGetLine` `stdin`).
getContents :: IO String
The `getContents` operation returns all user input as a single string, which is read lazily as it is needed (same as `hGetContents` `stdin`).
interact :: (String -> String) -> IO ()
The `interact` function takes a function of type `String->String` as its argument. The entire input from the standard input device is passed to this function as its argument, and the resulting string is output on the standard output device.
Files
type FilePath = String
File and directory names are values of type `String`, whose precise meaning is operating system dependent. Files can be opened, yielding a handle which can then be used to operate on the contents of that file.
readFile :: FilePath -> IO String
The `readFile` function reads a file and returns the contents of the file as a string. The file is read lazily, on demand, as with `getContents`.
writeFile :: FilePath -> String -> IO ()
The computation `writeFile` `file str` function writes the string `str`, to the file `file`.
appendFile :: FilePath -> String -> IO ()

The computation `appendFile` `file str` function appends the string `str`, to the file `file`.

Note that `writeFile` and `appendFile` write a literal string to a file. To write a value of any printable type, as with `print`, use the `show` function to convert the value to a string first.

     main = appendFile "squares" (show [(x,x*x) | x <- [0,0.1..2]])

readIO :: Read a => String -> IO a
The `readIO` function is similar to `read` except that it signals parse failure to the `IO` monad instead of terminating the program.
readLn :: Read a => IO a
The `readLn` function combines `getLine` and `readIO`.
Exception handling in the I/O monad
type IOError = IOException
The Haskell 98 type for exceptions in the `IO` monad. Any I/O operation may raise an `IOError` instead of returning a result. For a more general type of exception, including also those that arise in pure code, see `Exception`. In Haskell 98, this is an opaque type.
ioError :: IOError -> IO a
Raise an `IOError` in the `IO` monad.
userError :: String -> IOError

Construct an `IOError` value with a string describing the error. The `fail` method of the `IO` instance of the `Monad` class raises a `userError`, thus:

     instance Monad IO where
       ...
       fail s = ioError (userError s)

catch :: IO a -> (IOError -> IO a) -> IO a

The `catch` function establishes a handler that receives any `IOError` raised in the action protected by `catch`. An `IOError` is caught by the most recent handler established by `catch`. These handlers are not selective: all `IOError`s are caught. Exception propagation must be explicitly provided in a handler by re-raising any unwanted exceptions. For example, in

     f = catch g (\e -> if IO.isEOFError e then return [] else ioError e)

the function `f` returns `[]` when an end-of-file exception (cf. `isEOFError`) occurs in `g`; otherwise, the exception is propagated to the next outer handler.

When an exception propagates outside the main program, the Haskell system prints the associated `IOError` value and exits the program.

Non-I/O exceptions are not caught by this variant; to catch all exceptions, use `catch` from Control.Exception.

Produced by Haddock version 0.6