base-4.8.1.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 
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 

Methods

(+) :: CGid -> CGid -> CGid Source

(-) :: CGid -> CGid -> CGid Source

(*) :: CGid ->