Copyright  (c) The University of Glasgow 2001 

License  BSDstyle (see the file libraries/base/LICENSE) 
Maintainer  libraries@haskell.org 
Stability  stable 
Portability  portable 
Safe Haskell  Trustworthy 
Language  Haskell2010 
The Prelude: a standard module. The Prelude is imported by default into all Haskell modules unless either there is an explicit import statement for it, or the NoImplicitPrelude extension is enabled.
(&&) :: Bool > Bool > Bool infixr 3 Source
Boolean "and"
() :: Bool > Bool > Bool infixr 2 Source
Boolean "or"
Boolean "not"
otherwise
is defined as the value True
. It helps to make guards more readable. eg.
f x  x < 0 = ...  otherwise = ...
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.
Monad Maybe  
Functor Maybe  
MonadFix Maybe  
Applicative Maybe  
Foldable Maybe  
Traversable Maybe  
Generic1 Maybe  
MonadPlus Maybe  
Alternative Maybe  
Eq a => Eq (Maybe a)  
Data a => Data (Maybe a)  
Ord a => Ord (Maybe a)  
Read a => Read (Maybe a)  
Show a => Show (Maybe a)  
Generic (Maybe a)  
Monoid a => Monoid (Maybe a)  Lift a semigroup into 
type Rep1 Maybe  
type Rep (Maybe a)  
type (==) (Maybe k) a b 
maybe :: b > (a > b) > Maybe a > b Source
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 the result.
Basic usage:
>>>
maybe False odd (Just 3)
True
>>>
maybe False odd Nothing
False
Read an integer from a string using readMaybe
. If we succeed, return twice the integer; that is, apply (*2)
to it. If instead we fail to parse an integer, return 0
by default:
>>>
import Text.Read ( readMaybe )
>>>
maybe 0 (*2) (readMaybe "5")
10>>>
maybe 0 (*2) (readMaybe "")
0
Apply show
to a Maybe Int
. If we have Just n
, we want to show the underlying Int
n
. But if we have Nothing
, we return the empty string instead of (for example) "Nothing":
>>>
maybe "" show (Just 5)
"5">>>
maybe "" show Nothing
""
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").
The type Either String Int
is the type of values which can be either a String
or an Int
. The Left
constructor can be used only on String
s, and the Right
constructor can be used only on Int
s:
>>>
let s = Left "foo" :: Either String Int
>>>
s
Left "foo">>>
let n = Right 3 :: Either String Int
>>>
n
Right 3>>>
:type s
s :: Either String Int>>>
:type n
n :: Either String Int
The fmap
from our Functor
instance will ignore Left
values, but will apply the supplied function to values contained in a Right
:
>>>
let s = Left "foo" :: Either String Int
>>>
let n = Right 3 :: Either String Int
>>>
fmap (*2) s
Left "foo">>>
fmap (*2) n
Right 6
The Monad
instance for Either
allows us to chain together multiple actions which may fail, and fail overall if any of the individual steps failed. First we'll write a function that can either parse an Int
from a Char
, or fail.
>>>
import Data.Char ( digitToInt, isDigit )
>>>
:{
let parseEither :: Char > Either String Int parseEither c  isDigit c = Right (digitToInt c)  otherwise = Left "parse error">>>
:}
The following should work, since both '1'
and '2'
can be parsed as Int
s.
>>>
:{
let parseMultiple :: Either String Int parseMultiple = do x < parseEither '1' y < parseEither '2' return (x + y)>>>
:}
>>>
parseMultiple
Right 3
But the following should fail overall, since the first operation where we attempt to parse 'm'
as an Int
will fail:
>>>
:{
let parseMultiple :: Either String Int parseMultiple = do x < parseEither 'm' y < parseEither '2' return (x + y)>>>
:}
>>>
parseMultiple
Left "parse error"
Bifunctor Either  
Monad (Either e)  
Functor (Either a)  
MonadFix (Either e)  
Applicative (Either e)  
Foldable (Either a)  
Traversable (Either a)  
Generic1 (Either a)  
(Eq a, Eq b) => Eq (Either a b)  
(Data a, Data b) => Data (Either a b)  
(Ord a, Ord b) => Ord (Either a b)  
(Read a, Read b) => Read (Either a b)  
(Show a, Show b) => Show (Either a b)  
Generic (Either a b)  
type Rep1 (Either a)  
type Rep (Either a b)  
type (==) (Either k k1) a b 
either :: (a > c) > (b > c) > Either a b > c Source
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
.
We create two values of type Either String Int
, one using the Left
constructor and another using the Right
constructor. Then we apply "either" the length
function (if we have a String
) or the "timestwo" function (if we have an Int
):
>>>
let s = Left "foo" :: Either String Int
>>>
let n = Right 3 :: Either String Int
>>>
either length (*2) s
3>>>
either length (*2) n
6
The character type Char
is an enumeration whose values represent Unicode (or equivalently ISO/IEC 10646) characters (see http://www.unicode.org/ for details). This set extends the ISO 88591 (Latin1) character set (the first 256 characters), 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
).
A String
is a list of characters. String constants in Haskell are values of type String
.
Extract the first component of a pair.
Extract the second component of a pair.
curry :: ((a, b) > c) > a > b > c Source
curry
converts an uncurried function to a curried function.
uncurry :: (a > b > c) > (a, b) > c Source
uncurry
converts a curried function to a function on pairs.
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 /=
.
Eq Bool  
Eq Char  
Eq Double  
Eq Float  
Eq Int  
Eq Int8  
Eq Int16  
Eq Int32  
Eq Int64  
Eq Integer  
Eq Ordering  
Eq Word  
Eq Word8  
Eq Word16  
Eq Word32  
Eq Word64  
Eq CallStack  
Eq TypeRep  
Eq ()  
Eq BigNat  
Eq Number  
Eq Lexeme  
Eq GeneralCategory  
Eq Fingerprint  
Eq TyCon  
Eq Associativity  
Eq Fixity  
Eq Arity  
Eq Any  
Eq All  
Eq ArithException  
Eq ErrorCall  
Eq IOException  
Eq MaskingState  
Eq CUIntMax  
Eq CIntMax  
Eq CUIntPtr  
Eq CIntPtr  
Eq CSUSeconds  
Eq CUSeconds  
Eq CTime  
Eq CClock  
Eq CSigAtomic  
Eq CWchar  
Eq CSize  
Eq CPtrdiff  
Eq CDouble  
Eq CFloat  
Eq CULLong  
Eq CLLong  
Eq CULong  
Eq CLong  
Eq CUInt  
Eq CInt  
Eq CUShort  
Eq CShort  
Eq CUChar  
Eq CSChar  
Eq CChar  
Eq IntPtr  
Eq WordPtr  
Eq BufferState  
Eq CodingProgress  
Eq SeekMode  
Eq IODeviceType  
Eq NewlineMode  
Eq Newline  
Eq BufferMode  
Eq Handle  
Eq IOErrorType  
Eq ExitCode  
Eq ArrayException  
Eq AsyncException  
Eq Errno  
Eq Fd  
Eq CRLim  
Eq CTcflag  
Eq CSpeed  
Eq CCc  
Eq CUid  
Eq CNlink  
Eq CGid  
Eq CSsize  
Eq CPid  
Eq COff  
Eq CMode  
Eq CIno  
Eq CDev  
Eq ThreadStatus  
Eq BlockReason  
Eq ThreadId  
Eq IOMode  
Eq Lifetime  
Eq Event  
Eq FdKey  
Eq TimeoutKey  
Eq HandlePosn  
Eq Version  
Eq Fixity  
Eq ConstrRep  
Eq DataRep  
Eq Constr  Equality of constructors 
Eq Natural  
Eq SomeSymbol  
Eq SomeNat  
Eq SrcLoc  
Eq SpecConstrAnnotation  
Eq Unique  
Eq Void  
Eq a => Eq [a]  
Eq a => Eq (Ratio a)  
Eq (StablePtr a)  
Eq (Ptr a)  
Eq (FunPtr a)  
Eq (U1 p)  
Eq p => Eq (Par1 p)  
Eq a => Eq (Maybe a)  
Eq a => Eq (Down a)  
Eq a => Eq (Last a)  
Eq a => Eq (First a)  
Eq a => Eq (Product a)  
Eq a => Eq (Sum a)  
Eq a => Eq (Dual a)  
Eq (MVar a)  
Eq (IORef a)  
Eq (ForeignPtr a)  
Eq (TVar a)  
Eq a => Eq (ZipList a)  
Eq (Chan a)  
Eq a => Eq (Complex a)  
Eq (Fixed a)  
Eq a => Eq (Identity a)  
Eq (StableName a)  
(Eq a, Eq b) => Eq (Either a b)  
Eq (f p) => Eq (Rec1 f p)  
(Eq a, Eq b) => Eq (a, b)  
Eq (STRef s a)  
Eq (Proxy k s)  
Eq a => Eq (Const a b)  
Eq c => Eq (K1 i c p)  
(Eq (f p), Eq (g p)) => Eq ((:+:) f g p)  
(Eq (f p), Eq (g p)) => Eq ((:*:) f g p)  
Eq (f (g p)) => Eq ((:.:) f g p)  
(Eq a, Eq b, Eq c) => Eq (a, b, c)  
Eq ((:~:) k a b)  
Eq (Coercion k a b)  
Eq (f a) => Eq (Alt k f a)  
Eq (f p) => Eq (M1 i c f p)  
(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) 
class Eq a => Ord a where Source
The Ord
class is used for totally ordered datatypes.
Instances of Ord
can be derived for any userdefined datatype whose constituent types are in Ord
. The declared order of the constructors in the data declaration determines the ordering in derived Ord
instances. The Ordering
datatype allows a single comparison to determine the precise ordering of two objects.
Minimal complete definition: either compare
or <=
. Using compare
can be more efficient for complex types.
compare :: a > a > Ordering Source
(<) :: a > a > Bool infix 4 Source
(<=) :: a > a > Bool infix 4 Source
(>) :: a > a > Bool infix 4 Source
Class Enum
defines operations on sequentially ordered types.
The enumFrom
... methods are used in Haskell's translation of arithmetic sequences.
Instances of Enum
may be derived for any enumeration type (types whose constructors have no fields). The nullary constructors are assumed to be numbered lefttoright by fromEnum
from 0
through n1
. See Chapter 10 of the Haskell Report for more details.
For any type that is an instance of class Bounded
as well as Enum
, the following should hold:
succ maxBound
and pred minBound
should result in a runtime error.fromEnum
and toEnum
should give a runtime error if the result value is not representable in the result type. For example, toEnum 7 :: Bool
is an error.enumFrom
and enumFromThen
should be defined with an implicit bound, thus:enumFrom x = enumFromTo x maxBound enumFromThen x y = enumFromThenTo x y bound where bound  fromEnum y >= fromEnum x = maxBound  otherwise = minBound
the successor of a value. For numeric types, succ
adds 1.
the predecessor of a value. For numeric types, pred
subtracts 1.
Convert from an Int
.
Convert to an Int
. It is implementationdependent what fromEnum
returns when applied to a value that is too large to fit in an Int
.
Used in Haskell's translation of [n..]
.
enumFromThen :: a > a > [a] Source
Used in Haskell's translation of [n,n'..]
.
enumFromTo :: a > a > [a] Source
Used in Haskell's translation of [n..m]
.
enumFromThenTo :: a > a > a > [a] Source
Used in Haskell's translation of [n,n'..m]
.
Enum Bool  
Enum Char  
Enum Int  
Enum Int8  
Enum Int16  
Enum Int32  
Enum Int64  
Enum Integer  
Enum Ordering  
Enum Word  
Enum Word8  
Enum Word16  
Enum Word32  
Enum Word64  
Enum ()  
Enum GeneralCategory  
Enum CUIntMax  
Enum CIntMax  
Enum CUIntPtr  
Enum CIntPtr  
Enum CSUSeconds  
Enum CUSeconds  
Enum CTime  
Enum CClock  
Enum CSigAtomic  
Enum CWchar  
Enum CSize  
Enum CPtrdiff  
Enum CDouble  
Enum CFloat  
Enum CULLong  
Enum CLLong  
Enum CULong  
Enum CLong  
Enum CUInt  
Enum CInt  
Enum CUShort  
Enum CShort  
Enum CUChar  
Enum CSChar  
Enum CChar  
Enum IntPtr  
Enum WordPtr  
Enum SeekMode  
Enum Fd  
Enum CRLim  
Enum CTcflag  
Enum CSpeed  
Enum CCc  
Enum CUid  
Enum CNlink  
Enum CGid  
Enum CSsize  
Enum CPid  
Enum COff  
Enum CMode  
Enum CIno  
Enum CDev  
Enum IOMode  
Enum Natural  
Enum DoTrace  
Enum DoHeapProfile  
Enum DoCostCentres  
Enum GiveGCStats  
Integral a => Enum (Ratio a)  
Enum (Fixed a)  
Enum (Proxy k s)  
(~) k a b => Enum ((:~:) k a b)  
Coercible k a b => Enum (Coercion k a b)  
Enum (f a) => Enum (Alt k f a) 
The Bounded
class is used to name the upper and lower limits of a type. Ord
is not a superclass of Bounded
since types that are not totally ordered may also have upper and lower bounds.
The Bounded
class may be derived for any enumeration type; minBound
is the first constructor listed in the data
declaration and maxBound
is the last. Bounded
may also be derived for singleconstructor datatypes whose constituent types are in Bounded
.
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.
Invariant: Jn#
and Jp#
are used iff value doesn't fit in S#
Useful properties resulting from the invariants:
Singleprecision floating point numbers. It is desirable that this type be at least equal in range and precision to the IEEE singleprecision type.
Doubleprecision floating point numbers. It is desirable that this type be at least equal in range and precision to the IEEE doubleprecision type.
type Rational = Ratio Integer Source
Arbitraryprecision rational numbers, represented as a ratio of two Integer
values. A rational number may be constructed using the %
operator.
A Word
is an unsigned integral type, with the same size as Int
.
Basic numeric class.
(+), (), (*) :: a > a > a infixl 7 *infixl 6 +,  Source
Unary negation.
Absolute value.
Sign of a number. The functions abs
and signum
should satisfy the law:
abs x * signum x == x
For real numbers, the signum
is either 1
(negative), 0
(zero) or 1
(positive).
fromInteger :: Integer > a Source
Conversion from an Integer
. An integer literal represents the application of the function fromInteger
to the appropriate value of type Integer
, so such literals have type (Num a) => a
.
Num Int  
Num Int8  
Num Int16  
Num Int32  
Num Int64  
Num Integer  
Num Word  
Num Word8  
Num Word16  
Num Word32  
Num Word64  
Num CUIntMax  
Num CIntMax  
Num CUIntPtr  
Num CIntPtr  
Num CSUSeconds  
Num CUSeconds  
Num CTime  
Num CClock  
Num CSigAtomic  
Num CWchar  
Num CSize  
Num CPtrdiff  
Num CDouble  
Num CFloat  
Num CULLong  
Num CLLong  
Num CULong  
Num CLong  
Num CUInt  
Num CInt  
Num CUShort  
Num CShort  
Num CUChar  
Num CSChar  
Num CChar  
Num IntPtr  
Num WordPtr  
Num Fd  
Num CRLim  
Num CTcflag  
Num CSpeed  
Num CCc  
Num CUid  
Num CNlink  
Num CGid  
Num CSsize  
Num CPid  
Num COff  
Num CMode  
Num CIno  
Num CDev  
Num Natural  
Integral a => Num (Ratio a)  
Num a => Num (Product a)  
Num a => Num (Sum a)  
RealFloat a => Num (Complex a)  
HasResolution a => Num (Fixed a)  
Num (f a) => Num (Alt k f a) 
class (Num a, Ord a) => Real a where Source
toRational :: a > Rational Source
the rational equivalent of its real argument with full precision
class (Real a, Enum a) => Integral a where Source
Integral numbers, supporting integer division.
quot :: a > a > a infixl 7 Source
integer division truncated toward zero
rem :: a > a > a infixl 7 Source
integer remainder, satisfying
(x `quot` y)*y + (x `rem` y) == x
div :: a > a > a infixl 7 Source
integer division truncated toward negative infinity
mod :: a > a > a infixl 7 Source
integer modulus, satisfying
(x `div` y)*y + (x `mod` y) == x
quotRem :: a > a > (a, a) Source
divMod :: a > a > (a, a) Source
toInteger :: a > Integer Source
conversion to Integer
class Num a => Fractional a where Source
Fractional numbers, supporting real division.
fromRational, (recip  (/))
(/) :: a > a > a infixl 7 Source
fractional division
reciprocal fraction
fromRational :: Rational > a Source
Conversion from a Rational
(that is Ratio Integer
). A floating literal stands for an application of fromRational
to a value of type Rational
, so such literals have type (Fractional a) => a
.
Fractional CDouble  
Fractional CFloat  
Integral a => Fractional (Ratio a)  
RealFloat a => Fractional (Complex a)  
HasResolution a => Fractional (Fixed a) 
class Fractional a => Floating a where Source
Trigonometric and hyperbolic functions and related functions.
pi, exp, log, sin, cos, asin, acos, atan, sinh, cosh, asinh, acosh, atanh
exp, log, sqrt :: a > a Source
(**), logBase :: a > a > a infixr 8 Source
sin, cos, tan :: a > a Source
asin, acos, atan :: a > a Source
class (Real a, Fractional a) => RealFrac a where Source
Extracting components of fractions.
properFraction :: Integral b => a > (b, a) Source
The function properFraction
takes a real fractional number x
and returns a pair (n,f)
such that x = n+f
, and:
n
is an integral number with the same sign as x
; andf
is a fraction with the same type and sign as x
, and with absolute value less than 1
.The default definitions of the ceiling
, floor
, truncate
and round
functions are in terms of properFraction
.
truncate :: Integral b => a > b Source
truncate x
returns the integer nearest x
between zero and x
round :: Integral b => a > b Source
round x
returns the nearest integer to x
; the even integer if x
is equidistant between two integers
ceiling :: Integral b => a > b Source
ceiling x
returns the least integer not less than x
floor :: Integral b => a > b Source
floor x
returns the greatest integer not greater than x
class (RealFrac a, Floating a) => RealFloat a where Source
Efficient, machineindependent access to the components of a floatingpoint number.
floatRadix, floatDigits, floatRange, decodeFloat, encodeFloat, isNaN, isInfinite, isDenormalized, isNegativeZero, isIEEE
floatRadix :: a > Integer Source
a constant function, returning the radix of the representation (often 2
)
floatDigits :: a > Int Source
a constant function, returning the number of digits of floatRadix
in the significand
floatRange :: a > (Int, Int) Source
a constant function, returning the lowest and highest values the exponent may assume
decodeFloat :: a > (Integer, Int) Source
The function decodeFloat
applied to a real floatingpoint number returns the significand expressed as an Integer
and an appropriately scaled exponent (an Int
). If decodeFloat x
yields (m,n)
, then x
is equal in value to m*b^^n
, where b
is the floatingpoint radix, and furthermore, either m
and n
are both zero or else b^(d1) <= abs m < b^d
, where d
is the value of floatDigits x
. In particular, decodeFloat 0 = (0,0)
. If the type contains a negative zero, also decodeFloat (0.0) = (0,0)
. The result of decodeFloat x
is unspecified if either of isNaN x
or isInfinite x
is True
.
encodeFloat :: Integer > Int > a Source
encodeFloat
performs the inverse of decodeFloat
in the sense that for finite x
with the exception of 0.0
, uncurry encodeFloat (decodeFloat x) = x
. encodeFloat m n
is one of the two closest representable floatingpoint numbers to m*b^^n
(or ±Infinity
if overflow occurs); usually the closer, but if m
contains too many bits, the result may be rounded in the wrong direction.
exponent
corresponds to the second component of decodeFloat
. exponent 0 = 0
and for finite nonzero x
, exponent x = snd (decodeFloat x) + floatDigits x
. If x
is a finite floatingpoint number, it is equal in value to significand x * b ^^ exponent x
, where b
is the floatingpoint radix. The behaviour is unspecified on infinite or NaN
values.
significand :: a > a Source
The first component of decodeFloat
, scaled to lie in the open interval (1
,1
), either 0.0
or of absolute value >= 1/b
, where b
is the floatingpoint radix. The behaviour is unspecified on infinite or NaN
values.
scaleFloat :: Int > a > a Source
multiplies a floatingpoint number by an integer power of the radix
True
if the argument is an IEEE "notanumber" (NaN) value
isInfinite :: a > Bool Source
True
if the argument is an IEEE infinity or negative infinity
isDenormalized :: a > Bool Source
True
if the argument is too small to be represented in normalized format
isNegativeZero :: a > Bool Source
True
if the argument is an IEEE negative zero
True
if the argument is an IEEE floating point number
a version of arctangent taking two real floatingpoint arguments. For real floating x
and y
, atan2 y x
computes the angle (from the positive xaxis) of the vector from the origin to the point (x,y)
. atan2 y x
returns a value in the range [pi
, pi
]. It follows the Common Lisp semantics for the origin when signed zeroes are supported. atan2 y 1
, with y
in a type that is RealFloat
, should return the same value as atan y
. A default definition of atan2
is provided, but implementors can provide a more accurate implementation.
subtract :: Num a => a > a > a Source
Because 
is treated specially in the Haskell grammar, (
e)
is not a section, but an application of prefix negation. However, (subtract
exp)
is equivalent to the disallowed section.
even :: Integral a => a > Bool Source
odd :: Integral a => a > Bool Source
gcd :: Integral a => a > a > a Source
gcd x y
is the nonnegative factor of both x
and y
of which every common factor of x
and y
is also a factor; for example gcd 4 2 = 2
, gcd (4) 6 = 2
, gcd 0 4
= 4
. gcd 0 0
= 0
. (That is, the common divisor that is "greatest" in the divisibility preordering.)
Note: Since for signed fixedwidth integer types, abs minBound < 0
, the result may be negative if one of the arguments is minBound
(and necessarily is if the other is 0
or minBound
) for such types.
lcm :: Integral a => a > a > a Source
lcm x y
is the smallest positive integer that both x
and y
divide.
(^) :: (Num a, Integral b) => a > b > a infixr 8 Source
raise a number to a nonnegative integral power
(^^) :: (Fractional a, Integral b) => a > b > a infixr 8 Source
raise a number to an integral power
fromIntegral :: (Integral a, Num b) => a > b Source
general coercion from integral types
realToFrac :: (Real a, Fractional b) => a > b Source
general coercion to fractional types
The class of monoids (types with an associative binary operation that has an identity). Instances should satisfy the following laws:
mappend mempty x = x
mappend x mempty = x
mappend x (mappend y z) = mappend (mappend x y) z
mconcat = foldr
mappend mempty
The method names refer to the monoid of lists under concatenation, but there are many other instances.
Some types can be viewed as a monoid in more than one way, e.g. both addition and multiplication on numbers. In such cases we often define newtype
s and make those instances of Monoid
, e.g. Sum
and Product
.
Identity of mappend
An associative operation
Fold a list using the monoid. For most types, the default definition for mconcat
will be used, but the function is included in the class definition so that an optimized version can be provided for specific types.
Monoid Ordering  
Monoid ()  
Monoid Any  
Monoid All  
Monoid Lifetime 

Monoid Event  
Monoid [a]  
Monoid a => Monoid (Maybe a)  Lift a semigroup into 
Monoid (Last a)  
Monoid (First a)  
Num a => Monoid (Product a)  
Num a => Monoid (Sum a)  
Monoid (Endo a)  
Monoid a => Monoid (Dual a)  
Monoid b => Monoid (a > b)  
(Monoid a, Monoid b) => Monoid (a, b)  
Monoid (Proxy k s)  
Monoid a => Monoid (Const a b)  
(Monoid a, Monoid b, Monoid c) => Monoid (a, b, c)  
Alternative f => Monoid (Alt * f a)  
(Monoid a, Monoid b, Monoid c, Monoid d) => Monoid (a, b, c, d)  
(Monoid a, Monoid b, Monoid c, Monoid d, Monoid e) => Monoid (a, b, c, d, e) 
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
satisfy these laws.
fmap :: (a > b) > f a > f b Source
(<$) :: a > f b > f a infixl 4 Source
Replace all locations in the input with the same value. The default definition is fmap . const
, but this may be overridden with a more efficient version.
Functor []  
Functor IO  
Functor Maybe  
Functor ReadP  
Functor ReadPrec  
Functor Last  
Functor First  
Functor STM  
Functor Handler  
Functor ZipList  
Functor Identity  
Functor ArgDescr  
Functor OptDescr  
Functor ArgOrder  
Functor ((>) r)  
Functor (Either a)  
Functor ((,) a)  
Functor (ST s)  
Functor (Proxy *)  
Arrow a => Functor (ArrowMonad a)  
Monad m => Functor (WrappedMonad m)  
Functor (Const m)  
Functor (ST s)  
Functor f => Functor (Alt * f)  
Arrow a => Functor (WrappedArrow a b) 
(<$>) :: Functor f => (a > b) > f a > f b infixl 4 Source
An infix synonym for fmap
.
Convert from a Maybe Int
to a Maybe String
using show
:
>>>
show <$> Nothing
Nothing>>>
show <$> Just 3
Just "3"
Convert from an Either Int Int
to an Either Int
String
using show
:
>>>
show <$> Left 17
Left 17>>>
show <$> Right 17
Right "17"
Double each element of a list:
>>>
(*2) <$> [1,2,3]
[2,4,6]
Apply even
to the second element of a pair:
>>>
even <$> (2,2)
(2,True)
class Functor f => Applicative f where Source
A functor with application, providing operations to
A minimal complete definition must include implementations of these functions satisfying the following laws:
pure
id
<*>
v = v
pure
(.)<*>
u<*>
v<*>
w = u<*>
(v<*>
w)
pure
f<*>
pure
x =pure
(f x)
u<*>
pure
y =pure
($
y)<*>
u
The other methods have the following default definitions, which may be overridden with equivalent specialized implementations:
As a consequence of these laws, the Functor
instance for f
will satisfy
If f
is also a Monad
, it should satisfy
(which implies that pure
and <*>
satisfy the applicative functor laws).
Lift a value.
(<*>) :: f (a > b) > f a > f b infixl 4 Source
Sequential application.
(*>) :: f a > f b > f b infixl 4 Source
Sequence actions, discarding the value of the first argument.
(<*) :: f a > f b > f a infixl 4 Source
Sequence actions, discarding the value of the second argument.
Applicative []  
Applicative IO  
Applicative Maybe  
Applicative ReadP  
Applicative ReadPrec  
Applicative Last  
Applicative First  
Applicative STM  
Applicative ZipList  
Applicative Identity  
Applicative ((>) a)  
Applicative (Either e)  
Monoid a => Applicative ((,) a)  
Applicative (ST s)  
Applicative (Proxy *)  
Arrow a => Applicative (ArrowMonad a)  
Monad m => Applicative (WrappedMonad m)  
Monoid m => Applicative (Const m)  
Applicative (ST s)  
Applicative f => Applicative (Alt * f)  
Arrow a => Applicative (WrappedArrow a b) 
class Applicative m => Monad m where Source
The Monad
class defines the basic operations over a monad, a concept from a branch of mathematics known as category theory. From the perspective of a Haskell programmer, however, it is best to think of a monad as an abstract datatype of actions. Haskell's do
expressions provide a convenient syntax for writing monadic expressions.
Instances of Monad
should satisfy the following laws:
Furthermore, the Monad
and Applicative
operations should relate as follows:
The above laws imply:
and that pure
and (<*>
) satisfy the applicative functor laws.
The instances of Monad
for lists, Maybe
and IO
defined in the Prelude satisfy these laws.
(>>=) :: forall a b. m a > (a > m b) > m b infixl 1 Source
Sequentially compose two actions, passing any value produced by the first as an argument to the second.
(>>) :: forall a b. m a > m b > m b infixl 1 Source
Sequentially compose two actions, discarding any value produced by the first, like sequencing operators (such as the semicolon) in imperative languages.
Inject a value into the monadic type.
Fail with a message. This operation is not part of the mathematical definition of a monad, but is invoked on patternmatch failure in a do
expression.
mapM_ :: (Foldable t, Monad m) => (a > m b) > t a > m () Source
Map each element of a structure to a monadic action, evaluate these actions from left to right, and ignore the results. For a version that doesn't ignore the results see mapM
.
As of base 4.8.0.0, mapM_
is just traverse_
, specialized to Monad
.
sequence_ :: (Foldable t, Monad m) => t (m a) > m () Source
Evaluate each monadic action in the structure from left to right, and ignore the results. For a version that doesn't ignore the results see sequence
.
As of base 4.8.0.0, sequence_
is just sequenceA_
, specialized to Monad
.
(=<<) :: Monad m => (a > m b) > m a > m b infixr 1 Source
Same as >>=
, but with the arguments interchanged.
Data structures that can be folded.
For example, given a data type
data Tree a = Empty  Leaf a  Node (Tree a) a (Tree a)
a suitable instance would be
instance Foldable Tree where foldMap f Empty = mempty foldMap f (Leaf x) = f x foldMap f (Node l k r) = foldMap f l `mappend` f k `mappend` foldMap f r
This is suitable even for abstract types, as the monoid is assumed to satisfy the monoid laws. Alternatively, one could define foldr
:
instance Foldable Tree where foldr f z Empty = z foldr f z (Leaf x) = f x z foldr f z (Node l k r) = foldr f (f k (foldr f z r)) l
Foldable
instances are expected to satisfy the following laws:
foldr f z t = appEndo (foldMap (Endo . f) t ) z
foldl f z t = appEndo (getDual (foldMap (Dual . Endo . flip f) t)) z
fold = foldMap id
sum
, product
, maximum
, and minimum
should all be essentially equivalent to foldMap
forms, such as
sum = getSum . foldMap Sum
but may be less defined.
If the type is also a Functor
instance, it should satisfy
foldMap f = fold . fmap f
which implies that
foldMap f . fmap g = foldMap (f . g)
foldMap :: Monoid m => (a > m) > t a > m Source
Map each element of the structure to a monoid, and combine the results.
foldr :: (a > b > b) > b > t a > b Source
Rightassociative fold of a structure.
foldr
f z =foldr
f z .toList
foldl :: (b > a > b) > b > t a > b Source
Leftassociative fold of a structure.
foldl
f z =foldl
f z .toList
foldr1 :: (a > a > a) > t a > a Source
A variant of foldr
that has no base case, and thus may only be applied to nonempty structures.
foldr1
f =foldr1
f .toList
foldl1 :: (a > a > a) > t a > a Source
A variant of foldl
that has no base case, and thus may only be applied to nonempty structures.
foldl1
f =foldl1
f .toList
Test whether the structure is empty. The default implementation is optimized for structures that are similar to conslists, because there is no general way to do better.
Returns the size/length of a finite structure as an Int
. The default implementation is optimized for structures that are similar to conslists, because there is no general way to do better.
elem :: Eq a => a > t a > Bool infix 4 Source
Does the element occur in the structure?
maximum :: forall a. Ord a => t a > a Source
The largest element of a nonempty structure.
minimum :: forall a. Ord a => t a > a Source
The least element of a nonempty structure.
sum :: Num a => t a > a Source
The sum
function computes the sum of the numbers of a structure.
product :: Num a => t a > a Source
The product
function computes the product of the numbers of a structure.
class (Functor t, Foldable t) => Traversable t where Source
Functors representing data structures that can be traversed from left to right.
A definition of traverse
must satisfy the following laws:
t . traverse f = traverse (t . f)
for every applicative transformation t
traverse Identity = Identity
traverse (Compose . fmap g . f) = Compose . fmap (traverse g) . traverse f
A definition of sequenceA
must satisfy the following laws:
t . sequenceA = sequenceA . fmap t
for every applicative transformation t
sequenceA . fmap Identity = Identity
sequenceA . fmap Compose = Compose . fmap sequenceA . sequenceA
where an applicative transformation is a function
t :: (Applicative f, Applicative g) => f a > g a
preserving the Applicative
operations, i.e.
and the identity functor Identity
and composition of functors Compose
are defined as
newtype Identity a = Identity a instance Functor Identity where fmap f (Identity x) = Identity (f x) instance Applicative Indentity where pure x = Identity x Identity f <*> Identity x = Identity (f x) newtype Compose f g a = Compose (f (g a)) instance (Functor f, Functor g) => Functor (Compose f g) where fmap f (Compose x) = Compose (fmap (fmap f) x) instance (Applicative f, Applicative g) => Applicative (Compose f g) where pure x = Compose (pure (pure x)) Compose f <*> Compose x = Compose ((<*>) <$> f <*> x)
(The naturality law is implied by parametricity.)
Instances are similar to Functor
, e.g. given a data type
data Tree a = Empty  Leaf a  Node (Tree a) a (Tree a)
a suitable instance would be
instance Traversable Tree where traverse f Empty = pure Empty traverse f (Leaf x) = Leaf <$> f x traverse f (Node l k r) = Node <$> traverse f l <*> f k <*> traverse f r
This is suitable even for abstract types, as the laws for <*>
imply a form of associativity.
The superclass instances should satisfy the following:
Functor
instance, fmap
should be equivalent to traversal with the identity applicative functor (fmapDefault
).Foldable
instance, foldMap
should be equivalent to traversal with a constant applicative functor (foldMapDefault
).traverse :: Applicative f => (a > f b) > t a > f (t b) Source
Map each element of a structure to an action, evaluate these actions from left to right, and collect the results. For a version that ignores the results see traverse_
.
sequenceA :: Applicative f => t (f a) > f (t a) Source
Evaluate each action in the structure from left to right, and and collect the results. For a version that ignores the results see sequenceA_
.
mapM :: Monad m => (a > m b) > t a > m (t b) Source
Map each element of a structure to a monadic action, evaluate these actions from left to right, and collect the results. For a version that ignores the results see mapM_
.
sequence :: Monad m => t (m a) > m (t a) Source
Evaluate each monadic action in the structure from left to right, and collect the results. For a version that ignores the results see sequence_
.
Traversable []  
Traversable Maybe  
Traversable Identity  
Traversable (Either a)  
Traversable ((,) a)  
Traversable (Proxy *)  
Traversable (Const m) 
Identity function.
Constant function.
(.) :: (b > c) > (a > b) > a > c infixr 9 Source
Function composition.
flip :: (a > b > c) > b > a > c Source
flip f
takes its (first) two arguments in the reverse order of f
.
($) :: (a > b) > a > b infixr 0 Source
Application operator. This operator is redundant, since ordinary application (f x)
means the same as (f $ x)
. However, $
has low, rightassociative binding precedence, so it sometimes allows parentheses to be omitted; for example:
f $ g $ h x = f (g (h x))
It is also useful in higherorder situations, such as map ($ 0) xs
, or zipWith ($) fs xs
.
until :: (a > Bool) > (a > a) > a > a Source
until p f
yields the result of applying f
until p
holds.
asTypeOf :: a > a > a Source
asTypeOf
is a typerestricted version of const
. It is usually used as an infix operator, and its typing forces its first argument (which is usually overloaded) to have the same type as the second.
error
stops execution and displays an error message.
A special case of error
. It is expected that compilers will recognize this and insert error messages which are more appropriate to the context in which undefined
appears.
The value of seq a b
is bottom if a
is bottom, and otherwise equal to b
. seq
is usually introduced to improve performance by avoiding unneeded laziness.
A note on evaluation order: the expression seq a b
does not guarantee that a
will be evaluated before b
. The only guarantee given by seq
is that the both a
and b
will be evaluated before seq
returns a value. In particular, this means that b
may be evaluated before a
. If you need to guarantee a specific order of evaluation, you must use the function pseq
from the "parallel" package.
($!) :: (a > b) > a > b infixr 0 Source
Strict (callbyvalue) application operator. It takes a function and an argument, evaluates the argument to weak head normal form (WHNF), then calls the function with that value.
map :: (a > b) > [a] > [b] Source
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] infixr 5 Source
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] Source
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]
Extract the first element of a list, which must be nonempty.
Extract the last element of a list, which must be finite and nonempty.
Extract the elements after the head of a list, which must be nonempty.
Return all the elements of a list except the last one. The list must be nonempty.
(!!) :: [a] > Int > a infixl 9 Source
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
xs
returns the elements of xs
in reverse order. xs
must be finite.
and :: Foldable t => t Bool > Bool Source
and
returns the conjunction of a container of Bools. For the result to be True
, the container must be finite; False
, however, results from a False
value finitely far from the left end.
or :: Foldable t => t Bool > Bool Source
or
returns the disjunction of a container of Bools. For the result to be False
, the container must be finite; True
, however, results from a True
value finitely far from the left end.
any :: Foldable t => (a > Bool) > t a > Bool Source
Determines whether any element of the structure satisfies the predicate.
all :: Foldable t => (a > Bool) > t a > Bool Source
Determines whether all elements of the structure satisfy the predicate.
concat :: Foldable t => t [a] > [a] Source
The concatenation of all the elements of a container of lists.
concatMap :: Foldable t => (a > [b]) > t a > [b] Source
Map a function over all the elements of a container and concatenate the resulting lists.
scanl :: (b > a > b) > b > [a] > [b] Source
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] Source
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] Source
scanr
is the righttoleft dual of scanl
. Note that
head (scanr f z xs) == foldr f z xs.
scanr1 :: (a > a > a) > [a] > [a] Source
scanr1
is a variant of scanr
that has no starting value argument.
iterate :: (a > a) > a > [a] Source
iterate
f x
returns an infinite list of repeated applications of f
to x
:
iterate f x == [x, f x, f (f x), ...]
repeat
x
is an infinite list, with x
the value of every element.
replicate :: Int > a > [a] Source
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
ties a finite list into a circular one, or equivalently, the infinite repetition of the original list. It is the identity on infinite lists.
take :: Int > [a] > [a] Source
take
n
, applied to a list xs
, returns the prefix of xs
of length n
, or xs
itself if n > length xs
:
take 5 "Hello World!" == "Hello" take 3 [1,2,3,4,5] == [1,2,3] take 3 [1,2] == [1,2] take 3 [] == [] take (1) [1,2] == [] take 0 [1,2] == []
It is an instance of the more general genericTake
, in which n
may be of any integral type.
drop :: Int > [a] > [a] Source
drop
n xs
returns the suffix of xs
after the first n
elements, or []
if n > length xs
:
drop 6 "Hello World!" == "World!" drop 3 [1,2,3,4,5] == [4,5] drop 3 [1,2] == [] drop 3 [] == [] drop (1) [1,2] == [1,2] drop 0 [1,2] == [1,2]
It is an instance of the more general genericDrop
, in which n
may be of any integral type.
splitAt :: Int > [a] > ([a], [a]) Source
splitAt
n xs
returns a tuple where first element is xs
prefix of length n
and second element is the remainder of the list:
splitAt 6 "Hello World!" == ("Hello ","World!") splitAt 3 [1,2,3,4,5] == ([1,2,3],[4,5]) splitAt 1 [1,2,3] == ([1],[2,3]) splitAt 3 [1,2,3] == ([1,2,3],[]) splitAt 4 [1,2,3] == ([1,2,3],[]) splitAt 0 [1,2,3] == ([],[1,2,3]) splitAt (1) [1,2,3] == ([],[1,2,3])
It is equivalent to (take n xs, drop n xs)
when n
is not __
(splitAt __ xs = __
). splitAt
is an instance of the more general genericSplitAt
, in which n
may be of any integral type.
takeWhile :: (a > Bool) > [a] > [a] Source
takeWhile
, applied to a predicate p
and a list xs
, returns the longest prefix (possibly empty) of xs
of elements that satisfy p
:
takeWhile (< 3) [1,2,3,4,1,2,3,4] == [1,2] takeWhile (< 9) [1,2,3] == [1,2,3] takeWhile (< 0) [1,2,3] == []
dropWhile :: (a > Bool) > [a] > [a] Source
dropWhile
p xs
returns the suffix remaining after takeWhile
p xs
:
dropWhile (< 3) [1,2,3,4,5,1,2,3] == [3,4,5,1,2,3] dropWhile (< 9) [1,2,3] == [] dropWhile (< 0) [1,2,3] == [1,2,3]
span :: (a > Bool) > [a] > ([a], [a]) Source
span
, applied to a predicate p
and a list xs
, returns a tuple where first element is longest prefix (possibly empty) of xs
of elements that satisfy p
and second element is the remainder of the list:
span (< 3) [1,2,3,4,1,2,3,4] == ([1,2],[3,4,1,2,3,4]) span (< 9) [1,2,3] == ([1,2,3],[]) span (< 0) [1,2,3] == ([],[1,2,3])
span
p xs
is equivalent to (takeWhile p xs, dropWhile p xs)
break :: (a > Bool) > [a] > ([a], [a]) Source
break
, applied to a predicate p
and a list xs
, returns a tuple where first element is longest prefix (possibly empty) of xs
of elements that do not satisfy p
and second element is the remainder of the list:
break (> 3) [1,2,3,4,1,2,3,4] == ([1,2,3],[4,1,2,3,4]) break (< 9) [1,2,3] == ([],[1,2,3]) break (> 9) [1,2,3] == ([1,2,3],[])
break
p
is equivalent to span (not . p)
.
notElem :: (Foldable t, Eq a) => a > t a > Bool infix 4 Source
notElem
is the negation of elem
.
lookup :: Eq a => a > [(a, b)] > Maybe b Source
lookup
key assocs
looks up a key in an association list.
zip :: [a] > [b] > [(a, b)] Source
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.
zip
is rightlazy:
zip [] __ = []
zip3 :: [a] > [b] > [c] > [(a, b, c)] Source
zip3
takes three lists and returns a list of triples, analogous to zip
.
zipWith :: (a > b > c) > [a] > [b] > [c] Source
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.
zipWith
is rightlazy:
zipWith f [] __ = []
zipWith3 :: (a > b > c > d) > [a] > [b] > [c] > [d] Source
The zipWith3
function takes a function which combines three elements, as well as three lists and returns a list of their pointwise combination, analogous to zipWith
.
unzip :: [(a, b)] > ([a], [b]) Source
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]) Source
The unzip3
function takes a list of triples and returns three lists, analogous to unzip
.
lines :: String > [String] Source
lines
breaks a string up into a list of strings at newline characters. The resulting strings do not contain newlines.
words :: String > [String] Source
words
breaks a string up into a list of words, which were delimited by white space.
unlines :: [String] > String Source
unlines
is an inverse operation to lines
. It joins lines, after appending a terminating newline to each.
unwords :: [String] > String Source
unwords
is an inverse operation to words
. It joins words with separating spaces.
String
type ShowS = String > String Source
The shows
functions return a function that prepends the output String
to an existing String
. This allows constanttime concatenation of results using function composition.
Conversion of values to readable String
s.
Derived instances of Show
have the following properties, which are compatible with derived instances of Read
:
show
is a syntactically correct Haskell expression containing only constants, given the fixity declarations in force at the point where the type is declared. It contains only the constructor names defined in the data type, parentheses, and spaces. When labelled constructor fields are used, braces, commas, field names, and equal signs are also used.showsPrec
will produce infix applications of the constructor.x
is less than d
(associativity is ignored). Thus, if d
is 0
then the result is never surrounded in parentheses; if d
is 11
it is always surrounded in parentheses, unless it is an atomic expression.show
will produce the recordsyntax form, with the fields given in the same order as the original declaration.For example, given the declarations
infixr 5 :^: data Tree a = Leaf a  Tree a :^: Tree a
the derived instance of Show
is equivalent to
instance (Show a) => Show (Tree a) where showsPrec d (Leaf m) = showParen (d > app_prec) $ showString "Leaf " . showsPrec (app_prec+1) m where app_prec = 10 showsPrec d (u :^: v) = showParen (d > up_prec) $ showsPrec (up_prec+1) u . showString " :^: " . showsPrec (up_prec+1) v where up_prec = 5
Note that rightassociativity of :^:
is ignored. For example,
show (Leaf 1 :^: Leaf 2 :^: Leaf 3)
produces the string "Leaf 1 :^: (Leaf 2 :^: Leaf 3)"
.:: Int  the operator precedence of the enclosing context (a number from 
> a  the value to be converted to a 
> ShowS 
Convert a value to a readable String
.
showsPrec
should satisfy the law
showsPrec d x r ++ s == showsPrec d x (r ++ s)
Derived instances of Read
and Show
satisfy the following:
That is, readsPrec
parses the string produced by showsPrec
, and delivers the value that showsPrec
started with.
A specialised variant of showsPrec
, using precedence context zero, and returning an ordinary String
.
showList :: [a] > ShowS Source
The method showList
is provided to allow the programmer to give a specialised way of showing lists of values. For example, this is used by the predefined Show
instance of the Char
type, where values of type String
should be shown in double quotes, rather than between square brackets.
shows :: Show a => a > ShowS Source
equivalent to showsPrec
with a precedence of 0.
showChar :: Char > ShowS Source
utility function converting a Char
to a show function that simply prepends the character unchanged.
showString :: String > ShowS Source
utility function converting a String
to a show function that simply prepends the string unchanged.
showParen :: Bool > ShowS > ShowS Source
utility function that surrounds the inner show function with parentheses when the Bool
parameter is True
.
String
type ReadS a = String > [(a, String)] Source
A parser for a type a
, represented as a function that takes a String
and returns a list of possible parses as (a,String)
pairs.
Note that this kind of backtracking parser is very inefficient; reading a large structure may be quite slow (cf ReadP
).
Parsing of String
s, producing values.
Derived instances of Read
make the following assumptions, which derived instances of Show
obey:
Read
instance will parse only infix applications of the constructor (not the prefix form).Read
will parse only the recordsyntax form, and furthermore, the fields must be given in the same order as the original declaration.Read
instance allows arbitrary Haskell whitespace between tokens of the input string. Extra parentheses are also allowed.For example, given the declarations
infixr 5 :^: data Tree a = Leaf a  Tree a :^: Tree a
the derived instance of Read
in Haskell 2010 is equivalent to
instance (Read a) => Read (Tree a) where readsPrec d r = readParen (d > app_prec) (\r > [(Leaf m,t)  ("Leaf",s) < lex r, (m,t) < readsPrec (app_prec+1) s]) r ++ readParen (d > up_prec) (\r > [(u:^:v,w)  (u,s) < readsPrec (up_prec+1) r, (":^:",t) < lex s, (v,w) < readsPrec (up_prec+1) t]) r where app_prec = 10 up_prec = 5
Note that rightassociativity of :^:
is unused.
The derived instance in GHC is equivalent to
instance (Read a) => Read (Tree a) where readPrec = parens $ (prec app_prec $ do Ident "Leaf" < lexP m < step readPrec return (Leaf m)) +++ (prec up_prec $ do u < step readPrec Symbol ":^:" < lexP v < step readPrec return (u :^: v)) where app_prec = 10 up_prec = 5 readListPrec = readListPrecDefault
:: Int  the operator precedence of the enclosing context (a number from 
> ReadS a 
attempts to parse a value from the front of the string, returning a list of (parsed value, remaining string) pairs. If there is no successful parse, the returned list is empty.
Derived instances of Read
and Show
satisfy the following:
That is, readsPrec
parses the string produced by showsPrec
, and delivers the value that showsPrec
started with.
The method readList
is provided to allow the programmer to give a specialised way of parsing lists of values. For example, this is used by the predefined Read
instance of the Char
type, where values of type String
should be are expected to use double quotes, rather than square brackets.
reads :: Read a => ReadS a Source
equivalent to readsPrec
with a precedence of 0.
readParen :: Bool > ReadS a > ReadS a Source
readParen True p
parses what p
parses, but surrounded with parentheses.
readParen False p
parses what p
parses, but optionally surrounded with parentheses.
read :: Read a => String > a Source
The read
function reads input from a string, which must be completely consumed by the input process.
The lex
function reads a single lexeme from the input, discarding initial white space, and returning the characters that constitute the lexeme. If the input string contains only white space, lex
returns a single successful `lexeme' consisting of the empty string. (Thus lex "" = [("","")]
.) If there is no legal lexeme at the beginning of the input string, lex
fails (i.e. returns []
).
This lexer is not completely faithful to the Haskell lexical syntax in the following respects:
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.
Monad IO  
Functor IO  
MonadFix IO  
Applicative IO  
(~) * a () => HPrintfType (IO a)  
(~) * a () => PrintfType (IO a) 
putChar :: Char > IO () Source
Write a character to the standard output device (same as hPutChar
stdout
).
putStr :: String > IO () Source
Write a string to the standard output device (same as hPutStr
stdout
).
putStrLn :: String > IO () Source
The same as putStr
, but adds a newline character.
print :: Show a => a > IO () Source
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]])
Read a character from the standard input device (same as hGetChar
stdin
).
Read a line from the standard input device (same as hGetLine
stdin
).
getContents :: IO String Source
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 () Source
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.
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 Source
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 () Source
The computation writeFile
file str
function writes the string str
, to the file file
.
appendFile :: FilePath > String > IO () Source
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 Source
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 Source
The readLn
function combines getLine
and readIO
.
type IOError = IOException Source
The Haskell 2010 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 Control.Exception.Exception.
In Haskell 2010, this is an opaque type.
ioError :: IOError > IO a Source
Raise an IOError
in the IO
monad.
userError :: String > IOError Source
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)
© The University of Glasgow and others
Licensed under a BSDstyle license (see top of the page).
https://downloads.haskell.org/~ghc/7.10.3/docs/html/libraries/base4.8.2.0/Prelude.html