base-4.8.2.0: Basic libraries

Copyright(c) The University of Glasgow 2001
LicenseBSD-style (see the file libraries/base/LICENSE)
Maintainerlibraries@haskell.org
Stabilitystable
Portabilityportable
Safe HaskellTrustworthy
LanguageHaskell2010

Prelude

Contents

Description

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.

Synopsis

Standard types, classes and related functions

Basic data types

data Bool :: *

Constructors

False 
True 

Instances

Bounded Bool Source 
Enum Bool Source 
Eq Bool 

Methods

(==) :: Bool -> Bool -> Bool

(/=) :: Bool -> Bool -> Bool

Data Bool Source 

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Bool -> c Bool Source

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Bool Source

toConstr :: Bool -> Constr Source

dataTypeOf :: Bool -> DataType Source

dataCast1 :: Typeable (* -> *) t => (forall d. Data d => c (t d)) -> Maybe (c Bool) Source

dataCast2 :: Typeable (* -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Bool) Source

gmapT :: (forall b. Data b => b -> b) -> Bool -> Bool Source

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Bool -> r Source

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Bool -> r Source

gmapQ :: (forall d. Data d => d -> u) -> Bool -> [u] Source

gmapQi :: Int -> (forall d. Data d => d -> u) -> Bool -> u Source

gmapM :: Monad m => (forall d. Data d => d -> m d) -> Bool -> m Bool Source

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Bool -> m Bool Source

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Bool -> m Bool Source

Ord Bool 

Methods

compare :: Bool -> Bool -> Ordering

(<) :: Bool -> Bool -> Bool

(<=) :: Bool -> Bool -> Bool

(>) :: Bool -> Bool -> Bool

(>=) :: Bool -> Bool -> Bool

max :: Bool -> Bool -> Bool

min :: Bool -> Bool -> Bool

Read Bool Source 
Show Bool Source 
Ix Bool Source 
Generic Bool Source 

Associated Types

type Rep Bool :: * -> * Source

Methods

from :: Bool -> Rep Bool x Source

to :: Rep Bool x -> Bool Source

FiniteBits Bool Source 
Bits Bool Source 
Storable Bool Source 
type Rep Bool 
type (==) Bool a b Source 

(&&) :: Bool -> Bool -> Bool infixr 3

Boolean "and"

(||) :: Bool -> Bool -> Bool infixr 2

Boolean "or"

not :: Bool -> Bool

Boolean "not"

otherwise :: Bool Source

otherwise is defined as the value True. It helps to make guards more readable. eg.

 f x | x < 0     = ...
     | otherwise = ...

data Maybe a Source

The Maybe type encapsulates an optional value. A value of type Maybe a either contains a value of type a (represented as Just a), or it is empty (represented as Nothing). Using Maybe is a good way to deal with errors or exceptional cases without resorting to drastic measures such as error.

The Maybe type is also a monad. It is a simple kind of error monad, where all errors are represented by Nothing. A richer error monad can be built using the Either type.

Constructors

Nothing 
Just a 

Instances

Monad Maybe Source 

Methods

(>>=) :: Maybe a -> (a -> Maybe b) -> Maybe b Source

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

return :: a -> Maybe a Source

fail :: String -> Maybe a Source

Functor Maybe Source 

Methods

fmap :: (a -> b) -> Maybe a -> Maybe b Source

(<$) :: a -> Maybe b -> Maybe a Source

MonadFix Maybe Source 

Methods

mfix :: (a -> Maybe a) -> Maybe a Source

Applicative Maybe Source 

Methods

pure :: a -> Maybe a Source

(<*>) :: Maybe (a -> b) -> Maybe a -> Maybe b Source

(*>) :: Maybe a -> Maybe b -> Maybe b Source

(<*) :: Maybe a -> Maybe b -> Maybe a Source

Foldable Maybe Source 

Methods

fold :: Monoid m => Maybe m -> m Source

foldMap :: Monoid m => (a -> m) -> Maybe a -> m Source

foldr :: (a -> b -> b) -> b -> Maybe a -> b Source

foldr' :: (a -> b -> b) -> b -> Maybe a -> b Source

foldl :: (b -> a -> b) -> b -> Maybe a -> b Source

foldl' :: (b -> a -> b) -> b -> Maybe a -> b Source

foldr1 :: (a -> a -> a) -> Maybe a -> a Source

foldl1 :: (a -> a -> a) -> Maybe a -> a Source

toList :: Maybe a -> [a] Source

null :: Maybe a -> Bool Source

length :: Maybe a -> Int Source

elem :: Eq a => a -> Maybe a -> Bool Source

maximum :: Ord a => Maybe a -> a Source

minimum :: Ord a => Maybe a -> a Source

sum :: Num a => Maybe a -> a Source

product :: Num a => Maybe a -> a Source

Traversable Maybe Source 

Methods

traverse :: Applicative f => (a -> f b) -> Maybe a -> f (Maybe b) Source

sequenceA :: Applicative f => Maybe (f a) -> f (Maybe a) Source

mapM :: Monad m => (a -> m b) -> Maybe a -> m (Maybe b) Source

sequence :: Monad m => Maybe (m a) -> m (Maybe a) Source

Generic1 Maybe Source 

Associated Types

type Rep1 (Maybe :: * -> *) :: * -> * Source

Methods

from1 :: Maybe a -> Rep1 Maybe a Source

to1 :: Rep1 Maybe a -> Maybe a Source

MonadPlus Maybe Source 

Methods

mzero :: Maybe a Source

mplus :: Maybe a -> Maybe a -> Maybe a Source

Alternative Maybe Source 

Methods

empty :: Maybe a Source

(<|>) :: Maybe a -> Maybe a -> Maybe a Source

some :: Maybe a -> Maybe [a] Source

many :: Maybe a -> Maybe [a] Source

Eq a => Eq (Maybe a) Source 

Methods

(==) :: Maybe a -> Maybe a -> Bool

(/=) :: Maybe a -> Maybe a -> Bool

Data a => Data (Maybe a) Source 

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Maybe a -> c (Maybe a) Source

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (Maybe a) Source

toConstr :: Maybe a -> Constr Source

dataTypeOf :: Maybe a -> DataType Source

dataCast1 :: Typeable (* -> *) t => (forall d. Data d => c (t d)) -> Maybe (c (Maybe a)) Source

dataCast2 :: Typeable (* -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Maybe a)) Source

gmapT :: (forall b. Data b => b -> b) -> Maybe a -> Maybe a Source

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Maybe a -> r Source

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Maybe a -> r Source

gmapQ :: (forall d. Data d => d -> u) -> Maybe a -> [u] Source

gmapQi :: Int -> (forall d. Data d => d -> u) -> Maybe a -> u Source

gmapM :: Monad m => (forall d. Data d => d -> m d) -> Maybe a -> m (Maybe a) Source

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Maybe a -> m (Maybe a) Source

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Maybe a -> m (Maybe a) Source

Ord a => Ord (Maybe a) Source 

Methods

compare :: Maybe a -> Maybe a -> Ordering

(<) :: Maybe a -> Maybe a -> Bool

(<=) :: Maybe a -> Maybe a -> Bool

(>) :: Maybe a -> Maybe a -> Bool

(>=) :: Maybe a -> Maybe a -> Bool

max :: Maybe a -> Maybe a -> Maybe a

min :: Maybe a -> Maybe a -> Maybe a

Read a => Read (Maybe a) Source 
Show a => Show (Maybe a) Source 
Generic (Maybe a) Source 

Associated Types

type Rep (Maybe a) :: * -> * Source

Methods

from :: Maybe a -> Rep (Maybe a) x Source

to :: Rep (Maybe a) x -> Maybe a Source

Monoid a => Monoid (Maybe a) Source

Lift a semigroup into Maybe forming a Monoid according to http://en.wikipedia.org/wiki/Monoid: "Any semigroup S may be turned into a monoid simply by adjoining an element e not in S and defining e*e = e and e*s = s = s*e for all s ∈ S." Since there is no "Semigroup" typeclass providing just mappend, we use Monoid instead.

Methods

mempty :: Maybe a Source

mappend :: Maybe a -> Maybe a -> Maybe a Source

mconcat :: [Maybe a] -> Maybe a Source

type Rep1 Maybe Source 
type Rep (Maybe a) Source 
type (==) (Maybe k) a b Source 

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.

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

data Either a b Source

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").

Examples

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 Strings, and the Right constructor can be used only on Ints:

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

>>> :{
    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"

Constructors

Left a 
Right b 

Instances

Bifunctor Either Source 

Methods

bimap :: (a -> b) -> (c -> d) -> Either a c -> Either b d Source

first :: (a -> b) -> Either a c -> Either b c Source

second :: (b -> c) -> Either a b -> Either a c Source

Monad (Either e) Source 

Methods

(>>=) :: Either e a -> (a -> Either e b) -> Either e b Source

(>>) :: Either e a -> Either e b -> Either e b Source

return :: a -> Either e a Source

fail :: String -> Either e a Source

Functor (Either a) Source 

Methods

fmap :: (b -> c) -> Either a b -> Either a c Source

(<$) :: b -> Either a c -> Either a b Source

MonadFix (Either e) Source 

Methods

mfix :: (a -> Either e a) -> Either e a Source

Applicative (Either e) Source 

Methods

pure :: a -> Either e a Source

(<*>) :: Either e (a -> b) -> Either e a -> Either e b Source

(*>) :: Either e a -> Either e b -> Either e b Source

(<*) :: Either e a -> Either e b -> Either e a Source

Foldable (Either a) Source 

Methods

fold :: Monoid m => Either a m -> m Source

foldMap :: Monoid m => (b -> m) -> Either a b -> m Source

foldr :: (b -> c -> c) -> c -> Either a b -> c Source

foldr' :: (b -> c -> c) -> c -> Either a b -> c Source

foldl :: (b -> c -> b) -> b -> Either a c -> b Source

foldl' :: (b -> c -> b) -> b -> Either a c -> b Source

foldr1 :: (b -> b -> b) -> Either a b -> b Source

foldl1 :: (b -> b -> b) -> Either a b -> b Source

toList :: Either a b -> [b] Source

null :: Either a b -> Bool Source

length :: Either a b -> Int Source

elem :: Eq b => b -> Either a b -> Bool Source

maximum :: Ord b => Either a b -> b Source

minimum :: Ord b => Either a b -> b Source

sum :: Num b => Either a b -> b Source

product :: Num b => Either a b -> b Source

Traversable (Either a) Source 

Methods

traverse :: Applicative f => (b -> f c) -> Either a b -> f (Either a c) Source

sequenceA :: Applicative f => Either a (f b) -> f (Either a b) Source

mapM :: Monad m => (b -> m c) -> Either a b -> m (Either a c) Source

sequence :: Monad m => Either a (m b) -> m (Either a b) Source

Generic1 (Either a) Source 

Associated Types

type Rep1 (Either a :: * -> *) :: * -> * Source

Methods

from1 :: Either a b -> Rep1 (Either a) b Source

to1 :: Rep1 (Either a) b -> Either a b Source

(Eq a, Eq b) => Eq (Either a b) Source 

Methods

(==) :: Either a b -> Either a b -> Bool

(/=) :: Either a b -> Either a b -> Bool

(Data a, Data b) => Data (Either a b) Source 

Methods

gfoldl :: (forall d e. Data d => c (d -> e) -> d -> c e) -> (forall g. g -> c g) -> Either a b -> c (Either a b) Source

gunfold :: (forall d r. Data d => c (d -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (Either a b) Source

toConstr :: Either a b -> Constr Source

dataTypeOf :: Either a b -> DataType Source

dataCast1 :: Typeable (* -> *) t => (forall d. Data d => c (t d)) -> Maybe (c (Either a b)) Source

dataCast2 :: Typeable (* -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Either a b)) Source

gmapT :: (forall c. Data c => c -> c) -> Either a b -> Either a b Source

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Either a b -> r Source

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Either a b -> r Source

gmapQ :: (forall d. Data d => d -> u) -> Either a b -> [u] Source

gmapQi :: Int -> (forall d. Data d => d -> u) -> Either a b -> u Source

gmapM :: Monad m => (forall d. Data d => d -> m d) -> Either a b -> m (Either a b) Source

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Either a b -> m (Either a b) Source

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Either a b -> m (Either a b) Source

(Ord a, Ord b) => Ord (Either a b) Source 

Methods

compare :: Either a b -> Either a b -> Ordering

(<) :: Either a b -> Either a b -> Bool

(<=) :: Either a b -> Either a b -> Bool

(>) :: Either a b -> Either a b -> Bool

(>=) :: Either a b -> Either a b -> Bool

max :: Either a b -> Either a b -> Either a b

min :: Either a b -> Either a b -> Either a b

(Read a, Read b) => Read (Either a b) Source 
(Show a, Show b) => Show (Either a b) Source 

Methods

showsPrec :: Int -> Either a b -> ShowS Source

show :: Either a b -> String Source

showList :: [Either a b] -> ShowS Source

Generic (Either a b) Source 

Associated Types

type Rep (Either a b) :: * -> * Source

Methods

from :: Either a b -> Rep (Either a b) x Source

to :: Rep (Either a b) x -> Either a b Source

type Rep1 (Either a) Source 
type Rep (Either a b) Source 
type (==) (Either k k1) a b Source 

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.

Examples

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 "times-two" 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

data Ordering :: *

Constructors

LT 
EQ 
GT 

Instances

Bounded Ordering Source 
Enum Ordering Source 
Eq Ordering 
Data Ordering Source 

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Ordering -> c Ordering Source

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Ordering Source

toConstr :: Ordering -> Constr Source

dataTypeOf :: Ordering -> DataType Source

dataCast1 :: Typeable (* -> *) t => (forall d. Data d => c (t d)) -> Maybe (c Ordering) Source

dataCast2 :: Typeable (* -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Ordering) Source

gmapT :: (forall b. Data b => b -> b) -> Ordering -> Ordering Source

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Ordering -> r Source

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Ordering -> r Source

gmapQ :: (forall d. Data d => d -> u) -> Ordering -> [u] Source

gmapQi :: Int -> (forall d. Data d => d -> u) -> Ordering -> u Source

gmapM :: Monad m => (forall d. Data d => d -> m d) -> Ordering -> m Ordering Source

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Ordering -> m Ordering Source

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Ordering -> m Ordering Source

Ord Ordering 
Read Ordering Source 
Show Ordering Source 
Ix Ordering Source 
Generic Ordering Source 

Associated Types

type Rep Ordering :: * -> * Source

Monoid Ordering Source 
type Rep Ordering 
type (==) Ordering a b Source 

data Char :: *

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 8859-1 (Latin-1) 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 Source 
Enum Char Source 
Eq Char 

Methods

(==) :: Char -> Char -> Bool

(/=) :: Char -> Char -> Bool

Data Char Source 

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Char -> c Char Source

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Char Source

toConstr :: Char -> Constr Source

dataTypeOf :: Char -> DataType Source

dataCast1 :: Typeable (* -> *) t => (forall d. Data d => c (t d)) -> Maybe (c Char) Source

dataCast2 :: Typeable (* -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Char) Source

gmapT :: (forall b. Data b => b -> b) -> Char -> Char Source

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Char -> r Source

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Char -> r Source

gmapQ :: (forall d. Data d => d -> u) -> Char -> [u] Source

gmapQi :: Int -> (forall d. Data d => d -> u) -> Char -> u Source

gmapM :: Monad m => (forall d. Data d => d -> m d) -> Char -> m Char Source

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Char -> m Char Source

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Char -> m Char Source

Ord Char 

Methods

compare :: Char -> Char -> Ordering

(<) :: Char -> Char -> Bool

(<=) :: Char -> Char -> Bool

(>) :: Char -> Char -> Bool

(>=) :: Char -> Char -> Bool

max :: Char -> Char -> Char

min :: Char -> Char -> Char

Read Char Source 
Show Char Source 
Ix Char Source 
Generic Char Source 

Associated Types

type Rep Char :: * -> * Source

Methods

from :: Char -> Rep Char x Source

to :: Rep Char x -> Char Source

Storable Char Source 
IsChar Char Source 
PrintfArg Char Source 
IsString [Char] Source 

Methods

fromString :: String -> [Char] Source

type Rep Char Source 

type String = [Char] Source

A String is a list of characters. String constants in Haskell are values of type String.

Tuples

fst :: (a, b) -> a Source

Extract the first component of a pair.

snd :: (a, b) -> b Source

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.

Basic type classes

class Eq a where

The Eq class defines equality (==) and inequality (/=). All the basic datatypes exported by the Prelude are instances of Eq, and Eq may be derived for any datatype whose constituents are also instances of Eq.

Minimal complete definition: either == or /=.

Minimal complete definition

(==) | (/=)

Methods

(==) :: a -> a -> Bool infix 4

(/=) :: a -> a -> Bool infix 4

Instances

Eq Bool 

Methods

(==) :: Bool -> Bool -> Bool

(/=) :: Bool -> Bool -> Bool

Eq Char 

Methods

(==) :: Char -> Char -> Bool

(/=) :: Char -> Char -> Bool

Eq Double 

Methods

(==) :: Double -> Double -> Bool

(/=) :: Double -> Double -> Bool

Eq Float 

Methods

(==) :: Float -> Float -> Bool

(/=) :: Float -> Float -> Bool

Eq Int 

Methods

(==) :: Int -> Int -> Bool

(/=) :: Int -> Int -> Bool

Eq Int8 

Methods

(==) :: Int8 -> Int8 -> Bool

(/=) :: Int8 -> Int8 -> Bool

Eq Int16 

Methods

(==) :: Int16 -> Int16 -> Bool

(/=) :: Int16 -> Int16 -> Bool

Eq Int32 

Methods

(==) :: Int32 -> Int32 -> Bool

(/=) :: Int32 -> Int32 -> Bool

Eq Int64 

Methods

(==) :: Int64 -> Int64 -> Bool

(/=) :: Int64 -> Int64 -> Bool

Eq Integer 

Methods

(==) :: Integer -> Integer -> Bool

(/=) :: Integer -> Integer -> Bool

Eq Ordering 
Eq Word 

Methods

(==) :: Word -> Word -> Bool

(/=) :: Word -> Word -> Bool

Eq Word8 

Methods

(==) :: Word8 -> Word8 -> Bool

(/=) :: Word8 -> Word8 -> Bool

Eq Word16 

Methods

(==) :: Word16 -> Word16 -> Bool

(/=) :: Word16 -> Word16 -> Bool

Eq Word32 

Methods

(==) :: Word32 -> Word32 -> Bool

(/=) :: Word32 -> Word32 -> Bool

Eq Word64 

Methods

(==) :: Word64 -> Word64 -> Bool

(/=) :: Word64 -> Word64 -> Bool

Eq CallStack 
Eq TypeRep 

Methods

(==) :: TypeRep -> TypeRep -> Bool

(/=) :: TypeRep -> TypeRep -> Bool

Eq () 

Methods

(==) :: () -> () -> Bool

(/=) :: () -> () -> Bool

Eq BigNat 

Methods

(==) :: BigNat -> BigNat -> Bool

(/=) :: BigNat -> BigNat -> Bool

Eq Number 

Methods

(==) :: Number -> Number -> Bool

(/=) :: Number -> Number -> Bool

Eq Lexeme 

Methods

(==) :: Lexeme -> Lexeme -> Bool

(/=) :: Lexeme -> Lexeme -> Bool

Eq GeneralCategory 
Eq Fingerprint 
Eq TyCon 

Methods

(==) :: TyCon -> TyCon -> Bool

(/=) :: TyCon -> TyCon -> Bool

Eq Associativity 
Eq Fixity 

Methods

(==) :: Fixity -> Fixity -> Bool

(/=) :: Fixity -> Fixity -> Bool

Eq Arity 

Methods

(==) :: Arity -> Arity -> Bool

(/=) :: Arity -> Arity -> Bool

Eq Any 

Methods

(==) :: Any -> Any -> Bool

(/=) :: Any -> Any -> Bool

Eq All 

Methods

(==) :: All -> All -> Bool

(/=) :: All -> All -> Bool

Eq ArithException 
Eq ErrorCall 
Eq IOException 
Eq MaskingState 
Eq CUIntMax 
Eq CIntMax 

Methods

(==) :: CIntMax -> CIntMax -> Bool

(/=) :: CIntMax -> CIntMax -> Bool

Eq CUIntPtr 
Eq CIntPtr 

Methods

(==) :: CIntPtr -> CIntPtr -> Bool

(/=) :: CIntPtr -> CIntPtr -> Bool

Eq CSUSeconds 
Eq CUSeconds 
Eq CTime 

Methods

(==) :: CTime -> CTime -> Bool

(/=) :: CTime -> CTime -> Bool

Eq CClock 

Methods

(==) :: CClock -> CClock -> Bool

(/=) :: CClock -> CClock -> Bool

Eq CSigAtomic 
Eq CWchar 

Methods

(==) :: CWchar -> CWchar -> Bool

(/=) :: CWchar -> CWchar -> Bool

Eq CSize 

Methods

(==) :: CSize -> CSize -> Bool

(/=) :: CSize -> CSize -> Bool

Eq CPtrdiff 
Eq CDouble 

Methods

(==) :: CDouble -> CDouble -> Bool

(/=) :: CDouble -> CDouble -> Bool

Eq CFloat 

Methods

(==) :: CFloat -> CFloat -> Bool

(/=) :: CFloat -> CFloat -> Bool

Eq CULLong 

Methods

(==) :: CULLong -> CULLong -> Bool

(/=) :: CULLong -> CULLong -> Bool

Eq CLLong 

Methods

(==) :: CLLong -> CLLong -> Bool

(/=) :: CLLong -> CLLong -> Bool

Eq CULong 

Methods

(==) :: CULong -> CULong -> Bool

(/=) :: CULong -> CULong -> Bool

Eq CLong 

Methods

(==) :: CLong -> CLong -> Bool

(/=) :: CLong -> CLong -> Bool

Eq CUInt 

Methods

(==) :: CUInt -> CUInt -> Bool

(/=) :: CUInt -> CUInt -> Bool

Eq CInt 

Methods

(==) :: CInt -> CInt -> Bool

(/=) :: CInt -> CInt -> Bool

Eq CUShort 

Methods

(==) :: CUShort -> CUShort -> Bool

(/=) :: CUShort -> CUShort -> Bool

Eq CShort 

Methods

(==) :: CShort -> CShort -> Bool

(/=) :: CShort -> CShort -> Bool

Eq CUChar 

Methods

(==) :: CUChar -> CUChar -> Bool

(/=) :: CUChar -> CUChar -> Bool

Eq CSChar 

Methods

(==) :: CSChar -> CSChar -> Bool

(/=) :: CSChar -> CSChar -> Bool

Eq CChar 

Methods

(==) :: CChar -> CChar -> Bool

(/=) :: CChar -> CChar -> Bool

Eq IntPtr 

Methods

(==) :: IntPtr -> IntPtr -> Bool

(/=) :: IntPtr -> IntPtr -> Bool

Eq WordPtr 

Methods

(==) :: WordPtr -> WordPtr -> Bool

(/=) :: WordPtr -> WordPtr -> Bool

Eq BufferState 
Eq CodingProgress 
Eq SeekMode 
Eq IODeviceType 
Eq NewlineMode 
Eq Newline 

Methods

(==) :: Newline -> Newline -> Bool

(/=) :: Newline -> Newline -> Bool

Eq BufferMode 
Eq Handle 

Methods

(==) :: Handle -> Handle -> Bool

(/=) :: Handle -> Handle -> Bool

Eq IOErrorType 
Eq ExitCode 
Eq ArrayException 
Eq AsyncException 
Eq Errno 

Methods

(==) :: Errno -> Errno -> Bool

(/=) :: Errno -> Errno -> Bool

Eq Fd 

Methods

(==) :: Fd -> Fd -> Bool

(/=) :: Fd -> Fd -> Bool

Eq CRLim 

Methods

(==) :: CRLim -> CRLim -> Bool

(/=) :: CRLim -> CRLim -> Bool

Eq CTcflag 

Methods

(==) :: CTcflag -> CTcflag -> Bool

(/=) :: CTcflag -> CTcflag -> Bool

Eq CSpeed 

Methods

(==) :: CSpeed -> CSpeed -> Bool

(/=) :: CSpeed -> CSpeed -> Bool

Eq CCc 

Methods

(==) :: CCc -> CCc -> Bool

(/=) :: CCc -> CCc -> Bool

Eq CUid 

Methods

(==) :: CUid -> CUid -> Bool

(/=) :: CUid -> CUid -> Bool

Eq CNlink 

Methods

(==) :: CNlink -> CNlink -> Bool

(/=) :: CNlink -> CNlink -> Bool

Eq CGid 

Methods

(==) :: CGid -> CGid -> Bool

(/=) :: CGid -> CGid -> Bool

Eq CSsize 

Methods

(==) :: CSsize -> CSsize -> Bool

(/=) :: CSsize -> CSsize -> Bool

Eq CPid 

Methods

(==) :: CPid -> CPid -> Bool

(/=) :: CPid -> CPid -> Bool

Eq COff 

Methods

(==) :: COff -> COff -> Bool

(/=) :: COff -> COff -> Bool

Eq CMode 

Methods

(==) :: CMode -> CMode -> Bool

(/=) :: CMode -> CMode -> Bool

Eq CIno 

Methods

(==) :: CIno -> CIno -> Bool

(/=) :: CIno -> CIno -> Bool

Eq CDev 

Methods

(==) :: CDev -> CDev -> Bool

(/=) :: CDev -> CDev -> Bool

Eq ThreadStatus 
Eq BlockReason 
Eq ThreadId 
Eq IOMode 

Methods

(==) :: IOMode -> IOMode -> Bool

(/=) :: IOMode -> IOMode -> Bool

Eq Lifetime 
Eq Event 

Methods

(==) :: Event -> Event -> Bool

(/=) :: Event -> Event -> Bool

Eq FdKey 

Methods

(==) :: FdKey -> FdKey -> Bool

(/=) :: FdKey -> FdKey -> Bool

Eq TimeoutKey 
Eq HandlePosn 
Eq Version 

Methods

(==) :: Version -> Version -> Bool

(/=) :: Version -> Version -> Bool

Eq Fixity 

Methods

(==) :: Fixity -> Fixity -> Bool

(/=) :: Fixity -> Fixity -> Bool

Eq ConstrRep 
Eq DataRep 

Methods

(==) :: DataRep -> DataRep -> Bool

(/=) :: DataRep -> DataRep -> Bool

Eq Constr

Equality of constructors

Methods

(==) :: Constr -> Constr -> Bool

(/=) :: Constr -> Constr -> Bool

Eq Natural 

Methods

(==) :: Natural -> Natural -> Bool

(/=) :: Natural -> Natural -> Bool

Eq SomeSymbol 
Eq SomeNat 

Methods

(==) :: SomeNat -> SomeNat -> Bool

(/=) :: SomeNat -> SomeNat -> Bool

Eq SrcLoc 

Methods

(==) :: SrcLoc -> SrcLoc -> Bool

(/=) :: SrcLoc -> SrcLoc -> Bool

Eq SpecConstrAnnotation 
Eq Unique 

Methods

(==) :: Unique -> Unique -> Bool

(/=) :: Unique -> Unique -> Bool

Eq Void 

Methods

(==) :: Void -> Void -> Bool

(/=) :: Void -> Void -> Bool

Eq a => Eq [a] 

Methods

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

(/=) :: [a] -> [a] -> Bool

Eq a => Eq (Ratio a) 

Methods

(==) :: Ratio a -> Ratio a -> Bool

(/=) :: Ratio a -> Ratio a -> Bool

Eq (StablePtr a) 

Methods

(==) :: StablePtr a -> StablePtr a -> Bool

(/=) :: StablePtr a -> StablePtr a -> Bool

Eq (Ptr a) 

Methods

(==) :: Ptr a -> Ptr a -> Bool

(/=) :: Ptr a -> Ptr a -> Bool

Eq (FunPtr a) 

Methods

(==) :: FunPtr a -> FunPtr a -> Bool

(/=) :: FunPtr a -> FunPtr a -> Bool

Eq (U1 p) 

Methods

(==) :: U1 p -> U1 p -> Bool

(/=) :: U1 p -> U1 p -> Bool

Eq p => Eq (Par1 p) 

Methods

(==) :: Par1 p -> Par1 p -> Bool

(/=) :: Par1 p -> Par1 p -> Bool

Eq a => Eq (Maybe a) 

Methods

(==) :: Maybe a -> Maybe a -> Bool

(/=) :: Maybe a -> Maybe a -> Bool

Eq a => Eq (Down a) 

Methods

(==) :: Down a -> Down a -> Bool

(/=) :: Down a -> Down a -> Bool

Eq a => Eq (Last a) 

Methods

(==) :: Last a -> Last a -> Bool

(/=) :: Last a -> Last a -> Bool

Eq a => Eq (First a) 

Methods

(==) :: First a -> First a -> Bool

(/=) :: First a -> First a -> Bool

Eq a => Eq (Product a) 

Methods

(==) :: Product a -> Product a -> Bool

(/=) :: Product a -> Product a -> Bool

Eq a => Eq (Sum a) 

Methods

(==) :: Sum a -> Sum a -> Bool

(/=) :: Sum a -> Sum a -> Bool

Eq a => Eq (Dual a) 

Methods

(==) :: Dual a -> Dual a -> Bool

(/=) :: Dual a -> Dual a -> Bool

Eq (MVar a) 

Methods

(==) :: MVar a -> MVar a -> Bool

(/=) :: MVar a -> MVar a -> Bool

Eq (IORef a) 

Methods

(==) :: IORef a -> IORef a -> Bool

(/=) :: IORef a -> IORef a -> Bool

Eq (ForeignPtr a) 

Methods

(==) :: ForeignPtr a -> ForeignPtr a -> Bool

(/=) :: ForeignPtr a -> ForeignPtr a -> Bool

Eq (TVar a) 

Methods

(==) :: TVar a -> TVar a -> Bool

(/=) :: TVar a -> TVar a -> Bool

Eq a => Eq (ZipList a) 

Methods

(==) :: ZipList a -> ZipList a -> Bool

(/=) :: ZipList a -> ZipList a -> Bool

Eq (Chan a) 

Methods

(==) :: Chan a -> Chan a -> Bool

(/=) :: Chan a -> Chan a -> Bool

Eq a => Eq (Complex a) 

Methods

(==) :: Complex a -> Complex a -> Bool

(/=) :: Complex a -> Complex a -> Bool

Eq (Fixed a) 

Methods

(==) :: Fixed a -> Fixed a -> Bool

(/=) :: Fixed a -> Fixed a -> Bool

Eq a => Eq (Identity a) 

Methods

(==) :: Identity a -> Identity a -> Bool

(/=) :: Identity a -> Identity a -> Bool

Eq (StableName a) 

Methods

(==) :: StableName a -> StableName a -> Bool

(/=) :: StableName a -> StableName a -> Bool

(Eq a, Eq b) => Eq (Either a b) 

Methods

(==) :: Either a b -> Either a b -> Bool

(/=) :: Either a b -> Either a b -> Bool

Eq (f p) => Eq (Rec1 f p) 

Methods

(==) :: Rec1 f p -> Rec1 f p -> Bool

(/=) :: Rec1 f p -> Rec1 f p -> Bool

(Eq a, Eq b) => Eq (a, b) 

Methods

(==) :: (a, b) -> (a, b) -> Bool

(/=) :: (a, b) -> (a, b) -> Bool

Eq (STRef s a) 

Methods

(==) :: STRef s a -> STRef s a -> Bool

(/=) :: STRef s a -> STRef s a -> Bool

Eq (Proxy k s) 

Methods

(==) :: Proxy k s -> Proxy k s -> Bool

(/=) :: Proxy k s -> Proxy k s -> Bool

Eq a => Eq (Const a b) 

Methods

(==) :: Const a b -> Const a b -> Bool

(/=) :: Const a b -> Const a b -> Bool

Eq c => Eq (K1 i c p) 

Methods

(==) :: K1 i c p -> K1 i c p -> Bool

(/=) :: K1 i c p -> K1 i c p -> Bool

(Eq (f p), Eq (g p)) => Eq ((:+:) f g p) 

Methods

(==) :: (f :+: g) p -> (f :+: g) p -> Bool

(/=) :: (f :+: g) p -> (f :+: g) p -> Bool

(Eq (f p), Eq (g p)) => Eq ((:*:) f g p) 

Methods

(==) :: (f :*: g) p -> (f :*: g) p -> Bool

(/=) :: (f :*: g) p -> (f :*: g) p -> Bool

Eq (f (g p)) => Eq ((:.:) f g p) 

Methods

(==) :: (f :.: g) p -> (f :.: g) p -> Bool

(/=) :: (f :.: g) p -> (f :.: g) p -> Bool

(Eq a, Eq b, Eq c) => Eq (a, b, c) 

Methods

(==) :: (a, b, c) -> (a, b, c) -> Bool

(/=) :: (a, b, c) -> (a, b, c) -> Bool

Eq ((:~:) k a b) 

Methods

(==) :: (k :~: a) b -> (k :~: a) b -> Bool

(/=) :: (k :~: a) b -> (k :~: a) b -> Bool

Eq (Coercion k a b) 

Methods

(==) :: Coercion k a b -> Coercion k a b -> Bool

(/=) :: Coercion k a b -> Coercion k a b -> Bool

Eq (f a) => Eq (Alt k f a) 

Methods

(==) :: Alt k f a -> Alt k f a -> Bool

(/=) :: Alt k f a -> Alt k f a -> Bool

Eq (f p) => Eq (M1 i c f p) 

Methods

(==) :: M1 i c f p -> M1 i c f p -> Bool

(/=) :: M1 i c f p -> M1 i c f p -> Bool

(Eq a, Eq b, Eq c, Eq d) => Eq (a, b, c, d) 

Methods

(==) :: (a, b, c, d) -> (a, b, c, d) -> Bool

(/=) :: (a, b, c, d) -> (a, b, c, d) -> Bool

(Eq a, Eq b, Eq c, Eq d, Eq e) => Eq (a, b, c, d, e) 

Methods

(==) :: (a, b, c, d, e) -> (a, b, c, d, e) -> Bool

(/=) :: (a, b, c, d, e) -> (a, b, c, d, e) -> Bool

(Eq a, Eq b, Eq c, Eq d, Eq e, Eq f) => Eq (a, b, c, d, e, f) 

Methods

(==) :: (a, b, c, d, e, f) -> (a, b, c, d, e, f) -> Bool

(/=) :: (a, b, c, d, e, f) -> (a, b, c, d, e, f) -> Bool

(Eq a, Eq b, Eq c, Eq d, Eq e, Eq f, Eq g) => Eq (a, b, c, d, e, f, g) 

Methods

(==) :: (a, b, c, d, e, f, g) -> (a, b, c, d, e, f, g) -> Bool

(/=) :: (a, b, c, d, e, f, g) -> (a, b, c, d, e, f, g) -> Bool

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

Methods

(==) :: (a, b, c, d, e, f, g, h) -> (a, b, c, d, e, f, g, h) -> Bool

(/=) :: (a, b, c, d, e, f, g, h) -> (a, b, c, d, e, f, g, h) -> Bool

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

Methods

(==) :: (a, b, c, d, e, f, g, h, i) -> (a, b, c, d, e, f, g, h, i) -> Bool

(/=) :: (a, b, c, d, e, f, g, h, i) -> (a, b, c, d, e, f, g, h, i) -> Bool

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

Methods

(==) :: (a, b, c, d, e, f, g, h, i, j) -> (a, b, c, d, e, f, g, h, i, j) -> Bool

(/=) :: (a, b, c, d, e, f, g, h, i, j) -> (a, b, c, d, e, f, g, h, i, j) -> Bool

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

Methods

(==) :: (a, b, c, d, e, f, g, h, i, j, k) -> (a, b, c, d, e, f, g, h, i, j, k) -> Bool

(/=) :: (a, b, c, d, e, f, g, h, i, j, k) -> (a, b, c, d, e, f, g, h, i, j, k) -> Bool

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

Methods

(==) :: (a, b, c, d, e, f, g, h, i, j, k, l) -> (a, b, c, d, e, f, g, h, i, j, k, l) -> Bool

(/=) :: (a, b, c, d, e, f, g, h, i, j, k, l) -> (a, b, c, d, e, f, g, h, i, j, k, l) -> Bool

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

Methods

(==) :: (a, b, c, d, e, f, g, h, i, j, k, l, m) -> (a, b, c, d, e, f, g, h, i, j, k, l, m) -> Bool

(/=) :: (a, b, c, d, e, f, g, h, i, j, k, l, m) -> (a, b, c, d, e, f, g, h, i, j, k, l, m) -> Bool

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

Methods

(==) :: (a, b, c, d, e, f, g, h, i, j, k, l, m, n) -> (a, b, c, d, e, f, g, h, i, j, k, l, m, n) -> Bool

(/=) :: (a, b, c, d, e, f, g, h, i, j, k, l, m, n) -> (a, b, c, d, e, f, g, h, i, j, k, l, m, n) -> Bool

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

Methods

(==) :: (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o) -> (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o) -> Bool

(/=) :: (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o) -> (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o) -> Bool

class Eq a => Ord a where

The Ord class is used for totally ordered datatypes.

Instances of Ord can be derived for any user-defined 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.

Minimal complete definition

compare | (<=)

Methods

compare :: a -> a -> Ordering

(<) :: a -> a -> Bool infix 4

(<=) :: a -> a -> Bool infix 4

(>) :: a -> a -> Bool infix 4

(>=) :: a -> a -> Bool infix 4

max :: a -> a -> a

min :: a -> a -> a

Instances

Ord Bool 

Methods

compare :: Bool -> Bool -> Ordering

(<) :: Bool -> Bool -> Bool

(<=) :: Bool -> Bool -> Bool

(>) :: Bool -> Bool -> Bool

(>=) :: Bool -> Bool -> Bool

max :: Bool -> Bool -> Bool

min :: Bool -> Bool -> Bool

Ord Char 

Methods

compare :: Char -> Char -> Ordering

(<) :: Char -> Char -> Bool

(<=) :: Char -> Char -> Bool

(>) :: Char -> Char -> Bool

(>=) :: Char -> Char -> Bool

max :: Char -> Char -> Char

min :: Char -> Char -> Char

Ord Double 
Ord Float 

Methods

compare :: Float -> Float -> Ordering

(<) :: Float -> Float -> Bool

(<=) :: Float -> Float -> Bool

(>) :: Float -> Float -> Bool

(>=) :: Float -> Float -> Bool

max :: Float -> Float -> Float

min :: Float -> Float -> Float

Ord Int 

Methods

compare :: Int -> Int -> Ordering

(<) :: Int -> Int -> Bool

(<=) :: Int -> Int -> Bool

(>) :: Int -> Int -> Bool

(>=) :: Int -> Int -> Bool

max :: Int -> Int -> Int

min :: Int -> Int -> Int

Ord Int8 

Methods

compare :: Int8 -> Int8 -> Ordering

(<) :: Int8 -> Int8 -> Bool

(<=) :: Int8 -> Int8 -> Bool

(>) :: Int8 -> Int8 -> Bool

(>=) :: Int8 -> Int8 -> Bool

max :: Int8 -> Int8 -> Int8

min :: Int8 -> Int8 -> Int8

Ord Int16 

Methods

compare :: Int16 -> Int16 -> Ordering

(<) :: Int16 -> Int16 -> Bool

(<=) :: Int16 -> Int16 -> Bool

(>) :: Int16 -> Int16 -> Bool

(>=) :: Int16 -> Int16 -> Bool

max :: Int16 -> Int16 -> Int16

min :: Int16 -> Int16 -> Int16

Ord Int32 

Methods

compare :: Int32 -> Int32 -> Ordering

(<) :: Int32 -> Int32 -> Bool

(<=) :: Int32 -> Int32 -> Bool

(>) :: Int32 -> Int32 -> Bool

(>=) :: Int32 -> Int32 -> Bool

max :: Int32 -> Int32 -> Int32

min :: Int32 -> Int32 -> Int32

Ord Int64 

Methods

compare :: Int64 -> Int64 -> Ordering

(<) :: Int64 -> Int64 -> Bool

(<=) :: Int64 -> Int64 -> Bool

(>) :: Int64 -> Int64 -> Bool

(>=) :: Int64 -> Int64 -> Bool

max :: Int64 -> Int64 -> Int64

min :: Int64 -> Int64 -> Int64

Ord Integer 
Ord Ordering 
Ord Word 

Methods

compare :: Word -> Word -> Ordering

(<) :: Word -> Word -> Bool

(<=) :: Word -> Word -> Bool

(>) :: Word -> Word -> Bool

(>=) :: Word -> Word -> Bool

max :: Word -> Word -> Word

min :: Word -> Word -> Word

Ord Word8 

Methods

compare :: Word8 -> Word8 -> Ordering

(<) :: Word8 -> Word8 -> Bool

(<=) :: Word8 -> Word8 -> Bool

(>) :: Word8 -> Word8 -> Bool

(>=) :: Word8 -> Word8 -> Bool

max :: Word8 -> Word8 -> Word8

min :: Word8 -> Word8 -> Word8

Ord Word16 
Ord Word32 
Ord Word64 
Ord TypeRep 
Ord () 

Methods

compare :: () -> () -> Ordering

(<) :: () -> () -> Bool

(<=) :: () -> () -> Bool

(>) :: () -> () -> Bool

(>=) :: () -> () -> Bool

max :: () -> () -> ()

min :: () -> () -> ()

Ord BigNat 
Ord GeneralCategory 
Ord Fingerprint 
Ord TyCon 

Methods

compare :: TyCon -> TyCon -> Ordering

(<) :: TyCon -> TyCon -> Bool

(<=) :: TyCon -> TyCon -> Bool

(>) :: TyCon -> TyCon -> Bool

(>=) :: TyCon -> TyCon -> Bool

max :: TyCon -> TyCon -> TyCon

min :: TyCon -> TyCon -> TyCon

Ord Associativity 
Ord Fixity 
Ord Arity 

Methods

compare :: Arity -> Arity -> Ordering

(<) :: Arity -> Arity -> Bool

(<=) :: Arity -> Arity -> Bool

(>) :: Arity -> Arity -> Bool

(>=) :: Arity -> Arity -> Bool

max :: Arity -> Arity -> Arity

min :: Arity -> Arity -> Arity

Ord Any 

Methods

compare :: Any -> Any -> Ordering

(<) :: Any -> Any -> Bool

(<=) :: Any -> Any -> Bool

(>) :: Any -> Any -> Bool

(>=) :: Any -> Any -> Bool

max :: Any -> Any -> Any

min :: Any -> Any -> Any

Ord All 

Methods

compare :: All -> All -> Ordering

(<) :: All -> All -> Bool

(<=) :: All -> All -> Bool

(>) :: All -> All -> Bool

(>=) :: All -> All -> Bool

max :: All -> All -> All

min :: All -> All -> All

Ord ArithException 
Ord ErrorCall 
Ord CUIntMax 
Ord CIntMax 
Ord CUIntPtr 
Ord CIntPtr 
Ord CSUSeconds 
Ord CUSeconds 
Ord CTime 

Methods

compare :: CTime -> CTime -> Ordering

(<) :: CTime -> CTime -> Bool

(<=) :: CTime -> CTime -> Bool

(>) :: CTime -> CTime -> Bool

(>=) :: CTime -> CTime -> Bool

max :: CTime -> CTime -> CTime

min :: CTime -> CTime -> CTime

Ord CClock 
Ord CSigAtomic 
Ord CWchar 
Ord CSize 

Methods

compare :: CSize -> CSize -> Ordering

(<) :: CSize -> CSize -> Bool

(<=) :: CSize -> CSize -> Bool

(>) :: CSize -> CSize -> Bool

(>=) :: CSize -> CSize -> Bool

max :: CSize -> CSize -> CSize

min :: CSize -> CSize -> CSize

Ord CPtrdiff 
Ord CDouble 
Ord CFloat 
Ord CULLong 
Ord CLLong 
Ord CULong 
Ord CLong 

Methods

compare :: CLong -> CLong -> Ordering

(<) :: CLong -> CLong -> Bool

(<=) :: CLong -> CLong -> Bool

(>) :: CLong -> CLong -> Bool

(>=) :: CLong -> CLong -> Bool

max :: CLong -> CLong -> CLong

min :: CLong -> CLong -> CLong

Ord CUInt 

Methods

compare :: CUInt -> CUInt -> Ordering

(<) :: CUInt -> CUInt -> Bool

(<=) :: CUInt -> CUInt -> Bool

(>) :: CUInt -> CUInt -> Bool

(>=) :: CUInt -> CUInt -> Bool

max :: CUInt -> CUInt -> CUInt

min :: CUInt -> CUInt -> CUInt

Ord CInt 

Methods

compare :: CInt -> CInt -> Ordering

(<) :: CInt -> CInt -> Bool

(<=) :: CInt -> CInt -> Bool

(>) :: CInt -> CInt -> Bool

(>=) :: CInt -> CInt -> Bool

max :: CInt -> CInt -> CInt

min :: CInt -> CInt -> CInt

Ord CUShort 
Ord CShort 
Ord CUChar 
Ord CSChar 
Ord CChar 

Methods

compare :: CChar -> CChar -> Ordering

(<) :: CChar -> CChar -> Bool

(<=) :: CChar -> CChar -> Bool

(>) :: CChar -> CChar -> Bool

(>=) :: CChar -> CChar -> Bool

max :: CChar -> CChar -> CChar

min :: CChar -> CChar -> CChar

Ord IntPtr 
Ord WordPtr 
Ord SeekMode 
Ord NewlineMode 
Ord Newline 
Ord BufferMode 
Ord ExitCode 
Ord ArrayException 
Ord AsyncException 
Ord Fd 

Methods

compare :: Fd -> Fd -> Ordering

(<) :: Fd -> Fd -> Bool

(<=) :: Fd -> Fd -> Bool

(>) :: Fd -> Fd -> Bool

(>=) :: Fd -> Fd -> Bool

max :: Fd -> Fd -> Fd

min :: Fd -> Fd -> Fd

Ord CRLim 

Methods

compare :: CRLim -> CRLim -> Ordering

(<) :: CRLim -> CRLim -> Bool

(<=) :: CRLim -> CRLim -> Bool

(>) :: CRLim -> CRLim -> Bool

(>=) :: CRLim -> CRLim -> Bool

max :: CRLim -> CRLim -> CRLim

min :: CRLim -> CRLim -> CRLim

Ord CTcflag 
Ord CSpeed 
Ord CCc 

Methods

compare :: CCc -> CCc -> Ordering

(<) :: CCc -> CCc -> Bool

(<=) :: CCc -> CCc -> Bool

(>) :: CCc -> CCc -> Bool

(>=) :: CCc -> CCc -> Bool

max :: CCc -> CCc -> CCc

min :: CCc -> CCc -> CCc

Ord CUid 

Methods

compare :: CUid -> CUid -> Ordering

(<) :: CUid -> CUid -> Bool

(<=) :: CUid -> CUid -> Bool

(>) :: CUid -> CUid -> Bool

(>=) :: CUid -> CUid -> Bool

max :: CUid -> CUid -> CUid

min :: CUid -> CUid -> CUid

Ord CNlink 
Ord CGid 

Methods

compare :: CGid -> CGid -> Ordering

(<) :: CGid -> CGid -> Bool

(<=) :: CGid -> CGid -> Bool

(>) :: CGid -> CGid -> Bool

(>=) :: CGid -> CGid -> Bool

max :: CGid -> CGid -> CGid

min :: CGid -> CGid -> CGid

Ord CSsize 
Ord CPid 

Methods

compare :: CPid -> CPid -> Ordering

(<) :: CPid -> CPid -> Bool

(<=) :: CPid -> CPid -> Bool

(>) :: CPid -> CPid -> Bool

(>=) :: CPid -> CPid -> Bool

max :: CPid -> CPid -> CPid

min :: CPid -> CPid -> CPid

Ord COff 

Methods

compare :: COff -> COff -> Ordering

(<) :: COff -> COff -> Bool

(<=) :: COff -> COff -> Bool

(>) :: COff -> COff -> Bool

(>=) :: COff -> COff -> Bool

max :: COff -> COff -> COff

min :: COff -> COff -> COff

Ord CMode 

Methods

compare :: CMode -> CMode -> Ordering

(<) :: CMode -> CMode -> Bool

(<=) :: CMode -> CMode -> Bool

(>) :: CMode -> CMode -> Bool

(>=) :: CMode -> CMode -> Bool

max :: CMode -> CMode -> CMode

min :: CMode -> CMode -> CMode

Ord CIno 

Methods

compare :: CIno -> CIno -> Ordering

(<) :: CIno -> CIno -> Bool

(<=) :: CIno -> CIno -> Bool

(>) :: CIno -> CIno -> Bool

(>=) :: CIno -> CIno -> Bool

max :: CIno -> CIno -> CIno

min :: CIno -> CIno -> CIno

Ord CDev 

Methods

compare :: CDev -> CDev -> Ordering

(<) :: CDev -> CDev -> Bool

(<=) :: CDev -> CDev -> Bool

(>) :: CDev -> CDev -> Bool

(>=) :: CDev -> CDev -> Bool

max :: CDev -> CDev -> CDev

min :: CDev -> CDev -> CDev

Ord ThreadStatus 
Ord BlockReason 
Ord ThreadId 
Ord IOMode 
Ord Version 
Ord Natural 
Ord SomeSymbol 
Ord SomeNat 
Ord Unique 
Ord Void 

Methods

compare :: Void -> Void -> Ordering

(<) :: Void -> Void -> Bool

(<=) :: Void -> Void -> Bool

(>) :: Void -> Void -> Bool

(>=) :: Void -> Void -> Bool

max :: Void -> Void -> Void

min :: Void -> Void -> Void

Ord a => Ord [a] 

Methods

compare :: [a] -> [a] -> Ordering

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

(<=) :: [a] -> [a] -> Bool

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

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

max :: [a] -> [a] -> [a]

min :: [a] -> [a] -> [a]

Integral a => Ord (Ratio a) 

Methods

compare :: Ratio a -> Ratio a -> Ordering

(<) :: Ratio a -> Ratio a -> Bool

(<=) :: Ratio a -> Ratio a -> Bool

(>) :: Ratio a -> Ratio a -> Bool

(>=) :: Ratio a -> Ratio a -> Bool

max :: Ratio a -> Ratio a -> Ratio a

min :: Ratio a -> Ratio a -> Ratio a

Ord (Ptr a) 

Methods

compare :: Ptr a -> Ptr a -> Ordering

(<) :: Ptr a -> Ptr a -> Bool

(<=) :: Ptr a -> Ptr a -> Bool

(>) :: Ptr a -> Ptr a -> Bool

(>=) :: Ptr a -> Ptr a -> Bool

max :: Ptr a -> Ptr a -> Ptr a

min :: Ptr a -> Ptr a -> Ptr a

Ord (FunPtr a) 

Methods

compare :: FunPtr a -> FunPtr a -> Ordering

(<) :: FunPtr a -> FunPtr a -> Bool

(<=) :: FunPtr a -> FunPtr a -> Bool

(>) :: FunPtr a -> FunPtr a -> Bool

(>=) :: FunPtr a -> FunPtr a -> Bool

max :: FunPtr a -> FunPtr a -> FunPtr a

min :: FunPtr a -> FunPtr a -> FunPtr a

Ord (U1 p) 

Methods

compare :: U1 p -> U1 p -> Ordering

(<) :: U1 p -> U1 p -> Bool

(<=) :: U1 p -> U1 p -> Bool

(>) :: U1 p -> U1 p -> Bool

(>=) :: U1 p -> U1 p -> Bool

max :: U1 p -> U1 p -> U1 p

min :: U1 p -> U1 p -> U1 p

Ord p => Ord (Par1 p) 

Methods

compare :: Par1 p -> Par1 p -> Ordering

(<) :: Par1 p -> Par1 p -> Bool

(<=) :: Par1 p -> Par1 p -> Bool

(>) :: Par1 p -> Par1 p -> Bool

(>=) :: Par1 p -> Par1 p -> Bool

max :: Par1 p -> Par1 p -> Par1 p

min :: Par1 p -> Par1 p -> Par1 p

Ord a => Ord (Maybe a) 

Methods

compare :: Maybe a -> Maybe a -> Ordering

(<) :: Maybe a -> Maybe a -> Bool

(<=) :: Maybe a -> Maybe a -> Bool

(>) :: Maybe a -> Maybe a -> Bool

(>=) :: Maybe a -> Maybe a -> Bool

max :: Maybe a -> Maybe a -> Maybe a

min :: Maybe a -> Maybe a -> Maybe a

Ord a => Ord (Down a) 

Methods

compare :: Down a -> Down a -> Ordering

(<) :: Down a -> Down a -> Bool

(<=) :: Down a -> Down a -> Bool

(>) :: Down a -> Down a -> Bool

(>=) :: Down a -> Down a -> Bool

max :: Down a -> Down a -> Down a

min :: Down a -> Down a -> Down a

Ord a => Ord (Last a) 

Methods

compare :: Last a -> Last a -> Ordering

(<) :: Last a -> Last a -> Bool

(<=) :: Last a -> Last a -> Bool

(>) :: Last a -> Last a -> Bool

(>=) :: Last a -> Last a -> Bool

max :: Last a -> Last a -> Last a

min :: Last a -> Last a -> Last a

Ord a => Ord (First a) 

Methods

compare :: First a -> First a -> Ordering

(<) :: First a -> First a -> Bool

(<=) :: First a -> First a -> Bool

(>) :: First a -> First a -> Bool

(>=) :: First a -> First a -> Bool

max :: First a -> First a -> First a

min :: First a -> First a -> First a

Ord a => Ord (Product a) 

Methods

compare :: Product a -> Product a -> Ordering

(<) :: Product a -> Product a -> Bool

(<=) :: Product a -> Product a -> Bool

(>) :: Product a -> Product a -> Bool

(>=) :: Product a -> Product a -> Bool

max :: Product a -> Product a -> Product a

min :: Product a -> Product a -> Product a

Ord a => Ord (Sum a) 

Methods

compare :: Sum a -> Sum a -> Ordering

(<) :: Sum a -> Sum a -> Bool

(<=) :: Sum a -> Sum a -> Bool

(>) :: Sum a -> Sum a -> Bool

(>=) :: Sum a -> Sum a -> Bool

max :: Sum a -> Sum a -> Sum a

min :: Sum a -> Sum a -> Sum a

Ord a => Ord (Dual a) 

Methods

compare :: Dual a -> Dual a -> Ordering

(<) :: Dual a -> Dual a -> Bool

(<=) :: Dual a -> Dual a -> Bool

(>) :: Dual a -> Dual a -> Bool

(>=) :: Dual a -> Dual a -> Bool

max :: Dual a -> Dual a -> Dual a

min :: Dual a -> Dual a -> Dual a

Ord (ForeignPtr a) 
Ord a => Ord (ZipList a) 

Methods

compare :: ZipList a -> ZipList a -> Ordering

(<) :: ZipList a -> ZipList a -> Bool

(<=) :: ZipList a -> ZipList a -> Bool

(>) :: ZipList a -> ZipList a -> Bool

(>=) :: ZipList a -> ZipList a -> Bool

max :: ZipList a -> ZipList a -> ZipList a

min :: ZipList a -> ZipList a -> ZipList a

Ord (Fixed a) 

Methods

compare :: Fixed a -> Fixed a -> Ordering

(<) :: Fixed a -> Fixed a -> Bool

(<=) :: Fixed a -> Fixed a -> Bool

(>) :: Fixed a -> Fixed a -> Bool

(>=) :: Fixed a -> Fixed a -> Bool

max :: Fixed a -> Fixed a -> Fixed a

min :: Fixed a -> Fixed a -> Fixed a

Ord a => Ord (Identity a) 

Methods

compare :: Identity a -> Identity a -> Ordering

(<) :: Identity a -> Identity a -> Bool

(<=) :: Identity a -> Identity a -> Bool

(>) :: Identity a -> Identity a -> Bool

(>=) :: Identity a -> Identity a -> Bool

max :: Identity a -> Identity a -> Identity a

min :: Identity a -> Identity a -> Identity a

(Ord a, Ord b) => Ord (Either a b) 

Methods

compare :: Either a b -> Either a b -> Ordering

(<) :: Either a b -> Either a b -> Bool

(<=) :: Either a b -> Either a b -> Bool

(>) :: Either a b -> Either a b -> Bool

(>=) :: Either a b -> Either a b -> Bool

max :: Either a b -> Either a b -> Either a b

min :: Either a b -> Either a b -> Either a b

Ord (f p) => Ord (Rec1 f p) 

Methods

compare :: Rec1 f p -> Rec1 f p -> Ordering

(<) :: Rec1 f p -> Rec1 f p -> Bool

(<=) :: Rec1 f p -> Rec1 f p -> Bool

(>) :: Rec1 f p -> Rec1 f p -> Bool

(>=) :: Rec1 f p -> Rec1 f p -> Bool

max :: Rec1 f p -> Rec1 f p -> Rec1 f p

min :: Rec1 f p -> Rec1 f p -> Rec1 f p

(Ord a, Ord b) => Ord (a, b) 

Methods

compare :: (a, b) -> (a, b) -> Ordering

(<) :: (a, b) -> (a, b) -> Bool

(<=) :: (a, b) -> (a, b) -> Bool

(>) :: (a, b) -> (a, b) -> Bool

(>=) :: (a, b) -> (a, b) -> Bool

max :: (a, b) -> (a, b) -> (a, b)

min :: (a, b) -> (a, b) -> (a, b)

Ord (Proxy k s) 

Methods

compare :: Proxy k s -> Proxy k s -> Ordering

(<) :: Proxy k s -> Proxy k s -> Bool

(<=) :: Proxy k s -> Proxy k s -> Bool

(>) :: Proxy k s -> Proxy k s -> Bool

(>=) :: Proxy k s -> Proxy k s -> Bool

max :: Proxy k s -> Proxy k s -> Proxy k s

min :: Proxy k s -> Proxy k s -> Proxy k s

Ord a => Ord (Const a b) 

Methods

compare :: Const a b -> Const a b -> Ordering

(<) :: Const a b -> Const a b -> Bool

(<=) :: Const a b -> Const a b -> Bool

(>) :: Const a b -> Const a b -> Bool

(>=) :: Const a b -> Const a b -> Bool

max :: Const a b -> Const a b -> Const a b

min :: Const a b -> Const a b -> Const a b

Ord c => Ord (K1 i c p) 

Methods

compare :: K1 i c p -> K1 i c p -> Ordering

(<) :: K1 i c p -> K1 i c p -> Bool

(<=) :: K1 i c p -> K1 i c p -> Bool

(>) :: K1 i c p -> K1 i c p -> Bool

(>=) :: K1 i c p -> K1 i c p -> Bool

max :: K1 i c p -> K1 i c p -> K1 i c p

min :: K1 i c p -> K1 i c p -> K1 i c p

(Ord (f p), Ord (g p)) => Ord ((:+:) f g p) 

Methods

compare :: (f :+: g) p -> (f :+: g) p -> Ordering

(<) :: (f :+: g) p -> (f :+: g) p -> Bool

(<=) :: (f :+: g) p -> (f :+: g) p -> Bool

(>) :: (f :+: g) p -> (f :+: g) p -> Bool

(>=) :: (f :+: g) p -> (f :+: g) p -> Bool

max :: (f :+: g) p -> (f :+: g) p -> (f :+: g) p

min :: (f :+: g) p -> (f :+: g) p -> (f :+: g) p

(Ord (f p), Ord (g p)) => Ord ((:*:) f g p) 

Methods

compare :: (f :*: g) p -> (f :*: g) p -> Ordering

(<) :: (f :*: g) p -> (f :*: g) p -> Bool

(<=) :: (f :*: g) p -> (f :*: g) p -> Bool

(>) :: (f :*: g) p -> (f :*: g) p -> Bool

(>=) :: (f :*: g) p -> (f :*: g) p -> Bool

max :: (f :*: g) p -> (f :*: g) p -> (f :*: g) p

min :: (f :*: g) p -> (f :*: g) p -> (f :*: g) p

Ord (f (g p)) => Ord ((:.:) f g p) 

Methods

compare :: (f :.: g) p -> (f :.: g) p -> Ordering

(<) :: (f :.: g) p -> (f :.: g) p -> Bool

(<=) :: (f :.: g) p -> (f :.: g) p -> Bool

(>) :: (f :.: g) p -> (f :.: g) p -> Bool

(>=) :: (f :.: g) p -> (f :.: g) p -> Bool

max :: (f :.: g) p -> (f :.: g) p -> (f :.: g) p

min :: (f :.: g) p -> (f :.: g) p -> (f :.: g) p

(Ord a, Ord b, Ord c) => Ord (a, b, c) 

Methods

compare :: (a, b, c) -> (a, b, c) -> Ordering

(<) :: (a, b, c) -> (a, b, c) -> Bool

(<=) :: (a, b, c) -> (a, b, c) -> Bool

(>) :: (a, b, c) -> (a, b, c) -> Bool

(>=) :: (a, b, c) -> (a, b, c) -> Bool

max :: (a, b, c) -> (a, b, c) -> (a, b, c)

min :: (a, b, c) -> (a, b, c) -> (a, b, c)

Ord ((:~:) k a b) 

Methods

compare :: (k :~: a) b -> (k :~: a) b -> Ordering

(<) :: (k :~: a) b -> (k :~: a) b -> Bool

(<=) :: (k :~: a) b -> (k :~: a) b -> Bool

(>) :: (k :~: a) b -> (k :~: a) b -> Bool

(>=) :: (k :~: a) b -> (k :~: a) b -> Bool

max :: (k :~: a) b -> (k :~: a) b -> (k :~: a) b

min :: (k :~: a) b -> (k :~: a) b -> (k :~: a) b

Ord (Coercion k a b) 

Methods

compare :: Coercion k a b -> Coercion k a b -> Ordering

(<) :: Coercion k a b -> Coercion k a b -> Bool

(<=) :: Coercion k a b -> Coercion k a b -> Bool

(>) :: Coercion k a b -> Coercion k a b -> Bool

(>=) :: Coercion k a b -> Coercion k a b -> Bool

max :: Coercion k a b -> Coercion k a b -> Coercion k a b

min :: Coercion k a b -> Coercion k a b -> Coercion k a b

Ord (f a) => Ord (Alt k f a) 

Methods

compare :: Alt k f a -> Alt k f a -> Ordering

(<) :: Alt k f a -> Alt k f a -> Bool

(<=) :: Alt k f a -> Alt k f a -> Bool

(>) :: Alt k f a -> Alt k f a -> Bool

(>=) :: Alt k f a -> Alt k f a -> Bool

max :: Alt k f a -> Alt k f a -> Alt k f a

min :: Alt k f a -> Alt k f a -> Alt k f a

Ord (f p) => Ord (M1 i c f p) 

Methods

compare :: M1 i c f p -> M1 i c f p -> Ordering

(<) :: M1 i c f p -> M1 i c f p -> Bool

(<=) :: M1 i c f p -> M1 i c f p -> Bool

(>) :: M1 i c f p -> M1 i c f p -> Bool

(>=) :: M1 i c f p -> M1 i c f p -> Bool

max :: M1 i c f p -> M1 i c f p -> M1 i c f p

min :: M1 i c f p -> M1 i c f p -> M1 i c f p

(Ord a, Ord b, Ord c, Ord d) => Ord (a, b, c, d) 

Methods

compare :: (a, b, c, d) -> (a, b, c, d) -> Ordering

(<) :: (a, b, c, d) -> (a, b, c, d) -> Bool

(<=) :: (a, b, c, d) -> (a, b, c, d) -> Bool

(>) :: (a, b, c, d) -> (a, b, c, d) -> Bool

(>=) :: (a, b, c, d) -> (a, b, c, d) -> Bool

max :: (a, b, c, d) -> (a, b, c, d) -> (a, b, c, d)

min :: (a, b, c, d) -> (a, b, c, d) -> (a, b, c, d)

(Ord a, Ord b, Ord c, Ord d, Ord e) => Ord (a, b, c, d, e) 

Methods

compare :: (a, b, c, d, e) -> (a, b, c, d, e) -> Ordering

(<) :: (a, b, c, d, e) -> (a, b, c, d, e) -> Bool

(<=) :: (a, b, c, d, e) -> (a, b, c, d, e) -> Bool

(>) :: (a, b, c, d, e) -> (a, b, c, d, e) -> Bool

(>=) :: (a, b, c, d, e) -> (a, b, c, d, e) -> Bool

max :: (a, b, c, d, e) -> (a, b, c, d, e) -> (a, b, c, d, e)

min :: (a, b, c, d, e) -> (a, b, c, d, e) -> (a, b, c, d, e)

(Ord a, Ord b, Ord c, Ord d, Ord e, Ord f) => Ord (a, b, c, d, e, f) 

Methods

compare :: (a, b, c, d, e, f) -> (a, b, c, d, e, f) -> Ordering

(<) :: (a, b, c, d, e, f) -> (a, b, c, d, e, f) -> Bool

(<=) :: (a, b, c, d, e, f) -> (a, b, c, d, e, f) -> Bool

(>) :: (a, b, c, d, e, f) -> (a, b, c, d, e, f) -> Bool

(>=) :: (a, b, c, d, e, f) -> (a, b, c, d, e, f) -> Bool

max :: (a, b, c, d, e, f) -> (a, b, c, d, e, f) -> (a, b, c, d, e, f)

min :: (a, b, c, d, e, f) -> (a, b, c, d, e, f) -> (a, b, c, d, e, f)

(Ord a, Ord b, Ord c, Ord d, Ord e, Ord f, Ord g) => Ord (a, b, c, d, e, f, g) 

Methods

compare :: (a, b, c, d, e, f, g) -> (a, b, c, d, e, f, g) -> Ordering

(<) :: (a, b, c, d, e, f, g) -> (a, b, c, d, e, f, g) -> Bool

(<=) :: (a, b, c, d, e, f, g) -> (a, b, c, d, e, f, g) -> Bool

(>) :: (a, b, c, d, e, f, g) -> (a, b, c, d, e, f, g) -> Bool

(>=) :: (a, b, c, d, e, f, g) -> (a, b, c, d, e, f, g) -> Bool

max :: (a, b, c, d, e, f, g) -> (a, b, c, d, e, f, g) -> (a, b, c, d, e, f, g)

min :: (a, b, c, d, e, f, g) -> (a, b, c, d, e, f, g) -> (a, b, c, d, e, f, g)

(Ord a, Ord b, Ord c, Ord d, Ord e, Ord f, Ord g, Ord h) => Ord (a, b, c, d, e, f, g, h) 

Methods

compare :: (a, b, c, d, e, f, g, h) -> (a, b, c, d, e, f, g, h) -> Ordering

(<) :: (a, b, c, d, e, f, g, h) -> (a, b, c, d, e, f, g, h) -> Bool

(<=) :: (a, b, c, d, e, f, g, h) -> (a, b, c, d, e, f, g, h) -> Bool

(>) :: (a, b, c, d, e, f, g, h) -> (a, b, c, d, e, f, g, h) -> Bool

(>=) :: (a, b, c, d, e, f, g, h) -> (a, b, c, d, e, f, g, h) -> Bool

max :: (a, b, c, d, e, f, g, h) -> (a, b, c, d, e, f, g, h) -> (a, b, c, d, e, f, g, h)

min :: (a, b, c, d, e, f, g, h) -> (a, b, c, d, e, f, g, h) -> (a, b, c, d, e, f, g, h)

(Ord a, Ord b, Ord c, Ord d, Ord e, Ord f, Ord g, Ord h, Ord i) => Ord (a, b, c, d, e, f, g, h, i) 

Methods

compare :: (a, b, c, d, e, f, g, h, i) -> (a, b, c, d, e, f, g, h, i) -> Ordering

(<) :: (a, b, c, d, e, f, g, h, i) -> (a, b, c, d, e, f, g, h, i) -> Bool

(<=) :: (a, b, c, d, e, f, g, h, i) -> (a, b, c, d, e, f, g, h, i) -> Bool

(>) :: (a, b, c, d, e, f, g, h, i) -> (a, b, c, d, e, f, g, h, i) -> Bool

(>=) :: (a, b, c, d, e, f, g, h, i) -> (a, b, c, d, e, f, g, h, i) -> Bool

max :: (a, b, c, d, e, f, g, h, i) -> (a, b, c, d, e, f, g, h, i) -> (a, b, c, d, e, f, g, h, i)

min :: (a, b, c, d, e, f, g, h, i) -> (a, b, c, d, e, f, g, h, i) -> (a, b, c, d, e, f, g, h, i)

(Ord a, Ord b, Ord c, Ord d, Ord e, Ord f, Ord g, Ord h, Ord i, Ord j) => Ord (a, b, c, d, e, f, g, h, i, j) 

Methods

compare :: (a, b, c, d, e, f, g, h, i, j) -> (a, b, c, d, e, f, g, h, i, j) -> Ordering

(<) :: (a, b, c, d, e, f, g, h, i, j) -> (a, b, c, d, e, f, g, h, i, j) -> Bool

(<=) :: (a, b, c, d, e, f, g, h, i, j) -> (a, b, c, d, e, f, g, h, i, j) -> Bool

(>) :: (a, b, c, d, e, f, g, h, i, j) -> (a, b, c, d, e, f, g, h, i, j) -> Bool

(>=) :: (a, b, c, d, e, f, g, h, i, j) -> (a, b, c, d, e, f, g, h, i, j) -> Bool

max :: (a, b, c, d, e, f, g, h, i, j) -> (a, b, c, d, e, f, g, h, i, j) -> (a, b, c, d, e, f, g, h, i, j)

min :: (a, b, c, d, e, f, g, h, i, j) -> (a, b, c, d, e, f, g, h, i, j) -> (a, b, c, d, e, f, g, h, i, j)

(Ord a, Ord b, Ord c, Ord d, Ord e, Ord f, Ord g, Ord h, Ord i, Ord j, Ord k) => Ord (a, b, c, d, e, f, g, h, i, j, k) 

Methods

compare :: (a, b, c, d, e, f, g, h, i, j, k) -> (a, b, c, d, e, f, g, h, i, j, k) -> Ordering

(<) :: (a, b, c, d, e, f, g, h, i, j, k) -> (a, b, c, d, e, f, g, h, i, j, k) -> Bool

(<=) :: (a, b, c, d, e, f, g, h, i, j, k) -> (a, b, c, d, e, f, g, h, i, j, k) -> Bool

(>) :: (a, b, c, d, e, f, g, h, i, j, k) -> (a, b, c, d, e, f, g, h, i, j, k) -> Bool

(>=) :: (a, b, c, d, e, f, g, h, i, j, k) -> (a, b, c, d, e, f, g, h, i, j, k) -> Bool

max :: (a, b, c, d, e, f, g, h, i, j, k) -> (a, b, c, d, e, f, g, h, i, j, k) -> (a, b, c, d, e, f, g, h, i, j, k)

min :: (a, b, c, d, e, f, g, h, i, j, k) -> (a, b, c, d, e, f, g, h, i, j, k) -> (a, b, c, d, e, f, g, h, i, j, k)

(Ord a, Ord b, Ord c, Ord d, Ord e, Ord f, Ord g, Ord h, Ord i, Ord j, Ord k, Ord l) => Ord (a, b, c, d, e, f, g, h, i, j, k, l) 

Methods

compare :: (a, b, c, d, e, f, g, h, i, j, k, l) -> (a, b, c, d, e, f, g, h, i, j, k, l) -> Ordering

(<) :: (a, b, c, d, e, f, g, h, i, j, k, l) -> (a, b, c, d, e, f, g, h, i, j, k, l) -> Bool

(<=) :: (a, b, c, d, e, f, g, h, i, j, k, l) -> (a, b, c, d, e, f, g, h, i, j, k, l) -> Bool

(>) :: (a, b, c, d, e, f, g, h, i, j, k, l) -> (a, b, c, d, e, f, g, h, i, j, k, l) -> Bool

(>=) :: (a, b, c, d, e, f, g, h, i, j, k, l) -> (a, b, c, d, e, f, g, h, i, j, k, l) -> Bool

max :: (a, b, c, d, e, f, g, h, i, j, k, l) -> (a, b, c, d, e, f, g, h, i, j, k, l) -> (a, b, c, d, e, f, g, h, i, j, k, l)

min :: (a, b, c, d, e, f, g, h, i, j, k, l) -> (a, b, c, d, e, f, g, h, i, j, k, l) -> (a, b, c, d, e, f, g, h, i, j, k, l)

(Ord a, Ord b, Ord c, Ord d, Ord e, Ord f, Ord g, Ord h, Ord i, Ord j, Ord k, Ord l, Ord m) => Ord (a, b, c, d, e, f, g, h, i, j, k, l, m) 

Methods

compare :: (a, b, c, d, e, f, g, h, i, j, k, l, m) -> (a, b, c, d, e, f, g, h, i, j, k, l, m) -> Ordering

(<) :: (a, b, c, d, e, f, g, h, i, j, k, l, m) -> (a, b, c, d, e, f, g, h, i, j, k, l, m) -> Bool

(<=) :: (a, b, c, d, e, f, g, h, i, j, k, l, m) -> (a, b, c, d, e, f, g, h, i, j, k, l, m) -> Bool

(>) :: (a, b, c, d, e, f, g, h, i, j, k, l, m) -> (a, b, c, d, e, f, g, h, i, j, k, l, m) -> Bool

(>=) :: (a, b, c, d, e, f, g, h, i, j, k, l, m) -> (a, b, c, d, e, f, g, h, i, j, k, l, m) -> Bool

max :: (a, b, c, d, e, f, g, h, i, j, k, l, m) -> (a, b, c, d, e, f, g, h, i, j, k, l, m) -> (a, b, c, d, e, f, g, h, i, j, k, l, m)

min :: (a, b, c, d, e, f, g, h, i, j, k, l, m) -> (a, b, c, d, e, f, g, h, i, j, k, l, m) -> (a, b, c, d, e, f, g, h, i, j, k, l, m)

(Ord a, Ord b, Ord c, Ord d, Ord e, Ord f, Ord g, Ord h, Ord i, Ord j, Ord k, Ord l, Ord m, Ord n) => Ord (a, b, c, d, e, f, g, h, i, j, k, l, m, n) 

Methods

compare :: (a, b, c, d, e, f, g, h, i, j, k, l, m, n) -> (a, b, c, d, e, f, g, h, i, j, k, l, m, n) -> Ordering

(<) :: (a, b, c, d, e, f, g, h, i, j, k, l, m, n) -> (a, b, c, d, e, f, g, h, i, j, k, l, m, n) -> Bool

(<=) :: (a, b, c, d, e, f, g, h, i, j, k, l, m, n) -> (a, b, c, d, e, f, g, h, i, j, k, l, m, n) -> Bool

(>) :: (a, b, c, d, e, f, g, h, i, j, k, l, m, n) -> (a, b, c, d, e, f, g, h, i, j, k, l, m, n) -> Bool

(>=) :: (a, b, c, d, e, f, g, h, i, j, k, l, m, n) -> (a, b, c, d, e, f, g, h, i, j, k, l, m, n) -> Bool

max :: (a, b, c, d, e, f, g, h, i, j, k, l, m, n) -> (a, b, c, d, e, f, g, h, i, j, k, l, m, n) -> (a, b, c, d, e, f, g, h, i, j, k, l, m, n)

min :: (a, b, c, d, e, f, g, h, i, j, k, l, m, n) -> (a, b, c, d, e, f, g, h, i, j, k, l, m, n) -> (a, b, c, d, e, f, g, h, i, j, k, l, m, n)

(Ord a, Ord b, Ord c, Ord d, Ord e, Ord f, Ord g, Ord h, Ord i, Ord j, Ord k, Ord l, Ord m, Ord n, Ord o) => Ord (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o) 

Methods

compare :: (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o) -> (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o) -> Ordering

(<) :: (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o) -> (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o) -> Bool

(<=) :: (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o) -> (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o) -> Bool

(>) :: (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o) -> (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o) -> Bool

(>=) :: (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o) -> (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o) -> Bool

max :: (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o) -> (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o) -> (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o)

min :: (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o) -> (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o) -> (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o)

class Enum a where 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 left-to-right by fromEnum from 0 through n-1. 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:

   enumFrom     x   = enumFromTo     x maxBound
   enumFromThen x y = enumFromThenTo x y bound
     where
       bound | fromEnum y >= fromEnum x = maxBound
             | otherwise                = minBound

Minimal complete definition

toEnum, fromEnum

Methods

succ :: a -> a Source

the successor of a value. For numeric types, succ adds 1.

pred :: a -> a Source

the predecessor of a value. For numeric types, pred subtracts 1.

toEnum :: Int -> a Source

Convert from an Int.

fromEnum :: a -> Int Source

Convert to an Int. It is implementation-dependent what fromEnum returns when applied to a value that is too large to fit in an Int.

enumFrom :: a -> [a] Source

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

Instances

Enum Bool Source 
Enum Char Source 
Enum Int Source 
Enum Int8 Source 
Enum Int16 Source 
Enum Int32 Source 
Enum Int64 Source 
Enum Integer Source 
Enum Ordering Source 
Enum Word Source 
Enum Word8 Source 
Enum Word16 Source 
Enum Word32 Source 
Enum Word64 Source 
Enum () Source 

Methods

succ :: () -> () Source

pred :: () -> () Source

toEnum :: Int -> () Source

fromEnum :: () -> Int Source

enumFrom :: () -> [()] Source

enumFromThen :: () -> () -> [()] Source

enumFromTo :: () -> () -> [()] Source

enumFromThenTo :: () -> () -> () -> [()] Source

Enum GeneralCategory Source 
Enum CUIntMax Source 
Enum CIntMax Source 
Enum CUIntPtr Source 
Enum CIntPtr Source 
Enum CSUSeconds Source 
Enum CUSeconds Source 
Enum CTime Source 
Enum CClock Source 
Enum CSigAtomic Source 
Enum CWchar Source 
Enum CSize Source 
Enum CPtrdiff Source 
Enum CDouble Source 
Enum CFloat Source 
Enum CULLong Source 
Enum CLLong Source 
Enum CULong Source 
Enum CLong Source 
Enum CUInt Source 
Enum CInt Source 
Enum CUShort Source 
Enum CShort Source 
Enum CUChar Source 
Enum CSChar Source 
Enum CChar Source 
Enum IntPtr Source 
Enum WordPtr Source 
Enum SeekMode Source 
Enum Fd Source 
Enum CRLim Source 
Enum CTcflag Source 
Enum CSpeed Source 
Enum CCc Source 
Enum CUid Source 
Enum CNlink Source 
Enum CGid Source 
Enum CSsize Source 
Enum CPid Source 
Enum COff Source 
Enum CMode Source 
Enum CIno Source 
Enum CDev Source 
Enum IOMode Source 
Enum Natural Source 
Enum DoTrace Source 
Enum DoHeapProfile Source 
Enum DoCostCentres Source 
Enum GiveGCStats Source 
Integral a => Enum (Ratio a) Source 
Enum (Fixed a) Source 
Enum (Proxy k s) Source 

Methods

succ :: Proxy k s -> Proxy k s Source

pred :: Proxy k s -> Proxy k s Source

toEnum :: Int -> Proxy k s Source

fromEnum :: Proxy k s -> Int Source

enumFrom :: Proxy k s -> [Proxy k s] Source

enumFromThen :: Proxy k s -> Proxy k s -> [Proxy k s] Source

enumFromTo :: Proxy k s -> Proxy k s -> [Proxy k s] Source

enumFromThenTo :: Proxy k s -> Proxy k s -> Proxy k s -> [Proxy k s] Source

(~) k a b => Enum ((:~:) k a b) Source 

Methods

succ :: (k :~: a) b -> (k :~: a) b Source

pred :: (k :~: a) b -> (k :~: a) b Source

toEnum :: Int -> (k :~: a) b Source

fromEnum :: (k :~: a) b -> Int Source

enumFrom :: (k :~: a) b -> [(k :~: a) b] Source

enumFromThen :: (k :~: a) b -> (k :~: a) b -> [(k :~: a) b] Source

enumFromTo :: (k :~: a) b -> (k :~: a) b -> [(k :~: a) b] Source

enumFromThenTo :: (k :~: a) b -> (k :~: a) b -> (k :~: a) b -> [(k :~: a) b] Source

Coercible k a b => Enum (Coercion k a b) Source 

Methods

succ :: Coercion k a b -> Coercion k a b Source

pred :: Coercion k a b -> Coercion k a b Source

toEnum :: Int -> Coercion k a b Source

fromEnum :: Coercion k a b -> Int Source

enumFrom :: Coercion k a b -> [Coercion k a b] Source

enumFromThen :: Coercion k a b -> Coercion k a b -> [Coercion k a b] Source

enumFromTo :: Coercion k a b -> Coercion k a b -> [Coercion k a b] Source

enumFromThenTo :: Coercion k a b -> Coercion k a b -> Coercion k a b -> [Coercion k a b] Source

Enum (f a) => Enum (Alt k f a) Source 

Methods

succ :: Alt k f a -> Alt k f a Source

pred :: Alt k f a -> Alt k f a Source

toEnum :: Int -> Alt k f a Source

fromEnum :: Alt k f a -> Int Source

enumFrom :: Alt k f a -> [Alt k f a] Source

enumFromThen :: Alt k f a -> Alt k f a -> [Alt k f a] Source

enumFromTo :: Alt k f a -> Alt k f a -> [Alt k f a] Source

enumFromThenTo :: Alt k f a -> Alt k f a -> Alt k f a -> [Alt k f a] Source

class Bounded a where Source

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 single-constructor datatypes whose constituent types are in Bounded.

Methods

minBound, maxBound :: a Source

Instances

Bounded Bool Source 
Bounded Char Source 
Bounded Int Source 
Bounded Int8 Source 
Bounded Int16 Source 
Bounded Int32 Source 
Bounded Int64 Source 
Bounded Ordering Source 
Bounded Word Source 
Bounded Word8 Source 
Bounded Word16 Source 
Bounded Word32 Source 
Bounded Word64 Source 
Bounded () Source 

Methods

minBound :: () Source

maxBound :: () Source

Bounded GeneralCategory Source 
Bounded Any Source 
Bounded All Source 
Bounded CUIntMax Source 
Bounded CIntMax Source 
Bounded CUIntPtr Source 
Bounded CIntPtr Source 
Bounded CSigAtomic Source 
Bounded CWchar Source 
Bounded CSize Source 
Bounded CPtrdiff Source 
Bounded CULLong Source 
Bounded CLLong Source 
Bounded CULong Source 
Bounded CLong Source 
Bounded CUInt Source 
Bounded CInt Source 
Bounded CUShort Source 
Bounded CShort Source 
Bounded CUChar Source 
Bounded CSChar Source 
Bounded CChar Source 
Bounded IntPtr Source 
Bounded WordPtr Source 
Bounded Fd Source 
Bounded CRLim Source 
Bounded CTcflag Source 
Bounded CUid Source 
Bounded CNlink Source 
Bounded CGid Source 
Bounded CSsize Source 
Bounded CPid Source 
Bounded COff Source 
Bounded CMode Source 
Bounded CIno Source 
Bounded CDev Source 
Bounded a => Bounded (Product a) Source 
Bounded a => Bounded (Sum a) Source 
Bounded a => Bounded (Dual a) Source 
(Bounded a, Bounded b) => Bounded (a, b) Source 

Methods

minBound :: (a, b) Source

maxBound :: (a, b) Source

Bounded (Proxy k s) Source 
(Bounded a, Bounded b, Bounded c) => Bounded (a, b, c) Source 

Methods

minBound :: (a, b, c) Source

maxBound :: (a, b, c) Source

(~) k a b => Bounded ((:~:) k a b) Source 

Methods

minBound :: (k :~: a) b Source

maxBound :: (k :~: a) b Source

Coercible k a b => Bounded (Coercion k a b) Source 
(Bounded a, Bounded b, Bounded c, Bounded d) => Bounded (a, b, c, d) Source 

Methods

minBound :: (a, b, c, d) Source

maxBound :: (a, b, c, d) Source

(Bounded a, Bounded b, Bounded c, Bounded d, Bounded e) => Bounded (a, b, c, d, e) Source 

Methods

minBound :: (a, b, c, d, e) Source

maxBound :: (a, b, c, d, e) Source

(Bounded a, Bounded b, Bounded c, Bounded d, Bounded e, Bounded f) => Bounded (a, b, c, d, e, f) Source 

Methods

minBound :: (a, b, c, d, e, f) Source

maxBound :: (a, b, c, d, e, f) Source

(Bounded a, Bounded b, Bounded c, Bounded d, Bounded e, Bounded f, Bounded g) => Bounded (a, b, c, d, e, f, g) Source 

Methods

minBound :: (a, b, c, d, e, f, g) Source

maxBound :: (a, b, c, d, e, f, g) Source

(Bounded a, Bounded b, Bounded c, Bounded d, Bounded e, Bounded f, Bounded g, Bounded h) => Bounded (a, b, c, d, e, f, g, h) Source 

Methods

minBound :: (a, b, c, d, e, f, g, h) Source

maxBound :: (a, b, c, d, e, f, g, h) Source

(Bounded a, Bounded b, Bounded c, Bounded d, Bounded e, Bounded f, Bounded g, Bounded h, Bounded i) => Bounded (a, b, c, d, e, f, g, h, i) Source 

Methods

minBound :: (a, b, c, d, e, f, g, h, i) Source

maxBound :: (a, b, c, d, e, f, g, h, i) Source

(Bounded a, Bounded b, Bounded c, Bounded d, Bounded e, Bounded f, Bounded g, Bounded h, Bounded i, Bounded j) => Bounded (a, b, c, d, e, f, g, h, i, j) Source 

Methods

minBound :: (a, b, c, d, e, f, g, h, i, j) Source

maxBound :: (a, b, c, d, e, f, g, h, i, j) Source

(Bounded a, Bounded b, Bounded c, Bounded d, Bounded e, Bounded f, Bounded g, Bounded h, Bounded i, Bounded j, Bounded k) => Bounded (a, b, c, d, e, f, g, h, i, j, k) Source 

Methods

minBound :: (a, b, c, d, e, f, g, h, i, j, k) Source

maxBound :: (a, b, c, d, e, f, g, h, i, j, k) Source

(Bounded a, Bounded b, Bounded c, Bounded d, Bounded e, Bounded f, Bounded g, Bounded h, Bounded i, Bounded j, Bounded k, Bounded l) => Bounded (a, b, c, d, e, f, g, h, i, j, k, l) Source 

Methods

minBound :: (a, b, c, d, e, f, g, h, i, j, k, l) Source

maxBound :: (a, b, c, d, e, f, g, h, i, j, k, l) Source

(Bounded a, Bounded b, Bounded c, Bounded d, Bounded e, Bounded f, Bounded g, Bounded h, Bounded i, Bounded j, Bounded k, Bounded l, Bounded m) => Bounded (a, b, c, d, e, f, g, h, i, j, k, l, m) Source 

Methods

minBound :: (a, b, c, d, e, f, g, h, i, j, k, l, m) Source

maxBound :: (a, b, c, d, e, f, g, h, i, j, k, l, m) Source

(Bounded a, Bounded b, Bounded c, Bounded d, Bounded e, Bounded f, Bounded g, Bounded h, Bounded i, Bounded j, Bounded k, Bounded l, Bounded m, Bounded n) => Bounded (a, b, c, d, e, f, g, h, i, j, k, l, m, n) Source 

Methods

minBound :: (a, b, c, d, e, f, g, h, i, j, k, l, m, n) Source

maxBound :: (a, b, c, d, e, f, g, h, i, j, k, l, m, n) Source

(Bounded a, Bounded b, Bounded c, Bounded d, Bounded e, Bounded f, Bounded g, Bounded h, Bounded i, Bounded j, Bounded k, Bounded l, Bounded m, Bounded n, Bounded o) => Bounded (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o) Source 

Methods

minBound :: (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o) Source

maxBound :: (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o) Source

Numbers

Numeric types

data Int :: *

A fixed-precision integer type with at least the range [-2^29 .. 2^29-1]. The exact range for a given implementation can be determined by using minBound and maxBound from the Bounded class.

Instances

Bounded Int Source 
Enum Int Source 
Eq Int 

Methods

(==) :: Int -> Int -> Bool

(/=) :: Int -> Int -> Bool

Integral Int Source 

Methods

quot :: Int -> Int -> Int Source

rem :: Int -> Int -> Int Source

div :: Int -> Int -> Int Source

mod :: Int -> Int -> Int Source

quotRem :: Int -> Int -> (Int, Int) Source

divMod :: Int -> Int -> (Int, Int) Source

toInteger :: Int -> Integer Source

Data Int Source 

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Int -> c Int Source

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Int Source

toConstr :: Int -> Constr Source

dataTypeOf :: Int -> DataType Source

dataCast1 :: Typeable (* -> *) t => (forall d. Data d => c (t d)) -> Maybe (c Int) Source

dataCast2 :: Typeable (* -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Int) Source

gmapT :: (forall b. Data b => b -> b) -> Int -> Int Source

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Int -> r Source

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Int -> r Source

gmapQ :: (forall d. Data d => d -> u) -> Int -> [u] Source

gmapQi :: Int -> (forall d. Data d => d -> u) -> Int -> u Source

gmapM :: Monad m => (forall d. Data d => d -> m d) -> Int -> m Int Source

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Int -> m Int Source

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Int -> m Int Source

Num Int Source 
Ord Int 

Methods

compare :: Int -> Int -> Ordering

(<) :: Int -> Int -> Bool

(<=) :: Int -> Int -> Bool

(>) :: Int -> Int -> Bool

(>=) :: Int -> Int -> Bool

max :: Int -> Int -> Int

min :: Int -> Int -> Int

Read Int Source 
Real Int Source 
Show Int Source 
Ix Int Source 

Methods

range :: (Int, Int) -> [Int] Source

index :: (Int, Int) -> Int -> Int Source

unsafeIndex :: (Int, Int) -> Int -> Int

inRange :: (Int, Int) -> Int -> Bool Source

rangeSize :: (Int, Int) -> Int Source

unsafeRangeSize :: (Int, Int) -> Int

Generic Int Source 

Associated Types

type Rep Int :: * -> * Source

Methods

from :: Int -> Rep Int x Source

to :: Rep Int x -> Int Source

FiniteBits Int Source 
Bits Int Source 
Storable Int Source 
PrintfArg Int Source 
type Rep Int Source 

data Integer :: *

Invariant: Jn# and Jp# are used iff value doesn't fit in S#

Useful properties resulting from the invariants:

Instances

Enum Integer Source 
Eq Integer 

Methods

(==) :: Integer -> Integer -> Bool

(/=) :: Integer -> Integer -> Bool

Integral Integer Source 
Data Integer Source 

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Integer -> c Integer Source

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Integer Source

toConstr :: Integer -> Constr Source

dataTypeOf :: Integer -> DataType Source

dataCast1 :: Typeable (* -> *) t => (forall d. Data d => c (t d)) -> Maybe (c Integer) Source

dataCast2 :: Typeable (* -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Integer) Source

gmapT :: (forall b. Data b => b -> b) -> Integer -> Integer Source

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Integer -> r Source

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Integer -> r Source

gmapQ :: (forall d. Data d => d -> u) -> Integer -> [u] Source

gmapQi :: Int -> (forall d. Data d => d -> u) -> Integer -> u Source

gmapM :: Monad m => (forall d. Data d => d -> m d) -> Integer -> m Integer Source

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Integer -> m Integer Source

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Integer -> m Integer Source

Num Integer Source 
Ord Integer 
Read Integer Source 
Real Integer Source 
Show Integer Source 
Ix Integer Source 
Bits Integer Source 
PrintfArg Integer Source 

data Float :: *

Single-precision floating point numbers. It is desirable that this type be at least equal in range and precision to the IEEE single-precision type.

Instances

Eq Float 

Methods

(==) :: Float -> Float -> Bool

(/=) :: Float -> Float -> Bool

Floating Float Source 
Data Float Source 

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Float -> c Float Source

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Float Source

toConstr :: Float -> Constr Source

dataTypeOf :: Float -> DataType Source

dataCast1 :: Typeable (* -> *) t => (forall d. Data d => c (t d)) -> Maybe (c Float) Source

dataCast2 :: Typeable (* -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Float) Source

gmapT :: (forall b. Data b => b -> b) -> Float -> Float Source

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Float -> r Source

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Float -> r Source

gmapQ :: (forall d. Data d => d -> u) -> Float -> [u] Source

gmapQi :: Int -> (forall d. Data d => d -> u) -> Float -> u Source

gmapM :: Monad m => (forall d. Data d => d -> m d) -> Float -> m Float Source

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Float -> m Float Source

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Float -> m Float Source

Ord Float 

Methods

compare :: Float -> Float -> Ordering

(<) :: Float -> Float -> Bool

(<=) :: Float -> Float -> Bool

(>) :: Float -> Float -> Bool

(>=) :: Float -> Float -> Bool

max :: Float -> Float -> Float

min :: Float -> Float -> Float

Read Float Source 
RealFloat Float Source 
Generic Float Source 

Associated Types

type Rep Float :: * -> * Source

Methods

from :: Float -> Rep Float x Source

to :: Rep Float x -> Float Source

Storable Float Source 
PrintfArg Float Source 
type Rep Float Source 

data Double :: *

Double-precision floating point numbers. It is desirable that this type be at least equal in range and precision to the IEEE double-precision type.

Instances

Eq Double 

Methods

(==) :: Double -> Double -> Bool

(/=) :: Double -> Double -> Bool

Floating Double Source 
Data Double Source 

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Double -> c Double Source

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Double Source

toConstr :: Double -> Constr Source

dataTypeOf :: Double -> DataType Source

dataCast1 :: Typeable (* -> *) t => (forall d. Data d => c (t d)) -> Maybe (c Double) Source

dataCast2 :: Typeable (* -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Double) Source

gmapT :: (forall b. Data b => b -> b) -> Double -> Double Source

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Double -> r Source

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Double -> r Source

gmapQ :: (forall d. Data d => d -> u) -> Double -> [u] Source

gmapQi :: Int -> (forall d. Data d => d -> u) -> Double -> u Source

gmapM :: Monad m => (forall d. Data d => d -> m d) -> Double -> m Double Source

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Double -> m Double Source

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Double -> m Double Source

Ord Double 
Read Double Source 
RealFloat Double Source 
Generic Double Source 

Associated Types

type Rep Double :: * -> * Source

Storable Double Source 
PrintfArg Double Source 
type Rep Double Source 

type Rational = Ratio Integer Source

Arbitrary-precision rational numbers, represented as a ratio of two Integer values. A rational number may be constructed using the % operator.

data Word :: *

A Word is an unsigned integral type, with the same size as Int.

Instances

Bounded Word Source 
Enum Word Source 
Eq Word 

Methods

(==) :: Word -> Word -> Bool

(/=) :: Word -> Word -> Bool

Integral Word Source 
Data Word Source 

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Word -> c Word Source

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Word Source

toConstr :: Word -> Constr Source

dataTypeOf :: Word -> DataType Source

dataCast1 :: Typeable (* -> *) t => (forall d. Data d => c (t d)) -> Maybe (c Word) Source

dataCast2 :: Typeable (* -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Word) Source

gmapT :: (forall b. Data b => b -> b) -> Word -> Word Source

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Word -> r Source

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Word -> r Source

gmapQ :: (forall d. Data d => d -> u) -> Word -> [u] Source

gmapQi :: Int -> (forall d. Data d => d -> u) -> Word -> u Source

gmapM :: Monad m => (forall d. Data d => d -> m d) -> Word -> m Word Source

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Word -> m Word Source

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Word -> m Word Source

Num Word Source 
Ord Word 

Methods

compare :: Word -> Word -> Ordering

(<) :: Word -> Word -> Bool

(<=) :: Word -> Word -> Bool

(>) :: Word -> Word -> Bool

(>=) :: Word -> Word -> Bool

max :: Word -> Word -> Word

min :: Word -> Word -> Word

Read Word Source 
Real Word Source 
Show Word Source 
Ix Word Source 
FiniteBits Word Source 
Bits Word Source 
Storable Word Source 
PrintfArg Word Source 

Numeric type classes

class Num a where Source

Basic numeric class.

Minimal complete definition

(+), (*), abs, signum, fromInteger, (negate | (-))

Methods

(+), (-), (*) :: a -> a -> a infixl 7 *infixl 6 +, - Source

negate :: a -> a Source

Unary negation.

abs :: a -> a Source

Absolute value.

signum :: a -> a Source

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.

Instances

Num Int Source 
Num Int8 Source 
Num Int16 Source 
Num Int32 Source 
Num Int64 Source 
Num Integer Source 
Num Word Source 
Num Word8 Source 
Num Word16 Source 
Num Word32 Source 
Num Word64 Source 
Num CUIntMax Source 
Num CIntMax Source 
Num CUIntPtr Source 
Num CIntPtr Source 
Num CSUSeconds Source 
Num CUSeconds Source 
Num CTime Source 
Num CClock Source 
Num CSigAtomic Source 
Num CWchar Source 
Num CSize Source 
Num CPtrdiff Source 
Num CDouble Source 
Num CFloat Source 
Num CULLong Source 
Num CLLong Source 
Num CULong Source 
Num CLong Source 
Num CUInt Source 
Num CInt Source 
Num CUShort Source 
Num CShort Source 
Num CUChar Source 
Num CSChar Source 
Num CChar Source 
Num IntPtr Source 
Num WordPtr Source 
Num Fd Source 

Methods

(+) :: Fd -> Fd -> Fd Source

(-) :: Fd -> Fd -> Fd Source

(*) :: Fd -> Fd -> Fd Source

negate :: Fd -> Fd Source

abs :: Fd -> Fd Source

signum :: Fd -> Fd Source

fromInteger :: Integer -> Fd Source

Num CRLim Source 
Num CTcflag Source 
Num CSpeed Source 
Num CCc Source 
Num CUid Source 
Num CNlink Source 
Num CGid Source 
Num CSsize Source 
Num CPid Source 
Num COff Source 
Num CMode Source 
Num CIno Source 
Num CDev Source 
Num Natural Source 
Integral a => Num (Ratio a) Source 

Methods

(+) :: Ratio a -> Ratio a -> Ratio a Source

(-) :: Ratio a -> Ratio a -> Ratio a Source

(*) :: Ratio a -> Ratio a -> Ratio a Source

negate :: Ratio a -> Ratio a Source

abs :: Ratio a -> Ratio a Source

signum :: Ratio a -> Ratio a Source

fromInteger :: Integer -> Ratio a Source

Num a => Num (Product a) Source 
Num a => Num (Sum a) Source 

Methods

(+) :: Sum a -> Sum a -> Sum a Source

(-) :: Sum a -> Sum a -> Sum a Source

(*) :: Sum a -> Sum a -> Sum a Source

negate :: Sum a -> Sum a Source

abs :: Sum a -> Sum a Source

signum :: Sum a -> Sum a Source

fromInteger :: Integer -> Sum a Source

RealFloat a => Num (Complex a) Source 
HasResolution a => Num (Fixed a) Source 

Methods

(+) :: Fixed a -> Fixed a -> Fixed a Source

(-) :: Fixed a -> Fixed a -> Fixed a Source

(*) :: Fixed a -> Fixed a -> Fixed a Source

negate :: Fixed a -> Fixed a Source

abs :: Fixed a -> Fixed a Source

signum :: Fixed a -> Fixed a Source

fromInteger :: Integer -> Fixed a Source

Num (f a) => Num (Alt k f a) Source 

Methods

(+) :: Alt k f a -> Alt k f a -> Alt k f a Source

(-) :: Alt k f a -> Alt k f a -> Alt k f a Source

(*) :: Alt k f a -> Alt k f a -> Alt k f a Source

negate :: Alt k f a -> Alt k f a Source

abs :: Alt k f a -> Alt k f a Source

signum :: Alt k f a -> Alt k f a Source

fromInteger :: Integer -> Alt k f a Source

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

Methods

toRational :: a -> Rational Source

the rational equivalent of its real argument with full precision

Instances

Real Int Source 
Real Int8 Source 
Real Int16 Source 
Real Int32 Source 
Real Int64 Source 
Real Integer Source 
Real Word Source 
Real Word8 Source 
Real Word16 Source 
Real Word32 Source 
Real Word64 Source 
Real CUIntMax Source 
Real CIntMax Source 
Real CUIntPtr Source 
Real CIntPtr Source 
Real CSUSeconds Source 
Real CUSeconds Source 
Real CTime Source 
Real CClock Source 
Real CSigAtomic Source 
Real CWchar Source 
Real CSize Source 
Real CPtrdiff Source 
Real CDouble Source 
Real CFloat Source 
Real CULLong Source 
Real CLLong Source 
Real CULong Source 
Real CLong Source 
Real CUInt Source 
Real CInt Source 
Real CUShort Source 
Real CShort Source 
Real CUChar Source 
Real CSChar Source 
Real CChar Source 
Real IntPtr Source 
Real WordPtr Source 
Real Fd Source 
Real CRLim Source 
Real CTcflag Source 
Real CSpeed Source 
Real CCc Source 
Real CUid Source 
Real CNlink Source 
Real CGid Source 
Real CSsize Source 
Real CPid Source 
Real COff Source 
Real CMode Source 
Real CIno Source 
Real CDev Source 
Real Natural Source 
Integral a => Real (Ratio a) Source 
HasResolution a => Real (Fixed a) Source 

class (Real a, Enum a) => Integral a where Source

Integral numbers, supporting integer division.

Minimal complete definition

quotRem, toInteger

Methods

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

simultaneous quot and rem

divMod :: a -> a -> (a, a) Source

simultaneous div and mod

toInteger :: a -> Integer Source

conversion to Integer

Instances

Integral Int Source 

Methods

quot :: Int -> Int -> Int Source

rem :: Int -> Int -> Int Source

div :: Int -> Int -> Int Source

mod :: Int -> Int -> Int Source

quotRem :: Int -> Int -> (Int, Int) Source

divMod :: Int -> Int -> (Int, Int) Source

toInteger :: Int -> Integer Source

Integral Int8 Source 
Integral Int16 Source 
Integral Int32 Source 
Integral Int64 Source 
Integral Integer Source 
Integral Word Source 
Integral Word8 Source 
Integral Word16 Source 
Integral Word32 Source 
Integral Word64 Source 
Integral CUIntMax Source 
Integral CIntMax Source 
Integral CUIntPtr Source 
Integral CIntPtr Source 
Integral CSigAtomic Source 
Integral CWchar Source 
Integral CSize Source 
Integral CPtrdiff Source 
Integral CULLong Source 
Integral CLLong Source 
Integral CULong Source 
Integral CLong Source 
Integral CUInt Source 
Integral CInt Source 
Integral CUShort Source 
Integral CShort Source 
Integral CUChar Source 
Integral CSChar Source 
Integral CChar Source 
Integral IntPtr Source 
Integral WordPtr Source 
Integral Fd Source 

Methods

quot :: Fd -> Fd -> Fd Source

rem :: Fd -> Fd -> Fd Source

div :: Fd -> Fd -> Fd Source

mod :: Fd -> Fd -> Fd Source

quotRem :: Fd -> Fd -> (Fd, Fd) Source

divMod :: Fd -> Fd -> (Fd, Fd) Source

toInteger :: Fd -> Integer Source

Integral CRLim Source 
Integral CTcflag Source 
Integral CUid Source 
Integral CNlink Source 
Integral CGid Source 
Integral CSsize Source 
Integral CPid Source 
Integral COff Source 
Integral CMode Source 
Integral CIno Source 
Integral CDev Source 
Integral Natural Source 

class Num a => Fractional a where Source

Fractional numbers, supporting real division.

Minimal complete definition

fromRational, (recip | (/))

Methods

(/) :: a -> a -> a infixl 7 Source

fractional division

recip :: a -> a Source

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.

class Fractional a => Floating a where Source

Trigonometric and hyperbolic functions and related functions.

Minimal complete definition

pi, exp, log, sin, cos, asin, acos, atan, sinh, cosh, asinh, acosh, atanh

Methods

pi :: a Source

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

sinh, cosh, tanh :: a -> a Source

asinh, acosh, atanh :: a -> a Source

Instances

Floating Double Source 
Floating Float Source 
Floating CDouble Source 
Floating CFloat Source 
RealFloat a => Floating (Complex a) Source 

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

Extracting components of fractions.

Minimal complete definition

properFraction

Methods

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; and
  • f 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, machine-independent access to the components of a floating-point number.

Methods

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 floating-point 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 floating-point radix, and furthermore, either m and n are both zero or else b^(d-1) <= 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 floating-point 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 :: a -> Int Source

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 floating-point number, it is equal in value to significand x * b ^^ exponent x, where b is the floating-point 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 floating-point radix. The behaviour is unspecified on infinite or NaN values.

scaleFloat :: Int -> a -> a Source

multiplies a floating-point number by an integer power of the radix

isNaN :: a -> Bool Source

True if the argument is an IEEE "not-a-number" (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

isIEEE :: a -> Bool Source

True if the argument is an IEEE floating point number

atan2 :: a -> a -> a Source

a version of arctangent taking two real floating-point arguments. For real floating x and y, atan2 y x computes the angle (from the positive x-axis) 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.

Instances

RealFloat Double Source 
RealFloat Float Source 
RealFloat CDouble Source 
RealFloat CFloat Source 

Numeric functions

subtract :: Num a => a -> a -> a Source

the same as flip (-).

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 non-negative 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 fixed-width 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 non-negative 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

Monoids

class Monoid a where Source

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 newtypes and make those instances of Monoid, e.g. Sum and Product.

Minimal complete definition

mempty, mappend

Methods

mempty :: a Source

Identity of mappend

mappend :: a -> a -> a Source

An associative operation

mconcat :: [a] -> a Source

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 Source 
Monoid () Source 

Methods

mempty :: () Source

mappend :: () -> () -> () Source

mconcat :: [()] -> () Source

Monoid Any Source 
Monoid All Source 
Monoid Lifetime Source

mappend == elSupremum

Monoid Event Source 
Monoid [a] Source 

Methods

mempty :: [a] Source

mappend :: [a] -> [a] -> [a] Source

mconcat :: [[a]] -> [a] Source

Monoid a => Monoid (Maybe a) Source

Lift a semigroup into Maybe forming a Monoid according to http://en.wikipedia.org/wiki/Monoid: "Any semigroup S may be turned into a monoid simply by adjoining an element e not in S and defining e*e = e and e*s = s = s*e for all s ∈ S." Since there is no "Semigroup" typeclass providing just mappend, we use Monoid instead.

Methods

mempty :: Maybe a Source

mappend :: Maybe a -> Maybe a -> Maybe a Source

mconcat :: [Maybe a] -> Maybe a Source

Monoid (Last a) Source 

Methods

mempty :: Last a Source

mappend :: Last a -> Last a -> Last a Source

mconcat :: [Last a] -> Last a Source

Monoid (First a) Source 

Methods

mempty :: First a Source

mappend :: First a -> First a -> First a Source

mconcat :: [First a] -> First a Source

Num a => Monoid (Product a) Source 
Num a => Monoid (Sum a) Source 

Methods

mempty :: Sum a Source

mappend :: Sum a -> Sum a -> Sum a Source

mconcat :: [Sum a] -> Sum a Source

Monoid (Endo a) Source 

Methods

mempty :: Endo a Source

mappend :: Endo a -> Endo a -> Endo a Source

mconcat :: [Endo a] -> Endo a Source

Monoid a => Monoid (Dual a) Source 

Methods

mempty :: Dual a Source

mappend :: Dual a -> Dual a -> Dual a Source

mconcat :: [Dual a] -> Dual a Source

Monoid b => Monoid (a -> b) Source 

Methods

mempty :: a -> b Source

mappend :: (a -> b) -> (a -> b) -> a -> b Source

mconcat :: [a -> b] -> a -> b Source

(Monoid a, Monoid b) => Monoid (a, b) Source 

Methods

mempty :: (a, b) Source

mappend :: (a, b) -> (a, b) -> (a, b) Source

mconcat :: [(a, b)] -> (a, b) Source

Monoid (Proxy k s) Source 

Methods

mempty :: Proxy k s Source

mappend :: Proxy k s -> Proxy k s -> Proxy k s Source

mconcat :: [Proxy k s] -> Proxy k s Source

Monoid a => Monoid (Const a b) Source 

Methods

mempty :: Const a b Source

mappend :: Const a b -> Const a b -> Const a b Source

mconcat :: [Const a b] -> Const a b Source

(Monoid a, Monoid b, Monoid c) => Monoid (a, b, c) Source 

Methods

mempty :: (a, b, c) Source

mappend :: (a, b, c) -> (a, b, c) -> (a, b, c) Source

mconcat :: [(a, b, c)] -> (a, b, c) Source

Alternative f => Monoid (Alt * f a) Source 

Methods

mempty :: Alt * f a Source

mappend :: Alt * f a -> Alt * f a -> Alt * f a Source

mconcat :: [Alt * f a] -> Alt * f a Source

(Monoid a, Monoid b, Monoid c, Monoid d) => Monoid (a, b, c, d) Source 

Methods

mempty :: (a, b, c, d) Source

mappend :: (a, b, c, d) -> (a, b, c, d) -> (a, b, c, d) Source

mconcat :: [(a, b, c, d)] -> (a, b, c, d) Source

(Monoid a, Monoid b, Monoid c, Monoid d, Monoid e) => Monoid (a, b, c, d, e) Source 

Methods

mempty :: (a, b, c, d, e) Source

mappend :: (a, b, c, d, e) -> (a, b, c, d, e) -> (a, b, c, d, e) Source

mconcat :: [(a, b, c, d, e)] -> (a, b, c, d, e) Source

Monads and functors

class Functor f where Source

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.

Minimal complete definition

fmap

Methods

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.

Instances

Functor [] Source 

Methods

fmap :: (a -> b) -> [a] -> [b] Source

(<$) :: a -> [b] -> [a] Source

Functor IO Source 

Methods

fmap :: (a -> b) -> IO a -> IO b Source

(<$) :: a -> IO b -> IO a Source

Functor Maybe Source 

Methods

fmap :: (a -> b) -> Maybe a -> Maybe b Source

(<$) :: a -> Maybe b -> Maybe a Source

Functor ReadP Source 

Methods

fmap :: (a -> b) -> ReadP a -> ReadP b Source

(<$) :: a -> ReadP b -> ReadP a Source

Functor ReadPrec Source 

Methods

fmap :: (a -> b) -> ReadPrec a -> ReadPrec b Source

(<$) :: a -> ReadPrec b -> ReadPrec a Source

Functor Last Source 

Methods

fmap :: (a -> b) -> Last a -> Last b Source

(<$) :: a -> Last b -> Last a Source

Functor First Source 

Methods

fmap :: (a -> b) -> First a -> First b Source

(<$) :: a -> First b -> First a Source

Functor STM Source 

Methods

fmap :: (a -> b) -> STM a -> STM b Source

(<$) :: a -> STM b -> STM a Source

Functor Handler Source 

Methods

fmap :: (a -> b) -> Handler a -> Handler b Source

(<$) :: a -> Handler b -> Handler a Source

Functor ZipList Source 

Methods

fmap :: (a -> b) -> ZipList a -> ZipList b Source

(<$) :: a -> ZipList b -> ZipList a Source

Functor Identity Source 

Methods

fmap :: (a -> b) -> Identity a -> Identity b Source

(<$) :: a -> Identity b -> Identity a Source

Functor ArgDescr Source 

Methods

fmap :: (a -> b) -> ArgDescr a -> ArgDescr b Source

(<$) :: a -> ArgDescr b -> ArgDescr a Source

Functor OptDescr Source 

Methods

fmap :: (a -> b) -> OptDescr a -> OptDescr b Source

(<$) :: a -> OptDescr b -> OptDescr a Source

Functor ArgOrder Source 

Methods

fmap :: (a -> b) -> ArgOrder a -> ArgOrder b Source

(<$) :: a -> ArgOrder b -> ArgOrder a Source

Functor ((->) r) Source 

Methods

fmap :: (a -> b) -> (r -> a) -> r -> b Source

(<$) :: a -> (r -> b) -> r -> a Source

Functor (Either a) Source 

Methods

fmap :: (b -> c) -> Either a b -> Either a c Source

(<$) :: b -> Either a c -> Either a b Source

Functor ((,) a) Source 

Methods

fmap :: (b -> c) -> (a, b) -> (a, c) Source

(<$) :: b -> (a, c) -> (a, b) Source

Functor (ST s) Source 

Methods

fmap :: (a -> b) -> ST s a -> ST s b Source

(<$) :: a -> ST s b -> ST s a Source

Functor (Proxy *) Source 

Methods

fmap :: (a -> b) -> Proxy * a -> Proxy * b Source

(<$) :: a -> Proxy * b -> Proxy * a Source

Arrow a => Functor (ArrowMonad a) Source 

Methods

fmap :: (b -> c) -> ArrowMonad a b -> ArrowMonad a c Source

(<$) :: b -> ArrowMonad a c -> ArrowMonad a b Source

Monad m => Functor (WrappedMonad m) Source 

Methods

fmap :: (a -> b) -> WrappedMonad m a -> WrappedMonad m b Source

(<$) :: a -> WrappedMonad m b -> WrappedMonad m a Source

Functor (Const m) Source 

Methods

fmap :: (a -> b) -> Const m a -> Const m b Source

(<$) :: a -> Const m b -> Const m a Source

Functor (ST s) Source 

Methods

fmap :: (a -> b) -> ST s a -> ST s b Source

(<$) :: a -> ST s b -> ST s a Source

Functor f => Functor (Alt * f) Source 

Methods

fmap :: (a -> b) -> Alt * f a -> Alt * f b Source

(<$) :: a -> Alt * f b -> Alt * f a Source

Arrow a => Functor (WrappedArrow a b) Source 

Methods

fmap :: (c -> d) -> WrappedArrow a b c -> WrappedArrow a b d Source

(<$) :: c -> WrappedArrow a b d -> WrappedArrow a b c Source

(<$>) :: Functor f => (a -> b) -> f a -> f b infixl 4 Source

An infix synonym for fmap.

Examples

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

  • embed pure expressions (pure), and
  • sequence computations and combine their results (<*>).

A minimal complete definition must include implementations of these functions satisfying the following laws:

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

If f is also a Monad, it should satisfy

(which implies that pure and <*> satisfy the applicative functor laws).

Minimal complete definition

pure, (<*>)

Methods

pure :: a -> f a Source

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.

Instances

Applicative [] Source 

Methods

pure :: a -> [a] Source

(<*>) :: [a -> b] -> [a] -> [b] Source

(*>) :: [a] -> [b] -> [b] Source

(<*) :: [a] -> [b] -> [a] Source

Applicative IO Source 

Methods

pure :: a -> IO a Source

(<*>) :: IO (a -> b) -> IO a -> IO b Source

(*>) :: IO a -> IO b -> IO b Source

(<*) :: IO a -> IO b -> IO a Source

Applicative Maybe Source 

Methods

pure :: a -> Maybe a Source

(<*>) :: Maybe (a -> b) -> Maybe a -> Maybe b Source

(*>) :: Maybe a -> Maybe b -> Maybe b Source

(<*) :: Maybe a -> Maybe b -> Maybe a Source

Applicative ReadP Source 

Methods

pure :: a -> ReadP a Source

(<*>) :: ReadP (a -> b) -> ReadP a -> ReadP b Source

(*>) :: ReadP a -> ReadP b -> ReadP b Source

(<*) :: ReadP a -> ReadP b -> ReadP a Source

Applicative ReadPrec Source 

Methods

pure :: a -> ReadPrec a Source

(<*>) :: ReadPrec (a -> b) -> ReadPrec a -> ReadPrec b Source

(*>) :: ReadPrec a -> ReadPrec b -> ReadPrec b Source

(<*) :: ReadPrec a -> ReadPrec b -> ReadPrec a Source

Applicative Last Source 

Methods

pure :: a -> Last a Source

(<*>) :: Last (a -> b) -> Last a -> Last b Source

(*>) :: Last a -> Last b -> Last b Source

(<*) :: Last a -> Last b -> Last a Source

Applicative First Source 

Methods

pure :: a -> First a Source

(<*>) :: First (a -> b) -> First a -> First b Source

(*>) :: First a -> First b -> First b Source

(<*) :: First a -> First b -> First a Source

Applicative STM Source 

Methods

pure :: a -> STM a Source

(<*>) :: STM (a -> b) -> STM a -> STM b Source

(*>) :: STM a -> STM b -> STM b Source

(<*) :: STM a -> STM b -> STM a Source

Applicative ZipList Source 

Methods

pure :: a -> ZipList a Source

(<*>) :: ZipList (a -> b) -> ZipList a -> ZipList b Source

(*>) :: ZipList a -> ZipList b -> ZipList b Source

(<*) :: ZipList a -> ZipList b -> ZipList a Source

Applicative Identity Source 

Methods

pure :: a -> Identity a Source

(<*>) :: Identity (a -> b) -> Identity a -> Identity b Source

(*>) :: Identity a -> Identity b -> Identity b Source

(<*) :: Identity a -> Identity b -> Identity a Source

Applicative ((->) a) Source 

Methods

pure :: b -> a -> b Source

(<*>) :: (a -> b -> c) -> (a -> b) -> a -> c Source

(*>) :: (a -> b) -> (a -> c) -> a -> c Source

(<*) :: (a -> b) -> (a -> c) -> a -> b Source

Applicative (Either e) Source 

Methods

pure :: a -> Either e a Source

(<*>) :: Either e (a -> b) -> Either e a -> Either e b Source

(*>) :: Either e a -> Either e b -> Either e b Source

(<*) :: Either e a -> Either e b -> Either e a Source

Monoid a => Applicative ((,) a) Source 

Methods

pure :: b -> (a, b) Source

(<*>) :: (a, b -> c) -> (a, b) -> (a, c) Source

(*>) :: (a, b) -> (a, c) -> (a, c) Source

(<*) :: (a, b) -> (a, c) -> (a, b) Source

Applicative (ST s) Source 

Methods

pure :: a -> ST s a Source

(<*>) :: ST s (a -> b) -> ST s a -> ST s b Source

(*>) :: ST s a -> ST s b -> ST s b Source

(<*) :: ST s a -> ST s b -> ST s a Source

Applicative (Proxy *) Source 

Methods

pure :: a -> Proxy * a Source

(<*>) :: Proxy * (a -> b) -> Proxy * a -> Proxy * b Source

(*>) :: Proxy * a -> Proxy * b -> Proxy * b Source

(<*) :: Proxy * a -> Proxy * b -> Proxy * a Source

Arrow a => Applicative (ArrowMonad a) Source 

Methods

pure :: b -> ArrowMonad a b Source

(<*>) :: ArrowMonad a (b -> c) -> ArrowMonad a b -> ArrowMonad a c Source

(*>) :: ArrowMonad a b -> ArrowMonad a c -> ArrowMonad a c Source

(<*) :: ArrowMonad a b -> ArrowMonad a c -> ArrowMonad a b Source

Monad m => Applicative (WrappedMonad m) Source 
Monoid m => Applicative (Const m) Source 

Methods

pure :: a -> Const m a Source

(<*>) :: Const m (a -> b) -> Const m a -> Const m b Source

(*>) :: Const m a -> Const m b -> Const m b Source

(<*) :: Const m a -> Const m b -> Const m a Source

Applicative (ST s) Source 

Methods

pure :: a -> ST s a Source

(<*>) :: ST s (a -> b) -> ST s a -> ST s b Source

(*>) :: ST s a -> ST s b -> ST s b Source

(<*) :: ST s a -> ST s b -> ST s a Source

Applicative f => Applicative (Alt * f) Source 

Methods

pure :: a -> Alt * f a Source

(<*>) :: Alt * f (a -> b) -> Alt * f a -> Alt * f b Source

(*>) :: Alt * f a -> Alt * f b -> Alt * f b Source

(<*) :: Alt * f a -> Alt * f b -> Alt * f a Source

Arrow a => Applicative (WrappedArrow a b) Source 

Methods

pure :: c -> WrappedArrow a b c Source

(<*>) :: WrappedArrow a b (c -> d) -> WrappedArrow a b c -> WrappedArrow a b d Source

(*>) :: WrappedArrow a b c -> WrappedArrow a b d -> WrappedArrow a b d Source

(<*) :: WrappedArrow a b c -> WrappedArrow a b d -> WrappedArrow a b c Source

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.

Minimal complete definition

(>>=)

Methods

(>>=) :: 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.

return :: a -> m a Source

Inject a value into the monadic type.

fail :: String -> m a Source

Fail with a message. This operation is not part of the mathematical definition of a monad, but is invoked on pattern-match failure in a do expression.

Instances

Monad [] Source 

Methods

(>>=) :: [a] -> (a -> [b]) -> [b] Source

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

return :: a -> [a] Source

fail :: String -> [a] Source

Monad IO Source 

Methods

(>>=) :: IO a -> (a -> IO b) -> IO b Source

(>>) :: IO a -> IO b -> IO b Source

return :: a -> IO a Source

fail :: String -> IO a Source

Monad Maybe Source 

Methods

(>>=) :: Maybe a -> (a -> Maybe b) -> Maybe b Source

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

return :: a -> Maybe a Source

fail :: String -> Maybe a Source

Monad ReadP Source 

Methods

(>>=) :: ReadP a -> (a -> ReadP b) -> ReadP b Source

(>>) :: ReadP a -> ReadP b -> ReadP b Source

return :: a -> ReadP a Source

fail :: String -> ReadP a Source

Monad ReadPrec Source 
Monad Last Source 

Methods

(>>=) :: Last a -> (a -> Last b) -> Last b Source

(>>) :: Last a -> Last b -> Last b Source

return :: a -> Last a Source

fail :: String -> Last a Source

Monad First Source 

Methods

(>>=) :: First a -> (a -> First b) -> First b Source

(>>) :: First a -> First b -> First b Source

return :: a -> First a Source

fail :: String -> First a Source

Monad STM Source 

Methods

(>>=) :: STM a -> (a -> STM b) -> STM b Source

(>>) :: STM a -> STM b -> STM b Source

return :: a -> STM a Source

fail :: String -> STM a Source

Monad Identity Source 
Monad ((->) r) Source 

Methods

(>>=) :: (r -> a) -> (a -> r -> b) -> r -> b Source

(>>) :: (r -> a) -> (r -> b) -> r -> b Source

return :: a -> r -> a Source

fail :: String -> r -> a Source

Monad (Either e) Source 

Methods

(>>=) :: Either e a -> (a -> Either e b) -> Either e b Source

(>>) :: Either e a -> Either e b -> Either e b Source

return :: a -> Either e a Source

fail :: String -> Either e a Source

Monad (ST s) Source 

Methods

(>>=) :: ST s a -> (a -> ST s b) -> ST s b Source

(>>) :: ST s a -> ST s b -> ST s b Source

return :: a -> ST s a Source

fail :: String -> ST s a Source

Monad (Proxy *) Source 

Methods

(>>=) :: Proxy * a -> (a -> Proxy * b) -> Proxy * b Source

(>>) :: Proxy * a -> Proxy * b -> Proxy * b Source

return :: a -> Proxy * a Source

fail :: String -> Proxy * a Source

ArrowApply a => Monad (ArrowMonad a) Source 

Methods

(>>=) :: ArrowMonad a b -> (b -> ArrowMonad a c) -> ArrowMonad a c Source

(>>) :: ArrowMonad a b -> ArrowMonad a c -> ArrowMonad a c Source

return :: b -> ArrowMonad a b Source

fail :: String -> ArrowMonad a b Source

Monad m => Monad (WrappedMonad m) Source 
Monad (ST s) Source 

Methods

(>>=) :: ST s a -> (a -> ST s b) -> ST s b Source

(>>) :: ST s a -> ST s b -> ST s b Source

return :: a -> ST s a Source

fail :: String -> ST s a Source

Monad f => Monad (Alt * f) Source 

Methods

(>>=) :: Alt * f a -> (a -> Alt * f b) -> Alt * f b Source

(>>) :: Alt * f a -> Alt * f b -> Alt * f b Source

return :: a -> Alt * f a Source

fail :: String -> Alt * f a Source

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.

Folds and traversals

class Foldable t where Source

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)

Minimal complete definition

foldMap | foldr

Methods

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

Right-associative fold of a structure.

foldr f z = foldr f z . toList

foldl :: (b -> a -> b) -> b -> t a -> b Source

Left-associative 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 non-empty 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 non-empty structures.

foldl1 f = foldl1 f . toList

null :: t a -> Bool Source

Test whether the structure is empty. The default implementation is optimized for structures that are similar to cons-lists, because there is no general way to do better.

length :: t a -> Int Source

Returns the size/length of a finite structure as an Int. The default implementation is optimized for structures that are similar to cons-lists, 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 non-empty structure.

minimum :: forall a. Ord a => t a -> a Source

The least element of a non-empty 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.

Instances

Foldable [] Source 

Methods

fold :: Monoid m => [m] -> m Source

foldMap :: Monoid m => (a -> m) -> [a] -> m Source

foldr :: (a -> b -> b) -> b -> [a] -> b Source

foldr' :: (a -> b -> b) -> b -> [a] -> b Source

foldl :: (b -> a -> b) -> b -> [a] -> b Source

foldl' :: (b -> a -> b) -> b -> [a] -> b Source

foldr1 :: (a -> a -> a) -> [a] -> a Source

foldl1 :: (a -> a -> a) -> [a] -> a Source

toList :: [a] -> [a] Source

null :: [a] -> Bool Source

length :: [a] -> Int Source

elem :: Eq a => a -> [a] -> Bool Source

maximum :: Ord a => [a] -> a Source

minimum :: Ord a => [a] -> a Source

sum :: Num a => [a] -> a Source

product :: Num a => [a] -> a Source

Foldable Maybe Source 

Methods

fold :: Monoid m => Maybe m -> m Source

foldMap :: Monoid m => (a -> m) -> Maybe a -> m Source

foldr :: (a -> b -> b) -> b -> Maybe a -> b Source

foldr' :: (a -> b -> b) -> b -> Maybe a -> b Source

foldl :: (b -> a -> b) -> b -> Maybe a -> b Source

foldl' :: (b -> a -> b) -> b -> Maybe a -> b Source

foldr1 :: (a -> a -> a) -> Maybe a -> a Source

foldl1 :: (a -> a -> a) -> Maybe a -> a Source

toList :: Maybe a -> [a] Source

null :: Maybe a -> Bool Source

length :: Maybe a -> Int Source

elem :: Eq a => a -> Maybe a -> Bool Source

maximum :: Ord a => Maybe a -> a Source

minimum :: Ord a => Maybe a -> a Source

sum :: Num a => Maybe a -> a Source

product :: Num a => Maybe a -> a Source

Foldable Identity Source 

Methods

fold :: Monoid m => Identity m -> m Source

foldMap :: Monoid m => (a -> m) -> Identity a -> m Source

foldr :: (a -> b -> b) -> b -> Identity a -> b Source

foldr' :: (a -> b -> b) -> b -> Identity a -> b Source

foldl :: (b -> a -> b) -> b -> Identity a -> b Source

foldl' :: (b -> a -> b) -> b -> Identity a -> b Source

foldr1 :: (a -> a -> a) -> Identity a -> a Source

foldl1 :: (a -> a -> a) -> Identity a -> a Source

toList :: Identity a -> [a] Source

null :: Identity a -> Bool Source

length :: Identity a -> Int Source

elem :: Eq a => a -> Identity a -> Bool Source

maximum :: Ord a => Identity a -> a Source

minimum :: Ord a => Identity a -> a Source

sum :: Num a => Identity a -> a Source

product :: Num a => Identity a -> a Source

Foldable (Either a) Source 

Methods

fold :: Monoid m => Either a m -> m Source

foldMap :: Monoid m => (b -> m) -> Either a b -> m Source

foldr :: (b -> c -> c) -> c -> Either a b -> c Source

foldr' :: (b -> c -> c) -> c -> Either a b -> c Source

foldl :: (b -> c -> b) -> b -> Either a c -> b Source

foldl' :: (b -> c -> b) -> b -> Either a c -> b Source

foldr1 :: (b -> b -> b) -> Either a b -> b Source

foldl1 :: (b -> b -> b) -> Either a b -> b Source

toList :: Either a b -> [b] Source

null :: Either a b -> Bool Source

length :: Either a b -> Int Source

elem :: Eq b => b -> Either a b -> Bool Source

maximum :: Ord b => Either a b -> b Source

minimum :: Ord b => Either a b -> b Source

sum :: Num b => Either a b -> b Source

product :: Num b => Either a b -> b Source

Foldable ((,) a) Source 

Methods

fold :: Monoid m => (a, m) -> m Source

foldMap :: Monoid m => (b -> m) -> (a, b) -> m Source

foldr :: (b -> c -> c) -> c -> (a, b) -> c Source

foldr' :: (b -> c -> c) -> c -> (a, b) -> c Source

foldl :: (b -> c -> b) -> b -> (a, c) -> b Source

foldl' :: (b -> c -> b) -> b -> (a, c) -> b Source

foldr1 :: (b -> b -> b) -> (a, b) -> b Source

foldl1 :: (b -> b -> b) -> (a, b) -> b Source

toList :: (a, b) -> [b] Source

null :: (a, b) -> Bool Source

length :: (a, b) -> Int Source

elem :: Eq b => b -> (a, b) -> Bool Source

maximum :: Ord b => (a, b) -> b Source

minimum :: Ord b => (a, b) -> b Source

sum :: Num b => (a, b) -> b Source

product :: Num b => (a, b) -> b Source

Foldable (Proxy *) Source 

Methods

fold :: Monoid m => Proxy * m -> m Source

foldMap :: Monoid m => (a -> m) -> Proxy * a -> m Source

foldr :: (a -> b -> b) -> b -> Proxy * a -> b Source

foldr' :: (a -> b -> b) -> b -> Proxy * a -> b Source

foldl :: (b -> a -> b) -> b -> Proxy * a -> b Source

foldl' :: (b -> a -> b) -> b -> Proxy * a -> b Source

foldr1 :: (a -> a -> a) -> Proxy * a -> a Source

foldl1 :: (a -> a -> a) -> Proxy * a -> a Source

toList :: Proxy * a -> [a] Source

null :: Proxy * a -> Bool Source

length :: Proxy * a -> Int Source

elem :: Eq a => a -> Proxy * a -> Bool Source

maximum :: Ord a => Proxy * a -> a Source

minimum :: Ord a => Proxy * a -> a Source

sum :: Num a => Proxy * a -> a Source

product :: Num a => Proxy * a -> a Source

Foldable (Const m) Source 

Methods

fold :: Monoid a => Const m a -> a Source

foldMap :: Monoid b => (a -> b) -> Const m a -> b Source

foldr :: (a -> b -> b) -> b -> Const m a -> b Source

foldr' :: (a -> b -> b) -> b -> Const m a -> b Source

foldl :: (b -> a -> b) -> b -> Const m a -> b Source

foldl' :: (b -> a -> b) -> b -> Const m a -> b Source

foldr1 :: (a -> a -> a) -> Const m a -> a Source

foldl1 :: (a -> a -> a) -> Const m a -> a Source

toList :: Const m a -> [a] Source

null :: Const m a -> Bool Source

length :: Const m a -> Int Source

elem :: Eq a => a -> Const m a -> Bool Source

maximum :: Ord a => Const m a -> a Source

minimum :: Ord a => Const m a -> a Source

sum :: Num a => Const m a -> a Source

product :: Num a => Const m a -> a Source

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:

naturality
t . traverse f = traverse (t . f) for every applicative transformation t
identity
traverse Identity = Identity
composition
traverse (Compose . fmap g . f) = Compose . fmap (traverse g) . traverse f

A definition of sequenceA must satisfy the following laws:

naturality
t . sequenceA = sequenceA . fmap t for every applicative transformation t
identity
sequenceA . fmap Identity = Identity
composition
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:

Minimal complete definition

traverse | sequenceA

Methods

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

Instances

Traversable [] Source 

Methods

traverse :: Applicative f => (a -> f b) -> [a] -> f [b] Source

sequenceA :: Applicative f => [f a] -> f [a] Source

mapM :: Monad m => (a -> m b) -> [a] -> m [b] Source

sequence :: Monad m => [m a] -> m [a] Source

Traversable Maybe Source 

Methods

traverse :: Applicative f => (a -> f b) -> Maybe a -> f (Maybe b) Source

sequenceA :: Applicative f => Maybe (f a) -> f (Maybe a) Source

mapM :: Monad m => (a -> m b) -> Maybe a -> m (Maybe b) Source

sequence :: Monad m => Maybe (m a) -> m (Maybe a) Source

Traversable Identity Source 

Methods

traverse :: Applicative f => (a -> f b) -> Identity a -> f (Identity b) Source

sequenceA :: Applicative f => Identity (f a) -> f (Identity a) Source

mapM :: Monad m => (a -> m b) -> Identity a -> m (Identity b) Source

sequence :: Monad m => Identity (m a) -> m (Identity a) Source

Traversable (Either a) Source 

Methods

traverse :: Applicative f => (b -> f c) -> Either a b -> f (Either a c) Source

sequenceA :: Applicative f => Either a (f b) -> f (Either a b) Source

mapM :: Monad m => (b -> m c) -> Either a b -> m (Either a c) Source

sequence :: Monad m => Either a (m b) -> m (Either a b) Source

Traversable ((,) a) Source 

Methods

traverse :: Applicative f => (b -> f c) -> (a, b) -> f (a, c) Source

sequenceA :: Applicative f => (a, f b) -> f (a, b) Source

mapM :: Monad m => (b -> m c) -> (a, b) -> m (a, c) Source

sequence :: Monad m => (a, m b) -> m (a, b) Source

Traversable (Proxy *) Source 

Methods

traverse :: Applicative f => (a -> f b) -> Proxy * a -> f (Proxy * b) Source

sequenceA :: Applicative f => Proxy * (f a) -> f (Proxy * a) Source

mapM :: Monad m => (a -> m b) -> Proxy * a -> m (Proxy * b) Source

sequence :: Monad m => Proxy * (m a) -> m (Proxy * a) Source

Traversable (Const m) Source 

Methods

traverse :: Applicative f => (a -> f b) -> Const m a -> f (Const m b) Source

sequenceA :: Applicative f => Const m (f a) -> f (Const m a) Source

mapM :: Monad b => (a -> b c) -> Const m a -> b (Const m c) Source

sequence :: Monad a => Const m (a b) -> a (Const m b) Source

Miscellaneous functions

id :: a -> a Source

Identity function.

const :: a -> b -> a Source

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, right-associative 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 higher-order 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 type-restricted 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 :: [Char] -> a Source

error stops execution and displays an error message.

undefined :: a Source

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.

seq :: a -> b -> b

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 (call-by-value) 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.

List operations

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]

head :: [a] -> a Source

Extract the first element of a list, which must be non-empty.

last :: [a] -> a Source

Extract the last element of a list, which must be finite and non-empty.

tail :: [a] -> [a] Source

Extract the elements after the head of a list, which must be non-empty.

init :: [a] -> [a] Source

Return all the elements of a list except the last one. The list must be non-empty.

(!!) :: [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 :: [a] -> [a] Source

reverse xs returns the elements of xs in reverse order. xs must be finite.

Special folds

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.

Building lists

Scans

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 right-to-left 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.

Infinite lists

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 :: a -> [a] Source

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 :: [a] -> [a] Source

cycle ties a finite list into a circular one, or equivalently, the infinite repetition of the original list. It is the identity on infinite lists.

Sublists

take :: Int -> [a] -> [a] 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).

Searching lists

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.

Zipping and unzipping lists

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 right-lazy:

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 right-lazy:

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 point-wise 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.

Functions on strings

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.

Converting to and from String

Converting to String

type ShowS = String -> String Source

The shows functions return a function that prepends the output String to an existing String. This allows constant-time concatenation of results using function composition.

class Show a where Source

Conversion of values to readable Strings.

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 top-level constructor in 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.
  • If the constructor is defined using record syntax, then show will produce the record-syntax 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 right-associativity of :^: is ignored. For example,

  • show (Leaf 1 :^: Leaf 2 :^: Leaf 3) produces the string "Leaf 1 :^: (Leaf 2 :^: Leaf 3)".

Minimal complete definition

showsPrec | show

Methods

showsPrec Source

Arguments

:: Int

the operator precedence of the enclosing context (a number from 0 to 11). Function application has precedence 10.

-> a

the value to be converted to a String

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

show :: a -> String Source

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.

Instances

Show Bool Source 
Show Char Source 
Show Int Source 
Show Int8 Source 
Show Int16 Source 
Show Int32 Source 
Show Int64 Source 
Show Integer Source 
Show Ordering Source 
Show Word Source 
Show Word8 Source 
Show Word16 Source 
Show Word32 Source 
Show Word64 Source 
Show CallStack Source 
Show TypeRep Source 
Show () Source 

Methods

showsPrec :: Int -> () -> ShowS Source

show :: () -> String Source

showList :: [()] -> ShowS Source

Show SomeException Source 
Show Number Source 
Show Lexeme Source 
Show GeneralCategory Source 
Show Fingerprint Source 
Show TyCon Source 
Show Associativity Source 
Show Fixity Source 
Show Arity Source 
Show Any Source 
Show All Source 
Show ArithException Source 
Show ErrorCall Source 
Show IOException Source 
Show MaskingState Source 
Show Dynamic Source 
Show CUIntMax Source 
Show CIntMax Source 
Show CUIntPtr Source 
Show CIntPtr Source 
Show CSUSeconds Source 
Show CUSeconds Source 
Show CTime Source 
Show CClock Source 
Show CSigAtomic Source 
Show CWchar Source 
Show CSize Source 
Show CPtrdiff Source 
Show CDouble Source 
Show CFloat Source 
Show CULLong Source 
Show CLLong Source 
Show CULong Source 
Show CLong Source 
Show CUInt Source 
Show CInt Source 
Show CUShort Source 
Show CShort Source 
Show CUChar Source 
Show CSChar Source 
Show CChar Source 
Show IntPtr Source 
Show WordPtr Source 
Show CodingProgress Source 
Show TextEncoding Source 
Show SeekMode Source 
Show NewlineMode Source 
Show Newline Source 
Show BufferMode Source 
Show Handle Source 
Show IOErrorType Source 
Show ExitCode Source 
Show ArrayException Source 
Show AsyncException Source 
Show SomeAsyncException Source 
Show AssertionFailed Source 
Show AllocationLimitExceeded Source 
Show Deadlock Source 
Show BlockedIndefinitelyOnSTM Source 
Show BlockedIndefinitelyOnMVar Source 
Show Fd Source 
Show CRLim Source 
Show CTcflag Source 
Show CSpeed Source 
Show CCc Source 
Show CUid Source 
Show CNlink Source 
Show CGid Source 
Show CSsize Source 
Show CPid Source 
Show COff Source 
Show CMode Source 
Show CIno Source 
Show CDev Source 
Show CodingFailureMode Source 
Show ThreadStatus Source 
Show BlockReason Source 
Show ThreadId Source 
Show NestedAtomically Source 
Show NonTermination Source 
Show NoMethodError Source 
Show RecUpdError Source 
Show RecConError Source 
Show RecSelError Source 
Show PatternMatchFail Source 
Show IOMode Source 
Show Lifetime Source 
Show Event Source 
Show FdKey Source 
Show HandlePosn Source 
Show GCStats Source 
Show Version Source 
Show Fixity Source 
Show ConstrRep Source 
Show DataRep Source 
Show Constr Source 
Show DataType Source 
Show Natural Source 
Show RTSFlags Source 
Show TickyFlags Source 
Show TraceFlags Source 
Show DoTrace Source 
Show ProfFlags Source 
Show DoHeapProfile Source 
Show CCFlags Source 
Show DoCostCentres Source 
Show DebugFlags Source 
Show MiscFlags Source 
Show ConcFlags Source 
Show GCFlags Source 
Show GiveGCStats Source 
Show SomeSymbol Source 
Show SomeNat Source 
Show SrcLoc Source 
Show StaticPtrInfo Source 
Show Void Source 
Show a => Show [a] Source 

Methods

showsPrec :: Int -> [a] -> ShowS Source

show :: [a] -> String Source

showList :: [[a]] -> ShowS Source

(Integral a, Show a) => Show (Ratio a) Source 
Show (Ptr a) Source 

Methods

showsPrec :: Int -> Ptr a -> ShowS Source

show :: Ptr a -> String Source

showList :: [Ptr a] -> ShowS Source

Show (FunPtr a) Source 
Show (U1 p) Source 

Methods

showsPrec :: Int -> U1 p -> ShowS Source

show :: U1 p -> String Source

showList :: [U1 p] -> ShowS Source

Show p => Show (Par1 p) Source 
Show a => Show (Maybe a) Source 
Show a => Show (Down a) Source 
Show a => Show (Last a) Source 
Show a => Show (First a) Source 
Show a => Show (Product a) Source 
Show a => Show (Sum a) Source 

Methods

showsPrec :: Int -> Sum a -> ShowS Source

show :: Sum a -> String Source

showList :: [Sum a] -> ShowS Source

Show a => Show (Dual a) Source 
Show (ForeignPtr a) Source 
Show a => Show (ZipList a) Source 
Show a => Show (Complex a) Source 
HasResolution a => Show (Fixed a) Source 
Show a => Show (Identity a) Source

This instance would be equivalent to the derived instances of the Identity newtype if the runIdentity field were removed

(Show a, Show b) => Show (Either a b) Source 

Methods

showsPrec :: Int -> Either a b -> ShowS Source

show :: Either a b -> String Source

showList :: [Either a b] -> ShowS Source

Show (f p) => Show (Rec1 f p) Source 

Methods

showsPrec :: Int -> Rec1 f p -> ShowS Source

show :: Rec1 f p -> String Source

showList :: [Rec1 f p] -> ShowS Source

(Show a, Show b) => Show (a, b) Source 

Methods

showsPrec :: Int -> (a, b) -> ShowS Source

show :: (a, b) -> String Source

showList :: [(a, b)] -> ShowS Source

Show (ST s a) Source 

Methods

showsPrec :: Int -> ST s a -> ShowS Source

show :: ST s a -> String Source

showList :: [ST s a] -> ShowS Source

Show (Proxy k s) Source 

Methods

showsPrec :: Int -> Proxy k s -> ShowS Source

show :: Proxy k s -> String Source

showList :: [Proxy k s] -> ShowS Source

Show a => Show (Const a b) Source 

Methods

showsPrec :: Int -> Const a b -> ShowS Source

show :: Const a b -> String Source

showList :: [Const a b] -> ShowS Source

Show c => Show (K1 i c p) Source 

Methods

showsPrec :: Int -> K1 i c p -> ShowS Source

show :: K1 i c p -> String Source

showList :: [K1 i c p] -> ShowS Source

(Show (f p), Show (g p)) => Show ((:+:) f g p) Source 

Methods

showsPrec :: Int -> (f :+: g) p -> ShowS Source

show :: (f :+: g) p -> String Source

showList :: [(f :+: g) p] -> ShowS Source

(Show (f p), Show (g p)) => Show ((:*:) f g p) Source 

Methods

showsPrec :: Int -> (f :*: g) p -> ShowS Source

show :: (f :*: g) p -> String Source

showList :: [(f :*: g) p] -> ShowS Source

Show (f (g p)) => Show ((:.:) f g p) Source 

Methods

showsPrec :: Int -> (f :.: g) p -> ShowS Source

show :: (f :.: g) p -> String Source

showList :: [(f :.: g) p] -> ShowS Source

(Show a, Show b, Show c) => Show (a, b, c) Source 

Methods

showsPrec :: Int -> (a, b, c) -> ShowS Source

show :: (a, b, c) -> String Source

showList :: [(a, b, c)] -> ShowS Source

Show ((:~:) k a b) Source 

Methods

showsPrec :: Int -> (k :~: a) b -> ShowS Source

show :: (k :~: a) b -> String Source

showList :: [(k :~: a) b] -> ShowS Source

Show (Coercion k a b) Source 

Methods

showsPrec :: Int -> Coercion k a b -> ShowS Source

show :: Coercion k a b -> String Source

showList :: [Coercion k a b] -> ShowS Source

Show (f a) => Show (Alt k f a) Source 

Methods

showsPrec :: Int -> Alt k f a -> ShowS Source

show :: Alt k f a -> String Source

showList :: [Alt k f a] -> ShowS Source

Show (f p) => Show (M1 i c f p) Source 

Methods

showsPrec :: Int -> M1 i c f p -> ShowS Source

show :: M1 i c f p -> String Source

showList :: [M1 i c f p] -> ShowS Source

(Show a, Show b, Show c, Show d) => Show (a, b, c, d) Source 

Methods

showsPrec :: Int -> (a, b, c, d) -> ShowS Source

show :: (a, b, c, d) -> String Source

showList :: [(a, b, c, d)] -> ShowS Source

(Show a, Show b, Show c, Show d, Show e) => Show (a, b, c, d, e) Source 

Methods

showsPrec :: Int -> (a, b, c, d, e) -> ShowS Source

show :: (a, b, c, d, e) -> String Source

showList :: [(a, b, c, d, e)] -> ShowS Source

(Show a, Show b, Show c, Show d, Show e, Show f) => Show (a, b, c, d, e, f) Source 

Methods

showsPrec :: Int -> (a, b, c, d, e, f) -> ShowS Source

show :: (a, b, c, d, e, f) -> String Source

showList :: [(a, b, c, d, e, f)] -> ShowS Source

(Show a, Show b, Show c, Show d, Show e, Show f, Show g) => Show (a, b, c, d, e, f, g) Source 

Methods

showsPrec :: Int -> (a, b, c, d, e, f, g) -> ShowS Source

show :: (a, b, c, d, e, f, g) -> String Source

showList :: [(a, b, c, d, e, f, g)] -> ShowS Source

(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) Source 

Methods

showsPrec :: Int -> (a, b, c, d, e, f, g, h) -> ShowS Source

show :: (a, b, c, d, e, f, g, h) -> String Source

showList :: [(a, b, c, d, e, f, g, h)] -> ShowS Source

(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) Source 

Methods

showsPrec :: Int -> (a, b, c, d, e, f, g, h, i) -> ShowS Source

show :: (a, b, c, d, e, f, g, h, i) -> String Source

showList :: [(a, b, c, d, e, f, g, h, i)] -> ShowS Source

(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) Source 

Methods

showsPrec :: Int -> (a, b, c, d, e, f, g, h, i, j) -> ShowS Source

show :: (a, b, c, d, e, f, g, h, i, j) -> String Source

showList :: [(a, b, c, d, e, f, g, h, i, j)] -> ShowS Source

(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) Source 

Methods

showsPrec :: Int -> (a, b, c, d, e, f, g, h, i, j, k) -> ShowS Source

show :: (a, b, c, d, e, f, g, h, i, j, k) -> String Source

showList :: [(a, b, c, d, e, f, g, h, i, j, k)] -> ShowS Source

(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) Source 

Methods

showsPrec :: Int -> (a, b, c, d, e, f, g, h, i, j, k, l) -> ShowS Source

show :: (a, b, c, d, e, f, g, h, i, j, k, l) -> String Source

showList :: [(a, b, c, d, e, f, g, h, i, j, k, l)] -> ShowS Source

(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) Source 

Methods

showsPrec :: Int -> (a, b, c, d, e, f, g, h, i, j, k, l, m) -> ShowS Source

show :: (a, b, c, d, e, f, g, h, i, j, k, l, m) -> String Source

showList :: [(a, b, c, d, e, f, g, h, i, j, k, l, m)] -> ShowS Source

(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) Source 

Methods

showsPrec :: Int -> (a, b, c, d, e, f, g, h, i, j, k, l, m, n) -> ShowS Source

show :: (a, b, c, d, e, f, g, h, i, j, k, l, m, n) -> String Source

showList :: [(a, b, c, d, e, f, g, h, i, j, k, l, m, n)] -> ShowS Source

(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) Source 

Methods

showsPrec :: Int -> (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o) -> ShowS Source

show :: (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o) -> String Source

showList :: [(a, b, c, d, e, f, g, h, i, j, k, l, m, n, o)] -> ShowS Source

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.

Converting from 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).

class Read a where Source

Parsing of Strings, 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 record-syntax 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 right-associativity 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

Minimal complete definition

readsPrec | readPrec

Methods

readsPrec Source

Arguments

:: Int

the operator precedence of the enclosing context (a number from 0 to 11). Function application has precedence 10.

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

readList :: ReadS [a] Source

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.

Instances

Read Bool Source 
Read Char Source 
Read Double Source 
Read Float Source 
Read Int Source 
Read Int8 Source 
Read Int16 Source 
Read Int32 Source 
Read Int64 Source 
Read Integer Source 
Read Ordering Source 
Read Word Source 
Read Word8 Source 
Read Word16 Source 
Read Word32 Source 
Read Word64 Source 
Read () Source 
Read Lexeme Source 
Read GeneralCategory Source 
Read Associativity Source 
Read Fixity Source 
Read Arity Source 
Read Any Source 
Read All Source 
Read CUIntMax Source 
Read CIntMax Source 
Read CUIntPtr Source 
Read CIntPtr Source 
Read CSUSeconds Source 
Read CUSeconds Source 
Read CTime Source 
Read CClock Source 
Read CSigAtomic Source 
Read CWchar Source 
Read CSize Source 
Read CPtrdiff Source 
Read CDouble Source 
Read CFloat Source 
Read CULLong Source 
Read CLLong Source 
Read CULong Source 
Read CLong Source 
Read CUInt Source 
Read CInt Source 
Read CUShort Source 
Read CShort Source 
Read CUChar Source 
Read CSChar Source 
Read CChar Source 
Read IntPtr Source 
Read WordPtr Source 
Read SeekMode Source 
Read NewlineMode Source 
Read Newline Source 
Read BufferMode Source 
Read ExitCode Source 
Read Fd Source 
Read CRLim Source 
Read CTcflag Source 
Read CSpeed Source 
Read CCc Source 
Read CUid Source 
Read CNlink Source 
Read CGid Source 
Read CSsize Source 
Read CPid Source 
Read COff Source 
Read CMode Source 
Read CIno Source 
Read CDev Source 
Read IOMode Source 
Read GCStats Source 
Read Version Source 
Read Natural Source 
Read SomeSymbol Source 
Read SomeNat Source 
Read Void Source

Reading a Void value is always a parse error, considering Void as a data type with no constructors.

Read a => Read [a] Source 
(Integral a, Read a) => Read (Ratio a) Source 
Read (U1 p) Source 
Read p => Read (Par1 p) Source 
Read a => Read (Maybe a) Source 
Read a => Read (Down a) Source 
Read a => Read (Last a) Source 
Read a => Read (First a) Source 
Read a => Read (Product a) Source 
Read a => Read (Sum a) Source 
Read a => Read (Dual a) Source 
Read a => Read (ZipList a) Source 
Read a => Read (Complex a) Source 
HasResolution a => Read (Fixed a) Source 
Read a => Read (Identity a) Source

This instance would be equivalent to the derived instances of the Identity newtype if the runIdentity field were removed

(Read a, Read b) => Read (Either a b) Source 
Read (f p) => Read (Rec1 f p) Source 
(Read a, Read b) => Read (a, b) Source 

Methods

readsPrec :: Int -> ReadS (a, b) Source

readList :: ReadS [(a, b)] Source

readPrec :: ReadPrec (a, b) Source

readListPrec :: ReadPrec [(a, b)] Source

Read (Proxy k s) Source 
Read a => Read (Const a b) Source 
Read c => Read (K1 i c p) Source 

Methods

readsPrec :: Int -> ReadS (K1 i c p) Source

readList :: ReadS [K1 i c p] Source

readPrec :: ReadPrec (K1 i c p) Source

readListPrec :: ReadPrec [K1 i c p] Source

(Read (f p), Read (g p)) => Read ((:+:) f g p) Source 

Methods

readsPrec :: Int -> ReadS ((f :+: g) p) Source

readList :: ReadS [(f :+: g) p] Source

readPrec :: ReadPrec ((f :+: g) p) Source

readListPrec :: ReadPrec [(f :+: g) p] Source

(Read (f p), Read (g p)) => Read ((:*:) f g p) Source 

Methods

readsPrec :: Int -> ReadS ((f :*: g) p) Source

readList :: ReadS [(f :*: g) p] Source

readPrec :: ReadPrec ((f :*: g) p) Source

readListPrec :: ReadPrec [(f :*: g) p] Source

Read (f (g p)) => Read ((:.:) f g p) Source 

Methods

readsPrec :: Int -> ReadS ((f :.: g) p) Source

readList :: ReadS [(f :.: g) p] Source

readPrec :: ReadPrec ((f :.: g) p) Source

readListPrec :: ReadPrec [(f :.: g) p] Source

(Read a, Read b, Read c) => Read (a, b, c) Source 

Methods

readsPrec :: Int -> ReadS (a, b, c) Source

readList :: ReadS [(a, b, c)] Source

readPrec :: ReadPrec (a, b, c) Source

readListPrec :: ReadPrec [(a, b, c)] Source

(~) k a b => Read ((:~:) k a b) Source 

Methods

readsPrec :: Int -> ReadS ((k :~: a) b) Source

readList :: ReadS [(k :~: a) b] Source

readPrec :: ReadPrec ((k :~: a) b) Source

readListPrec :: ReadPrec [(k :~: a) b] Source

Coercible k a b => Read (Coercion k a b) Source 
Read (f a) => Read (Alt k f a) Source 
Read (f p) => Read (M1 i c f p) Source 

Methods

readsPrec :: Int -> ReadS (M1 i c f p) Source

readList :: ReadS [M1 i c f p] Source

readPrec :: ReadPrec (M1 i c f p) Source

readListPrec :: ReadPrec [M1 i c f p] Source

(Read a, Read b, Read c, Read d) => Read (a, b, c, d) Source 

Methods

readsPrec :: Int -> ReadS (a, b, c, d) Source

readList :: ReadS [(a, b, c, d)] Source

readPrec :: ReadPrec (a, b, c, d) Source

readListPrec :: ReadPrec [(a, b, c, d)] Source

(Read a, Read b, Read c, Read d, Read e) => Read (a, b, c, d, e) Source 

Methods

readsPrec :: Int -> ReadS (a, b, c, d, e) Source

readList :: ReadS [(a, b, c, d, e)] Source

readPrec :: ReadPrec (a, b, c, d, e) Source

readListPrec :: ReadPrec [(a, b, c, d, e)] Source

(Read a, Read b, Read c, Read d, Read e, Read f) => Read (a, b, c, d, e, f) Source 

Methods

readsPrec :: Int -> ReadS (a, b, c, d, e, f) Source

readList :: ReadS [(a, b, c, d, e, f)] Source

readPrec :: ReadPrec (a, b, c, d, e, f) Source

readListPrec :: ReadPrec [(a, b, c, d, e, f)] Source

(Read a, Read b, Read c, Read d, Read e, Read f, Read g) => Read (a, b, c, d, e, f, g) Source 

Methods

readsPrec :: Int -> ReadS (a, b, c, d, e, f, g) Source

readList :: ReadS [(a, b, c, d, e, f, g)] Source

readPrec :: ReadPrec (a, b, c, d, e, f, g) Source

readListPrec :: ReadPrec [(a, b, c, d, e, f, g)] Source

(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) Source 

Methods

readsPrec :: Int -> ReadS (a, b, c, d, e, f, g, h) Source

readList :: ReadS [(a, b, c, d, e, f, g, h)] Source

readPrec :: ReadPrec (a, b, c, d, e, f, g, h) Source

readListPrec :: ReadPrec [(a, b, c, d, e, f, g, h)] Source

(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) Source 

Methods

readsPrec :: Int -> ReadS (a, b, c, d, e, f, g, h, i) Source

readList :: ReadS [(a, b, c, d, e, f, g, h, i)] Source

readPrec :: ReadPrec (a, b, c, d, e, f, g, h, i) Source

readListPrec :: ReadPrec [(a, b, c, d, e, f, g, h, i)] Source

(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) Source 

Methods

readsPrec :: Int -> ReadS (a, b, c, d, e, f, g, h, i, j) Source

readList :: ReadS [(a, b, c, d, e, f, g, h, i, j)] Source

readPrec :: ReadPrec (a, b, c, d, e, f, g, h, i, j) Source

readListPrec :: ReadPrec [(a, b, c, d, e, f, g, h, i, j)] Source

(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) Source 

Methods

readsPrec :: Int -> ReadS (a, b, c, d, e, f, g, h, i, j, k) Source

readList :: ReadS [(a, b, c, d, e, f, g, h, i, j, k)] Source

readPrec :: ReadPrec (a, b, c, d, e, f, g, h, i, j, k) Source

readListPrec :: ReadPrec [(a, b, c, d, e, f, g, h, i, j, k)] Source

(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) Source 

Methods

readsPrec :: Int -> ReadS (a, b, c, d, e, f, g, h, i, j, k, l) Source

readList :: ReadS [(a, b, c, d, e, f, g, h, i, j, k, l)] Source

readPrec :: ReadPrec (a, b, c, d, e, f, g, h, i, j, k, l) Source

readListPrec :: ReadPrec [(a, b, c, d, e, f, g, h, i, j, k, l)] Source

(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) Source 

Methods

readsPrec :: Int -> ReadS (a, b, c, d, e, f, g, h, i, j, k, l, m) Source

readList :: ReadS [(a, b, c, d, e, f, g, h, i, j, k, l, m)] Source

readPrec :: ReadPrec (a, b, c, d, e, f, g, h, i, j, k, l, m) Source

readListPrec :: ReadPrec [(a, b, c, d, e, f, g, h, i, j, k, l, m)] Source

(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) Source 

Methods

readsPrec :: Int -> ReadS (a, b, c, d, e, f, g, h, i, j, k, l, m, n) Source

readList :: ReadS [(a, b, c, d, e, f, g, h, i, j, k, l, m, n)] Source

readPrec :: ReadPrec (a, b, c, d, e, f, g, h, i, j, k, l, m, n) Source

readListPrec :: ReadPrec [(a, b, c, d, e, f, g, h, i, j, k, l, m, n)] Source

(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) Source 

Methods

readsPrec :: Int -> ReadS (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o) Source

readList :: ReadS [(a, b, c, d, e, f, g, h, i, j, k, l, m, n, o)] Source

readPrec :: ReadPrec (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o) Source

readListPrec :: ReadPrec [(a, b, c, d, e, f, g, h, i, j, k, l, m, n, o)] Source

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.

lex :: ReadS String Source

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:

  • Qualified names are not handled properly
  • Octal and hexadecimal numerics are not recognized as a single token
  • Comments are not treated properly

Basic Input and output

data IO a :: * -> *

A value of type IO a is a computation which, when performed, does some I/O before returning a value of type a.

There is really only one way to "perform" an I/O action: bind it to Main.main in your program. When your program is run, the I/O will be performed. It isn't possible to perform I/O from an arbitrary function, unless that function is itself in the IO monad and called at some point, directly or indirectly, from Main.main.

IO is a monad, so IO actions can be combined using either the do-notation or the >> and >>= operations from the Monad class.

Instances

Monad IO Source 

Methods

(>>=) :: IO a -> (a -> IO b) -> IO b Source

(>>) :: IO a -> IO b -> IO b Source

return :: a -> IO a Source

fail :: String -> IO a Source

Functor IO Source 

Methods

fmap :: (a -> b) -> IO a -> IO b Source

(<$) :: a -> IO b -> IO a Source

MonadFix IO Source 

Methods

mfix :: (a -> IO a) -> IO a Source

Applicative IO Source 

Methods

pure :: a -> IO a Source

(<*>) :: IO (a -> b) -> IO a -> IO b Source

(*>) :: IO a -> IO b -> IO b Source

(<*) :: IO a -> IO b -> IO a Source

(~) * a () => HPrintfType (IO a) Source 

Methods

hspr :: Handle -> String -> [UPrintf] -> IO a

(~) * a () => PrintfType (IO a) Source 

Methods

spr :: String -> [UPrintf] -> IO a

Simple I/O operations

Output functions

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

Input functions

getChar :: IO Char Source

Read a character from the standard input device (same as hGetChar stdin).

getLine :: IO String Source

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.

Files

type FilePath = String Source

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.

Exception handling in the I/O monad

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)