
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 

          type String = [Char]             type Rational = Ratio Integer   module Data.Tuple   class Eq a where    class (Eq a) => Ord a where    class Enum a where    class Bounded a where    class (Eq a, Show a) => Num a where    class (Num a, Ord a) => Real a where    class (Real a, Enum a) => Integral a where    class (Num a) => Fractional a where    class (Fractional a) => Floating a where    class (Real a, Fractional a) => RealFrac a where    class (RealFrac a, Floating a) => RealFloat a where    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    class Show a where    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    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   Instances  


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   Instances  


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   Instances  


data Ordering 
Represents an ordering relationship between two values: less
than, equal to, or greater than. An Ordering is returned by
compare.  Constructors   Instances  


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  


type String = [Char] 
A String is a list of characters. String constants in Haskell are values
of type String.


data Int 
A fixedprecision integer type with at least the range [2^29
.. 2^291]. The exact range for a given implementation can be
determined by using minBound and maxBound from the Bounded
class.  Instances  


data Integer 
Arbitraryprecision integers.  Instances  


data Float 
Singleprecision floating point numbers.  Instances  


data Double 
Doubleprecision floating point numbers.  Instances  


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 donotation
or the >> and >>= operations from the Monad class.
 Instances  


type Rational = Ratio Integer 
Arbitraryprecision 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  


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  


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  


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  


class (Num a, Ord a) => Real a where 


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  


class (Num a) => Fractional a where 
 Methods  (/) :: a > a > a   recip :: a > a   fromRational :: Rational > a 
  Instances  


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  


class (Real a, Fractional a) => RealFrac a where 


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  


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    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    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  


class Functor f where 
 Methods  fmap :: (a > b) > f a > f b 
  Instances  


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 