Safe Haskell  None 

Language  Haskell98 
Synopsis
 data Bool
 bool :: a > a > Bool > a
 (&&) :: Bool > Bool > Bool
 () :: Bool > Bool > Bool
 not :: Bool > Bool
 otherwise :: Bool
 data Char
 data Integer
 data Int
 data Int8
 data Int16
 data Int32
 data Int64
 data Word64
 fromIntegral :: (Integral a, Num b) => a > b
 fromRational :: Fractional a => Rational > a
 class Semigroup a => Monoid a where
 (<>) :: Semigroup a => a > a > a
 class Functor (f :: Type > Type) where
 (<$>) :: Functor f => (a > b) > f a > f b
 ($>) :: Functor f => f a > b > f b
 void :: Functor f => f a > f ()
 with :: Functor f => f a > (a > b) > f b
 class Bifunctor (p :: Type > Type > Type) where
 class Functor f => Applicative (f :: Type > Type) where
 (<**>) :: Applicative f => f a > f (a > b) > f b
 class Applicative f => Alternative (f :: Type > Type) where
 asum :: (Foldable t, Alternative f) => t (f a) > f a
 class Applicative m => Monad (m :: Type > Type) where
 (=<<) :: Monad m => (a > m b) > m a > m b
 join :: Monad m => m (m a) > m a
 forM :: (Traversable t, Monad m) => t a > (a > m b) > m (t b)
 forM_ :: (Foldable t, Monad m) => t a > (a > m b) > m ()
 mapM_ :: (Foldable t, Monad m) => (a > m b) > t a > m ()
 when :: Applicative f => Bool > f () > f ()
 unless :: Applicative f => Bool > f () > f ()
 class (Alternative m, Monad m) => MonadPlus (m :: Type > Type) where
 guard :: Alternative f => Bool > f ()
 msum :: (Foldable t, MonadPlus m) => t (m a) > m a
 data Either a b
 either :: (a > c) > (b > c) > Either a b > c
 note :: a > Maybe b > Either a b
 data Maybe a
 fromMaybe :: a > Maybe a > a
 maybe :: b > (a > b) > Maybe a > b
 hush :: Either a b > Maybe b
 fst :: (a, b) > a
 snd :: (a, b) > b
 curry :: ((a, b) > c) > a > b > c
 uncurry :: (a > b > c) > (a, b) > c
 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 Num a where
 class Eq a where
 class Read a where
 readEither :: Read a => String > Either String a
 readMaybe :: Read a => String > Maybe a
 class Show a where
 type ShowS = String > String
 showString :: String > ShowS
 class Foldable (t :: Type > Type) where
 fold :: Monoid m => t m > m
 foldMap :: Monoid m => (a > m) > t a > m
 foldr :: (a > b > b) > b > t a > b
 foldr' :: (a > b > b) > b > t a > b
 foldl :: (b > a > b) > b > t a > b
 foldl' :: (b > a > b) > b > t a > b
 foldr1 :: (a > a > a) > t a > a
 foldl1 :: (a > a > a) > t a > a
 toList :: t a > [a]
 null :: t a > Bool
 length :: t a > Int
 elem :: Eq a => a > t a > Bool
 maximum :: Ord a => t a > a
 minimum :: Ord a => t a > a
 sum :: Num a => t a > a
 product :: Num a => t a > a
 for_ :: (Foldable t, Applicative f) => t a > (a > f b) > f ()
 all :: Foldable t => (a > Bool) > t a > Bool
 class Eq a => Ord a where
 data Ordering
 comparing :: Ord a => (b > a) > b > b > Ordering
 class (Functor t, Foldable t) => Traversable (t :: Type > Type) where
 traverse :: Applicative f => (a > f b) > t a > f (t b)
 sequenceA :: Applicative f => t (f a) > f (t a)
 mapM :: Monad m => (a > m b) > t a > m (t b)
 sequence :: Monad m => t (m a) > m (t a)
 for :: (Traversable t, Applicative f) => t a > (a > f b) > f (t b)
 traverse_ :: (Foldable t, Applicative f) => (a > f b) > t a > f ()
 id :: a > a
 (.) :: (b > c) > (a > b) > a > c
 ($) :: (a > b) > a > b
 ($!) :: (a > b) > a > b
 (&) :: a > (a > b) > b
 const :: a > b > a
 flip :: (a > b > c) > b > a > c
 fix :: (a > a) > a
 on :: (b > b > c) > (a > b) > a > a > c
 seq :: a > b > b
 data IO a
 type FilePath = String
 undefined :: HasCallStack => a
 error :: HasCallStack => [Char] > a
 trace :: [Char] > a > a
 traceM :: Applicative f => [Char] > f ()
 traceIO :: [Char] > IO ()
 data Text
 class Bounded a
Primitive types
Bool
Case analysis for the Bool
type.
evaluates to bool
x y px
when p
is False
, and evaluates to y
when p
is True
.
This is equivalent to if p then y else x
; that is, one can
think of it as an ifthenelse construct with its arguments
reordered.
Examples
Basic usage:
>>>
bool "foo" "bar" True
"bar">>>
bool "foo" "bar" False
"foo"
Confirm that
and bool
x y pif p then y else x
are
equivalent:
>>>
let p = True; x = "bar"; y = "foo"
>>>
bool x y p == if p then y else x
True>>>
let p = False
>>>
bool x y p == if p then y else x
True
Since: base4.7.0.0
Char
The character type Char
is an enumeration whose values represent
Unicode (or equivalently ISO/IEC 10646) code points (i.e. 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
).
Instances
Bounded Char  Since: base2.1 
Enum Char  Since: base2.1 
Eq Char  
Ord Char  
Read Char  Since: base2.1 
Show Char  Since: base2.1 
Foldable (URec Char :: Type > Type)  Since: base4.9.0.0 
Defined in Data.Foldable fold :: Monoid m => URec Char m > m # foldMap :: Monoid m => (a > m) > URec Char a > m # foldr :: (a > b > b) > b > URec Char a > b # foldr' :: (a > b > b) > b > URec Char a > b # foldl :: (b > a > b) > b > URec Char a > b # foldl' :: (b > a > b) > b > URec Char a > b # foldr1 :: (a > a > a) > URec Char a > a # foldl1 :: (a > a > a) > URec Char a > a # toList :: URec Char a > [a] # length :: URec Char a > Int # elem :: Eq a => a > URec Char a > Bool # maximum :: Ord a => URec Char a > a # minimum :: Ord a => URec Char a > a #  
Traversable (URec Char :: Type > Type)  Since: base4.9.0.0 
Int
Invariant: Jn#
and Jp#
are used iff value doesn't fit in S#
Useful properties resulting from the invariants:
Instances
Enum Integer  Since: base2.1 
Eq Integer  
Integral Integer  Since: base2.0.1 
Defined in GHC.Real  
Num Integer  Since: base2.1 
Ord Integer  
Read Integer  Since: base2.1 
Real Integer  Since: base2.0.1 
Defined in GHC.Real toRational :: Integer > Rational #  
Show Integer  Since: base2.1 
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
Bounded Int  Since: base2.1 
Enum Int  Since: base2.1 
Eq Int  
Integral Int  Since: base2.0.1 
Num Int  Since: base2.1 
Ord Int  
Read Int  Since: base2.1 
Real Int  Since: base2.0.1 
Defined in GHC.Real toRational :: Int > Rational #  
Show Int  Since: base2.1 
Foldable (URec Int :: Type > Type)  Since: base4.9.0.0 
Defined in Data.Foldable fold :: Monoid m => URec Int m > m # foldMap :: Monoid m => (a > m) > URec Int a > m # foldr :: (a > b > b) > b > URec Int a > b # foldr' :: (a > b > b) > b > URec Int a > b # foldl :: (b > a > b) > b > URec Int a > b # foldl' :: (b > a > b) > b > URec Int a > b # foldr1 :: (a > a > a) > URec Int a > a # foldl1 :: (a > a > a) > URec Int a > a # elem :: Eq a => a > URec Int a > Bool # maximum :: Ord a => URec Int a > a # minimum :: Ord a => URec Int a > a #  
Traversable (URec Int :: Type > Type)  Since: base4.9.0.0 
8bit signed integer type
Instances
Bounded Int8  Since: base2.1 
Enum Int8  Since: base2.1 
Eq Int8  Since: base2.1 
Integral Int8  Since: base2.1 
Num Int8  Since: base2.1 
Ord Int8  Since: base2.1 
Read Int8  Since: base2.1 
Real Int8  Since: base2.1 
Defined in GHC.Int toRational :: Int8 > Rational #  
Show Int8  Since: base2.1 
Ix Int8  Since: base2.1 
Bits Int8  Since: base2.1 
Defined in GHC.Int (.&.) :: Int8 > Int8 > Int8 # (..) :: Int8 > Int8 > Int8 # complement :: Int8 > Int8 # shift :: Int8 > Int > Int8 # rotate :: Int8 > Int > Int8 # setBit :: Int8 > Int > Int8 # clearBit :: Int8 > Int > Int8 # complementBit :: Int8 > Int > Int8 # testBit :: Int8 > Int > Bool # bitSizeMaybe :: Int8 > Maybe Int # shiftL :: Int8 > Int > Int8 # unsafeShiftL :: Int8 > Int > Int8 # shiftR :: Int8 > Int > Int8 # unsafeShiftR :: Int8 > Int > Int8 # rotateL :: Int8 > Int > Int8 #  
FiniteBits Int8  Since: base4.6.0.0 
Defined in GHC.Int 
16bit signed integer type
Instances
32bit signed integer type
Instances
64bit signed integer type
Instances
Word
64bit unsigned integer type
Instances
Real
fromIntegral :: (Integral a, Num b) => a > b #
general coercion from integral types
fromRational :: Fractional a => Rational > a #
Conversion from a Rational
(that is
).
A floating literal stands for an application of Ratio
Integer
fromRational
to a value of type Rational
, so such literals have type
(
.Fractional
a) => a
Algebraic structures
Monoid
class Semigroup a => Monoid a where #
The class of monoids (types with an associative binary operation that has an identity). Instances should satisfy the following laws:
x
<>
mempty
= xmempty
<>
x = xx
(<>
(y<>
z) = (x<>
y)<>
zSemigroup
law)mconcat
=foldr
'(<>)'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
.
NOTE: Semigroup
is a superclass of Monoid
since base4.11.0.0.
Identity of mappend
An associative operation
NOTE: This method is redundant and has the default
implementation
since base4.11.0.0.mappend
= '(<>)'
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.
Instances
Monoid Ordering  Since: base2.1 
Monoid ()  Since: base2.1 
Monoid [a]  Since: base2.1 
Semigroup a => Monoid (Maybe a)  Lift a semigroup into Since 4.11.0: constraint on inner Since: base2.1 
Monoid a => Monoid (IO a)  Since: base4.9.0.0 
Monoid (First a)  Since: base2.1 
Monoid (Last a)  Since: base2.1 
Monoid a => Monoid (Down a)  Since: base4.11.0.0 
Monoid b => Monoid (a > b)  Since: base2.1 
(Monoid a, Monoid b) => Monoid (a, b)  Since: base2.1 
(Monoid a, Monoid b, Monoid c) => Monoid (a, b, c)  Since: base2.1 
(Applicative f, Monoid a) => Monoid (Ap f a)  Since: base4.12.0.0 
(Monoid a, Monoid b, Monoid c, Monoid d) => Monoid (a, b, c, d)  Since: base2.1 
(Monoid a, Monoid b, Monoid c, Monoid d, Monoid e) => Monoid (a, b, c, d, e)  Since: base2.1 
Functor
class Functor (f :: Type > Type) 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
satisfy these laws.
Instances
Functor []  Since: base2.1 
Functor Maybe  Since: base2.1 
Functor IO  Since: base2.1 
Functor ZipList  Since: base2.1 
Functor First  Since: base4.8.0.0 
Functor Last  Since: base4.8.0.0 
Functor Down  Since: base4.11.0.0 
Functor NonEmpty  Since: base4.9.0.0 
Functor (Either a)  Since: base3.0 
Functor ((,) a)  Since: base2.1 
Monad m => Functor (WrappedMonad m)  Since: base2.1 
Defined in Control.Applicative fmap :: (a > b) > WrappedMonad m a > WrappedMonad m b # (<$) :: a > WrappedMonad m b > WrappedMonad m a #  
Arrow a => Functor (ArrowMonad a)  Since: base4.6.0.0 
Defined in Control.Arrow fmap :: (a0 > b) > ArrowMonad a a0 > ArrowMonad a b # (<$) :: a0 > ArrowMonad a b > ArrowMonad a a0 #  
Arrow a => Functor (WrappedArrow a b)  Since: base2.1 
Defined in Control.Applicative fmap :: (a0 > b0) > WrappedArrow a b a0 > WrappedArrow a b b0 # (<$) :: a0 > WrappedArrow a b b0 > WrappedArrow a b a0 #  
Functor f => Functor (Ap f)  Since: base4.12.0.0 
Functor ((>) r :: Type > Type)  Since: base2.1 
(<$>) :: Functor f => (a > b) > f a > f b infixl 4 #
An infix synonym for fmap
.
The name of this operator is an allusion to $
.
Note the similarities between their types:
($) :: (a > b) > a > b (<$>) :: Functor f => (a > b) > f a > f b
Whereas $
is function application, <$>
is function
application lifted over a Functor
.
Examples
Convert from a
to a Maybe
Int
using Maybe
String
show
:
>>>
show <$> Nothing
Nothing>>>
show <$> Just 3
Just "3"
Convert from an
to an Either
Int
Int
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)
($>) :: Functor f => f a > b > f b infixl 4 #
Flipped version of <$
.
Examples
Replace the contents of a
with a constant Maybe
Int
String
:
>>>
Nothing $> "foo"
Nothing>>>
Just 90210 $> "foo"
Just "foo"
Replace the contents of an
with a constant
Either
Int
Int
String
, resulting in an
:Either
Int
String
>>>
Left 8675309 $> "foo"
Left 8675309>>>
Right 8675309 $> "foo"
Right "foo"
Replace each element of a list with a constant String
:
>>>
[1,2,3] $> "foo"
["foo","foo","foo"]
Replace the second element of a pair with a constant String
:
>>>
(1,2) $> "foo"
(1,"foo")
Since: base4.7.0.0
void :: Functor f => f a > f () #
discards or ignores the result of evaluation, such
as the return value of an void
valueIO
action.
Examples
Replace the contents of a
with unit:Maybe
Int
>>>
void Nothing
Nothing>>>
void (Just 3)
Just ()
Replace the contents of an
with unit,
resulting in an Either
Int
Int
:Either
Int
'()'
>>>
void (Left 8675309)
Left 8675309>>>
void (Right 8675309)
Right ()
Replace every element of a list with unit:
>>>
void [1,2,3]
[(),(),()]
Replace the second element of a pair with unit:
>>>
void (1,2)
(1,())
Discard the result of an IO
action:
>>>
mapM print [1,2]
1 2 [(),()]>>>
void $ mapM print [1,2]
1 2
Bifunctor
class Bifunctor (p :: Type > Type > Type) where #
A bifunctor is a type constructor that takes
two type arguments and is a functor in both arguments. That
is, unlike with Functor
, a type constructor such as Either
does not need to be partially applied for a Bifunctor
instance, and the methods in this class permit mapping
functions over the Left
value or the Right
value,
or both at the same time.
Formally, the class Bifunctor
represents a bifunctor
from Hask
> Hask
.
Intuitively it is a bifunctor where both the first and second arguments are covariant.
You can define a Bifunctor
by either defining bimap
or by
defining both first
and second
.
If you supply bimap
, you should ensure that:
bimap
id
id
≡id
If you supply first
and second
, ensure:
first
id
≡id
second
id
≡id
If you supply both, you should also ensure:
bimap
f g ≡first
f.
second
g
These ensure by parametricity:
bimap
(f.
g) (h.
i) ≡bimap
f h.
bimap
g ifirst
(f.
g) ≡first
f.
first
gsecond
(f.
g) ≡second
f.
second
g
Since: base4.8.0.0
bimap :: (a > b) > (c > d) > p a c > p b d #
Map over both arguments at the same time.
bimap
f g ≡first
f.
second
g
Examples
>>>
bimap toUpper (+1) ('j', 3)
('J',4)
>>>
bimap toUpper (+1) (Left 'j')
Left 'J'
>>>
bimap toUpper (+1) (Right 3)
Right 4
Instances
Bifunctor Either  Since: base4.8.0.0 
Bifunctor (,)  Since: base4.8.0.0 
Bifunctor ((,,) x1)  Since: base4.8.0.0 
Bifunctor (Const :: Type > Type > Type)  Since: base4.8.0.0 
Bifunctor (K1 i :: Type > Type > Type)  Since: base4.9.0.0 
Bifunctor ((,,,) x1 x2)  Since: base4.8.0.0 
Bifunctor ((,,,,) x1 x2 x3)  Since: base4.8.0.0 
Bifunctor ((,,,,,) x1 x2 x3 x4)  Since: base4.8.0.0 
Bifunctor ((,,,,,,) x1 x2 x3 x4 x5)  Since: base4.8.0.0 
Applicative
class Functor f => Applicative (f :: Type > Type) where #
A functor with application, providing operations to
A minimal complete definition must include implementations of pure
and of either <*>
or liftA2
. If it defines both, then they must behave
the same as their default definitions:
(<*>
) =liftA2
id
liftA2
f x y = f<$>
x<*>
y
Further, any definition must satisfy the following:
 identity
pure
id
<*>
v = v composition
pure
(.)<*>
u<*>
v<*>
w = u<*>
(v<*>
w) homomorphism
pure
f<*>
pure
x =pure
(f x) interchange
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
It may be useful to note that supposing
forall x y. p (q x y) = f x . g y
it follows from the above that
liftA2
p (liftA2
q u v) =liftA2
f u .liftA2
g v
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 #
Sequential application.
A few functors support an implementation of <*>
that is more
efficient than the default one.
liftA2 :: (a > b > c) > f a > f b > f c #
Lift a binary function to actions.
Some functors support an implementation of liftA2
that is more
efficient than the default one. In particular, if fmap
is an
expensive operation, it is likely better to use liftA2
than to
fmap
over the structure and then use <*>
.
(*>) :: f a > f b > f b infixl 4 #
Sequence actions, discarding the value of the first argument.
(<*) :: f a > f b > f a infixl 4 #
Sequence actions, discarding the value of the second argument.
Instances
Applicative []  Since: base2.1 
Applicative Maybe  Since: base2.1 
Applicative IO  Since: base2.1 
Applicative ZipList  f '<$>' 'ZipList' xs1 '<*>' ... '<*>' 'ZipList' xsN = 'ZipList' (zipWithN f xs1 ... xsN) where (\a b c > stimes c [a, b]) <$> ZipList "abcd" <*> ZipList "567" <*> ZipList [1..] = ZipList (zipWith3 (\a b c > stimes c [a, b]) "abcd" "567" [1..]) = ZipList {getZipList = ["a5","b6b6","c7c7c7"]} Since: base2.1 
Applicative First  Since: base4.8.0.0 
Applicative Last  Since: base4.8.0.0 
Applicative Down  Since: base4.11.0.0 
Applicative NonEmpty  Since: base4.9.0.0 
Applicative (Either e)  Since: base3.0 
Monoid a => Applicative ((,) a)  For tuples, the ("hello ", (+15)) <*> ("world!", 2002) ("hello world!",2017) Since: base2.1 
Monad m => Applicative (WrappedMonad m)  Since: base2.1 
Defined in Control.Applicative pure :: a > WrappedMonad m a # (<*>) :: WrappedMonad m (a > b) > WrappedMonad m a > WrappedMonad m b # liftA2 :: (a > b > c) > WrappedMonad m a > WrappedMonad m b > WrappedMonad m c # (*>) :: WrappedMonad m a > WrappedMonad m b > WrappedMonad m b # (<*) :: WrappedMonad m a > WrappedMonad m b > WrappedMonad m a #  
Arrow a => Applicative (ArrowMonad a)  Since: base4.6.0.0 
Defined in Control.Arrow pure :: a0 > ArrowMonad a a0 # (<*>) :: ArrowMonad a (a0 > b) > ArrowMonad a a0 > ArrowMonad a b # liftA2 :: (a0 > b > c) > ArrowMonad a a0 > ArrowMonad a b > ArrowMonad a c # (*>) :: ArrowMonad a a0 > ArrowMonad a b > ArrowMonad a b # (<*) :: ArrowMonad a a0 > ArrowMonad a b > ArrowMonad a a0 #  
Arrow a => Applicative (WrappedArrow a b)  Since: base2.1 
Defined in Control.Applicative pure :: a0 > WrappedArrow a b a0 # (<*>) :: WrappedArrow a b (a0 > b0) > WrappedArrow a b a0 > WrappedArrow a b b0 # liftA2 :: (a0 > b0 > c) > WrappedArrow a b a0 > WrappedArrow a b b0 > WrappedArrow a b c # (*>) :: WrappedArrow a b a0 > WrappedArrow a b b0 > WrappedArrow a b b0 # (<*) :: WrappedArrow a b a0 > WrappedArrow a b b0 > WrappedArrow a b a0 #  
Applicative f => Applicative (Ap f)  Since: base4.12.0.0 
Applicative ((>) a :: Type > Type)  Since: base2.1 
(<**>) :: Applicative f => f a > f (a > b) > f b infixl 4 #
A variant of <*>
with the arguments reversed.
Alternative
class Applicative f => Alternative (f :: Type > Type) where #
A monoid on applicative functors.
If defined, some
and many
should be the least solutions
of the equations:
The identity of <>
(<>) :: f a > f a > f a infixl 3 #
An associative binary operation
One or more.
Zero or more.
Instances
asum :: (Foldable t, Alternative f) => t (f a) > f a #
Monad
class Applicative m => Monad (m :: Type > Type) where #
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.
(>>=) :: m a > (a > m b) > m b infixl 1 #
Sequentially compose two actions, passing any value produced by the first as an argument to the second.
(>>) :: m a > m b > m b infixl 1 #
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.
As part of the MonadFail proposal (MFP), this function is moved
to its own class MonadFail
(see Control.Monad.Fail for more
details). The definition here will be removed in a future
release.
Instances
Monad []  Since: base2.1 
Monad Maybe  Since: base2.1 
Monad IO  Since: base2.1 
Monad First  Since: base4.8.0.0 
Monad Last  Since: base4.8.0.0 
Monad Down  Since: base4.11.0.0 
Monad NonEmpty  Since: base4.9.0.0 
Monad (Either e)  Since: base4.4.0.0 
Monoid a => Monad ((,) a)  Since: base4.9.0.0 
Monad m => Monad (WrappedMonad m)  Since: base4.7.0.0 
Defined in Control.Applicative (>>=) :: WrappedMonad m a > (a > WrappedMonad m b) > WrappedMonad m b # (>>) :: WrappedMonad m a > WrappedMonad m b > WrappedMonad m b # return :: a > WrappedMonad m a # fail :: String > WrappedMonad m a #  
ArrowApply a => Monad (ArrowMonad a)  Since: base2.1 
Defined in Control.Arrow (>>=) :: ArrowMonad a a0 > (a0 > ArrowMonad a b) > ArrowMonad a b # (>>) :: ArrowMonad a a0 > ArrowMonad a b > ArrowMonad a b # return :: a0 > ArrowMonad a a0 # fail :: String > ArrowMonad a a0 #  
Monad f => Monad (Ap f)  Since: base4.12.0.0 
Monad ((>) r :: Type > Type)  Since: base2.1 
(=<<) :: Monad m => (a > m b) > m a > m b infixr 1 #
Same as >>=
, but with the arguments interchanged.
join :: Monad m => m (m a) > m a #
The join
function is the conventional monad join operator. It
is used to remove one level of monadic structure, projecting its
bound argument into the outer level.
Examples
A common use of join
is to run an IO
computation returned from
an STM
transaction, since STM
transactions
can't perform IO
directly. Recall that
atomically
:: STM a > IO a
is used to run STM
transactions atomically. So, by
specializing the types of atomically
and join
to
atomically
:: STM (IO b) > IO (IO b)join
:: IO (IO b) > IO b
we can compose them as
join
.atomically
:: STM (IO b) > IO b
forM :: (Traversable t, Monad m) => t a > (a > m b) > m (t b) #
when :: Applicative f => Bool > f () > f () #
Conditional execution of Applicative
expressions. For example,
when debug (putStrLn "Debugging")
will output the string Debugging
if the Boolean value debug
is True
, and otherwise do nothing.
unless :: Applicative f => Bool > f () > f () #
The reverse of when
.
MonadPlus
class (Alternative m, Monad m) => MonadPlus (m :: Type > Type) where #
Monads that also support choice and failure.
Nothing
The identity of mplus
. It should also satisfy the equations
mzero >>= f = mzero v >> mzero = mzero
The default definition is
mzero = empty
An associative operation. The default definition is
mplus = (<>
)
Instances
MonadPlus []  Since: base2.1 
MonadPlus Maybe  Since: base2.1 
MonadPlus IO  Since: base4.9.0.0 
(ArrowApply a, ArrowPlus a) => MonadPlus (ArrowMonad a)  Since: base4.6.0.0 
Defined in Control.Arrow mzero :: ArrowMonad a a0 # mplus :: ArrowMonad a a0 > ArrowMonad a a0 > ArrowMonad a a0 #  
MonadPlus f => MonadPlus (Ap f)  Since: base4.12.0.0 
guard :: Alternative f => Bool > f () #
Conditional failure of Alternative
computations. Defined by
guard True =pure
() guard False =empty
Examples
Common uses of guard
include conditionally signaling an error in
an error monad and conditionally rejecting the current choice in an
Alternative
based parser.
As an example of signaling an error in the error monad Maybe
,
consider a safe division function safeDiv x y
that returns
Nothing
when the denominator y
is zero and
otherwise. For example:Just
(x `div`
y)
>>> safeDiv 4 0 Nothing >>> safeDiv 4 2 Just 2
A definition of safeDiv
using guards, but not guard
:
safeDiv :: Int > Int > Maybe Int safeDiv x y  y /= 0 = Just (x `div` y)  otherwise = Nothing
A definition of safeDiv
using guard
and Monad
do
notation:
safeDiv :: Int > Int > Maybe Int safeDiv x y = do guard (y /= 0) return (x `div` y)
Data structures
Either
The Either
type represents values with two possibilities: a value of
type
is either Either
a b
or Left
a
.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").
Examples
The type
is the type of values which can be either
a Either
String
Int
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"
Instances
Bifunctor Either  Since: base4.8.0.0 
Monad (Either e)  Since: base4.4.0.0 
Functor (Either a)  Since: base3.0 
Applicative (Either e)  Since: base3.0 
Foldable (Either a)  Since: base4.7.0.0 
Defined in Data.Foldable fold :: Monoid m => Either a m > m # foldMap :: Monoid m => (a0 > m) > Either a a0 > m # foldr :: (a0 > b > b) > b > Either a a0 > b # foldr' :: (a0 > b > b) > b > Either a a0 > b # foldl :: (b > a0 > b) > b > Either a a0 > b # foldl' :: (b > a0 > b) > b > Either a a0 > b # foldr1 :: (a0 > a0 > a0) > Either a a0 > a0 # foldl1 :: (a0 > a0 > a0) > Either a a0 > a0 # toList :: Either a a0 > [a0] # length :: Either a a0 > Int # elem :: Eq a0 => a0 > Either a a0 > Bool # maximum :: Ord a0 => Either a a0 > a0 # minimum :: Ord a0 => Either a a0 > a0 #  
Traversable (Either a)  Since: base4.7.0.0 
(Eq a, Eq b) => Eq (Either a b)  Since: base2.1 
(Ord a, Ord b) => Ord (Either a b)  Since: base2.1 
(Read a, Read b) => Read (Either a b)  Since: base3.0 
(Show a, Show b) => Show (Either a b)  Since: base3.0 
Semigroup (Either a b)  Since: base4.9.0.0 
either :: (a > c) > (b > c) > Either a b > c #
Case analysis for the Either
type.
If the value is
, apply the first function to Left
aa
;
if it is
, apply the second function to Right
bb
.
Examples
We create two values of type
, one using the
Either
String
Int
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
Maybe
The Maybe
type encapsulates an optional value. A value of type
either contains a value of type Maybe
aa
(represented as
),
or it is empty (represented as Just
aNothing
). 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.
Instances
Monad Maybe  Since: base2.1 
Functor Maybe  Since: base2.1 
Applicative Maybe  Since: base2.1 
Foldable Maybe  Since: base2.1 
Defined in Data.Foldable fold :: Monoid m => Maybe m > m # foldMap :: Monoid m => (a > m) > Maybe a > m # foldr :: (a > b > b) > b > Maybe a > b # foldr' :: (a > b > b) > b > Maybe a > b # foldl :: (b > a > b) > b > Maybe a > b # foldl' :: (b > a > b) > b > Maybe a > b # foldr1 :: (a > a > a) > Maybe a > a # foldl1 :: (a > a > a) > Maybe a > a # elem :: Eq a => a > Maybe a > Bool # maximum :: Ord a => Maybe a > a # minimum :: Ord a => Maybe a > a #  
Traversable Maybe  Since: base2.1 
Alternative Maybe  Since: base2.1 
MonadPlus Maybe  Since: base2.1 
Eq a => Eq (Maybe a)  Since: base2.1 
Ord a => Ord (Maybe a)  Since: base2.1 
Read a => Read (Maybe a)  Since: base2.1 
Show a => Show (Maybe a)  Since: base2.1 
Semigroup a => Semigroup (Maybe a)  Since: base4.9.0.0 
Semigroup a => Monoid (Maybe a)  Lift a semigroup into Since 4.11.0: constraint on inner Since: base2.1 
fromMaybe :: a > Maybe a > a #
The fromMaybe
function takes a default value and and Maybe
value. If the Maybe
is Nothing
, it returns the default values;
otherwise, it returns the value contained in the Maybe
.
Examples
Basic usage:
>>>
fromMaybe "" (Just "Hello, World!")
"Hello, World!"
>>>
fromMaybe "" Nothing
""
Read an integer from a string using readMaybe
. If we fail to
parse an integer, we want to return 0
by default:
>>>
import Text.Read ( readMaybe )
>>>
fromMaybe 0 (readMaybe "5")
5>>>
fromMaybe 0 (readMaybe "")
0
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 the result.
Examples
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
""
Tuple
uncurry :: (a > b > c) > (a, b) > c #
uncurry
converts a curried function to a function on pairs.
Examples
>>>
uncurry (+) (1,2)
3
>>>
uncurry ($) (show, 1)
"1"
>>>
map (uncurry max) [(1,2), (3,4), (6,8)]
[2,4,8]
Typeclasses
Enum
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:
 The calls
andsucc
maxBound
should result in a runtime error.pred
minBound
fromEnum
andtoEnum
should give a runtime error if the result value is not representable in the result type. For example,
is an error.toEnum
7 ::Bool
enumFrom
andenumFromThen
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..]
with [n..] = enumFrom n
,
a possible implementation being enumFrom n = n : enumFrom (succ n)
.
For example:
enumFrom 4 :: [Integer] = [4,5,6,7,...]
enumFrom 6 :: [Int] = [6,7,8,9,...,maxBound :: Int]
enumFromThen :: a > a > [a] #
Used in Haskell's translation of [n,n'..]
with [n,n'..] = enumFromThen n n'
, a possible implementation being
enumFromThen n n' = n : n' : worker (f x) (f x n')
,
worker s v = v : worker s (s v)
, x = fromEnum n'  fromEnum n
and
f n y
 n > 0 = f (n  1) (succ y)
 n < 0 = f (n + 1) (pred y)
 otherwise = y
For example:
enumFromThen 4 6 :: [Integer] = [4,6,8,10...]
enumFromThen 6 2 :: [Int] = [6,2,2,6,...,minBound :: Int]
enumFromTo :: a > a > [a] #
Used in Haskell's translation of [n..m]
with
[n..m] = enumFromTo n m
, a possible implementation being
enumFromTo n m
 n <= m = n : enumFromTo (succ n) m
 otherwise = []
.
For example:
enumFromTo 6 10 :: [Int] = [6,7,8,9,10]
enumFromTo 42 1 :: [Integer] = []
enumFromThenTo :: a > a > a > [a] #
Used in Haskell's translation of [n,n'..m]
with
[n,n'..m] = enumFromThenTo n n' m
, a possible implementation
being enumFromThenTo n n' m = worker (f x) (c x) n m
,
x = fromEnum n'  fromEnum n
, c x = bool (>=) ((x 0)
f n y
 n > 0 = f (n  1) (succ y)
 n < 0 = f (n + 1) (pred y)
 otherwise = y
and
worker s c v m
 c v m = v : worker s c (s v) m
 otherwise = []
For example:
enumFromThenTo 4 2 6 :: [Integer] = [4,2,0,2,4,6]
enumFromThenTo 6 8 2 :: [Int] = []
Instances
Enum Bool  Since: base2.1 
Enum Char  Since: base2.1 
Enum Int  Since: base2.1 
Enum Int8  Since: base2.1 
Enum Int16  Since: base2.1 
Enum Int32  Since: base2.1 
Enum Int64  Since: base2.1 
Enum Integer  Since: base2.1 
Enum Natural  Since: base4.8.0.0 
Enum Ordering  Since: base2.1 
Enum Word  Since: base2.1 
Enum Word8  Since: base2.1 
Enum Word16  Since: base2.1 
Defined in GHC.Word  
Enum Word32  Since: base2.1 
Defined in GHC.Word  
Enum Word64  Since: base2.1 
Defined in GHC.Word  
Enum VecCount  Since: base4.10.0.0 
Enum VecElem  Since: base4.10.0.0 
Enum ()  Since: base2.1 
Integral a => Enum (Ratio a)  Since: base2.0.1 
Enum (f a) => Enum (Ap f a)  Since: base4.12.0.0 
Defined in Data.Monoid 
Num
Basic numeric class.
The Haskell Report defines no laws for Num
. However, '(+)' and '(*)' are
customarily expected to define a ring and have the following properties:
 Associativity of (+)
(x + y) + z
=x + (y + z)
 Commutativity of (+)
x + y
=y + x
fromInteger 0
is the additive identityx + fromInteger 0
=x
negate
gives the additive inversex + negate x
=fromInteger 0
 Associativity of (*)
(x * y) * z
=x * (y * z)
fromInteger 1
is the multiplicative identityx * fromInteger 1
=x
andfromInteger 1 * x
=x
 Distributivity of (*) with respect to (+)
a * (b + c)
=(a * b) + (a * c)
and(b + c) * a
=(b * a) + (c * a)
Note that it isn't customarily expected that a type instance of both Num
and Ord
implement an ordered ring. Indeed, in base
only Integer
and
Rational
do.
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 #
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
Instances
Num Int  Since: base2.1 
Num Int8  Since: base2.1 
Num Int16  Since: base2.1 
Num Int32  Since: base2.1 
Num Int64  Since: base2.1 
Num Integer  Since: base2.1 
Num Natural  Note that Since: base4.8.0.0 
Num Word  Since: base2.1 
Num Word8  Since: base2.1 
Num Word16  Since: base2.1 
Num Word32  Since: base2.1 
Num Word64  Since: base2.1 
Integral a => Num (Ratio a)  Since: base2.0.1 
Num a => Num (Down a)  Since: base4.11.0.0 
(Applicative f, Num a) => Num (Ap f a)  Since: base4.12.0.0 
Eq
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
.
The Haskell Report defines no laws for Eq
. However, ==
is customarily
expected to implement an equivalence relationship where two values comparing
equal are indistinguishable by "public" functions, with a "public" function
being one not allowing to see implementation details. For example, for a
type representing nonnormalised natural numbers modulo 100, a "public"
function doesn't make the difference between 1 and 201. It is expected to
have the following properties:
Instances
Eq Bool  
Eq Char  
Eq Double  Note that due to the presence of
Also note that

Eq Float  Note that due to the presence of
Also note that

Eq Int  
Eq Int8  Since: base2.1 
Eq Int16  Since: base2.1 
Eq Int32  Since: base2.1 
Eq Int64  Since: base2.1 
Eq Integer  
Eq Ordering  
Eq Word  
Eq Word8  Since: base2.1 
Eq Word16  Since: base2.1 
Eq Word32  Since: base2.1 
Eq Word64  Since: base2.1 
Eq ()  
Eq TyCon  
Eq Module  
Eq TrName  
Eq BigNat  
Eq MaskingState  Since: base4.3.0.0 
Defined in GHC.IO (==) :: MaskingState > MaskingState > Bool # (/=) :: MaskingState > MaskingState > Bool #  
Eq SrcLoc  Since: base4.9.0.0 
Eq a => Eq [a]  
Eq a => Eq (Maybe a)  Since: base2.1 
Eq a => Eq (Ratio a)  Since: base2.1 
Eq a => Eq (ZipList a)  Since: base4.7.0.0 
Eq a => Eq (First a)  Since: base2.1 
Eq a => Eq (Last a)  Since: base2.1 
Eq a => Eq (Down a)  Since: base4.6.0.0 
Eq a => Eq (NonEmpty a)  Since: base4.9.0.0 
(Eq a, Eq b) => Eq (Either a b)  Since: base2.1 
(Eq a, Eq b) => Eq (a, b)  
(Eq a, Eq b, Eq c) => Eq (a, b, c)  
Eq (f a) => Eq (Ap f a)  Since: base4.12.0.0 
(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)  
Read
Parsing of String
s, producing values.
Derived instances of Read
make the following assumptions, which
derived instances of Show
obey:
 If the constructor is defined to be an infix operator, then the
derived
Read
instance will parse only infix applications of the constructor (not the prefix form).  Associativity is not used to reduce the occurrence of parentheses, although precedence may be.
 If the constructor is defined using record syntax, the derived
Read
will parse only the recordsyntax form, and furthermore, the fields must be given in the same order as the original declaration.  The derived
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
Why do both readsPrec
and readPrec
exist, and why does GHC opt to
implement readPrec
in derived Read
instances instead of readsPrec
?
The reason is that readsPrec
is based on the ReadS
type, and although
ReadS
is mentioned in the Haskell 2010 Report, it is not a very efficient
parser data structure.
readPrec
, on the other hand, is based on a much more efficient ReadPrec
datatype (a.k.a "newstyle parsers"), but its definition relies on the use
of the RankNTypes
language extension. Therefore, readPrec
(and its
cousin, readListPrec
) are marked as GHConly. Nevertheless, it is
recommended to use readPrec
instead of readsPrec
whenever possible
for the efficiency improvements it brings.
As mentioned above, derived Read
instances in GHC will implement
readPrec
instead of readsPrec
. The default implementations of
readsPrec
(and its cousin, readList
) will simply use readPrec
under
the hood. If you are writing a Read
instance by hand, it is recommended
to write it like so:
instanceRead
T wherereadPrec
= ...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.
Proposed replacement for readsPrec
using newstyle parsers (GHC only).
readListPrec :: ReadPrec [a] #
Proposed replacement for readList
using newstyle parsers (GHC only).
The default definition uses readList
. Instances that define readPrec
should also define readListPrec
as readListPrecDefault
.
Instances
Read Bool  Since: base2.1 
Read Char  Since: base2.1 
Read Double  Since: base2.1 
Read Float  Since: base2.1 
Read Int  Since: base2.1 
Read Int8  Since: base2.1 
Read Int16  Since: base2.1 
Read Int32  Since: base2.1 
Read Int64  Since: base2.1 
Read Integer  Since: base2.1 
Read Natural  Since: base4.8.0.0 
Read Ordering  Since: base2.1 
Read Word  Since: base4.5.0.0 
Read Word8  Since: base2.1 
Read Word16  Since: base2.1 
Read Word32  Since: base2.1 
Read Word64  Since: base2.1 
Read ()  Since: base2.1 
Read Lexeme  Since: base2.1 
Read GeneralCategory  Since: base2.1 
Defined in GHC.Read  
Read a => Read [a]  Since: base2.1 
Read a => Read (Maybe a)  Since: base2.1 
(Integral a, Read a) => Read (Ratio a)  Since: base2.1 
Read a => Read (ZipList a)  Since: base4.7.0.0 
Read a => Read (First a)  Since: base2.1 
Read a => Read (Last a)  Since: base2.1 
Read a => Read (Down a)  Since: base4.7.0.0 
Read a => Read (NonEmpty a)  Since: base4.11.0.0 
(Read a, Read b) => Read (Either a b)  Since: base3.0 
(Read a, Read b) => Read (a, b)  Since: base2.1 
(Ix a, Read a, Read b) => Read (Array a b)  Since: base2.1 
(Read a, Read b, Read c) => Read (a, b, c)  Since: base2.1 
Read (f a) => Read (Ap f a)  Since: base4.12.0.0 
(Read a, Read b, Read c, Read d) => Read (a, b, c, d)  Since: base2.1 
(Read a, Read b, Read c, Read d, Read e) => Read (a, b, c, d, e)  Since: base2.1 
(Read a, Read b, Read c, Read d, Read e, Read f) => Read (a, b, c, d, e, f)  Since: base2.1 
(Read a, Read b, Read c, Read d, Read e, Read f, Read g) => Read (a, b, c, d, e, f, g)  Since: base2.1 
(Read a, Read b, Read c, Read d, Read e, Read f, Read g, Read h) => Read (a, b, c, d, e, f, g, h)  Since: base2.1 
(Read a, Read b, Read c, Read d, Read e, Read f, Read g, Read h, Read i) => Read (a, b, c, d, e, f, g, h, i)  Since: base2.1 
(Read a, Read b, Read c, Read d, Read e, Read f, Read g, Read h, Read i, Read j) => Read (a, b, c, d, e, f, g, h, i, j)  Since: base2.1 
(Read a, Read b, Read c, Read d, Read e, Read f, Read g, Read h, Read i, Read j, Read k) => Read (a, b, c, d, e, f, g, h, i, j, k)  Since: base2.1 
(Read a, Read b, Read c, Read d, Read e, Read f, Read g, Read h, Read i, Read j, Read k, Read l) => Read (a, b, c, d, e, f, g, h, i, j, k, l)  Since: base2.1 
(Read a, Read b, Read c, Read d, Read e, Read f, Read g, Read h, Read i, Read j, Read k, Read l, Read m) => Read (a, b, c, d, e, f, g, h, i, j, k, l, m)  Since: base2.1 
(Read a, Read b, Read c, Read d, Read e, Read f, Read g, Read h, Read i, Read j, Read k, Read l, Read m, Read n) => Read (a, b, c, d, e, f, g, h, i, j, k, l, m, n)  Since: base2.1 
(Read a, Read b, Read c, Read d, Read e, Read f, Read g, Read h, Read i, Read j, Read k, Read l, Read m, Read n, Read o) => Read (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o)  Since: base2.1 
Defined in GHC.Read 
readMaybe :: Read a => String > Maybe a #
Parse a string using the Read
instance.
Succeeds if there is exactly one valid result.
>>>
readMaybe "123" :: Maybe Int
Just 123
>>>
readMaybe "hello" :: Maybe Int
Nothing
Since: base4.6.0.0
Show
Conversion of values to readable String
s.
Derived instances of Show
have the following properties, which
are compatible with derived instances of Read
:
 The result of
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.  If the constructor is defined to be an infix operator, then
showsPrec
will produce infix applications of the constructor.  the representation will be enclosed in parentheses if the
precedence of the toplevel constructor in
x
is less thand
(associativity is ignored). Thus, ifd
is0
then the result is never surrounded in parentheses; ifd
is11
it is always surrounded in parentheses, unless it is an atomic expression.  If the constructor is defined using record syntax, then
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,
produces the stringshow
(Leaf 1 :^: Leaf 2 :^: Leaf 3)"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.
Instances
Show Bool  Since: base2.1 
Show Char  Since: base2.1 
Show Int  Since: base2.1 
Show Int8  Since: base2.1 
Show Int16  Since: base2.1 
Show Int32  Since: base2.1 
Show Int64  Since: base2.1 
Show Integer  Since: base2.1 
Show Natural  Since: base4.8.0.0 
Show Ordering  Since: base2.1 
Show Word  Since: base2.1 
Show Word8  Since: base2.1 
Show Word16  Since: base2.1 
Show Word32  Since: base2.1 
Show Word64  Since: base2.1 
Show RuntimeRep  Since: base4.11.0.0 
Defined in GHC.Show showsPrec :: Int > RuntimeRep > ShowS # show :: RuntimeRep > String # showList :: [RuntimeRep] > ShowS #  
Show VecCount  Since: base4.11.0.0 
Show VecElem  Since: base4.11.0.0 
Show CallStack  Since: base4.9.0.0 
Show ()  Since: base2.1 
Show TyCon  Since: base2.1 
Show Module  Since: base4.9.0.0 
Show TrName  Since: base4.9.0.0 
Show KindRep  
Show TypeLitSort  Since: base4.11.0.0 
Defined in GHC.Show showsPrec :: Int > TypeLitSort > ShowS # show :: TypeLitSort > String # showList :: [TypeLitSort] > ShowS #  
Show MaskingState  Since: base4.3.0.0 
Defined in GHC.IO showsPrec :: Int > MaskingState > ShowS # show :: MaskingState > String # showList :: [MaskingState] > ShowS #  
Show SrcLoc  Since: base4.9.0.0 
Show a => Show [a]  Since: base2.1 
Show a => Show (Maybe a)  Since: base2.1 
Show a => Show (Ratio a)  Since: base2.0.1 
Show a => Show (ZipList a)  Since: base4.7.0.0 
Show a => Show (First a)  Since: base2.1 
Show a => Show (Last a)  Since: base2.1 
Show a => Show (Down a)  Since: base4.7.0.0 
Show a => Show (NonEmpty a)  Since: base4.11.0.0 
(Show a, Show b) => Show (Either a b)  Since: base3.0 
(Show a, Show b) => Show (a, b)  Since: base2.1 
(Show a, Show b, Show c) => Show (a, b, c)  Since: base2.1 
Show (f a) => Show (Ap f a)  Since: base4.12.0.0 
(Show a, Show b, Show c, Show d) => Show (a, b, c, d)  Since: base2.1 
(Show a, Show b, Show c, Show d, Show e) => Show (a, b, c, d, e)  Since: base2.1 
(Show a, Show b, Show c, Show d, Show e, Show f) => Show (a, b, c, d, e, f)  Since: base2.1 
(Show a, Show b, Show c, Show d, Show e, Show f, Show g) => Show (a, b, c, d, e, f, g)  Since: base2.1 
(Show a, Show b, Show c, Show d, Show e, Show f, Show g, Show h) => Show (a, b, c, d, e, f, g, h)  Since: base2.1 
(Show a, Show b, Show c, Show d, Show e, Show f, Show g, Show h, Show i) => Show (a, b, c, d, e, f, g, h, i)  Since: base2.1 
(Show a, Show b, Show c, Show d, Show e, Show f, Show g, Show h, Show i, Show j) => Show (a, b, c, d, e, f, g, h, i, j)  Since: base2.1 
(Show a, Show b, Show c, Show d, Show e, Show f, Show g, Show h, Show i, Show j, Show k) => Show (a, b, c, d, e, f, g, h, i, j, k)  Since: base2.1 
(Show a, Show b, Show c, Show d, Show e, Show f, Show g, Show h, Show i, Show j, Show k, Show l) => Show (a, b, c, d, e, f, g, h, i, j, k, l)  Since: base2.1 
(Show a, Show b, Show c, Show d, Show e, Show f, Show g, Show h, Show i, Show j, Show k, Show l, Show m) => Show (a, b, c, d, e, f, g, h, i, j, k, l, m)  Since: base2.1 
(Show a, Show b, Show c, Show d, Show e, Show f, Show g, Show h, Show i, Show j, Show k, Show l, Show m, Show n) => Show (a, b, c, d, e, f, g, h, i, j, k, l, m, n)  Since: base2.1 
(Show a, Show b, Show c, Show d, Show e, Show f, Show g, Show h, Show i, Show j, Show k, Show l, Show m, Show n, Show o) => Show (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o)  Since: base2.1 
ShowS
showString :: String > ShowS #
utility function converting a String
to a show function that
simply prepends the string unchanged.
Foldable
class Foldable (t :: Type > Type) where #
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
length = getSum . foldMap (Sum . const 1)
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)
fold :: Monoid m => t m > m #
Combine the elements of a structure using a monoid.
foldMap :: Monoid m => (a > m) > t a > m #
Map each element of the structure to a monoid, and combine the results.
foldr :: (a > b > b) > b > t a > b #
Rightassociative fold of a structure.
In the case of lists, foldr
, when applied to a binary operator, a
starting value (typically the rightidentity 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)...)
Note that, since the head of the resulting expression is produced by
an application of the operator to the first element of the list,
foldr
can produce a terminating expression from an infinite list.
For a general Foldable
structure this should be semantically identical
to,
foldr f z =foldr
f z .toList
foldr' :: (a > b > b) > b > t a > b #
Rightassociative fold of a structure, but with strict application of the operator.
foldl :: (b > a > b) > b > t a > b #
Leftassociative fold of a structure.
In the case of lists, foldl
, when applied to a binary
operator, a starting value (typically the leftidentity 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
Note that to produce the outermost application of the operator the
entire input list must be traversed. This means that foldl'
will
diverge if given an infinite list.
Also note that if you want an efficient leftfold, you probably want to
use foldl'
instead of foldl
. The reason for this is that latter does
not force the "inner" results (e.g. z
in the above example)
before applying them to the operator (e.g. to f
x1(
). This results
in a thunk chain f
x2)O(n)
elements long, which then must be evaluated from
the outsidein.
For a general Foldable
structure this should be semantically identical
to,
foldl f z =foldl
f z .toList
foldl' :: (b > a > b) > b > t a > b #
Leftassociative fold of a structure but with strict application of the operator.
This ensures that each step of the fold is forced to weak head normal
form before being applied, avoiding the collection of thunks that would
otherwise occur. This is often what you want to strictly reduce a finite
list to a single, monolithic result (e.g. length
).
For a general Foldable
structure this should be semantically identical
to,
foldl f z =foldl'
f z .toList
foldr1 :: (a > a > a) > t a > a #
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 #
A variant of foldl
that has no base case,
and thus may only be applied to nonempty structures.
foldl1
f =foldl1
f .toList
List of elements of a structure, from left to right.
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 #
Does the element occur in the structure?
maximum :: Ord a => t a > a #
The largest element of a nonempty structure.
minimum :: Ord a => t a > a #
The least element of a nonempty structure.
The sum
function computes the sum of the numbers of a structure.
product :: Num a => t a > a #
The product
function computes the product of the numbers of a
structure.
Instances
Foldable []  Since: base2.1 
Defined in Data.Foldable fold :: Monoid m => [m] > m # foldMap :: Monoid m => (a > m) > [a] > m # foldr :: (a > b > b) > b > [a] > b # foldr' :: (a > b > b) > b > [a] > b # foldl :: (b > a > b) > b > [a] > b # foldl' :: (b > a > b) > b > [a] > b # foldr1 :: (a > a > a) > [a] > a # foldl1 :: (a > a > a) > [a] > a # elem :: Eq a => a > [a] > Bool # maximum :: Ord a => [a] > a #  
Foldable Maybe  Since: base2.1 
Defined in Data.Foldable fold :: Monoid m => Maybe m > m # foldMap :: Monoid m => (a > m) > Maybe a > m # foldr :: (a > b > b) > b > Maybe a > b # foldr' :: (a > b > b) > b > Maybe a > b # foldl :: (b > a > b) > b > Maybe a > b # foldl' :: (b > a > b) > b > Maybe a > b # foldr1 :: (a > a > a) > Maybe a > a # foldl1 :: (a > a > a) > Maybe a > a # elem :: Eq a => a > Maybe a > Bool # maximum :: Ord a => Maybe a > a # minimum :: Ord a => Maybe a > a #  
Foldable Par1  Since: base4.9.0.0 
Defined in Data.Foldable fold :: Monoid m => Par1 m > m # foldMap :: Monoid m => (a > m) > Par1 a > m # foldr :: (a > b > b) > b > Par1 a > b # foldr' :: (a > b > b) > b > Par1 a > b # foldl :: (b > a > b) > b > Par1 a > b # foldl' :: (b > a > b) > b > Par1 a > b # foldr1 :: (a > a > a) > Par1 a > a # foldl1 :: (a > a > a) > Par1 a > a # elem :: Eq a => a > Par1 a > Bool # maximum :: Ord a => Par1 a > a #  
Foldable ZipList  Since: base4.9.0.0 
Defined in Control.Applicative fold :: Monoid m => ZipList m > m # foldMap :: Monoid m => (a > m) > ZipList a > m # foldr :: (a > b > b) > b > ZipList a > b # foldr' :: (a > b > b) > b > ZipList a > b # foldl :: (b > a > b) > b > ZipList a > b # foldl' :: (b > a > b) > b > ZipList a > b # foldr1 :: (a > a > a) > ZipList a > a # foldl1 :: (a > a > a) > ZipList a > a # elem :: Eq a => a > ZipList a > Bool # maximum :: Ord a => ZipList a > a # minimum :: Ord a => ZipList a > a #  
Foldable First  Since: base4.8.0.0 
Defined in Data.Foldable fold :: Monoid m => First m > m # foldMap :: Monoid m => (a > m) > First a > m # foldr :: (a > b > b) > b > First a > b # foldr' :: (a > b > b) > b > First a > b # foldl :: (b > a > b) > b > First a > b # foldl' :: (b > a > b) > b > First a > b # foldr1 :: (a > a > a) > First a > a # foldl1 :: (a > a > a) > First a > a # elem :: Eq a => a > First a > Bool # maximum :: Ord a => First a > a # minimum :: Ord a => First a > a #  
Foldable Last  Since: base4.8.0.0 
Defined in Data.Foldable fold :: Monoid m => Last m > m # foldMap :: Monoid m => (a > m) > Last a > m # foldr :: (a > b > b) > b > Last a > b # foldr' :: (a > b > b) > b > Last a > b # foldl :: (b > a > b) > b > Last a > b # foldl' :: (b > a > b) > b > Last a > b # foldr1 :: (a > a > a) > Last a > a # foldl1 :: (a > a > a) > Last a > a # elem :: Eq a => a > Last a > Bool # maximum :: Ord a => Last a > a #  
Foldable Dual  Since: base4.8.0.0 
Defined in Data.Foldable fold :: Monoid m => Dual m > m # foldMap :: Monoid m => (a > m) > Dual a > m # foldr :: (a > b > b) > b > Dual a > b # foldr' :: (a > b > b) > b > Dual a > b # foldl :: (b > a > b) > b > Dual a > b # foldl' :: (b > a > b) > b > Dual a > b # foldr1 :: (a > a > a) > Dual a > a # foldl1 :: (a > a > a) > Dual a > a # elem :: Eq a => a > Dual a > Bool # maximum :: Ord a => Dual a > a #  
Foldable Sum  Since: base4.8.0.0 
Defined in Data.Foldable fold :: Monoid m => Sum m > m # foldMap :: Monoid m => (a > m) > Sum a > m # foldr :: (a > b > b) > b > Sum a > b # foldr' :: (a > b > b) > b > Sum a > b # foldl :: (b > a > b) > b > Sum a > b # foldl' :: (b > a > b) > b > Sum a > b # foldr1 :: (a > a > a) > Sum a > a # foldl1 :: (a > a > a) > Sum a > a # elem :: Eq a => a > Sum a > Bool # maximum :: Ord a => Sum a > a #  
Foldable Product  Since: base4.8.0.0 
Defined in Data.Foldable fold :: Monoid m => Product m > m # foldMap :: Monoid m => (a > m) > Product a > m # foldr :: (a > b > b) > b > Product a > b # foldr' :: (a > b > b) > b > Product a > b # foldl :: (b > a > b) > b > Product a > b # foldl' :: (b > a > b) > b > Product a > b # foldr1 :: (a > a > a) > Product a > a # foldl1 :: (a > a > a) > Product a > a # elem :: Eq a => a > Product a > Bool # maximum :: Ord a => Product a > a # minimum :: Ord a => Product a > a #  
Foldable Down  Since: base4.12.0.0 
Defined in Data.Foldable fold :: Monoid m => Down m > m # foldMap :: Monoid m => (a > m) > Down a > m # foldr :: (a > b > b) > b > Down a > b # foldr' :: (a > b > b) > b > Down a > b # foldl :: (b > a > b) > b > Down a > b # foldl' :: (b > a > b) > b > Down a > b # foldr1 :: (a > a > a) > Down a > a # foldl1 :: (a > a > a) > Down a > a # elem :: Eq a => a > Down a > Bool # maximum :: Ord a => Down a > a #  
Foldable NonEmpty  Since: base4.9.0.0 
Defined in Data.Foldable fold :: Monoid m => NonEmpty m > m # foldMap :: Monoid m => (a > m) > NonEmpty a > m # foldr :: (a > b > b) > b > NonEmpty a > b # foldr' :: (a > b > b) > b > NonEmpty a > b # foldl :: (b > a > b) > b > NonEmpty a > b # foldl' :: (b > a > b) > b > NonEmpty a > b # foldr1 :: (a > a > a) > NonEmpty a > a # foldl1 :: (a > a > a) > NonEmpty a > a # elem :: Eq a => a > NonEmpty a > Bool # maximum :: Ord a => NonEmpty a > a # minimum :: Ord a => NonEmpty a > a #  
Foldable (Either a)  Since: base4.7.0.0 
Defined in Data.Foldable fold :: Monoid m => Either a m > m # foldMap :: Monoid m => (a0 > m) > Either a a0 > m # foldr :: (a0 > b > b) > b > Either a a0 > b # foldr' :: (a0 > b > b) > b > Either a a0 > b # foldl :: (b > a0 > b) > b > Either a a0 > b # foldl' :: (b > a0 > b) > b > Either a a0 > b # foldr1 :: (a0 > a0 > a0) > Either a a0 > a0 # foldl1 :: (a0 > a0 > a0) > Either a a0 > a0 # toList :: Either a a0 > [a0] # length :: Either a a0 > Int # elem :: Eq a0 => a0 > Either a a0 > Bool # maximum :: Ord a0 => Either a a0 > a0 # minimum :: Ord a0 => Either a a0 > a0 #  
Foldable (V1 :: Type > Type)  Since: base4.9.0.0 
Defined in Data.Foldable fold :: Monoid m => V1 m > m # foldMap :: Monoid m => (a > m) > V1 a > m # foldr :: (a > b > b) > b > V1 a > b # foldr' :: (a > b > b) > b > V1 a > b # foldl :: (b > a > b) > b > V1 a > b # foldl' :: (b > a > b) > b > V1 a > b # foldr1 :: (a > a > a) > V1 a > a # foldl1 :: (a > a > a) > V1 a > a # elem :: Eq a => a > V1 a > Bool # maximum :: Ord a => V1 a > a #  
Foldable (U1 :: Type > Type)  Since: base4.9.0.0 
Defined in Data.Foldable fold :: Monoid m => U1 m > m # foldMap :: Monoid m => (a > m) > U1 a > m # foldr :: (a > b > b) > b > U1 a > b # foldr' :: (a > b > b) > b > U1 a > b # foldl :: (b > a > b) > b > U1 a > b # foldl' :: (b > a > b) > b > U1 a > b # foldr1 :: (a > a > a) > U1 a > a # foldl1 :: (a > a > a) > U1 a > a # elem :: Eq a => a > U1 a > Bool # maximum :: Ord a => U1 a > a #  
Foldable ((,) a)  Since: base4.7.0.0 
Defined in Data.Foldable fold :: Monoid m => (a, m) > m # foldMap :: Monoid m => (a0 > m) > (a, a0) > m # foldr :: (a0 > b > b) > b > (a, a0) > b # foldr' :: (a0 > b > b) > b > (a, a0) > b # foldl :: (b > a0 > b) > b > (a, a0) > b # foldl' :: (b > a0 > b) > b > (a, a0) > b # foldr1 :: (a0 > a0 > a0) > (a, a0) > a0 # foldl1 :: (a0 > a0 > a0) > (a, a0) > a0 # elem :: Eq a0 => a0 > (a, a0) > Bool # maximum :: Ord a0 => (a, a0) > a0 # minimum :: Ord a0 => (a, a0) > a0 #  
Foldable (Array i)  Since: base4.8.0.0 
Defined in Data.Foldable fold :: Monoid m => Array i m > m # foldMap :: Monoid m => (a > m) > Array i a > m # foldr :: (a > b > b) > b > Array i a > b # foldr' :: (a > b > b) > b > Array i a > b # foldl :: (b > a > b) > b > Array i a > b # foldl' :: (b > a > b) > b > Array i a > b # foldr1 :: (a > a > a) > Array i a > a # foldl1 :: (a > a > a) > Array i a > a # elem :: Eq a => a > Array i a > Bool # maximum :: Ord a => Array i a > a # minimum :: Ord a => Array i a > a #  
Foldable (Proxy :: Type > Type)  Since: base4.7.0.0 
Defined in Data.Foldable fold :: Monoid m => Proxy m > m # foldMap :: Monoid m => (a > m) > Proxy a > m # foldr :: (a > b > b) > b > Proxy a > b # foldr' :: (a > b > b) > b > Proxy a > b # foldl :: (b > a > b) > b > Proxy a > b # foldl' :: (b > a > b) > b > Proxy a > b # foldr1 :: (a > a > a) > Proxy a > a # foldl1 :: (a > a > a) > Proxy a > a # elem :: Eq a => a > Proxy a > Bool # maximum :: Ord a => Proxy a > a # minimum :: Ord a => Proxy a > a #  
Foldable f => Foldable (Rec1 f)  Since: base4.9.0.0 
Defined in Data.Foldable fold :: Monoid m => Rec1 f m > m # foldMap :: Monoid m => (a > m) > Rec1 f a > m # foldr :: (a > b > b) > b > Rec1 f a > b # foldr' :: (a > b > b) > b > Rec1 f a > b # foldl :: (b > a > b) > b > Rec1 f a > b # foldl' :: (b > a > b) > b > Rec1 f a > b # foldr1 :: (a > a > a) > Rec1 f a > a # foldl1 :: (a > a > a) > Rec1 f a > a # elem :: Eq a => a > Rec1 f a > Bool # maximum :: Ord a => Rec1 f a > a # minimum :: Ord a => Rec1 f a > a #  
Foldable (URec Char :: Type > Type)  Since: base4.9.0.0 
Defined in Data.Foldable fold :: Monoid m => URec Char m > m # foldMap :: Monoid m => (a > m) > URec Char a > m # foldr :: (a > b > b) > b > URec Char a > b # foldr' :: (a > b > b) > b > URec Char a > b # foldl :: (b > a > b) > b > URec Char a > b # foldl' :: (b > a > b) > b > URec Char a > b # foldr1 :: (a > a > a) > URec Char a > a # foldl1 :: (a > a > a) > URec Char a > a # toList :: URec Char a > [a] # length :: URec Char a > Int # elem :: Eq a => a > URec Char a > Bool # maximum :: Ord a => URec Char a > a # minimum :: Ord a => URec Char a > a #  
Foldable (URec Double :: Type > Type)  Since: base4.9.0.0 
Defined in Data.Foldable fold :: Monoid m => URec Double m > m # foldMap :: Monoid m => (a > m) > URec Double a > m # foldr :: (a > b > b) > b > URec Double a > b # foldr' :: (a > b > b) > b > URec Double a > b # foldl :: (b > a > b) > b > URec Double a > b # foldl' :: (b > a > b) > b > URec Double a > b # foldr1 :: (a > a > a) > URec Double a > a # foldl1 :: (a > a > a) > URec Double a > a # toList :: URec Double a > [a] # null :: URec Double a > Bool # length :: URec Double a > Int # elem :: Eq a => a > URec Double a > Bool # maximum :: Ord a => URec Double a > a # minimum :: Ord a => URec Double a > a #  
Foldable (URec Float :: Type > Type)  Since: base4.9.0.0 
Defined in Data.Foldable fold :: Monoid m => URec Float m > m # foldMap :: Monoid m => (a > m) > URec Float a > m # foldr :: (a > b > b) > b > URec Float a > b # foldr' :: (a > b > b) > b > URec Float a > b # foldl :: (b > a > b) > b > URec Float a > b # foldl' :: (b > a > b) > b > URec Float a > b # foldr1 :: (a > a > a) > URec Float a > a # foldl1 :: (a > a > a) > URec Float a > a # toList :: URec Float a > [a] # null :: URec Float a > Bool # length :: URec Float a > Int # elem :: Eq a => a > URec Float a > Bool # maximum :: Ord a => URec Float a > a # minimum :: Ord a => URec Float a > a #  
Foldable (URec Int :: Type > Type)  Since: base4.9.0.0 
Defined in Data.Foldable fold :: Monoid m => URec Int m > m # foldMap :: Monoid m => (a > m) > URec Int a > m # foldr :: (a > b > b) > b > URec Int a > b # foldr' :: (a > b > b) > b > URec Int a > b # foldl :: (b > a > b) > b > URec Int a > b # foldl' :: (b > a > b) > b > URec Int a > b # foldr1 :: (a > a > a) > URec Int a > a # foldl1 :: (a > a > a) > URec Int a > a # elem :: Eq a => a > URec Int a > Bool # maximum :: Ord a => URec Int a > a # minimum :: Ord a => URec Int a > a #  
Foldable (URec Word :: Type > Type)  Since: base4.9.0.0 
Defined in Data.Foldable fold :: Monoid m => URec Word m > m # foldMap :: Monoid m => (a > m) > URec Word a > m # foldr :: (a > b > b) > b > URec Word a > b # foldr' :: (a > b > b) > b > URec Word a > b # foldl :: (b > a > b) > b > URec Word a > b # foldl' :: (b > a > b) > b > URec Word a > b # foldr1 :: (a > a > a) > URec Word a > a # foldl1 :: (a > a > a) > URec Word a > a # toList :: URec Word a > [a] # length :: URec Word a > Int # elem :: Eq a => a > URec Word a > Bool # maximum :: Ord a => URec Word a > a # minimum :: Ord a => URec Word a > a #  
Foldable (URec (Ptr ()) :: Type > Type)  Since: base4.9.0.0 
Defined in Data.Foldable fold :: Monoid m => URec (Ptr ()) m > m # foldMap :: Monoid m => (a > m) > URec (Ptr ()) a > m # foldr :: (a > b > b) > b > URec (Ptr ()) a > b # foldr' :: (a > b > b) > b > URec (Ptr ()) a > b # foldl :: (b > a > b) > b > URec (Ptr ()) a > b # foldl' :: (b > a > b) > b > URec (Ptr ()) a > b # foldr1 :: (a > a > a) > URec (Ptr ()) a > a # foldl1 :: (a > a > a) > URec (Ptr ()) a > a # toList :: URec (Ptr ()) a > [a] # null :: URec (Ptr ()) a > Bool # length :: URec (Ptr ()) a > Int # elem :: Eq a => a > URec (Ptr ()) a > Bool # maximum :: Ord a => URec (Ptr ()) a > a # minimum :: Ord a => URec (Ptr ()) a > a #  
Foldable f => Foldable (Ap f)  Since: base4.12.0.0 
Defined in Data.Foldable fold :: Monoid m => Ap f m > m # foldMap :: Monoid m => (a > m) > Ap f a > m # foldr :: (a > b > b) > b > Ap f a > b # foldr' :: (a > b > b) > b > Ap f a > b # foldl :: (b > a > b) > b > Ap f a > b # foldl' :: (b > a > b) > b > Ap f a > b # foldr1 :: (a > a > a) > Ap f a > a # foldl1 :: (a > a > a) > Ap f a > a # elem :: Eq a => a > Ap f a > Bool # maximum :: Ord a => Ap f a > a #  
Foldable f => Foldable (Alt f)  Since: base4.12.0.0 
Defined in Data.Foldable fold :: Monoid m => Alt f m > m # foldMap :: Monoid m => (a > m) > Alt f a > m # foldr :: (a > b > b) > b > Alt f a > b # foldr' :: (a > b > b) > b > Alt f a > b # foldl :: (b > a > b) > b > Alt f a > b # foldl' :: (b > a > b) > b > Alt f a > b # foldr1 :: (a > a > a) > Alt f a > a # foldl1 :: (a > a > a) > Alt f a > a # elem :: Eq a => a > Alt f a > Bool # maximum :: Ord a => Alt f a > a # minimum :: Ord a => Alt f a > a #  
Foldable (K1 i c :: Type > Type)  Since: base4.9.0.0 
Defined in Data.Foldable fold :: Monoid m => K1 i c m > m # foldMap :: Monoid m => (a > m) > K1 i c a > m # foldr :: (a > b > b) > b > K1 i c a > b # foldr' :: (a > b > b) > b > K1 i c a > b # foldl :: (b > a > b) > b > K1 i c a > b # foldl' :: (b > a > b) > b > K1 i c a > b # foldr1 :: (a > a > a) > K1 i c a > a # foldl1 :: (a > a > a) > K1 i c a > a # elem :: Eq a => a > K1 i c a > Bool # maximum :: Ord a => K1 i c a > a # minimum :: Ord a => K1 i c a > a #  
(Foldable f, Foldable g) => Foldable (f :+: g)  Since: base4.9.0.0 
Defined in Data.Foldable fold :: Monoid m => (f :+: g) m > m # foldMap :: Monoid m => (a > m) > (f :+: g) a > m # foldr :: (a > b > b) > b > (f :+: g) a > b # foldr' :: (a > b > b) > b > (f :+: g) a > b # foldl :: (b > a > b) > b > (f :+: g) a > b # foldl' :: (b > a > b) > b > (f :+: g) a > b # foldr1 :: (a > a > a) > (f :+: g) a > a # foldl1 :: (a > a > a) > (f :+: g) a > a # toList :: (f :+: g) a > [a] # length :: (f :+: g) a > Int # elem :: Eq a => a > (f :+: g) a > Bool # maximum :: Ord a => (f :+: g) a > a # minimum :: Ord a => (f :+: g) a > a #  
(Foldable f, Foldable g) => Foldable (f :*: g)  Since: base4.9.0.0 
Defined in Data.Foldable fold :: Monoid m => (f :*: g) m > m # foldMap :: Monoid m => (a > m) > (f :*: g) a > m # foldr :: (a > b > b) > b > (f :*: g) a > b # foldr' :: (a > b > b) > b > (f :*: g) a > b # foldl :: (b > a > b) > b > (f :*: g) a > b # foldl' :: (b > a > b) > b > (f :*: g) a > b # foldr1 :: (a > a > a) > (f :*: g) a > a # foldl1 :: (a > a > a) > (f :*: g) a > a # toList :: (f :*: g) a > [a] # length :: (f :*: g) a > Int # elem :: Eq a => a > (f :*: g) a > Bool # maximum :: Ord a => (f :*: g) a > a # minimum :: Ord a => (f :*: g) a > a #  
Foldable f => Foldable (M1 i c f)  Since: base4.9.0.0 
Defined in Data.Foldable fold :: Monoid m => M1 i c f m > m # foldMap :: Monoid m => (a > m) > M1 i c f a > m # foldr :: (a > b > b) > b > M1 i c f a > b # foldr' :: (a > b > b) > b > M1 i c f a > b # foldl :: (b > a > b) > b > M1 i c f a > b # foldl' :: (b > a > b) > b > M1 i c f a > b # foldr1 :: (a > a > a) > M1 i c f a > a # foldl1 :: (a > a > a) > M1 i c f a > a # elem :: Eq a => a > M1 i c f a > Bool # maximum :: Ord a => M1 i c f a > a # minimum :: Ord a => M1 i c f a > a #  
(Foldable f, Foldable g) => Foldable (f :.: g)  Since: base4.9.0.0 
Defined in Data.Foldable fold :: Monoid m => (f :.: g) m > m # foldMap :: Monoid m => (a > m) > (f :.: g) a > m # foldr :: (a > b > b) > b > (f :.: g) a > b # foldr' :: (a > b > b) > b > (f :.: g) a > b # foldl :: (b > a > b) > b > (f :.: g) a > b # foldl' :: (b > a > b) > b > (f :.: g) a > b # foldr1 :: (a > a > a) > (f :.: g) a > a # foldl1 :: (a > a > a) > (f :.: g) a > a # toList :: (f :.: g) a > [a] # length :: (f :.: g) a > Int # elem :: Eq a => a > (f :.: g) a > Bool # maximum :: Ord a => (f :.: g) a > a # minimum :: Ord a => (f :.: g) a > a # 
for_ :: (Foldable t, Applicative f) => t a > (a > f b) > f () #
all :: Foldable t => (a > Bool) > t a > Bool #
Determines whether all elements of the structure satisfy the predicate.
Ord
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.
The Haskell Report defines no laws for Ord
. However, <=
is customarily
expected to implement a nonstrict partial order and have the following
properties:
 Transitivity
 if
x <= y && y <= z
=True
, thenx <= z
=True
 Reflexivity
x <= x
=True
 Antisymmetry
 if
x <= y && y <= x
=True
, thenx == y
=True
Note that the following operator interactions are expected to hold:
x >= y
=y <= x
x < y
=x <= y && x /= y
x > y
=y < x
x < y
=compare x y == LT
x > y
=compare x y == GT
x == y
=compare x y == EQ
min x y == if x <= y then x else y
=True
max x y == if x >= y then x else y
=True
Minimal complete definition: either compare
or <=
.
Using compare
can be more efficient for complex types.
compare :: a > a > Ordering #
(<) :: a > a > Bool infix 4 #
(<=) :: a > a > Bool infix 4 #
(>) :: a > a > Bool infix 4 #
Instances
Ord Bool  
Ord Char  
Ord Double  Note that due to the presence of
Also note that, due to the same,

Ord Float  Note that due to the presence of
Also note that, due to the same,

Ord Int  
Ord Int8  Since: base2.1 
Ord Int16  Since: base2.1 
Ord Int32  Since: base2.1 
Ord Int64  Since: base2.1 
Ord Integer  
Ord Ordering  
Defined in GHC.Classes  
Ord Word  
Ord Word8  Since: base2.1 
Ord Word16  Since: base2.1 
Ord Word32  Since: base2.1 
Ord Word64  Since: base2.1 
Ord ()  
Ord TyCon  
Ord BigNat  
Ord a => Ord [a]  
Ord a => Ord (Maybe a)  Since: base2.1 
Integral a => Ord (Ratio a)  Since: base2.0.1 
Ord a => Ord (ZipList a)  Since: base4.7.0.0 
Defined in Control.Applicative  
Ord a => Ord (First a)  Since: base2.1 
Ord a => Ord (Last a)  Since: base2.1 
Ord a => Ord (Down a)  Since: base4.6.0.0 
Ord a => Ord (NonEmpty a)  Since: base4.9.0.0 
(Ord a, Ord b) => Ord (Either a b)  Since: base2.1 
(Ord a, Ord b) => Ord (a, b)  
(Ord a, Ord b, Ord c) => Ord (a, b, c)  
Defined in GHC.Classes 