GHC.Base

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

Minimal complete definition: either == or /=.

Methods

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

Source

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

Instances

Eq ()

Eq Inserts

Eq HashData

Eq KeyPr

Eq Key

Eq Timeout

Eq a => Eq ([] a)

Integral a => Eq (Ratio a)

Eq (StablePtr a)

Eq (Ptr a)

Eq (FunPtr a)

Eq a => Eq ([::] a)

Eq a => Eq (Maybe a)

Eq (IORef a)

Eq (MVar a)

Eq (ForeignPtr a)

Eq (TVar a)

Eq a => Eq (Last a)

Eq a => Eq (First a)

Eq a => Eq (Product a)

Eq a => Eq (Sum a)

Eq a => Eq (Dual a)

Eq (Fixed a)

Eq (StableName a)

RealFloat a => Eq (Complex a)

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

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

Eq (STRef s a)

(Ix i, Eq e) => Eq (Array i e)

Eq (IOArray i e)

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

Eq (STArray s i e)

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

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

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

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

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

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

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

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

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

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

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

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

class Eq a => Ord a where

Source

The Ord class is used for totally ordered datatypes.

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

Methods

compare :: a -> a -> Ordering

Source

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

Source

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

Source

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

Source

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

Source

max :: a -> a -> a

Source

min :: a -> a -> a

Instances

Ord ()

Ord a => Ord ([] a)

Integral a => Ord (Ratio a)

Ord (Ptr a)

Ord (FunPtr a)

Ord a => Ord ([::] a)

Ord a => Ord (Maybe a)

Ord (ForeignPtr a)

Ord a => Ord (Last a)

Ord a => Ord (First a)

Ord a => Ord (Product a)

Ord a => Ord (Sum a)

Ord a => Ord (Dual a)

Ord (Fixed a)

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

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

(Ix i, Ord e) => Ord (Array i e)

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

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

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

(Ord a, Ord b, Ord c, Ord d, Ord e, Ord f) => Ord ((,,,,,) 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)

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

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

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

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

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

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

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

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

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, Data.Maybe.Maybe and System.IO.IO defined in the Prelude satisfy these laws.

Methods

fmap :: (a -> b) -> f a -> f b

Source

Instances

Functor []

Functor [::]

Functor Id

Functor ((->) r)

Functor (Either a)

Functor ((,) a)

Functor (ST s)

Ix i => Functor (Array i)

Monad m => Functor (WrappedMonad m)

Functor (Const m)

Functor (ST s)

Arrow a => Functor (WrappedArrow a b)

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

Minimal complete definition: >>= and return.

Instances of Monad should satisfy the following laws:

 return a >>= k  ==  k a
 m >>= return  ==  m
 m >>= (\x -> k x >>= h)  ==  (m >>= k) >>= h

Instances of both Monad and Functor should additionally satisfy the law:

 fmap f xs  ==  xs >>= return . f

The instances of Monad for lists, Data.Maybe.Maybe and System.IO.IO defined in the Prelude satisfy these laws.

Methods

(>>=) :: forall a b. m a -> (a -> m b) -> m b

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

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

Monad [::]

Monad P

Monad ((->) r)

Monad (ST s)

ArrowApply a => Monad (ArrowMonad a)

Monad (ST s)

data [] a

Source

Constructors

[]
a : [a]

Instances

Monad []

Functor []

Typeable1 []

MonadFix []

MonadPlus []

Alternative []

Applicative []

Foldable []

Traversable []

Eq a => Eq ([] a)

Data a => Data ([] a)

Ord a => Ord ([] a)

Read a => Read ([] a)

Show a => Show ([] a)

IsString ([] Char)

Monoid ([] a)

IsChar c => PrintfArg ([] c)

IsChar c => PrintfType ([] c)

foldr :: (a -> b -> b) -> b -> [a] -> b

Source

foldr, applied to a binary operator, a starting value (typically the right-identity of the operator), and a list, reduces the list using the binary operator, from right to left:

 foldr f z [x1, x2, ..., xn] == x1 `f` (x2 `f` ... (xn `f` z)...)

build :: forall a. (forall b. (a -> b -> b) -> b -> b) -> [a]

Source

A list producer that can be fused with foldr. This function is merely

    build g = g (:) []

but GHC's simplifier will transform an expression of the form foldr k z (build g), which may arise after inlining, to g k z, which avoids producing an intermediate list.

augment :: forall a. (forall b. (a -> b -> b) -> b -> b) -> [a] -> [a]

Source

A list producer that can be fused with foldr. This function is merely

    augment g xs = g (:) xs

but GHC's simplifier will transform an expression of the form foldr k z (augment g xs), which may arise after inlining, to g k (foldr k z xs), which avoids producing an intermediate list.

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, ...]

mapFB :: (elt -> lst -> lst) -> (a -> elt) -> a -> lst -> lst

Source

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

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.

data Bool

Source

The Bool type is an enumeration. It is defined with False first so that the corresponding Prelude.Enum instance will give Prelude.fromEnum False the value zero, and Prelude.fromEnum True the value 1.

Constructors

False
True

Instances

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

Source

Boolean "and"

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

Source

Boolean "or"

not :: Bool -> Bool

Source

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

Source

The unit datatype () has one non-undefined member, the nullary constructor ().

Constructors

()

Instances

Bounded ()

Enum ()

Eq ()

Data ()

Ord ()

Read ()

Show ()

Ix ()

Typeable ()

Monoid ()

data Ordering

Source

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

Constructors

LT
EQ
GT

Instances

type String = [Char]

Source

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

data Char

Source

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 charachers), 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 Prelude.toEnum and Prelude.fromEnum from the Prelude.Enum class respectively (or equivalently ord and chr).

Constructors

C# Char#

Instances

chr :: Int -> Char

Source

The Prelude.toEnum method restricted to the type Data.Char.Char.

unsafeChr :: Int -> Char

Source

ord :: Char -> Int

Source

The Prelude.fromEnum method restricted to the type Data.Char.Char.

eqString :: String -> String -> Bool

Source

data Int

Source

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 Prelude.minBound and Prelude.maxBound from the Prelude.Bounded class.

Constructors

I# Int#

Instances

oneInt :: Int

compareInt :: Int -> Int -> Ordering

Source

compareInt# :: Int# -> Int# -> Ordering

Source

id :: a -> a

Source

Identity function.

lazy :: a -> a

Source

The call '(lazy e)' means the same as e, but lazy has a magical strictness property: it is lazy in its first argument, even though its semantics is strict.

inline :: a -> a

Source

The call '(inline f)' reduces to f, but inline has a BuiltInRule that tries to inline f (if it has an unfolding) unconditionally The NOINLINE pragma arranges that inline only gets inlined (and hence eliminated) late in compilation, after the rule has had a god chance to fire.

assert :: Bool -> a -> a

Source

If the first argument evaluates to True, then the result is the second argument. Otherwise an AssertionFailed exception is raised, containing a String with the source file and line number of the call to assert.

Assertions can normally be turned on or off with a compiler flag (for GHC, assertions are normally on unless optimisation is turned on with -O or the -fignore-asserts option is given). When assertions are turned off, the first argument to assert is ignored, and the second argument is returned as the result.

breakpoint :: a -> a

Source

breakpointCond :: Bool -> a -> a

Source

data Opaque

Source

Constructors

forall a . O a

const :: a -> b -> a

Source

Constant function.

(.) :: (b -> c) -> (a -> b) -> a -> c

Source

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

Source

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.

data Unit

Source

Constructors

Unit

data a :+: b

Source

Constructors