base-compat-0.10.2: A compatibility layer for base

Prelude.Compat

Synopsis

# Documentation

either :: (a -> c) -> (b -> c) -> Either a b -> c #

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

Expand

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


all :: Foldable t => (a -> Bool) -> t a -> Bool #

Determines whether all elements of the structure satisfy the predicate.

and :: Foldable t => t Bool -> Bool #

and returns the conjunction of a container of Bools. For the result to be True, the container must be finite; False, however, results from a False value finitely far from the left end.

any :: Foldable t => (a -> Bool) -> t a -> Bool #

Determines whether any element of the structure satisfies the predicate.

concat :: Foldable t => t [a] -> [a] #

The concatenation of all the elements of a container of lists.

concatMap :: Foldable t => (a -> [b]) -> t a -> [b] #

Map a function over all the elements of a container and concatenate the resulting lists.

mapM_ :: (Foldable t, Monad m) => (a -> m b) -> t a -> m () #

Map each element of a structure to a monadic action, evaluate these actions from left to right, and ignore the results. For a version that doesn't ignore the results see mapM.

As of base 4.8.0.0, mapM_ is just traverse_, specialized to Monad.

notElem :: (Foldable t, Eq a) => a -> t a -> Bool infix 4 #

notElem is the negation of elem.

or :: Foldable t => t Bool -> Bool #

or returns the disjunction of a container of Bools. For the result to be False, the container must be finite; True, however, results from a True value finitely far from the left end.

sequence_ :: (Foldable t, Monad m) => t (m a) -> m () #

Evaluate each monadic action in the structure from left to right, and ignore the results. For a version that doesn't ignore the results see sequence.

As of base 4.8.0.0, sequence_ is just sequenceA_, specialized to Monad.

(<$>) :: Functor f => (a -> b) -> f a -> f b infixl 4 # An infix synonym for fmap. The name of this operator is an allusion to $. Note the similarities between their types:

 ($) :: (a -> b) -> a -> b (<$>) :: Functor f => (a -> b) -> f a -> f b

Whereas $ is function application, <$> is function application lifted over a Functor.

#### Examples

Expand

Convert from a Maybe Int to a Maybe String using show:

>>> show <$> Nothing Nothing >>> show <$> Just 3
Just "3"


Convert from an Either Int Int to an Either Int String using show:

>>> show <$> Left 17 Left 17 >>> show <$> Right 17
Right "17"


Double each element of a list:

>>> (*2) <$> [1,2,3] [2,4,6]  Apply even to the second element of a pair: >>> even <$> (2,2)
(2,True)


maybe :: b -> (a -> b) -> Maybe a -> b #

The maybe function takes a default value, a function, and a Maybe value. If the Maybe value is Nothing, the function returns the default value. Otherwise, it applies the function to the value inside the Just and returns the result.

#### Examples

Expand

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


lines :: String -> [String] #

lines breaks a string up into a list of strings at newline characters. The resulting strings do not contain newlines.

Note that after splitting the string at newline characters, the last part of the string is considered a line even if it doesn't end with a newline. For example,

>>> lines ""
[]

>>> lines "\n"
[""]

>>> lines "one"
["one"]

>>> lines "one\n"
["one"]

>>> lines "one\n\n"
["one",""]

>>> lines "one\ntwo"
["one","two"]

>>> lines "one\ntwo\n"
["one","two"]


Thus lines s contains at least as many elements as newlines in s.

unlines :: [String] -> String #

unlines is an inverse operation to lines. It joins lines, after appending a terminating newline to each.

>>> unlines ["Hello", "World", "!"]
"Hello\nWorld\n!\n"


unwords :: [String] -> String #

unwords is an inverse operation to words. It joins words with separating spaces.

>>> unwords ["Lorem", "ipsum", "dolor"]
"Lorem ipsum dolor"


words :: String -> [String] #

words breaks a string up into a list of words, which were delimited by white space.

>>> words "Lorem ipsum\ndolor"
["Lorem","ipsum","dolor"]


curry :: ((a, b) -> c) -> a -> b -> c #

curry converts an uncurried function to a curried function.

#### Examples

Expand
>>> curry fst 1 2
1


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

Extract the first component of a pair.

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

Extract the second component of a pair.

uncurry :: (a -> b -> c) -> (a, b) -> c #

uncurry converts a curried function to a function on pairs.

#### Examples

Expand
>>> uncurry (+) (1,2)
3

>>> uncurry ($) (show, 1) "1"  >>> map (uncurry max) [(1,2), (3,4), (6,8)] [2,4,8]  ($!) :: forall r a (b :: TYPE r). (a -> b) -> a -> b Source #

Strict (call-by-value) application operator. It takes a function and an argument, evaluates the argument to weak head normal form (WHNF), then calls the function with that value.

(++) :: [a] -> [a] -> [a] infixr 5 #

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.

(.) :: (b -> c) -> (a -> b) -> a -> c infixr 9 #

Function composition.

(=<<) :: Monad m => (a -> m b) -> m a -> m b infixr 1 #

Same as >>=, but with the arguments interchanged.

asTypeOf :: a -> a -> a #

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.

const :: a -> b -> a #

const x is a unary function which evaluates to x for all inputs.

>>> const 42 "hello"
42

>>> map (const 42) [0..3]
[42,42,42,42]


flip :: (a -> b -> c) -> b -> a -> c #

flip f takes its (first) two arguments in the reverse order of f.

>>> flip (++) "hello" "world"
"worldhello"


id :: a -> a #

Identity function.

id x = x

map :: (a -> b) -> [a] -> [b] #

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

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

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

until :: (a -> Bool) -> (a -> a) -> a -> a #

until p f yields the result of applying f until p holds.

ioError :: IOError -> IO a #

Raise an IOError in the IO monad.

Construct an IOError value with a string describing the error. The fail method of the IO instance of the Monad class raises a userError, thus:

instance Monad IO where
...
fail s = ioError (userError s)

(!!) :: [a] -> Int -> a infixl 9 #

List index (subscript) operator, starting from 0. It is an instance of the more general genericIndex, which takes an index of any integral type.

break :: (a -> Bool) -> [a] -> ([a], [a]) #

break, applied to a predicate p and a list xs, returns a tuple where first element is longest prefix (possibly empty) of xs of elements that do not satisfy p and second element is the remainder of the list:

break (> 3) [1,2,3,4,1,2,3,4] == ([1,2,3],[4,1,2,3,4])
break (< 9) [1,2,3] == ([],[1,2,3])
break (> 9) [1,2,3] == ([1,2,3],[])

break p is equivalent to span (not . p).

cycle :: [a] -> [a] #

cycle ties a finite list into a circular one, or equivalently, the infinite repetition of the original list. It is the identity on infinite lists.

drop :: Int -> [a] -> [a] #

drop n xs returns the suffix of xs after the first n elements, or [] if n > length xs:

drop 6 "Hello World!" == "World!"
drop 3 [1,2,3,4,5] == [4,5]
drop 3 [1,2] == []
drop 3 [] == []
drop (-1) [1,2] == [1,2]
drop 0 [1,2] == [1,2]

It is an instance of the more general genericDrop, in which n may be of any integral type.

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

dropWhile p xs returns the suffix remaining after takeWhile p xs:

dropWhile (< 3) [1,2,3,4,5,1,2,3] == [3,4,5,1,2,3]
dropWhile (< 9) [1,2,3] == []
dropWhile (< 0) [1,2,3] == [1,2,3]

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

filter, applied to a predicate and a list, returns the list of those elements that satisfy the predicate; i.e.,

filter p xs = [ x | x <- xs, p x]

head :: [a] -> a #

Extract the first element of a list, which must be non-empty.

init :: [a] -> [a] #

Return all the elements of a list except the last one. The list must be non-empty.

iterate :: (a -> a) -> a -> [a] #

iterate f x returns an infinite list of repeated applications of f to x:

iterate f x == [x, f x, f (f x), ...]

Note that iterate is lazy, potentially leading to thunk build-up if the consumer doesn't force each iterate. See 'iterate\'' for a strict variant of this function.

last :: [a] -> a #

Extract the last element of a list, which must be finite and non-empty.

lookup :: Eq a => a -> [(a, b)] -> Maybe b #

lookup key assocs looks up a key in an association list.

repeat :: a -> [a] #

repeat x is an infinite list, with x the value of every element.

replicate :: Int -> a -> [a] #

replicate n x is a list of length n with x the value of every element. It is an instance of the more general genericReplicate, in which n may be of any integral type.

reverse :: [a] -> [a] #

reverse xs returns the elements of xs in reverse order. xs must be finite.

scanl :: (b -> a -> b) -> b -> [a] -> [b] #

scanl is similar to foldl, but returns a list of successive reduced values from the left:

scanl f z [x1, x2, ...] == [z, z f x1, (z f x1) f x2, ...]

Note that

last (scanl f z xs) == foldl f z xs.

scanl1 :: (a -> a -> a) -> [a] -> [a] #

scanl1 is a variant of scanl that has no starting value argument:

scanl1 f [x1, x2, ...] == [x1, x1 f x2, ...]

scanr :: (a -> b -> b) -> b -> [a] -> [b] #

scanr is the right-to-left dual of scanl. Note that

head (scanr f z xs) == foldr f z xs.

scanr1 :: (a -> a -> a) -> [a] -> [a] #

scanr1 is a variant of scanr that has no starting value argument.

span :: (a -> Bool) -> [a] -> ([a], [a]) #

span, applied to a predicate p and a list xs, returns a tuple where first element is longest prefix (possibly empty) of xs of elements that satisfy p and second element is the remainder of the list:

span (< 3) [1,2,3,4,1,2,3,4] == ([1,2],[3,4,1,2,3,4])
span (< 9) [1,2,3] == ([1,2,3],[])
span (< 0) [1,2,3] == ([],[1,2,3])

span p xs is equivalent to (takeWhile p xs, dropWhile p xs)

splitAt :: Int -> [a] -> ([a], [a]) #

splitAt n xs returns a tuple where first element is xs prefix of length n and second element is the remainder of the list:

splitAt 6 "Hello World!" == ("Hello ","World!")
splitAt 3 [1,2,3,4,5] == ([1,2,3],[4,5])
splitAt 1 [1,2,3] == ([1],[2,3])
splitAt 3 [1,2,3] == ([1,2,3],[])
splitAt 4 [1,2,3] == ([1,2,3],[])
splitAt 0 [1,2,3] == ([],[1,2,3])
splitAt (-1) [1,2,3] == ([],[1,2,3])

It is equivalent to (take n xs, drop n xs) when n is not _|_ (splitAt _|_ xs = _|_). splitAt is an instance of the more general genericSplitAt, in which n may be of any integral type.

tail :: [a] -> [a] #

Extract the elements after the head of a list, which must be non-empty.

take :: Int -> [a] -> [a] #

take n, applied to a list xs, returns the prefix of xs of length n, or xs itself if n > length xs:

take 5 "Hello World!" == "Hello"
take 3 [1,2,3,4,5] == [1,2,3]
take 3 [1,2] == [1,2]
take 3 [] == []
take (-1) [1,2] == []
take 0 [1,2] == []

It is an instance of the more general genericTake, in which n may be of any integral type.

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

takeWhile, applied to a predicate p and a list xs, returns the longest prefix (possibly empty) of xs of elements that satisfy p:

takeWhile (< 3) [1,2,3,4,1,2,3,4] == [1,2]
takeWhile (< 9) [1,2,3] == [1,2,3]
takeWhile (< 0) [1,2,3] == []

unzip :: [(a, b)] -> ([a], [b]) #

unzip transforms a list of pairs into a list of first components and a list of second components.

unzip3 :: [(a, b, c)] -> ([a], [b], [c]) #

The unzip3 function takes a list of triples and returns three lists, analogous to unzip.

zip :: [a] -> [b] -> [(a, b)] #

zip takes two lists and returns a list of corresponding pairs. If one input list is short, excess elements of the longer list are discarded.

zip is right-lazy:

zip [] _|_ = []

zip3 :: [a] -> [b] -> [c] -> [(a, b, c)] #

zip3 takes three lists and returns a list of triples, analogous to zip.

zipWith :: (a -> b -> c) -> [a] -> [b] -> [c] #

zipWith generalises zip by zipping with the function given as the first argument, instead of a tupling function. For example, zipWith (+) is applied to two lists to produce the list of corresponding sums.

zipWith is right-lazy:

zipWith f [] _|_ = []

zipWith3 :: (a -> b -> c -> d) -> [a] -> [b] -> [c] -> [d] #

The zipWith3 function takes a function which combines three elements, as well as three lists and returns a list of their point-wise combination, analogous to zipWith.

subtract :: Num a => a -> a -> a #

the same as flip (-).

Because - is treated specially in the Haskell grammar, (- e) is not a section, but an application of prefix negation. However, (subtract exp) is equivalent to the disallowed section.

The lex function reads a single lexeme from the input, discarding initial white space, and returning the characters that constitute the lexeme. If the input string contains only white space, lex returns a single successful lexeme' consisting of the empty string. (Thus lex "" = [("","")].) If there is no legal lexeme at the beginning of the input string, lex fails (i.e. returns []).

This lexer is not completely faithful to the Haskell lexical syntax in the following respects:

• Qualified names are not handled properly
• Octal and hexadecimal numerics are not recognized as a single token
• Comments are not treated properly

readParen True p parses what p parses, but surrounded with parentheses.

readParen False p parses what p parses, but optionally surrounded with parentheses.

(^) :: (Num a, Integral b) => a -> b -> a infixr 8 #

raise a number to a non-negative integral power

(^^) :: (Fractional a, Integral b) => a -> b -> a infixr 8 #

raise a number to an integral power

even :: Integral a => a -> Bool #

fromIntegral :: (Integral a, Num b) => a -> b #

general coercion from integral types

gcd :: Integral a => a -> a -> a #

gcd x y is the non-negative factor of both x and y of which every common factor of x and y is also a factor; for example gcd 4 2 = 2, gcd (-4) 6 = 2, gcd 0 4 = 4. gcd 0 0 = 0. (That is, the common divisor that is "greatest" in the divisibility preordering.)

Note: Since for signed fixed-width integer types, abs minBound < 0, the result may be negative if one of the arguments is minBound (and necessarily is if the other is 0 or minBound) for such types.

lcm :: Integral a => a -> a -> a #

lcm x y is the smallest positive integer that both x and y divide.

odd :: Integral a => a -> Bool #

realToFrac :: (Real a, Fractional b) => a -> b #

general coercion to fractional types

utility function converting a Char to a show function that simply prepends the character unchanged.

showParen :: Bool -> ShowS -> ShowS #

utility function that surrounds the inner show function with parentheses when the Bool parameter is True.

utility function converting a String to a show function that simply prepends the string unchanged.

shows :: Show a => a -> ShowS #

equivalent to showsPrec with a precedence of 0.

appendFile :: FilePath -> String -> IO () #

The computation appendFile file str function appends the string str, to the file file.

Note that writeFile and appendFile write a literal string to a file. To write a value of any printable type, as with print, use the show function to convert the value to a string first.

main = appendFile "squares" (show [(x,x*x) | x <- [0,0.1..2]])

Read a character from the standard input device (same as hGetChar stdin).

The getContents operation returns all user input as a single string, which is read lazily as it is needed (same as hGetContents stdin).

Read a line from the standard input device (same as hGetLine stdin).

interact :: (String -> String) -> IO () #

The interact function takes a function of type String->String as its argument. The entire input from the standard input device is passed to this function as its argument, and the resulting string is output on the standard output device.

print :: Show a => a -> IO () #

The print function outputs a value of any printable type to the standard output device. Printable types are those that are instances of class Show; print converts values to strings for output using the show operation and adds a newline.

For example, a program to print the first 20 integers and their powers of 2 could be written as:

main = print ([(n, 2^n) | n <- [0..19]])

putChar :: Char -> IO () #

Write a character to the standard output device (same as hPutChar stdout).

putStr :: String -> IO () #

Write a string to the standard output device (same as hPutStr stdout).

putStrLn :: String -> IO () #

The same as putStr, but adds a newline character.

The readFile function reads a file and returns the contents of the file as a string. The file is read lazily, on demand, as with getContents.

The readIO function is similar to read except that it signals parse failure to the IO monad instead of terminating the program.

The readLn function combines getLine and readIO.

writeFile :: FilePath -> String -> IO () #

The computation writeFile file str function writes the string str, to the file file.

The read function reads input from a string, which must be completely consumed by the input process. read fails with an error if the parse is unsuccessful, and it is therefore discouraged from being used in real applications. Use readMaybe or readEither for safe alternatives.

>>> read "123" :: Int
123

>>> read "hello" :: Int
*** Exception: Prelude.read: no parse


equivalent to readsPrec with a precedence of 0.

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

Boolean "and"

not :: Bool -> Bool #

Boolean "not"

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

Boolean "or"

($) :: (a -> b) -> a -> b infixr 0 # Application operator. This operator is redundant, since ordinary application (f x) means the same as (f$ x). However, $ has low, right-associative binding precedence, so it sometimes allows parentheses to be omitted; for example: f$ g $h x = f (g (h x)) It is also useful in higher-order situations, such as map ($ 0) xs, or zipWith ($) fs xs. error :: HasCallStack => [Char] -> a # error stops execution and displays an error message. errorWithoutStackTrace :: [Char] -> a # A variant of error that does not produce a stack trace. Since: base-4.9.0.0 undefined :: HasCallStack => a # A special case of error. It is expected that compilers will recognize this and insert error messages which are more appropriate to the context in which undefined appears. seq :: a -> b -> b # The value of seq a b is bottom if a is bottom, and otherwise equal to b. In other words, it evaluates the first argument a to weak head normal form (WHNF). seq is usually introduced to improve performance by avoiding unneeded laziness. A note on evaluation order: the expression seq a b does not guarantee that a will be evaluated before b. The only guarantee given by seq is that the both a and b will be evaluated before seq returns a value. In particular, this means that b may be evaluated before a. If you need to guarantee a specific order of evaluation, you must use the function pseq from the "parallel" package. elem :: (Foldable t, Eq a) => a -> t a -> Bool infix 4 # Does the element occur in the structure? foldMap :: (Foldable t, Monoid m) => (a -> m) -> t a -> m # Map each element of the structure to a monoid, and combine the results. foldl :: Foldable t => (b -> a -> b) -> b -> t a -> b # Left-associative fold of a structure. In the case of lists, foldl, when applied to a binary operator, a starting value (typically the left-identity of the operator), and a list, reduces the list using the binary operator, from left to right: foldl f z [x1, x2, ..., xn] == (...((z f x1) f x2) f...) f xn Note that to produce the outermost application of the operator the entire input list must be traversed. This means that foldl' will diverge if given an infinite list. Also note that if you want an efficient left-fold, you probably want to use foldl' instead of foldl. The reason for this is that latter does not force the "inner" results (e.g. z f x1 in the above example) before applying them to the operator (e.g. to (f x2)). This results in a thunk chain O(n) elements long, which then must be evaluated from the outside-in. For a general Foldable structure this should be semantically identical to, foldl f z = foldl f z . toList foldl1 :: Foldable t => (a -> a -> a) -> t a -> a # A variant of foldl that has no base case, and thus may only be applied to non-empty structures. foldl1 f = foldl1 f . toList foldr :: Foldable t => (a -> b -> b) -> b -> t a -> b # Right-associative fold of a structure. In the case of lists, foldr, when 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)...) Note that, since the head of the resulting expression is produced by an application of the operator to the first element of the list, foldr can produce a terminating expression from an infinite list. For a general Foldable structure this should be semantically identical to, foldr f z = foldr f z . toList foldr1 :: Foldable t => (a -> a -> a) -> t a -> a # A variant of foldr that has no base case, and thus may only be applied to non-empty structures. foldr1 f = foldr1 f . toList length :: Foldable t => t a -> Int # Returns the size/length of a finite structure as an Int. The default implementation is optimized for structures that are similar to cons-lists, because there is no general way to do better. maximum :: (Foldable t, Ord a) => t a -> a # The largest element of a non-empty structure. minimum :: (Foldable t, Ord a) => t a -> a # The least element of a non-empty structure. null :: Foldable t => t a -> Bool # Test whether the structure is empty. The default implementation is optimized for structures that are similar to cons-lists, because there is no general way to do better. product :: (Foldable t, Num a) => t a -> a # The product function computes the product of the numbers of a structure. sum :: (Foldable t, Num a) => t a -> a # The sum function computes the sum of the numbers of a structure. mapM :: (Traversable t, Monad m) => (a -> m b) -> t a -> m (t b) # Map each element of a structure to a monadic action, evaluate these actions from left to right, and collect the results. For a version that ignores the results see mapM_. sequence :: (Traversable t, Monad m) => t (m a) -> m (t a) # Evaluate each monadic action in the structure from left to right, and collect the results. For a version that ignores the results see sequence_. sequenceA :: (Traversable t, Applicative f) => t (f a) -> f (t a) # Evaluate each action in the structure from left to right, and and collect the results. For a version that ignores the results see sequenceA_. traverse :: (Traversable t, Applicative f) => (a -> f b) -> t a -> f (t b) # Map each element of a structure to an action, evaluate these actions from left to right, and collect the results. For a version that ignores the results see traverse_. (*>) :: Applicative f => f a -> f b -> f b infixl 4 # Sequence actions, discarding the value of the first argument. (<*) :: Applicative f => f a -> f b -> f a infixl 4 # Sequence actions, discarding the value of the second argument. (<*>) :: Applicative f => f (a -> b) -> f a -> f b infixl 4 # Sequential application. A few functors support an implementation of <*> that is more efficient than the default one. pure :: Applicative f => a -> f a # Lift a value. (<$) :: Functor f => a -> f b -> f a infixl 4 #

Replace all locations in the input with the same value. The default definition is fmap . const, but this may be overridden with a more efficient version.

fmap :: Functor f => (a -> b) -> f a -> f b #

(>>) :: Monad m => m a -> m b -> m b infixl 1 #

Sequentially compose two actions, discarding any value produced by the first, like sequencing operators (such as the semicolon) in imperative languages.

(>>=) :: Monad m => m a -> (a -> m b) -> m b infixl 1 #

Sequentially compose two actions, passing any value produced by the first as an argument to the second.

fail :: Monad m => String -> m a #

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.

As part of the MonadFail proposal (MFP), this function is moved to its own class MonadFail (see Control.Monad.Fail for more details). The definition here will be removed in a future release.

return :: Monad m => a -> m a #

Inject a value into the monadic type.

mappend :: Monoid a => a -> a -> a #

An associative operation

NOTE: This method is redundant and has the default implementation mappend = '(<>)' since base-4.11.0.0.

mconcat :: Monoid a => [a] -> a #

Fold a list using the monoid.

For most types, the default definition for mconcat will be used, but the function is included in the class definition so that an optimized version can be provided for specific types.

mempty :: Monoid a => a #

Identity of mappend

(<>) :: Semigroup a => a -> a -> a infixr 6 #

An associative operation.

maxBound :: Bounded a => a #

minBound :: Bounded a => a #

enumFrom :: Enum a => a -> [a] #

Used in Haskell's translation of [n..].

enumFromThen :: Enum a => a -> a -> [a] #

Used in Haskell's translation of [n,n'..].

enumFromThenTo :: Enum a => a -> a -> a -> [a] #

Used in Haskell's translation of [n,n'..m].

enumFromTo :: Enum a => a -> a -> [a] #

Used in Haskell's translation of [n..m].

fromEnum :: Enum a => a -> Int #

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.

pred :: Enum a => a -> a #

the predecessor of a value. For numeric types, pred subtracts 1.

succ :: Enum a => a -> a #

the successor of a value. For numeric types, succ adds 1.

toEnum :: Enum a => Int -> a #

Convert from an Int.

(**) :: Floating a => a -> a -> a infixr 8 #

acos :: Floating a => a -> a #

acosh :: Floating a => a -> a #

asin :: Floating a => a -> a #

asinh :: Floating a => a -> a #

atan :: Floating a => a -> a #

atanh :: Floating a => a -> a #

cos :: Floating a => a -> a #

cosh :: Floating a => a -> a #

exp :: Floating a => a -> a #

log :: Floating a => a -> a #

logBase :: Floating a => a -> a -> a #

pi :: Floating a => a #

sin :: Floating a => a -> a #

sinh :: Floating a => a -> a #

sqrt :: Floating a => a -> a #

tan :: Floating a => a -> a #

tanh :: Floating a => a -> a #

atan2 :: RealFloat a => a -> a -> a #

a version of arctangent taking two real floating-point arguments. For real floating x and y, atan2 y x computes the angle (from the positive x-axis) of the vector from the origin to the point (x,y). atan2 y x returns a value in the range [-pi, pi]. It follows the Common Lisp semantics for the origin when signed zeroes are supported. atan2 y 1, with y in a type that is RealFloat, should return the same value as atan y. A default definition of atan2 is provided, but implementors can provide a more accurate implementation.

decodeFloat :: RealFloat a => a -> (Integer, Int) #

The function decodeFloat applied to a real floating-point number returns the significand expressed as an Integer and an appropriately scaled exponent (an Int). If decodeFloat x yields (m,n), then x is equal in value to m*b^^n, where b is the floating-point radix, and furthermore, either m and n are both zero or else b^(d-1) <= abs m < b^d, where d is the value of floatDigits x. In particular, decodeFloat 0 = (0,0). If the type contains a negative zero, also decodeFloat (-0.0) = (0,0). The result of decodeFloat x is unspecified if either of isNaN x or isInfinite x is True.

encodeFloat :: RealFloat a => Integer -> Int -> a #

encodeFloat performs the inverse of decodeFloat in the sense that for finite x with the exception of -0.0, uncurry encodeFloat (decodeFloat x) = x. encodeFloat m n is one of the two closest representable floating-point numbers to m*b^^n (or ±Infinity if overflow occurs); usually the closer, but if m contains too many bits, the result may be rounded in the wrong direction.

exponent :: RealFloat a => a -> Int #

exponent corresponds to the second component of decodeFloat. exponent 0 = 0 and for finite nonzero x, exponent x = snd (decodeFloat x) + floatDigits x. If x is a finite floating-point number, it is equal in value to significand x * b ^^ exponent x, where b is the floating-point radix. The behaviour is unspecified on infinite or NaN values.

floatDigits :: RealFloat a => a -> Int #

a constant function, returning the number of digits of floatRadix in the significand

floatRadix :: RealFloat a => a -> Integer #

a constant function, returning the radix of the representation (often 2)

floatRange :: RealFloat a => a -> (Int, Int) #

a constant function, returning the lowest and highest values the exponent may assume

isDenormalized :: RealFloat a => a -> Bool #

True if the argument is too small to be represented in normalized format

isIEEE :: RealFloat a => a -> Bool #

True if the argument is an IEEE floating point number

isInfinite :: RealFloat a => a -> Bool #

True if the argument is an IEEE infinity or negative infinity

isNaN :: RealFloat a => a -> Bool #

True if the argument is an IEEE "not-a-number" (NaN) value

isNegativeZero :: RealFloat a => a -> Bool #

True if the argument is an IEEE negative zero

scaleFloat :: RealFloat a => Int -> a -> a #

multiplies a floating-point number by an integer power of the radix

significand :: RealFloat a => a -> a #

The first component of decodeFloat, scaled to lie in the open interval (-1,1), either 0.0 or of absolute value >= 1/b, where b is the floating-point radix. The behaviour is unspecified on infinite or NaN values.

(*) :: Num a => a -> a -> a infixl 7 #

(+) :: Num a => a -> a -> a infixl 6 #

(-) :: Num a => a -> a -> a infixl 6 #

abs :: Num a => a -> a #

Absolute value.

negate :: Num a => a -> a #

Unary negation.

signum :: Num a => a -> a #

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

The method readList is provided to allow the programmer to give a specialised way of parsing lists of values. For example, this is used by the predefined Read instance of the Char type, where values of type String should be are expected to use double quotes, rather than square brackets.

Arguments

 :: Read a => Int the operator precedence of the enclosing context (a number from 0 to 11). Function application has precedence 10. -> ReadS a

attempts to parse a value from the front of the string, returning a list of (parsed value, remaining string) pairs. If there is no successful parse, the returned list is empty.

Derived instances of Read and Show satisfy the following:

• (x,"") is an element of (readsPrec d (showsPrec d x "")).

That is, readsPrec parses the string produced by showsPrec, and delivers the value that showsPrec started with.

(/) :: Fractional a => a -> a -> a infixl 7 #

fractional division

fromRational :: Fractional a => Rational -> a #

Conversion from a Rational (that is Ratio Integer). A floating literal stands for an application of fromRational to a value of type Rational, so such literals have type (Fractional a) => a.

recip :: Fractional a => a -> a #

reciprocal fraction

div :: Integral a => a -> a -> a infixl 7 #

integer division truncated toward negative infinity

divMod :: Integral a => a -> a -> (a, a) #

simultaneous div and mod

mod :: Integral a => a -> a -> a infixl 7 #

integer modulus, satisfying

(x div y)*y + (x mod y) == x

quot :: Integral a => a -> a -> a infixl 7 #

integer division truncated toward zero

quotRem :: Integral a => a -> a -> (a, a) #

simultaneous quot and rem

rem :: Integral a => a -> a -> a infixl 7 #

integer remainder, satisfying

(x quot y)*y + (x rem y) == x

toInteger :: Integral a => a -> Integer #

conversion to Integer

toRational :: Real a => a -> Rational #

the rational equivalent of its real argument with full precision

ceiling :: (RealFrac a, Integral b) => a -> b #

ceiling x returns the least integer not less than x

floor :: (RealFrac a, Integral b) => a -> b #

floor x returns the greatest integer not greater than x

properFraction :: (RealFrac a, Integral b) => a -> (b, a) #

The function properFraction takes a real fractional number x and returns a pair (n,f) such that x = n+f, and:

• n is an integral number with the same sign as x; and
• f is a fraction with the same type and sign as x, and with absolute value less than 1.

The default definitions of the ceiling, floor, truncate and round functions are in terms of properFraction.

round :: (RealFrac a, Integral b) => a -> b #

round x returns the nearest integer to x; the even integer if x is equidistant between two integers

truncate :: (RealFrac a, Integral b) => a -> b #

truncate x returns the integer nearest x between zero and x

show :: Show a => a -> String #

A specialised variant of showsPrec, using precedence context zero, and returning an ordinary String.

showList :: Show a => [a] -> ShowS #

The method showList is provided to allow the programmer to give a specialised way of showing lists of values. For example, this is used by the predefined Show instance of the Char type, where values of type String should be shown in double quotes, rather than between square brackets.

Arguments

 :: Show a => Int the operator precedence of the enclosing context (a number from 0 to 11). Function application has precedence 10. -> a the value to be converted to a String -> ShowS

Convert a value to a readable String.

showsPrec should satisfy the law

showsPrec d x r ++ s  ==  showsPrec d x (r ++ s)

Derived instances of Read and Show satisfy the following:

• (x,"") is an element of (readsPrec d (showsPrec d x "")).

That is, readsPrec parses the string produced by showsPrec, and delivers the value that showsPrec started with.

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

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

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

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

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

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

compare :: Ord a => a -> a -> Ordering #

max :: Ord a => a -> a -> a #

min :: Ord a => a -> a -> a #

class Functor f => Applicative (f :: * -> *) #

A functor with application, providing operations to

• embed pure expressions (pure), and
• sequence computations and combine their results (<*> and liftA2).

A minimal complete definition must include implementations of pure and of either <*> or liftA2. If it defines both, then they must behave the same as their default definitions:

(<*>) = liftA2 id
liftA2 f x y = f <$> x <*> y Further, any definition must satisfy the following: identity pure id <*> v = v composition pure (.) <*> u <*> v <*> w = u <*> (v <*> w) homomorphism pure f <*> pure x = pure (f x) interchange u <*> pure y = pure ($ y) <*> u

The other methods have the following default definitions, which may be overridden with equivalent specialized implementations:

• u *> v = (id <$ u) <*> v • u <* v = liftA2 const u v As a consequence of these laws, the Functor instance for f will satisfy • fmap f x = pure f <*> x It may be useful to note that supposing forall x y. p (q x y) = f x . g y it follows from the above that liftA2 p (liftA2 q u v) = liftA2 f u . liftA2 g v If f is also a Monad, it should satisfy • pure = return • (<*>) = ap • (*>) = (>>) (which implies that pure and <*> satisfy the applicative functor laws). Minimal complete definition pure, ((<*>) | liftA2) Instances  Since: base-2.1 Instance detailsDefined in GHC.Base Methodspure :: a -> [a] #(<*>) :: [a -> b] -> [a] -> [b] #liftA2 :: (a -> b -> c) -> [a] -> [b] -> [c] #(*>) :: [a] -> [b] -> [b] #(<*) :: [a] -> [b] -> [a] # Since: base-2.1 Instance detailsDefined in GHC.Base Methodspure :: a -> Maybe a #(<*>) :: Maybe (a -> b) -> Maybe a -> Maybe b #liftA2 :: (a -> b -> c) -> Maybe a -> Maybe b -> Maybe c #(*>) :: Maybe a -> Maybe b -> Maybe b #(<*) :: Maybe a -> Maybe b -> Maybe a # Since: base-2.1 Instance detailsDefined in GHC.Base Methodspure :: a -> IO a #(<*>) :: IO (a -> b) -> IO a -> IO b #liftA2 :: (a -> b -> c) -> IO a -> IO b -> IO c #(*>) :: IO a -> IO b -> IO b #(<*) :: IO a -> IO b -> IO a # Since: base-4.9.0.0 Instance detailsDefined in Data.Complex Methodspure :: a -> Complex a #(<*>) :: Complex (a -> b) -> Complex a -> Complex b #liftA2 :: (a -> b -> c) -> Complex a -> Complex b -> Complex c #(*>) :: Complex a -> Complex b -> Complex b #(<*) :: Complex a -> Complex b -> Complex a # Since: base-4.9.0.0 Instance detailsDefined in Data.Semigroup Methodspure :: a -> Min a #(<*>) :: Min (a -> b) -> Min a -> Min b #liftA2 :: (a -> b -> c) -> Min a -> Min b -> Min c #(*>) :: Min a -> Min b -> Min b #(<*) :: Min a -> Min b -> Min a # Since: base-4.9.0.0 Instance detailsDefined in Data.Semigroup Methodspure :: a -> Max a #(<*>) :: Max (a -> b) -> Max a -> Max b #liftA2 :: (a -> b -> c) -> Max a -> Max b -> Max c #(*>) :: Max a -> Max b -> Max b #(<*) :: Max a -> Max b -> Max a # Since: base-4.9.0.0 Instance detailsDefined in Data.Semigroup Methodspure :: a -> First a #(<*>) :: First (a -> b) -> First a -> First b #liftA2 :: (a -> b -> c) -> First a -> First b -> First c #(*>) :: First a -> First b -> First b #(<*) :: First a -> First b -> First a # Since: base-4.9.0.0 Instance detailsDefined in Data.Semigroup Methodspure :: a -> Last a #(<*>) :: Last (a -> b) -> Last a -> Last b #liftA2 :: (a -> b -> c) -> Last a -> Last b -> Last c #(*>) :: Last a -> Last b -> Last b #(<*) :: Last a -> Last b -> Last a # Since: base-4.9.0.0 Instance detailsDefined in Data.Semigroup Methodspure :: a -> Option a #(<*>) :: Option (a -> b) -> Option a -> Option b #liftA2 :: (a -> b -> c) -> Option a -> Option b -> Option c #(*>) :: Option a -> Option b -> Option b #(<*) :: Option a -> Option b -> Option a # f '<$>' 'ZipList' xs1 '<*>' ... '<*>' 'ZipList' xsN = 'ZipList' (zipWithN f xs1 ... xsN)where zipWithN refers to the zipWith function of the appropriate arity (zipWith, zipWith3, zipWith4, ...). For example:(\a b c -> stimes c [a, b]) <$> ZipList "abcd" <*> ZipList "567" <*> ZipList [1..] = ZipList (zipWith3 (\a b c -> stimes c [a, b]) "abcd" "567" [1..]) = ZipList {getZipList = ["a5","b6b6","c7c7c7"]}Since: base-2.1 Instance detailsDefined in Control.Applicative Methodspure :: a -> ZipList a #(<*>) :: ZipList (a -> b) -> ZipList a -> ZipList b #liftA2 :: (a -> b -> c) -> ZipList a -> ZipList b -> ZipList c #(*>) :: ZipList a -> ZipList b -> ZipList b #(<*) :: ZipList a -> ZipList b -> ZipList a # Since: base-4.8.0.0 Instance detailsDefined in Data.Functor.Identity Methodspure :: a -> Identity a #(<*>) :: Identity (a -> b) -> Identity a -> Identity b #liftA2 :: (a -> b -> c) -> Identity a -> Identity b -> Identity c #(*>) :: Identity a -> Identity b -> Identity b #(<*) :: Identity a -> Identity b -> Identity a # Since: base-4.8.0.0 Instance detailsDefined in GHC.Conc.Sync Methodspure :: a -> STM a #(<*>) :: STM (a -> b) -> STM a -> STM b #liftA2 :: (a -> b -> c) -> STM a -> STM b -> STM c #(*>) :: STM a -> STM b -> STM b #(<*) :: STM a -> STM b -> STM a # Instance detailsDefined in Data.Monoid Methodspure :: a -> First a #(<*>) :: First (a -> b) -> First a -> First b #liftA2 :: (a -> b -> c) -> First a -> First b -> First c #(*>) :: First a -> First b -> First b #(<*) :: First a -> First b -> First a # Instance detailsDefined in Data.Monoid Methodspure :: a -> Last a #(<*>) :: Last (a -> b) -> Last a -> Last b #liftA2 :: (a -> b -> c) -> Last a -> Last b -> Last c #(*>) :: Last a -> Last b -> Last b #(<*) :: Last a -> Last b -> Last a # Since: base-4.8.0.0 Instance detailsDefined in Data.Semigroup.Internal Methodspure :: a -> Dual a #(<*>) :: Dual (a -> b) -> Dual a -> Dual b #liftA2 :: (a -> b -> c) -> Dual a -> Dual b -> Dual c #(*>) :: Dual a -> Dual b -> Dual b #(<*) :: Dual a -> Dual b -> Dual a # Since: base-4.8.0.0 Instance detailsDefined in Data.Semigroup.Internal Methodspure :: a -> Sum a #(<*>) :: Sum (a -> b) -> Sum a -> Sum b #liftA2 :: (a -> b -> c) -> Sum a -> Sum b -> Sum c #(*>) :: Sum a -> Sum b -> Sum b #(<*) :: Sum a -> Sum b -> Sum a # Since: base-4.8.0.0 Instance detailsDefined in Data.Semigroup.Internal Methodspure :: a -> Product a #(<*>) :: Product (a -> b) -> Product a -> Product b #liftA2 :: (a -> b -> c) -> Product a -> Product b -> Product c #(*>) :: Product a -> Product b -> Product b #(<*) :: Product a -> Product b -> Product a # Since: base-4.6.0.0 Instance detailsDefined in Text.ParserCombinators.ReadPrec Methodspure :: a -> ReadPrec a #(<*>) :: ReadPrec (a -> b) -> ReadPrec a -> ReadPrec b #liftA2 :: (a -> b -> c) -> ReadPrec a -> ReadPrec b -> ReadPrec c #(*>) :: ReadPrec a -> ReadPrec b -> ReadPrec b #(<*) :: ReadPrec a -> ReadPrec b -> ReadPrec a # Since: base-4.6.0.0 Instance detailsDefined in Text.ParserCombinators.ReadP Methodspure :: a -> ReadP a #(<*>) :: ReadP (a -> b) -> ReadP a -> ReadP b #liftA2 :: (a -> b -> c) -> ReadP a -> ReadP b -> ReadP c #(*>) :: ReadP a -> ReadP b -> ReadP b #(<*) :: ReadP a -> ReadP b -> ReadP a # Since: base-4.9.0.0 Instance detailsDefined in GHC.Base Methodspure :: a -> NonEmpty a #(<*>) :: NonEmpty (a -> b) -> NonEmpty a -> NonEmpty b #liftA2 :: (a -> b -> c) -> NonEmpty a -> NonEmpty b -> NonEmpty c #(*>) :: NonEmpty a -> NonEmpty b -> NonEmpty b #(<*) :: NonEmpty a -> NonEmpty b -> NonEmpty a # Since: base-4.5.0.0 Instance detailsDefined in Text.ParserCombinators.ReadP Methodspure :: a -> P a #(<*>) :: P (a -> b) -> P a -> P b #liftA2 :: (a -> b -> c) -> P a -> P b -> P c #(*>) :: P a -> P b -> P b #(<*) :: P a -> P b -> P a # Since: base-3.0 Instance detailsDefined in Data.Either Methodspure :: a -> Either e a #(<*>) :: Either e (a -> b) -> Either e a -> Either e b #liftA2 :: (a -> b -> c) -> Either e a -> Either e b -> Either e c #(*>) :: Either e a -> Either e b -> Either e b #(<*) :: Either e a -> Either e b -> Either e a # Monoid a => Applicative ((,) a) For tuples, the Monoid constraint on a determines how the first values merge. For example, Strings concatenate:("hello ", (+15)) <*> ("world!", 2002) ("hello world!",2017)Since: base-2.1 Instance detailsDefined in GHC.Base Methodspure :: a0 -> (a, a0) #(<*>) :: (a, a0 -> b) -> (a, a0) -> (a, b) #liftA2 :: (a0 -> b -> c) -> (a, a0) -> (a, b) -> (a, c) #(*>) :: (a, a0) -> (a, b) -> (a, b) #(<*) :: (a, a0) -> (a, b) -> (a, a0) # Since: base-4.4.0.0 Instance detailsDefined in GHC.ST Methodspure :: a -> ST s a #(<*>) :: ST s (a -> b) -> ST s a -> ST s b #liftA2 :: (a -> b -> c) -> ST s a -> ST s b -> ST s c #(*>) :: ST s a -> ST s b -> ST s b #(<*) :: ST s a -> ST s b -> ST s a # Since: base-2.1 Instance detailsDefined in Control.Monad.ST.Lazy.Imp Methodspure :: a -> ST s a #(<*>) :: ST s (a -> b) -> ST s a -> ST s b #liftA2 :: (a -> b -> c) -> ST s a -> ST s b -> ST s c #(*>) :: ST s a -> ST s b -> ST s b #(<*) :: ST s a -> ST s b -> ST s a # Monad m => Applicative (WrappedMonad m) Since: base-2.1 Instance detailsDefined in Control.Applicative Methodspure :: a -> WrappedMonad m a #(<*>) :: WrappedMonad m (a -> b) -> WrappedMonad m a -> WrappedMonad m b #liftA2 :: (a -> b -> c) -> WrappedMonad m a -> WrappedMonad m b -> WrappedMonad m c #(*>) :: WrappedMonad m a -> WrappedMonad m b -> WrappedMonad m b #(<*) :: WrappedMonad m a -> WrappedMonad m b -> WrappedMonad m a # Applicative (Proxy :: * -> *) Since: base-4.7.0.0 Instance detailsDefined in Data.Proxy Methodspure :: a -> Proxy a #(<*>) :: Proxy (a -> b) -> Proxy a -> Proxy b #liftA2 :: (a -> b -> c) -> Proxy a -> Proxy b -> Proxy c #(*>) :: Proxy a -> Proxy b -> Proxy b #(<*) :: Proxy a -> Proxy b -> Proxy a # Arrow a => Applicative (WrappedArrow a b) Since: base-2.1 Instance detailsDefined in Control.Applicative Methodspure :: a0 -> WrappedArrow a b a0 #(<*>) :: WrappedArrow a b (a0 -> b0) -> WrappedArrow a b a0 -> WrappedArrow a b b0 #liftA2 :: (a0 -> b0 -> c) -> WrappedArrow a b a0 -> WrappedArrow a b b0 -> WrappedArrow a b c #(*>) :: WrappedArrow a b a0 -> WrappedArrow a b b0 -> WrappedArrow a b b0 #(<*) :: WrappedArrow a b a0 -> WrappedArrow a b b0 -> WrappedArrow a b a0 # Monoid m => Applicative (Const m :: * -> *) Since: base-2.0.1 Instance detailsDefined in Data.Functor.Const Methodspure :: a -> Const m a #(<*>) :: Const m (a -> b) -> Const m a -> Const m b #liftA2 :: (a -> b -> c) -> Const m a -> Const m b -> Const m c #(*>) :: Const m a -> Const m b -> Const m b #(<*) :: Const m a -> Const m b -> Const m a # Applicative f => Applicative (Alt f) Instance detailsDefined in Data.Semigroup.Internal Methodspure :: a -> Alt f a #(<*>) :: Alt f (a -> b) -> Alt f a -> Alt f b #liftA2 :: (a -> b -> c) -> Alt f a -> Alt f b -> Alt f c #(*>) :: Alt f a -> Alt f b -> Alt f b #(<*) :: Alt f a -> Alt f b -> Alt f a # Applicative ((->) a :: * -> *) Since: base-2.1 Instance detailsDefined in GHC.Base Methodspure :: a0 -> a -> a0 #(<*>) :: (a -> a0 -> b) -> (a -> a0) -> a -> b #liftA2 :: (a0 -> b -> c) -> (a -> a0) -> (a -> b) -> a -> c #(*>) :: (a -> a0) -> (a -> b) -> a -> b #(<*) :: (a -> a0) -> (a -> b) -> a -> a0 # (Applicative f, Applicative g) => Applicative (Product f g) Since: base-4.9.0.0 Instance detailsDefined in Data.Functor.Product Methodspure :: a -> Product f g a #(<*>) :: Product f g (a -> b) -> Product f g a -> Product f g b #liftA2 :: (a -> b -> c) -> Product f g a -> Product f g b -> Product f g c #(*>) :: Product f g a -> Product f g b -> Product f g b #(<*) :: Product f g a -> Product f g b -> Product f g a # (Applicative f, Applicative g) => Applicative (Compose f g) Since: base-4.9.0.0 Instance detailsDefined in Data.Functor.Compose Methodspure :: a -> Compose f g a #(<*>) :: Compose f g (a -> b) -> Compose f g a -> Compose f g b #liftA2 :: (a -> b -> c) -> Compose f g a -> Compose f g b -> Compose f g c #(*>) :: Compose f g a -> Compose f g b -> Compose f g b #(<*) :: Compose f g a -> Compose f g b -> Compose f g a # class Bounded a # The Bounded class is used to name the upper and lower limits of a type. Ord is not a superclass of Bounded since types that are not totally ordered may also have upper and lower bounds. The Bounded class may be derived for any enumeration type; minBound is the first constructor listed in the data declaration and maxBound is the last. Bounded may also be derived for single-constructor datatypes whose constituent types are in Bounded. Minimal complete definition Instances  Since: base-2.1 Instance detailsDefined in GHC.Enum Methods Since: base-2.1 Instance detailsDefined in GHC.Enum Methods Since: base-2.1 Instance detailsDefined in GHC.Enum Methods Since: base-2.1 Instance detailsDefined in GHC.Int Methods Since: base-2.1 Instance detailsDefined in GHC.Int Methods Since: base-2.1 Instance detailsDefined in GHC.Int Methods Since: base-2.1 Instance detailsDefined in GHC.Int Methods Since: base-2.1 Instance detailsDefined in GHC.Enum Methods Since: base-2.1 Instance detailsDefined in GHC.Enum Methods Since: base-2.1 Instance detailsDefined in GHC.Word Methods Since: base-2.1 Instance detailsDefined in GHC.Word Methods Since: base-2.1 Instance detailsDefined in GHC.Word Methods Since: base-2.1 Instance detailsDefined in GHC.Word Methods Since: base-4.10.0.0 Instance detailsDefined in GHC.Enum Methods Since: base-4.10.0.0 Instance detailsDefined in GHC.Enum Methods Bounded () Since: base-2.1 Instance detailsDefined in GHC.Enum MethodsminBound :: () #maxBound :: () # Instance detailsDefined in Data.Semigroup.Internal Methods Instance detailsDefined in Data.Semigroup.Internal Methods Instance detailsDefined in Foreign.C.Types Methods Instance detailsDefined in Foreign.C.Types Methods Instance detailsDefined in Foreign.C.Types Methods Instance detailsDefined in Foreign.C.Types Methods Instance detailsDefined in Foreign.C.Types Methods Instance detailsDefined in Foreign.C.Types Methods Instance detailsDefined in Foreign.C.Types Methods Instance detailsDefined in Foreign.C.Types Methods Instance detailsDefined in Foreign.C.Types Methods Instance detailsDefined in Foreign.C.Types Methods Instance detailsDefined in Foreign.C.Types Methods Instance detailsDefined in Foreign.C.Types Methods Instance detailsDefined in Foreign.C.Types Methods Instance detailsDefined in Foreign.C.Types Methods Instance detailsDefined in Foreign.C.Types Methods Instance detailsDefined in Foreign.C.Types Methods Instance detailsDefined in Foreign.C.Types Methods Instance detailsDefined in Foreign.C.Types Methods Instance detailsDefined in Foreign.C.Types Methods Instance detailsDefined in Foreign.C.Types Methods Instance detailsDefined in Foreign.Ptr Methods Instance detailsDefined in Foreign.Ptr Methods Bounded a => Bounded (Min a) Instance detailsDefined in Data.Semigroup MethodsminBound :: Min a #maxBound :: Min a # Bounded a => Bounded (Max a) Instance detailsDefined in Data.Semigroup MethodsminBound :: Max a #maxBound :: Max a # Bounded a => Bounded (First a) Instance detailsDefined in Data.Semigroup Methods Bounded a => Bounded (Last a) Instance detailsDefined in Data.Semigroup Methods Bounded m => Bounded (WrappedMonoid m) Instance detailsDefined in Data.Semigroup Methods Bounded a => Bounded (Identity a) Instance detailsDefined in Data.Functor.Identity Methods Bounded a => Bounded (Dual a) Instance detailsDefined in Data.Semigroup.Internal Methods Bounded a => Bounded (Sum a) Instance detailsDefined in Data.Semigroup.Internal MethodsminBound :: Sum a #maxBound :: Sum a # Bounded a => Bounded (Product a) Instance detailsDefined in Data.Semigroup.Internal Methods (Bounded a, Bounded b) => Bounded (a, b) Since: base-2.1 Instance detailsDefined in GHC.Enum MethodsminBound :: (a, b) #maxBound :: (a, b) # Bounded (Proxy t) Instance detailsDefined in Data.Proxy Methods (Bounded a, Bounded b, Bounded c) => Bounded (a, b, c) Since: base-2.1 Instance detailsDefined in GHC.Enum MethodsminBound :: (a, b, c) #maxBound :: (a, b, c) # Bounded a => Bounded (Const a b) Instance detailsDefined in Data.Functor.Const MethodsminBound :: Const a b #maxBound :: Const a b # Coercible a b => Bounded (Coercion a b) Since: base-4.7.0.0 Instance detailsDefined in Data.Type.Coercion MethodsminBound :: Coercion a b #maxBound :: Coercion a b # a ~ b => Bounded (a :~: b) Since: base-4.7.0.0 Instance detailsDefined in Data.Type.Equality MethodsminBound :: a :~: b #maxBound :: a :~: b # (Bounded a, Bounded b, Bounded c, Bounded d) => Bounded (a, b, c, d) Since: base-2.1 Instance detailsDefined in GHC.Enum MethodsminBound :: (a, b, c, d) #maxBound :: (a, b, c, d) # a ~~ b => Bounded (a :~~: b) Since: base-4.10.0.0 Instance detailsDefined in Data.Type.Equality MethodsminBound :: a :~~: b #maxBound :: a :~~: b # (Bounded a, Bounded b, Bounded c, Bounded d, Bounded e) => Bounded (a, b, c, d, e) Since: base-2.1 Instance detailsDefined in GHC.Enum MethodsminBound :: (a, b, c, d, e) #maxBound :: (a, b, c, d, e) # (Bounded a, Bounded b, Bounded c, Bounded d, Bounded e, Bounded f) => Bounded (a, b, c, d, e, f) Since: base-2.1 Instance detailsDefined in GHC.Enum MethodsminBound :: (a, b, c, d, e, f) #maxBound :: (a, b, c, d, e, f) # (Bounded a, Bounded b, Bounded c, Bounded d, Bounded e, Bounded f, Bounded g) => Bounded (a, b, c, d, e, f, g) Since: base-2.1 Instance detailsDefined in GHC.Enum MethodsminBound :: (a, b, c, d, e, f, g) #maxBound :: (a, b, c, d, e, f, g) # (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) Since: base-2.1 Instance detailsDefined in GHC.Enum MethodsminBound :: (a, b, c, d, e, f, g, h) #maxBound :: (a, b, c, d, e, f, g, h) # (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) Since: base-2.1 Instance detailsDefined in GHC.Enum MethodsminBound :: (a, b, c, d, e, f, g, h, i) #maxBound :: (a, b, c, d, e, f, g, h, i) # (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) Since: base-2.1 Instance detailsDefined in GHC.Enum MethodsminBound :: (a, b, c, d, e, f, g, h, i, j) #maxBound :: (a, b, c, d, e, f, g, h, i, j) # (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) Since: base-2.1 Instance detailsDefined in GHC.Enum MethodsminBound :: (a, b, c, d, e, f, g, h, i, j, k) #maxBound :: (a, b, c, d, e, f, g, h, i, j, k) # (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) Since: base-2.1 Instance detailsDefined in GHC.Enum MethodsminBound :: (a, b, c, d, e, f, g, h, i, j, k, l) #maxBound :: (a, b, c, d, e, f, g, h, i, j, k, l) # (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) Since: base-2.1 Instance detailsDefined in GHC.Enum MethodsminBound :: (a, b, c, d, e, f, g, h, i, j, k, l, m) #maxBound :: (a, b, c, d, e, f, g, h, i, j, k, l, m) # (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) Since: base-2.1 Instance detailsDefined in GHC.Enum MethodsminBound :: (a, b, c, d, e, f, g, h, i, j, k, l, m, n) #maxBound :: (a, b, c, d, e, f, g, h, i, j, k, l, m, n) # (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) Since: base-2.1 Instance detailsDefined in GHC.Enum MethodsminBound :: (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o) #maxBound :: (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o) # class Enum a # 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: • The calls succ maxBound and pred minBound should result in a runtime error. • fromEnum and toEnum should give a runtime error if the result value is not representable in the result type. For example, toEnum 7 :: Bool is an error. • enumFrom and enumFromThen should be defined with an implicit bound, thus:  enumFrom x = enumFromTo x maxBound enumFromThen x y = enumFromThenTo x y bound where bound | fromEnum y >= fromEnum x = maxBound | otherwise = minBound Minimal complete definition Instances  Since: base-2.1 Instance detailsDefined in GHC.Enum Methodssucc :: Bool -> Bool #pred :: Bool -> Bool #toEnum :: Int -> Bool #fromEnum :: Bool -> Int #enumFrom :: Bool -> [Bool] #enumFromThen :: Bool -> Bool -> [Bool] #enumFromTo :: Bool -> Bool -> [Bool] #enumFromThenTo :: Bool -> Bool -> Bool -> [Bool] # Since: base-2.1 Instance detailsDefined in GHC.Enum Methodssucc :: Char -> Char #pred :: Char -> Char #toEnum :: Int -> Char #fromEnum :: Char -> Int #enumFrom :: Char -> [Char] #enumFromThen :: Char -> Char -> [Char] #enumFromTo :: Char -> Char -> [Char] #enumFromThenTo :: Char -> Char -> Char -> [Char] # Since: base-2.1 Instance detailsDefined in GHC.Enum Methodssucc :: Int -> Int #pred :: Int -> Int #toEnum :: Int -> Int #fromEnum :: Int -> Int #enumFrom :: Int -> [Int] #enumFromThen :: Int -> Int -> [Int] #enumFromTo :: Int -> Int -> [Int] #enumFromThenTo :: Int -> Int -> Int -> [Int] # Since: base-2.1 Instance detailsDefined in GHC.Int Methodssucc :: Int8 -> Int8 #pred :: Int8 -> Int8 #toEnum :: Int -> Int8 #fromEnum :: Int8 -> Int #enumFrom :: Int8 -> [Int8] #enumFromThen :: Int8 -> Int8 -> [Int8] #enumFromTo :: Int8 -> Int8 -> [Int8] #enumFromThenTo :: Int8 -> Int8 -> Int8 -> [Int8] # Since: base-2.1 Instance detailsDefined in GHC.Int Methodssucc :: Int16 -> Int16 #pred :: Int16 -> Int16 #toEnum :: Int -> Int16 #enumFrom :: Int16 -> [Int16] #enumFromThen :: Int16 -> Int16 -> [Int16] #enumFromTo :: Int16 -> Int16 -> [Int16] #enumFromThenTo :: Int16 -> Int16 -> Int16 -> [Int16] # Since: base-2.1 Instance detailsDefined in GHC.Int Methodssucc :: Int32 -> Int32 #pred :: Int32 -> Int32 #toEnum :: Int -> Int32 #enumFrom :: Int32 -> [Int32] #enumFromThen :: Int32 -> Int32 -> [Int32] #enumFromTo :: Int32 -> Int32 -> [Int32] #enumFromThenTo :: Int32 -> Int32 -> Int32 -> [Int32] # Since: base-2.1 Instance detailsDefined in GHC.Int Methodssucc :: Int64 -> Int64 #pred :: Int64 -> Int64 #toEnum :: Int -> Int64 #enumFrom :: Int64 -> [Int64] #enumFromThen :: Int64 -> Int64 -> [Int64] #enumFromTo :: Int64 -> Int64 -> [Int64] #enumFromThenTo :: Int64 -> Int64 -> Int64 -> [Int64] # Since: base-2.1 Instance detailsDefined in GHC.Enum MethodsenumFrom :: Integer -> [Integer] #enumFromThen :: Integer -> Integer -> [Integer] #enumFromTo :: Integer -> Integer -> [Integer] #enumFromThenTo :: Integer -> Integer -> Integer -> [Integer] # Since: base-4.8.0.0 Instance detailsDefined in GHC.Natural MethodsenumFrom :: Natural -> [Natural] #enumFromThen :: Natural -> Natural -> [Natural] #enumFromTo :: Natural -> Natural -> [Natural] #enumFromThenTo :: Natural -> Natural -> Natural -> [Natural] # Since: base-2.1 Instance detailsDefined in GHC.Enum MethodsenumFrom :: Ordering -> [Ordering] #enumFromTo :: Ordering -> Ordering -> [Ordering] # Since: base-2.1 Instance detailsDefined in GHC.Enum Methodssucc :: Word -> Word #pred :: Word -> Word #toEnum :: Int -> Word #fromEnum :: Word -> Int #enumFrom :: Word -> [Word] #enumFromThen :: Word -> Word -> [Word] #enumFromTo :: Word -> Word -> [Word] #enumFromThenTo :: Word -> Word -> Word -> [Word] # Since: base-2.1 Instance detailsDefined in GHC.Word Methodssucc :: Word8 -> Word8 #pred :: Word8 -> Word8 #toEnum :: Int -> Word8 #enumFrom :: Word8 -> [Word8] #enumFromThen :: Word8 -> Word8 -> [Word8] #enumFromTo :: Word8 -> Word8 -> [Word8] #enumFromThenTo :: Word8 -> Word8 -> Word8 -> [Word8] # Since: base-2.1 Instance detailsDefined in GHC.Word MethodstoEnum :: Int -> Word16 #enumFrom :: Word16 -> [Word16] #enumFromThen :: Word16 -> Word16 -> [Word16] #enumFromTo :: Word16 -> Word16 -> [Word16] #enumFromThenTo :: Word16 -> Word16 -> Word16 -> [Word16] # Since: base-2.1 Instance detailsDefined in GHC.Word MethodstoEnum :: Int -> Word32 #enumFrom :: Word32 -> [Word32] #enumFromThen :: Word32 -> Word32 -> [Word32] #enumFromTo :: Word32 -> Word32 -> [Word32] #enumFromThenTo :: Word32 -> Word32 -> Word32 -> [Word32] # Since: base-2.1 Instance detailsDefined in GHC.Word MethodstoEnum :: Int -> Word64 #enumFrom :: Word64 -> [Word64] #enumFromThen :: Word64 -> Word64 -> [Word64] #enumFromTo :: Word64 -> Word64 -> [Word64] #enumFromThenTo :: Word64 -> Word64 -> Word64 -> [Word64] # Since: base-4.10.0.0 Instance detailsDefined in GHC.Enum MethodsenumFrom :: VecCount -> [VecCount] #enumFromTo :: VecCount -> VecCount -> [VecCount] # Since: base-4.10.0.0 Instance detailsDefined in GHC.Enum MethodsenumFrom :: VecElem -> [VecElem] #enumFromThen :: VecElem -> VecElem -> [VecElem] #enumFromTo :: VecElem -> VecElem -> [VecElem] #enumFromThenTo :: VecElem -> VecElem -> VecElem -> [VecElem] # Enum () Since: base-2.1 Instance detailsDefined in GHC.Enum Methodssucc :: () -> () #pred :: () -> () #toEnum :: Int -> () #fromEnum :: () -> Int #enumFrom :: () -> [()] #enumFromThen :: () -> () -> [()] #enumFromTo :: () -> () -> [()] #enumFromThenTo :: () -> () -> () -> [()] # Instance detailsDefined in Foreign.C.Types Methodssucc :: CChar -> CChar #pred :: CChar -> CChar #toEnum :: Int -> CChar #enumFrom :: CChar -> [CChar] #enumFromThen :: CChar -> CChar -> [CChar] #enumFromTo :: CChar -> CChar -> [CChar] #enumFromThenTo :: CChar -> CChar -> CChar -> [CChar] # Instance detailsDefined in Foreign.C.Types MethodstoEnum :: Int -> CSChar #enumFrom :: CSChar -> [CSChar] #enumFromThen :: CSChar -> CSChar -> [CSChar] #enumFromTo :: CSChar -> CSChar -> [CSChar] #enumFromThenTo :: CSChar -> CSChar -> CSChar -> [CSChar] # Instance detailsDefined in Foreign.C.Types MethodstoEnum :: Int -> CUChar #enumFrom :: CUChar -> [CUChar] #enumFromThen :: CUChar -> CUChar -> [CUChar] #enumFromTo :: CUChar -> CUChar -> [CUChar] #enumFromThenTo :: CUChar -> CUChar -> CUChar -> [CUChar] # Instance detailsDefined in Foreign.C.Types MethodstoEnum :: Int -> CShort #enumFrom :: CShort -> [CShort] #enumFromThen :: CShort -> CShort -> [CShort] #enumFromTo :: CShort -> CShort -> [CShort] #enumFromThenTo :: CShort -> CShort -> CShort -> [CShort] # Instance detailsDefined in Foreign.C.Types MethodsenumFrom :: CUShort -> [CUShort] #enumFromThen :: CUShort -> CUShort -> [CUShort] #enumFromTo :: CUShort -> CUShort -> [CUShort] #enumFromThenTo :: CUShort -> CUShort -> CUShort -> [CUShort] # Instance detailsDefined in Foreign.C.Types Methodssucc :: CInt -> CInt #pred :: CInt -> CInt #toEnum :: Int -> CInt #fromEnum :: CInt -> Int #enumFrom :: CInt -> [CInt] #enumFromThen :: CInt -> CInt -> [CInt] #enumFromTo :: CInt -> CInt -> [CInt] #enumFromThenTo :: CInt -> CInt -> CInt -> [CInt] # Instance detailsDefined in Foreign.C.Types Methodssucc :: CUInt -> CUInt #pred :: CUInt -> CUInt #toEnum :: Int -> CUInt #enumFrom :: CUInt -> [CUInt] #enumFromThen :: CUInt -> CUInt -> [CUInt] #enumFromTo :: CUInt -> CUInt -> [CUInt] #enumFromThenTo :: CUInt -> CUInt -> CUInt -> [CUInt] # Instance detailsDefined in Foreign.C.Types Methodssucc :: CLong -> CLong #pred :: CLong -> CLong #toEnum :: Int -> CLong #enumFrom :: CLong -> [CLong] #enumFromThen :: CLong -> CLong -> [CLong] #enumFromTo :: CLong -> CLong -> [CLong] #enumFromThenTo :: CLong -> CLong -> CLong -> [CLong] # Instance detailsDefined in Foreign.C.Types MethodstoEnum :: Int -> CULong #enumFrom :: CULong -> [CULong] #enumFromThen :: CULong -> CULong -> [CULong] #enumFromTo :: CULong -> CULong -> [CULong] #enumFromThenTo :: CULong -> CULong -> CULong -> [CULong] # Instance detailsDefined in Foreign.C.Types MethodstoEnum :: Int -> CLLong #enumFrom :: CLLong -> [CLLong] #enumFromThen :: CLLong -> CLLong -> [CLLong] #enumFromTo :: CLLong -> CLLong -> [CLLong] #enumFromThenTo :: CLLong -> CLLong -> CLLong -> [CLLong] # Instance detailsDefined in Foreign.C.Types MethodsenumFrom :: CULLong -> [CULLong] #enumFromThen :: CULLong -> CULLong -> [CULLong] #enumFromTo :: CULLong -> CULLong -> [CULLong] #enumFromThenTo :: CULLong -> CULLong -> CULLong -> [CULLong] # Instance detailsDefined in Foreign.C.Types Methodssucc :: CBool -> CBool #pred :: CBool -> CBool #toEnum :: Int -> CBool #enumFrom :: CBool -> [CBool] #enumFromThen :: CBool -> CBool -> [CBool] #enumFromTo :: CBool -> CBool -> [CBool] #enumFromThenTo :: CBool -> CBool -> CBool -> [CBool] # Instance detailsDefined in Foreign.C.Types MethodstoEnum :: Int -> CFloat #enumFrom :: CFloat -> [CFloat] #enumFromThen :: CFloat -> CFloat -> [CFloat] #enumFromTo :: CFloat -> CFloat -> [CFloat] #enumFromThenTo :: CFloat -> CFloat -> CFloat -> [CFloat] # Instance detailsDefined in Foreign.C.Types MethodsenumFrom :: CDouble -> [CDouble] #enumFromThen :: CDouble -> CDouble -> [CDouble] #enumFromTo :: CDouble -> CDouble -> [CDouble] #enumFromThenTo :: CDouble -> CDouble -> CDouble -> [CDouble] # Instance detailsDefined in Foreign.C.Types MethodsenumFrom :: CPtrdiff -> [CPtrdiff] #enumFromTo :: CPtrdiff -> CPtrdiff -> [CPtrdiff] # Instance detailsDefined in Foreign.C.Types Methodssucc :: CSize -> CSize #pred :: CSize -> CSize #toEnum :: Int -> CSize #enumFrom :: CSize -> [CSize] #enumFromThen :: CSize -> CSize -> [CSize] #enumFromTo :: CSize -> CSize -> [CSize] #enumFromThenTo :: CSize -> CSize -> CSize -> [CSize] # Instance detailsDefined in Foreign.C.Types MethodstoEnum :: Int -> CWchar #enumFrom :: CWchar -> [CWchar] #enumFromThen :: CWchar -> CWchar -> [CWchar] #enumFromTo :: CWchar -> CWchar -> [CWchar] #enumFromThenTo :: CWchar -> CWchar -> CWchar -> [CWchar] # Instance detailsDefined in Foreign.C.Types Methods Instance detailsDefined in Foreign.C.Types MethodstoEnum :: Int -> CClock #enumFrom :: CClock -> [CClock] #enumFromThen :: CClock -> CClock -> [CClock] #enumFromTo :: CClock -> CClock -> [CClock] #enumFromThenTo :: CClock -> CClock -> CClock -> [CClock] # Instance detailsDefined in Foreign.C.Types Methodssucc :: CTime -> CTime #pred :: CTime -> CTime #toEnum :: Int -> CTime #enumFrom :: CTime -> [CTime] #enumFromThen :: CTime -> CTime -> [CTime] #enumFromTo :: CTime -> CTime -> [CTime] #enumFromThenTo :: CTime -> CTime -> CTime -> [CTime] # Instance detailsDefined in Foreign.C.Types MethodsenumFrom :: CUSeconds -> [CUSeconds] # Instance detailsDefined in Foreign.C.Types Methods Instance detailsDefined in Foreign.C.Types MethodsenumFrom :: CIntPtr -> [CIntPtr] #enumFromThen :: CIntPtr -> CIntPtr -> [CIntPtr] #enumFromTo :: CIntPtr -> CIntPtr -> [CIntPtr] #enumFromThenTo :: CIntPtr -> CIntPtr -> CIntPtr -> [CIntPtr] # Instance detailsDefined in Foreign.C.Types MethodsenumFrom :: CUIntPtr -> [CUIntPtr] #enumFromTo :: CUIntPtr -> CUIntPtr -> [CUIntPtr] # Instance detailsDefined in Foreign.C.Types MethodsenumFrom :: CIntMax -> [CIntMax] #enumFromThen :: CIntMax -> CIntMax -> [CIntMax] #enumFromTo :: CIntMax -> CIntMax -> [CIntMax] #enumFromThenTo :: CIntMax -> CIntMax -> CIntMax -> [CIntMax] # Instance detailsDefined in Foreign.C.Types MethodsenumFrom :: CUIntMax -> [CUIntMax] #enumFromTo :: CUIntMax -> CUIntMax -> [CUIntMax] # Instance detailsDefined in Foreign.Ptr MethodsenumFrom :: WordPtr -> [WordPtr] #enumFromThen :: WordPtr -> WordPtr -> [WordPtr] #enumFromTo :: WordPtr -> WordPtr -> [WordPtr] #enumFromThenTo :: WordPtr -> WordPtr -> WordPtr -> [WordPtr] # Instance detailsDefined in Foreign.Ptr MethodstoEnum :: Int -> IntPtr #enumFrom :: IntPtr -> [IntPtr] #enumFromThen :: IntPtr -> IntPtr -> [IntPtr] #enumFromTo :: IntPtr -> IntPtr -> [IntPtr] #enumFromThenTo :: IntPtr -> IntPtr -> IntPtr -> [IntPtr] # Integral a => Enum (Ratio a) Since: base-2.0.1 Instance detailsDefined in GHC.Real Methodssucc :: Ratio a -> Ratio a #pred :: Ratio a -> Ratio a #toEnum :: Int -> Ratio a #fromEnum :: Ratio a -> Int #enumFrom :: Ratio a -> [Ratio a] #enumFromThen :: Ratio a -> Ratio a -> [Ratio a] #enumFromTo :: Ratio a -> Ratio a -> [Ratio a] #enumFromThenTo :: Ratio a -> Ratio a -> Ratio a -> [Ratio a] # Enum a => Enum (Min a) Since: base-4.9.0.0 Instance detailsDefined in Data.Semigroup Methodssucc :: Min a -> Min a #pred :: Min a -> Min a #toEnum :: Int -> Min a #fromEnum :: Min a -> Int #enumFrom :: Min a -> [Min a] #enumFromThen :: Min a -> Min a -> [Min a] #enumFromTo :: Min a -> Min a -> [Min a] #enumFromThenTo :: Min a -> Min a -> Min a -> [Min a] # Enum a => Enum (Max a) Since: base-4.9.0.0 Instance detailsDefined in Data.Semigroup Methodssucc :: Max a -> Max a #pred :: Max a -> Max a #toEnum :: Int -> Max a #fromEnum :: Max a -> Int #enumFrom :: Max a -> [Max a] #enumFromThen :: Max a -> Max a -> [Max a] #enumFromTo :: Max a -> Max a -> [Max a] #enumFromThenTo :: Max a -> Max a -> Max a -> [Max a] # Enum a => Enum (First a) Since: base-4.9.0.0 Instance detailsDefined in Data.Semigroup Methodssucc :: First a -> First a #pred :: First a -> First a #toEnum :: Int -> First a #fromEnum :: First a -> Int #enumFrom :: First a -> [First a] #enumFromThen :: First a -> First a -> [First a] #enumFromTo :: First a -> First a -> [First a] #enumFromThenTo :: First a -> First a -> First a -> [First a] # Enum a => Enum (Last a) Since: base-4.9.0.0 Instance detailsDefined in Data.Semigroup Methodssucc :: Last a -> Last a #pred :: Last a -> Last a #toEnum :: Int -> Last a #fromEnum :: Last a -> Int #enumFrom :: Last a -> [Last a] #enumFromThen :: Last a -> Last a -> [Last a] #enumFromTo :: Last a -> Last a -> [Last a] #enumFromThenTo :: Last a -> Last a -> Last a -> [Last a] # Enum a => Enum (WrappedMonoid a) Since: base-4.9.0.0 Instance detailsDefined in Data.Semigroup MethodsenumFrom :: WrappedMonoid a -> [WrappedMonoid a] #enumFromThen :: WrappedMonoid a -> WrappedMonoid a -> [WrappedMonoid a] #enumFromTo :: WrappedMonoid a -> WrappedMonoid a -> [WrappedMonoid a] #enumFromThenTo :: WrappedMonoid a -> WrappedMonoid a -> WrappedMonoid a -> [WrappedMonoid a] # Enum a => Enum (Identity a) Instance detailsDefined in Data.Functor.Identity Methodssucc :: Identity a -> Identity a #pred :: Identity a -> Identity a #toEnum :: Int -> Identity a #fromEnum :: Identity a -> Int #enumFrom :: Identity a -> [Identity a] #enumFromThen :: Identity a -> Identity a -> [Identity a] #enumFromTo :: Identity a -> Identity a -> [Identity a] #enumFromThenTo :: Identity a -> Identity a -> Identity a -> [Identity a] # Enum (Proxy s) Since: base-4.7.0.0 Instance detailsDefined in Data.Proxy Methodssucc :: Proxy s -> Proxy s #pred :: Proxy s -> Proxy s #toEnum :: Int -> Proxy s #fromEnum :: Proxy s -> Int #enumFrom :: Proxy s -> [Proxy s] #enumFromThen :: Proxy s -> Proxy s -> [Proxy s] #enumFromTo :: Proxy s -> Proxy s -> [Proxy s] #enumFromThenTo :: Proxy s -> Proxy s -> Proxy s -> [Proxy s] # Enum a => Enum (Const a b) Instance detailsDefined in Data.Functor.Const Methodssucc :: Const a b -> Const a b #pred :: Const a b -> Const a b #toEnum :: Int -> Const a b #fromEnum :: Const a b -> Int #enumFrom :: Const a b -> [Const a b] #enumFromThen :: Const a b -> Const a b -> [Const a b] #enumFromTo :: Const a b -> Const a b -> [Const a b] #enumFromThenTo :: Const a b -> Const a b -> Const a b -> [Const a b] # Enum (f a) => Enum (Alt f a) Instance detailsDefined in Data.Semigroup.Internal Methodssucc :: Alt f a -> Alt f a #pred :: Alt f a -> Alt f a #toEnum :: Int -> Alt f a #fromEnum :: Alt f a -> Int #enumFrom :: Alt f a -> [Alt f a] #enumFromThen :: Alt f a -> Alt f a -> [Alt f a] #enumFromTo :: Alt f a -> Alt f a -> [Alt f a] #enumFromThenTo :: Alt f a -> Alt f a -> Alt f a -> [Alt f a] # Coercible a b => Enum (Coercion a b) Since: base-4.7.0.0 Instance detailsDefined in Data.Type.Coercion Methodssucc :: Coercion a b -> Coercion a b #pred :: Coercion a b -> Coercion a b #toEnum :: Int -> Coercion a b #fromEnum :: Coercion a b -> Int #enumFrom :: Coercion a b -> [Coercion a b] #enumFromThen :: Coercion a b -> Coercion a b -> [Coercion a b] #enumFromTo :: Coercion a b -> Coercion a b -> [Coercion a b] #enumFromThenTo :: Coercion a b -> Coercion a b -> Coercion a b -> [Coercion a b] # a ~ b => Enum (a :~: b) Since: base-4.7.0.0 Instance detailsDefined in Data.Type.Equality Methodssucc :: (a :~: b) -> a :~: b #pred :: (a :~: b) -> a :~: b #toEnum :: Int -> a :~: b #fromEnum :: (a :~: b) -> Int #enumFrom :: (a :~: b) -> [a :~: b] #enumFromThen :: (a :~: b) -> (a :~: b) -> [a :~: b] #enumFromTo :: (a :~: b) -> (a :~: b) -> [a :~: b] #enumFromThenTo :: (a :~: b) -> (a :~: b) -> (a :~: b) -> [a :~: b] # a ~~ b => Enum (a :~~: b) Since: base-4.10.0.0 Instance detailsDefined in Data.Type.Equality Methodssucc :: (a :~~: b) -> a :~~: b #pred :: (a :~~: b) -> a :~~: b #toEnum :: Int -> a :~~: b #fromEnum :: (a :~~: b) -> Int #enumFrom :: (a :~~: b) -> [a :~~: b] #enumFromThen :: (a :~~: b) -> (a :~~: b) -> [a :~~: b] #enumFromTo :: (a :~~: b) -> (a :~~: b) -> [a :~~: b] #enumFromThenTo :: (a :~~: b) -> (a :~~: b) -> (a :~~: b) -> [a :~~: b] # class Eq a # 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 Instances  Instance detailsDefined in GHC.Classes Methods(==) :: Bool -> Bool -> Bool #(/=) :: Bool -> Bool -> Bool # Instance detailsDefined in GHC.Classes Methods(==) :: Char -> Char -> Bool #(/=) :: Char -> Char -> Bool # Instance detailsDefined in GHC.Classes Methods(==) :: Double -> Double -> Bool #(/=) :: Double -> Double -> Bool # Instance detailsDefined in GHC.Classes Methods(==) :: Float -> Float -> Bool #(/=) :: Float -> Float -> Bool # Instance detailsDefined in GHC.Classes Methods(==) :: Int -> Int -> Bool #(/=) :: Int -> Int -> Bool # Since: base-2.1 Instance detailsDefined in GHC.Int Methods(==) :: Int8 -> Int8 -> Bool #(/=) :: Int8 -> Int8 -> Bool # Since: base-2.1 Instance detailsDefined in GHC.Int Methods(==) :: Int16 -> Int16 -> Bool #(/=) :: Int16 -> Int16 -> Bool # Since: base-2.1 Instance detailsDefined in GHC.Int Methods(==) :: Int32 -> Int32 -> Bool #(/=) :: Int32 -> Int32 -> Bool # Since: base-2.1 Instance detailsDefined in GHC.Int Methods(==) :: Int64 -> Int64 -> Bool #(/=) :: Int64 -> Int64 -> Bool # Instance detailsDefined in GHC.Integer.Type Methods(==) :: Integer -> Integer -> Bool #(/=) :: Integer -> Integer -> Bool # Instance detailsDefined in GHC.Natural Methods(==) :: Natural -> Natural -> Bool #(/=) :: Natural -> Natural -> Bool # Instance detailsDefined in GHC.Classes Methods Instance detailsDefined in GHC.Classes Methods(==) :: Word -> Word -> Bool #(/=) :: Word -> Word -> Bool # Since: base-2.1 Instance detailsDefined in GHC.Word Methods(==) :: Word8 -> Word8 -> Bool #(/=) :: Word8 -> Word8 -> Bool # Since: base-2.1 Instance detailsDefined in GHC.Word Methods(==) :: Word16 -> Word16 -> Bool #(/=) :: Word16 -> Word16 -> Bool # Since: base-2.1 Instance detailsDefined in GHC.Word Methods(==) :: Word32 -> Word32 -> Bool #(/=) :: Word32 -> Word32 -> Bool # Since: base-2.1 Instance detailsDefined in GHC.Word Methods(==) :: Word64 -> Word64 -> Bool #(/=) :: Word64 -> Word64 -> Bool # Instance detailsDefined in Data.Typeable.Internal Methods Eq () Instance detailsDefined in GHC.Classes Methods(==) :: () -> () -> Bool #(/=) :: () -> () -> Bool # Instance detailsDefined in GHC.Classes Methods(==) :: TyCon -> TyCon -> Bool #(/=) :: TyCon -> TyCon -> Bool # Instance detailsDefined in GHC.Classes Methods(==) :: Module -> Module -> Bool #(/=) :: Module -> Module -> Bool # Instance detailsDefined in GHC.Classes Methods(==) :: TrName -> TrName -> Bool #(/=) :: TrName -> TrName -> Bool # Since: base-4.1.0.0 Instance detailsDefined in GHC.IO.Handle.Types Methods(==) :: Handle -> Handle -> Bool #(/=) :: Handle -> Handle -> Bool # Instance detailsDefined in GHC.Integer.Type Methods(==) :: BigNat -> BigNat -> Bool #(/=) :: BigNat -> BigNat -> Bool # Since: base-4.8.0.0 Instance detailsDefined in Data.Void Methods(==) :: Void -> Void -> Bool #(/=) :: Void -> Void -> Bool # Instance detailsDefined in GHC.Exts Methods Since: base-2.1 Instance detailsDefined in Data.Version Methods(==) :: Version -> Version -> Bool #(/=) :: Version -> Version -> Bool # Since: base-4.2.0.0 Instance detailsDefined in GHC.Conc.Sync Methods Instance detailsDefined in GHC.Conc.Sync Methods Instance detailsDefined in GHC.Conc.Sync Methods Instance detailsDefined in GHC.IO.Exception Methods Instance detailsDefined in GHC.IO.Exception Methods Instance detailsDefined in GHC.IO.Exception Methods Since: base-4.1.0.0 Instance detailsDefined in GHC.IO.Exception Methods Instance detailsDefined in GHC.IO.Handle.Types Methods Instance detailsDefined in GHC.IO.Handle.Types Methods(==) :: Newline -> Newline -> Bool #(/=) :: Newline -> Newline -> Bool # Instance detailsDefined in GHC.IO.Handle.Types Methods Instance detailsDefined in GHC.IO Methods Since: base-4.1.0.0 Instance detailsDefined in GHC.IO.Exception Methods Instance detailsDefined in GHC.Exception Methods Instance detailsDefined in GHC.Exception Methods Instance detailsDefined in Data.Semigroup.Internal Methods(==) :: All -> All -> Bool #(/=) :: All -> All -> Bool # Instance detailsDefined in Data.Semigroup.Internal Methods(==) :: Any -> Any -> Bool #(/=) :: Any -> Any -> Bool # Instance detailsDefined in Foreign.C.Types Methods(==) :: CChar -> CChar -> Bool #(/=) :: CChar -> CChar -> Bool # Instance detailsDefined in Foreign.C.Types Methods(==) :: CSChar -> CSChar -> Bool #(/=) :: CSChar -> CSChar -> Bool # Instance detailsDefined in Foreign.C.Types Methods(==) :: CUChar -> CUChar -> Bool #(/=) :: CUChar -> CUChar -> Bool # Instance detailsDefined in Foreign.C.Types Methods(==) :: CShort -> CShort -> Bool #(/=) :: CShort -> CShort -> Bool # Instance detailsDefined in Foreign.C.Types Methods(==) :: CUShort -> CUShort -> Bool #(/=) :: CUShort -> CUShort -> Bool # Instance detailsDefined in Foreign.C.Types Methods(==) :: CInt -> CInt -> Bool #(/=) :: CInt -> CInt -> Bool # Instance detailsDefined in Foreign.C.Types Methods(==) :: CUInt -> CUInt -> Bool #(/=) :: CUInt -> CUInt -> Bool # Instance detailsDefined in Foreign.C.Types Methods(==) :: CLong -> CLong -> Bool #(/=) :: CLong -> CLong -> Bool # Instance detailsDefined in Foreign.C.Types Methods(==) :: CULong -> CULong -> Bool #(/=) :: CULong -> CULong -> Bool # Instance detailsDefined in Foreign.C.Types Methods(==) :: CLLong -> CLLong -> Bool #(/=) :: CLLong -> CLLong -> Bool # Instance detailsDefined in Foreign.C.Types Methods(==) :: CULLong -> CULLong -> Bool #(/=) :: CULLong -> CULLong -> Bool # Instance detailsDefined in Foreign.C.Types Methods(==) :: CBool -> CBool -> Bool #(/=) :: CBool -> CBool -> Bool # Instance detailsDefined in Foreign.C.Types Methods(==) :: CFloat -> CFloat -> Bool #(/=) :: CFloat -> CFloat -> Bool # Instance detailsDefined in Foreign.C.Types Methods(==) :: CDouble -> CDouble -> Bool #(/=) :: CDouble -> CDouble -> Bool # Instance detailsDefined in Foreign.C.Types Methods Instance detailsDefined in Foreign.C.Types Methods(==) :: CSize -> CSize -> Bool #(/=) :: CSize -> CSize -> Bool # Instance detailsDefined in Foreign.C.Types Methods(==) :: CWchar -> CWchar -> Bool #(/=) :: CWchar -> CWchar -> Bool # Instance detailsDefined in Foreign.C.Types Methods Instance detailsDefined in Foreign.C.Types Methods(==) :: CClock -> CClock -> Bool #(/=) :: CClock -> CClock -> Bool # Instance detailsDefined in Foreign.C.Types Methods(==) :: CTime -> CTime -> Bool #(/=) :: CTime -> CTime -> Bool # Instance detailsDefined in Foreign.C.Types Methods Instance detailsDefined in Foreign.C.Types Methods Instance detailsDefined in Foreign.C.Types Methods(==) :: CIntPtr -> CIntPtr -> Bool #(/=) :: CIntPtr -> CIntPtr -> Bool # Instance detailsDefined in Foreign.C.Types Methods Instance detailsDefined in Foreign.C.Types Methods(==) :: CIntMax -> CIntMax -> Bool #(/=) :: CIntMax -> CIntMax -> Bool # Instance detailsDefined in Foreign.C.Types Methods Instance detailsDefined in Foreign.Ptr Methods(==) :: WordPtr -> WordPtr -> Bool #(/=) :: WordPtr -> WordPtr -> Bool # Instance detailsDefined in Foreign.Ptr Methods(==) :: IntPtr -> IntPtr -> Bool #(/=) :: IntPtr -> IntPtr -> Bool # Instance detailsDefined in Text.Read.Lex Methods(==) :: Lexeme -> Lexeme -> Bool #(/=) :: Lexeme -> Lexeme -> Bool # Instance detailsDefined in Text.Read.Lex Methods(==) :: Number -> Number -> Bool #(/=) :: Number -> Number -> Bool # Instance detailsDefined in GHC.Stack.Types Methods(==) :: SrcLoc -> SrcLoc -> Bool #(/=) :: SrcLoc -> SrcLoc -> Bool # Eq a => Eq [a] Instance detailsDefined in GHC.Classes Methods(==) :: [a] -> [a] -> Bool #(/=) :: [a] -> [a] -> Bool # Eq a => Eq (Maybe a) Instance detailsDefined in GHC.Base Methods(==) :: Maybe a -> Maybe a -> Bool #(/=) :: Maybe a -> Maybe a -> Bool # Eq a => Eq (Ratio a) Instance detailsDefined in GHC.Real Methods(==) :: Ratio a -> Ratio a -> Bool #(/=) :: Ratio a -> Ratio a -> Bool # Eq (StablePtr a) Since: base-2.1 Instance detailsDefined in GHC.Stable Methods(==) :: StablePtr a -> StablePtr a -> Bool #(/=) :: StablePtr a -> StablePtr a -> Bool # Eq (Ptr a) Instance detailsDefined in GHC.Ptr Methods(==) :: Ptr a -> Ptr a -> Bool #(/=) :: Ptr a -> Ptr a -> Bool # Eq (FunPtr a) Instance detailsDefined in GHC.Ptr Methods(==) :: FunPtr a -> FunPtr a -> Bool #(/=) :: FunPtr a -> FunPtr a -> Bool # Eq (ForeignPtr a) Since: base-2.1 Instance detailsDefined in GHC.ForeignPtr Methods(==) :: ForeignPtr a -> ForeignPtr a -> Bool #(/=) :: ForeignPtr a -> ForeignPtr a -> Bool # Eq a => Eq (Complex a) Instance detailsDefined in Data.Complex Methods(==) :: Complex a -> Complex a -> Bool #(/=) :: Complex a -> Complex a -> Bool # Eq a => Eq (Min a) Instance detailsDefined in Data.Semigroup Methods(==) :: Min a -> Min a -> Bool #(/=) :: Min a -> Min a -> Bool # Eq a => Eq (Max a) Instance detailsDefined in Data.Semigroup Methods(==) :: Max a -> Max a -> Bool #(/=) :: Max a -> Max a -> Bool # Eq a => Eq (First a) Instance detailsDefined in Data.Semigroup Methods(==) :: First a -> First a -> Bool #(/=) :: First a -> First a -> Bool # Eq a => Eq (Last a) Instance detailsDefined in Data.Semigroup Methods(==) :: Last a -> Last a -> Bool #(/=) :: Last a -> Last a -> Bool # Eq m => Eq (WrappedMonoid m) Instance detailsDefined in Data.Semigroup Methods(==) :: WrappedMonoid m -> WrappedMonoid m -> Bool #(/=) :: WrappedMonoid m -> WrappedMonoid m -> Bool # Eq a => Eq (Option a) Instance detailsDefined in Data.Semigroup Methods(==) :: Option a -> Option a -> Bool #(/=) :: Option a -> Option a -> Bool # Eq (Chan a) Instance detailsDefined in Control.Concurrent.Chan Methods(==) :: Chan a -> Chan a -> Bool #(/=) :: Chan a -> Chan a -> Bool # Eq a => Eq (ZipList a) Instance detailsDefined in Control.Applicative Methods(==) :: ZipList a -> ZipList a -> Bool #(/=) :: ZipList a -> ZipList a -> Bool # Eq a => Eq (Identity a) Instance detailsDefined in Data.Functor.Identity Methods(==) :: Identity a -> Identity a -> Bool #(/=) :: Identity a -> Identity a -> Bool # Eq (TVar a) Since: base-4.8.0.0 Instance detailsDefined in GHC.Conc.Sync Methods(==) :: TVar a -> TVar a -> Bool #(/=) :: TVar a -> TVar a -> Bool # Eq (IORef a) Pointer equality.Since: base-4.1.0.0 Instance detailsDefined in GHC.IORef Methods(==) :: IORef a -> IORef a -> Bool #(/=) :: IORef a -> IORef a -> Bool # Eq a => Eq (First a) Instance detailsDefined in Data.Monoid Methods(==) :: First a -> First a -> Bool #(/=) :: First a -> First a -> Bool # Eq a => Eq (Last a) Instance detailsDefined in Data.Monoid Methods(==) :: Last a -> Last a -> Bool #(/=) :: Last a -> Last a -> Bool # Eq a => Eq (Dual a) Instance detailsDefined in Data.Semigroup.Internal Methods(==) :: Dual a -> Dual a -> Bool #(/=) :: Dual a -> Dual a -> Bool # Eq a => Eq (Sum a) Instance detailsDefined in Data.Semigroup.Internal Methods(==) :: Sum a -> Sum a -> Bool #(/=) :: Sum a -> Sum a -> Bool # Eq a => Eq (Product a) Instance detailsDefined in Data.Semigroup.Internal Methods(==) :: Product a -> Product a -> Bool #(/=) :: Product a -> Product a -> Bool # Eq (MVar a) Since: base-4.1.0.0 Instance detailsDefined in GHC.MVar Methods(==) :: MVar a -> MVar a -> Bool #(/=) :: MVar a -> MVar a -> Bool # Eq a => Eq (NonEmpty a) Instance detailsDefined in GHC.Base Methods(==) :: NonEmpty a -> NonEmpty a -> Bool #(/=) :: NonEmpty a -> NonEmpty a -> Bool # (Eq a, Eq b) => Eq (Either a b) Instance detailsDefined in Data.Either Methods(==) :: Either a b -> Either a b -> Bool #(/=) :: Either a b -> Either a b -> Bool # Eq (TypeRep a) Since: base-2.1 Instance detailsDefined in Data.Typeable.Internal Methods(==) :: TypeRep a -> TypeRep a -> Bool #(/=) :: TypeRep a -> TypeRep a -> Bool # (Eq a, Eq b) => Eq (a, b) Instance detailsDefined in GHC.Classes Methods(==) :: (a, b) -> (a, b) -> Bool #(/=) :: (a, b) -> (a, b) -> Bool # Eq a => Eq (Arg a b) Since: base-4.9.0.0 Instance detailsDefined in Data.Semigroup Methods(==) :: Arg a b -> Arg a b -> Bool #(/=) :: Arg a b -> Arg a b -> Bool # Eq (Proxy s) Since: base-4.7.0.0 Instance detailsDefined in Data.Proxy Methods(==) :: Proxy s -> Proxy s -> Bool #(/=) :: Proxy s -> Proxy s -> Bool # Eq (STRef s a) Pointer equality.Since: base-2.1 Instance detailsDefined in GHC.STRef Methods(==) :: STRef s a -> STRef s a -> Bool #(/=) :: STRef s a -> STRef s a -> Bool # (Eq a, Eq b, Eq c) => Eq (a, b, c) Instance detailsDefined in GHC.Classes Methods(==) :: (a, b, c) -> (a, b, c) -> Bool #(/=) :: (a, b, c) -> (a, b, c) -> Bool # Eq a => Eq (Const a b) Instance detailsDefined in Data.Functor.Const Methods(==) :: Const a b -> Const a b -> Bool #(/=) :: Const a b -> Const a b -> Bool # Eq (f a) => Eq (Alt f a) Instance detailsDefined in Data.Semigroup.Internal Methods(==) :: Alt f a -> Alt f a -> Bool #(/=) :: Alt f a -> Alt f a -> Bool # Eq (Coercion a b) Instance detailsDefined in Data.Type.Coercion Methods(==) :: Coercion a b -> Coercion a b -> Bool #(/=) :: Coercion a b -> Coercion a b -> Bool # Eq (a :~: b) Instance detailsDefined in Data.Type.Equality Methods(==) :: (a :~: b) -> (a :~: b) -> Bool #(/=) :: (a :~: b) -> (a :~: b) -> Bool # (Eq a, Eq b, Eq c, Eq d) => Eq (a, b, c, d) Instance detailsDefined in GHC.Classes Methods(==) :: (a, b, c, d) -> (a, b, c, d) -> Bool #(/=) :: (a, b, c, d) -> (a, b, c, d) -> Bool # (Eq1 f, Eq1 g, Eq a) => Eq (Product f g a) Since: base-4.9.0.0 Instance detailsDefined in Data.Functor.Product Methods(==) :: Product f g a -> Product f g a -> Bool #(/=) :: Product f g a -> Product f g a -> Bool # (Eq1 f, Eq1 g, Eq a) => Eq (Sum f g a) Since: base-4.9.0.0 Instance detailsDefined in Data.Functor.Sum Methods(==) :: Sum f g a -> Sum f g a -> Bool #(/=) :: Sum f g a -> Sum f g a -> Bool # Eq (a :~~: b) Since: base-4.10.0.0 Instance detailsDefined in Data.Type.Equality Methods(==) :: (a :~~: b) -> (a :~~: b) -> Bool #(/=) :: (a :~~: b) -> (a :~~: b) -> Bool # (Eq a, Eq b, Eq c, Eq d, Eq e) => Eq (a, b, c, d, e) Instance detailsDefined in GHC.Classes Methods(==) :: (a, b, c, d, e) -> (a, b, c, d, e) -> Bool #(/=) :: (a, b, c, d, e) -> (a, b, c, d, e) -> Bool # (Eq1 f, Eq1 g, Eq a) => Eq (Compose f g a) Since: base-4.9.0.0 Instance detailsDefined in Data.Functor.Compose Methods(==) :: Compose f g a -> Compose f g a -> Bool #(/=) :: Compose f g a -> Compose f g a -> Bool # (Eq a, Eq b, Eq c, Eq d, Eq e, Eq f) => Eq (a, b, c, d, e, f) Instance detailsDefined in GHC.Classes 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) Instance detailsDefined in GHC.Classes 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) Instance detailsDefined in GHC.Classes 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) Instance detailsDefined in GHC.Classes 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) Instance detailsDefined in GHC.Classes 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) Instance detailsDefined in GHC.Classes 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) Instance detailsDefined in GHC.Classes 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) Instance detailsDefined in GHC.Classes 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) Instance detailsDefined in GHC.Classes 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) Instance detailsDefined in GHC.Classes 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 Fractional a => Floating a # Trigonometric and hyperbolic functions and related functions. Minimal complete definition Instances  Since: base-2.1 Instance detailsDefined in GHC.Float Methodsexp :: Double -> Double #log :: Double -> Double #(**) :: Double -> Double -> Double #sin :: Double -> Double #cos :: Double -> Double #tan :: Double -> Double # Since: base-2.1 Instance detailsDefined in GHC.Float Methodspi :: Float #exp :: Float -> Float #log :: Float -> Float #sqrt :: Float -> Float #(**) :: Float -> Float -> Float #logBase :: Float -> Float -> Float #sin :: Float -> Float #cos :: Float -> Float #tan :: Float -> Float #asin :: Float -> Float #acos :: Float -> Float #atan :: Float -> Float #sinh :: Float -> Float #cosh :: Float -> Float #tanh :: Float -> Float #asinh :: Float -> Float #acosh :: Float -> Float #atanh :: Float -> Float #log1p :: Float -> Float #expm1 :: Float -> Float # Instance detailsDefined in Foreign.C.Types Methodsexp :: CFloat -> CFloat #log :: CFloat -> CFloat #(**) :: CFloat -> CFloat -> CFloat #sin :: CFloat -> CFloat #cos :: CFloat -> CFloat #tan :: CFloat -> CFloat # Instance detailsDefined in Foreign.C.Types Methods RealFloat a => Floating (Complex a) Since: base-2.1 Instance detailsDefined in Data.Complex Methodspi :: Complex a #exp :: Complex a -> Complex a #log :: Complex a -> Complex a #sqrt :: Complex a -> Complex a #(**) :: Complex a -> Complex a -> Complex a #logBase :: Complex a -> Complex a -> Complex a #sin :: Complex a -> Complex a #cos :: Complex a -> Complex a #tan :: Complex a -> Complex a #asin :: Complex a -> Complex a #acos :: Complex a -> Complex a #atan :: Complex a -> Complex a #sinh :: Complex a -> Complex a #cosh :: Complex a -> Complex a #tanh :: Complex a -> Complex a #asinh :: Complex a -> Complex a #acosh :: Complex a -> Complex a #atanh :: Complex a -> Complex a #log1p :: Complex a -> Complex a #expm1 :: Complex a -> Complex a #log1pexp :: Complex a -> Complex a #log1mexp :: Complex a -> Complex a # Floating a => Floating (Identity a) Instance detailsDefined in Data.Functor.Identity Methodspi :: Identity a #exp :: Identity a -> Identity a #log :: Identity a -> Identity a #sqrt :: Identity a -> Identity a #(**) :: Identity a -> Identity a -> Identity a #logBase :: Identity a -> Identity a -> Identity a #sin :: Identity a -> Identity a #cos :: Identity a -> Identity a #tan :: Identity a -> Identity a #asin :: Identity a -> Identity a #acos :: Identity a -> Identity a #atan :: Identity a -> Identity a #sinh :: Identity a -> Identity a #cosh :: Identity a -> Identity a #tanh :: Identity a -> Identity a #asinh :: Identity a -> Identity a #acosh :: Identity a -> Identity a #atanh :: Identity a -> Identity a #log1p :: Identity a -> Identity a #expm1 :: Identity a -> Identity a #log1pexp :: Identity a -> Identity a #log1mexp :: Identity a -> Identity a # Floating a => Floating (Const a b) Instance detailsDefined in Data.Functor.Const Methodspi :: Const a b #exp :: Const a b -> Const a b #log :: Const a b -> Const a b #sqrt :: Const a b -> Const a b #(**) :: Const a b -> Const a b -> Const a b #logBase :: Const a b -> Const a b -> Const a b #sin :: Const a b -> Const a b #cos :: Const a b -> Const a b #tan :: Const a b -> Const a b #asin :: Const a b -> Const a b #acos :: Const a b -> Const a b #atan :: Const a b -> Const a b #sinh :: Const a b -> Const a b #cosh :: Const a b -> Const a b #tanh :: Const a b -> Const a b #asinh :: Const a b -> Const a b #acosh :: Const a b -> Const a b #atanh :: Const a b -> Const a b #log1p :: Const a b -> Const a b #expm1 :: Const a b -> Const a b #log1pexp :: Const a b -> Const a b #log1mexp :: Const a b -> Const a b # class Foldable (t :: * -> *) # Data structures that can be folded. For example, given a data type data Tree a = Empty | Leaf a | Node (Tree a) a (Tree a) a suitable instance would be instance Foldable Tree where foldMap f Empty = mempty foldMap f (Leaf x) = f x foldMap f (Node l k r) = foldMap f l mappend f k mappend foldMap f r This is suitable even for abstract types, as the monoid is assumed to satisfy the monoid laws. Alternatively, one could define foldr: instance Foldable Tree where foldr f z Empty = z foldr f z (Leaf x) = f x z foldr f z (Node l k r) = foldr f (f k (foldr f z r)) l Foldable instances are expected to satisfy the following laws: foldr f z t = appEndo (foldMap (Endo . f) t ) z foldl f z t = appEndo (getDual (foldMap (Dual . Endo . flip f) t)) z fold = foldMap id length = getSum . foldMap (Sum . const 1) sum, product, maximum, and minimum should all be essentially equivalent to foldMap forms, such as sum = getSum . foldMap Sum but may be less defined. If the type is also a Functor instance, it should satisfy foldMap f = fold . fmap f which implies that foldMap f . fmap g = foldMap (f . g) Minimal complete definition Instances  Foldable [] Since: base-2.1 Instance detailsDefined in Data.Foldable Methodsfold :: Monoid m => [m] -> m #foldMap :: Monoid m => (a -> m) -> [a] -> m #foldr :: (a -> b -> b) -> b -> [a] -> b #foldr' :: (a -> b -> b) -> b -> [a] -> b #foldl :: (b -> a -> b) -> b -> [a] -> b #foldl' :: (b -> a -> b) -> b -> [a] -> b #foldr1 :: (a -> a -> a) -> [a] -> a #foldl1 :: (a -> a -> a) -> [a] -> a #toList :: [a] -> [a] #null :: [a] -> Bool #length :: [a] -> Int #elem :: Eq a => a -> [a] -> Bool #maximum :: Ord a => [a] -> a #minimum :: Ord a => [a] -> a #sum :: Num a => [a] -> a #product :: Num a => [a] -> a # Since: base-2.1 Instance detailsDefined in Data.Foldable Methodsfold :: Monoid m => Maybe m -> m #foldMap :: Monoid m => (a -> m) -> Maybe a -> m #foldr :: (a -> b -> b) -> b -> Maybe a -> b #foldr' :: (a -> b -> b) -> b -> Maybe a -> b #foldl :: (b -> a -> b) -> b -> Maybe a -> b #foldl' :: (b -> a -> b) -> b -> Maybe a -> b #foldr1 :: (a -> a -> a) -> Maybe a -> a #foldl1 :: (a -> a -> a) -> Maybe a -> a #toList :: Maybe a -> [a] #null :: Maybe a -> Bool #length :: Maybe a -> Int #elem :: Eq a => a -> Maybe a -> Bool #maximum :: Ord a => Maybe a -> a #minimum :: Ord a => Maybe a -> a #sum :: Num a => Maybe a -> a #product :: Num a => Maybe a -> a # Instance detailsDefined in Data.Foldable Methodsfold :: Monoid m => Par1 m -> m #foldMap :: Monoid m => (a -> m) -> Par1 a -> m #foldr :: (a -> b -> b) -> b -> Par1 a -> b #foldr' :: (a -> b -> b) -> b -> Par1 a -> b #foldl :: (b -> a -> b) -> b -> Par1 a -> b #foldl' :: (b -> a -> b) -> b -> Par1 a -> b #foldr1 :: (a -> a -> a) -> Par1 a -> a #foldl1 :: (a -> a -> a) -> Par1 a -> a #toList :: Par1 a -> [a] #null :: Par1 a -> Bool #length :: Par1 a -> Int #elem :: Eq a => a -> Par1 a -> Bool #maximum :: Ord a => Par1 a -> a #minimum :: Ord a => Par1 a -> a #sum :: Num a => Par1 a -> a #product :: Num a => Par1 a -> a # Instance detailsDefined in Data.Complex Methodsfold :: Monoid m => Complex m -> m #foldMap :: Monoid m => (a -> m) -> Complex a -> m #foldr :: (a -> b -> b) -> b -> Complex a -> b #foldr' :: (a -> b -> b) -> b -> Complex a -> b #foldl :: (b -> a -> b) -> b -> Complex a -> b #foldl' :: (b -> a -> b) -> b -> Complex a -> b #foldr1 :: (a -> a -> a) -> Complex a -> a #foldl1 :: (a -> a -> a) -> Complex a -> a #toList :: Complex a -> [a] #null :: Complex a -> Bool #length :: Complex a -> Int #elem :: Eq a => a -> Complex a -> Bool #maximum :: Ord a => Complex a -> a #minimum :: Ord a => Complex a -> a #sum :: Num a => Complex a -> a #product :: Num a => Complex a -> a # Since: base-4.9.0.0 Instance detailsDefined in Data.Semigroup Methodsfold :: Monoid m => Min m -> m #foldMap :: Monoid m => (a -> m) -> Min a -> m #foldr :: (a -> b -> b) -> b -> Min a -> b #foldr' :: (a -> b -> b) -> b -> Min a -> b #foldl :: (b -> a -> b) -> b -> Min a -> b #foldl' :: (b -> a -> b) -> b -> Min a -> b #foldr1 :: (a -> a -> a) -> Min a -> a #foldl1 :: (a -> a -> a) -> Min a -> a #toList :: Min a -> [a] #null :: Min a -> Bool #length :: Min a -> Int #elem :: Eq a => a -> Min a -> Bool #maximum :: Ord a => Min a -> a #minimum :: Ord a => Min a -> a #sum :: Num a => Min a -> a #product :: Num a => Min a -> a # Since: base-4.9.0.0 Instance detailsDefined in Data.Semigroup Methodsfold :: Monoid m => Max m -> m #foldMap :: Monoid m => (a -> m) -> Max a -> m #foldr :: (a -> b -> b) -> b -> Max a -> b #foldr' :: (a -> b -> b) -> b -> Max a -> b #foldl :: (b -> a -> b) -> b -> Max a -> b #foldl' :: (b -> a -> b) -> b -> Max a -> b #foldr1 :: (a -> a -> a) -> Max a -> a #foldl1 :: (a -> a -> a) -> Max a -> a #toList :: Max a -> [a] #null :: Max a -> Bool #length :: Max a -> Int #elem :: Eq a => a -> Max a -> Bool #maximum :: Ord a => Max a -> a #minimum :: Ord a => Max a -> a #sum :: Num a => Max a -> a #product :: Num a => Max a -> a # Since: base-4.9.0.0 Instance detailsDefined in Data.Semigroup Methodsfold :: Monoid m => First m -> m #foldMap :: Monoid m => (a -> m) -> First a -> m #foldr :: (a -> b -> b) -> b -> First a -> b #foldr' :: (a -> b -> b) -> b -> First a -> b #foldl :: (b -> a -> b) -> b -> First a -> b #foldl' :: (b -> a -> b) -> b -> First a -> b #foldr1 :: (a -> a -> a) -> First a -> a #foldl1 :: (a -> a -> a) -> First a -> a #toList :: First a -> [a] #null :: First a -> Bool #length :: First a -> Int #elem :: Eq a => a -> First a -> Bool #maximum :: Ord a => First a -> a #minimum :: Ord a => First a -> a #sum :: Num a => First a -> a #product :: Num a => First a -> a # Since: base-4.9.0.0 Instance detailsDefined in Data.Semigroup Methodsfold :: Monoid m => Last m -> m #foldMap :: Monoid m => (a -> m) -> Last a -> m #foldr :: (a -> b -> b) -> b -> Last a -> b #foldr' :: (a -> b -> b) -> b -> Last a -> b #foldl :: (b -> a -> b) -> b -> Last a -> b #foldl' :: (b -> a -> b) -> b -> Last a -> b #foldr1 :: (a -> a -> a) -> Last a -> a #foldl1 :: (a -> a -> a) -> Last a -> a #toList :: Last a -> [a] #null :: Last a -> Bool #length :: Last a -> Int #elem :: Eq a => a -> Last a -> Bool #maximum :: Ord a => Last a -> a #minimum :: Ord a => Last a -> a #sum :: Num a => Last a -> a #product :: Num a => Last a -> a # Since: base-4.9.0.0 Instance detailsDefined in Data.Semigroup Methodsfold :: Monoid m => Option m -> m #foldMap :: Monoid m => (a -> m) -> Option a -> m #foldr :: (a -> b -> b) -> b -> Option a -> b #foldr' :: (a -> b -> b) -> b -> Option a -> b #foldl :: (b -> a -> b) -> b -> Option a -> b #foldl' :: (b -> a -> b) -> b -> Option a -> b #foldr1 :: (a -> a -> a) -> Option a -> a #foldl1 :: (a -> a -> a) -> Option a -> a #toList :: Option a -> [a] #null :: Option a -> Bool #length :: Option a -> Int #elem :: Eq a => a -> Option a -> Bool #maximum :: Ord a => Option a -> a #minimum :: Ord a => Option a -> a #sum :: Num a => Option a -> a #product :: Num a => Option a -> a # Instance detailsDefined in Control.Applicative Methodsfold :: Monoid m => ZipList m -> m #foldMap :: Monoid m => (a -> m) -> ZipList a -> m #foldr :: (a -> b -> b) -> b -> ZipList a -> b #foldr' :: (a -> b -> b) -> b -> ZipList a -> b #foldl :: (b -> a -> b) -> b -> ZipList a -> b #foldl' :: (b -> a -> b) -> b -> ZipList a -> b #foldr1 :: (a -> a -> a) -> ZipList a -> a #foldl1 :: (a -> a -> a) -> ZipList a -> a #toList :: ZipList a -> [a] #null :: ZipList a -> Bool #length :: ZipList a -> Int #elem :: Eq a => a -> ZipList a -> Bool #maximum :: Ord a => ZipList a -> a #minimum :: Ord a => ZipList a -> a #sum :: Num a => ZipList a -> a #product :: Num a => ZipList a -> a # Since: base-4.8.0.0 Instance detailsDefined in Data.Functor.Identity Methodsfold :: Monoid m => Identity m -> m #foldMap :: Monoid m => (a -> m) -> Identity a -> m #foldr :: (a -> b -> b) -> b -> Identity a -> b #foldr' :: (a -> b -> b) -> b -> Identity a -> b #foldl :: (b -> a -> b) -> b -> Identity a -> b #foldl' :: (b -> a -> b) -> b -> Identity a -> b #foldr1 :: (a -> a -> a) -> Identity a -> a #foldl1 :: (a -> a -> a) -> Identity a -> a #toList :: Identity a -> [a] #null :: Identity a -> Bool #length :: Identity a -> Int #elem :: Eq a => a -> Identity a -> Bool #maximum :: Ord a => Identity a -> a #minimum :: Ord a => Identity a -> a #sum :: Num a => Identity a -> a #product :: Num a => Identity a -> a # Since: base-4.8.0.0 Instance detailsDefined in Data.Foldable Methodsfold :: Monoid m => First m -> m #foldMap :: Monoid m => (a -> m) -> First a -> m #foldr :: (a -> b -> b) -> b -> First a -> b #foldr' :: (a -> b -> b) -> b -> First a -> b #foldl :: (b -> a -> b) -> b -> First a -> b #foldl' :: (b -> a -> b) -> b -> First a -> b #foldr1 :: (a -> a -> a) -> First a -> a #foldl1 :: (a -> a -> a) -> First a -> a #toList :: First a -> [a] #null :: First a -> Bool #length :: First a -> Int #elem :: Eq a => a -> First a -> Bool #maximum :: Ord a => First a -> a #minimum :: Ord a => First a -> a #sum :: Num a => First a -> a #product :: Num a => First a -> a # Since: base-4.8.0.0 Instance detailsDefined in Data.Foldable Methodsfold :: Monoid m => Last m -> m #foldMap :: Monoid m => (a -> m) -> Last a -> m #foldr :: (a -> b -> b) -> b -> Last a -> b #foldr' :: (a -> b -> b) -> b -> Last a -> b #foldl :: (b -> a -> b) -> b -> Last a -> b #foldl' :: (b -> a -> b) -> b -> Last a -> b #foldr1 :: (a -> a -> a) -> Last a -> a #foldl1 :: (a -> a -> a) -> Last a -> a #toList :: Last a -> [a] #null :: Last a -> Bool #length :: Last a -> Int #elem :: Eq a => a -> Last a -> Bool #maximum :: Ord a => Last a -> a #minimum :: Ord a => Last a -> a #sum :: Num a => Last a -> a #product :: Num a => Last a -> a # Since: base-4.8.0.0 Instance detailsDefined in Data.Foldable Methodsfold :: Monoid m => Dual m -> m #foldMap :: Monoid m => (a -> m) -> Dual a -> m #foldr :: (a -> b -> b) -> b -> Dual a -> b #foldr' :: (a -> b -> b) -> b -> Dual a -> b #foldl :: (b -> a -> b) -> b -> Dual a -> b #foldl' :: (b -> a -> b) -> b -> Dual a -> b #foldr1 :: (a -> a -> a) -> Dual a -> a #foldl1 :: (a -> a -> a) -> Dual a -> a #toList :: Dual a -> [a] #null :: Dual a -> Bool #length :: Dual a -> Int #elem :: Eq a => a -> Dual a -> Bool #maximum :: Ord a => Dual a -> a #minimum :: Ord a => Dual a -> a #sum :: Num a => Dual a -> a #product :: Num a => Dual a -> a # Since: base-4.8.0.0 Instance detailsDefined in Data.Foldable Methodsfold :: Monoid m => Sum m -> m #foldMap :: Monoid m => (a -> m) -> Sum a -> m #foldr :: (a -> b -> b) -> b -> Sum a -> b #foldr' :: (a -> b -> b) -> b -> Sum a -> b #foldl :: (b -> a -> b) -> b -> Sum a -> b #foldl' :: (b -> a -> b) -> b -> Sum a -> b #foldr1 :: (a -> a -> a) -> Sum a -> a #foldl1 :: (a -> a -> a) -> Sum a -> a #toList :: Sum a -> [a] #null :: Sum a -> Bool #length :: Sum a -> Int #elem :: Eq a => a -> Sum a -> Bool #maximum :: Ord a => Sum a -> a #minimum :: Ord a => Sum a -> a #sum :: Num a => Sum a -> a #product :: Num a => Sum a -> a # Since: base-4.8.0.0 Instance detailsDefined in Data.Foldable Methodsfold :: Monoid m => Product m -> m #foldMap :: Monoid m => (a -> m) -> Product a -> m #foldr :: (a -> b -> b) -> b -> Product a -> b #foldr' :: (a -> b -> b) -> b -> Product a -> b #foldl :: (b -> a -> b) -> b -> Product a -> b #foldl' :: (b -> a -> b) -> b -> Product a -> b #foldr1 :: (a -> a -> a) -> Product a -> a #foldl1 :: (a -> a -> a) -> Product a -> a #toList :: Product a -> [a] #null :: Product a -> Bool #length :: Product a -> Int #elem :: Eq a => a -> Product a -> Bool #maximum :: Ord a => Product a -> a #minimum :: Ord a => Product a -> a #sum :: Num a => Product a -> a #product :: Num a => Product a -> a # Since: base-4.9.0.0 Instance detailsDefined in Data.Foldable Methodsfold :: Monoid m => NonEmpty m -> m #foldMap :: Monoid m => (a -> m) -> NonEmpty a -> m #foldr :: (a -> b -> b) -> b -> NonEmpty a -> b #foldr' :: (a -> b -> b) -> b -> NonEmpty a -> b #foldl :: (b -> a -> b) -> b -> NonEmpty a -> b #foldl' :: (b -> a -> b) -> b -> NonEmpty a -> b #foldr1 :: (a -> a -> a) -> NonEmpty a -> a #foldl1 :: (a -> a -> a) -> NonEmpty a -> a #toList :: NonEmpty a -> [a] #null :: NonEmpty a -> Bool #length :: NonEmpty a -> Int #elem :: Eq a => a -> NonEmpty a -> Bool #maximum :: Ord a => NonEmpty a -> a #minimum :: Ord a => NonEmpty a -> a #sum :: Num a => NonEmpty a -> a #product :: Num a => NonEmpty a -> a # Since: base-4.7.0.0 Instance detailsDefined in Data.Foldable Methodsfold :: Monoid m => Either a m -> m #foldMap :: Monoid m => (a0 -> m) -> Either a a0 -> m #foldr :: (a0 -> b -> b) -> b -> Either a a0 -> b #foldr' :: (a0 -> b -> b) -> b -> Either a a0 -> b #foldl :: (b -> a0 -> b) -> b -> Either a a0 -> b #foldl' :: (b -> a0 -> b) -> b -> Either a a0 -> b #foldr1 :: (a0 -> a0 -> a0) -> Either a a0 -> a0 #foldl1 :: (a0 -> a0 -> a0) -> Either a a0 -> a0 #toList :: Either a a0 -> [a0] #null :: Either a a0 -> Bool #length :: Either a a0 -> Int #elem :: Eq a0 => a0 -> Either a a0 -> Bool #maximum :: Ord a0 => Either a a0 -> a0 #minimum :: Ord a0 => Either a a0 -> a0 #sum :: Num a0 => Either a a0 -> a0 #product :: Num a0 => Either a a0 -> a0 # Foldable (V1 :: * -> *) Instance detailsDefined in Data.Foldable Methodsfold :: Monoid m => V1 m -> m #foldMap :: Monoid m => (a -> m) -> V1 a -> m #foldr :: (a -> b -> b) -> b -> V1 a -> b #foldr' :: (a -> b -> b) -> b -> V1 a -> b #foldl :: (b -> a -> b) -> b -> V1 a -> b #foldl' :: (b -> a -> b) -> b -> V1 a -> b #foldr1 :: (a -> a -> a) -> V1 a -> a #foldl1 :: (a -> a -> a) -> V1 a -> a #toList :: V1 a -> [a] #null :: V1 a -> Bool #length :: V1 a -> Int #elem :: Eq a => a -> V1 a -> Bool #maximum :: Ord a => V1 a -> a #minimum :: Ord a => V1 a -> a #sum :: Num a => V1 a -> a #product :: Num a => V1 a -> a # Foldable (U1 :: * -> *) Since: base-4.9.0.0 Instance detailsDefined in Data.Foldable Methodsfold :: Monoid m => U1 m -> m #foldMap :: Monoid m => (a -> m) -> U1 a -> m #foldr :: (a -> b -> b) -> b -> U1 a -> b #foldr' :: (a -> b -> b) -> b -> U1 a -> b #foldl :: (b -> a -> b) -> b -> U1 a -> b #foldl' :: (b -> a -> b) -> b -> U1 a -> b #foldr1 :: (a -> a -> a) -> U1 a -> a #foldl1 :: (a -> a -> a) -> U1 a -> a #toList :: U1 a -> [a] #null :: U1 a -> Bool #length :: U1 a -> Int #elem :: Eq a => a -> U1 a -> Bool #maximum :: Ord a => U1 a -> a #minimum :: Ord a => U1 a -> a #sum :: Num a => U1 a -> a #product :: Num a => U1 a -> a # Foldable ((,) a) Since: base-4.7.0.0 Instance detailsDefined in Data.Foldable Methodsfold :: Monoid m => (a, m) -> m #foldMap :: Monoid m => (a0 -> m) -> (a, a0) -> m #foldr :: (a0 -> b -> b) -> b -> (a, a0) -> b #foldr' :: (a0 -> b -> b) -> b -> (a, a0) -> b #foldl :: (b -> a0 -> b) -> b -> (a, a0) -> b #foldl' :: (b -> a0 -> b) -> b -> (a, a0) -> b #foldr1 :: (a0 -> a0 -> a0) -> (a, a0) -> a0 #foldl1 :: (a0 -> a0 -> a0) -> (a, a0) -> a0 #toList :: (a, a0) -> [a0] #null :: (a, a0) -> Bool #length :: (a, a0) -> Int #elem :: Eq a0 => a0 -> (a, a0) -> Bool #maximum :: Ord a0 => (a, a0) -> a0 #minimum :: Ord a0 => (a, a0) -> a0 #sum :: Num a0 => (a, a0) -> a0 #product :: Num a0 => (a, a0) -> a0 # Since: base-4.8.0.0 Instance detailsDefined in Data.Foldable Methodsfold :: Monoid m => Array i m -> m #foldMap :: Monoid m => (a -> m) -> Array i a -> m #foldr :: (a -> b -> b) -> b -> Array i a -> b #foldr' :: (a -> b -> b) -> b -> Array i a -> b #foldl :: (b -> a -> b) -> b -> Array i a -> b #foldl' :: (b -> a -> b) -> b -> Array i a -> b #foldr1 :: (a -> a -> a) -> Array i a -> a #foldl1 :: (a -> a -> a) -> Array i a -> a #toList :: Array i a -> [a] #null :: Array i a -> Bool #length :: Array i a -> Int #elem :: Eq a => a -> Array i a -> Bool #maximum :: Ord a => Array i a -> a #minimum :: Ord a => Array i a -> a #sum :: Num a => Array i a -> a #product :: Num a => Array i a -> a # Foldable (Arg a) Since: base-4.9.0.0 Instance detailsDefined in Data.Semigroup Methodsfold :: Monoid m => Arg a m -> m #foldMap :: Monoid m => (a0 -> m) -> Arg a a0 -> m #foldr :: (a0 -> b -> b) -> b -> Arg a a0 -> b #foldr' :: (a0 -> b -> b) -> b -> Arg a a0 -> b #foldl :: (b -> a0 -> b) -> b -> Arg a a0 -> b #foldl' :: (b -> a0 -> b) -> b -> Arg a a0 -> b #foldr1 :: (a0 -> a0 -> a0) -> Arg a a0 -> a0 #foldl1 :: (a0 -> a0 -> a0) -> Arg a a0 -> a0 #toList :: Arg a a0 -> [a0] #null :: Arg a a0 -> Bool #length :: Arg a a0 -> Int #elem :: Eq a0 => a0 -> Arg a a0 -> Bool #maximum :: Ord a0 => Arg a a0 -> a0 #minimum :: Ord a0 => Arg a a0 -> a0 #sum :: Num a0 => Arg a a0 -> a0 #product :: Num a0 => Arg a a0 -> a0 # Foldable (Proxy :: * -> *) Since: base-4.7.0.0 Instance detailsDefined in Data.Foldable Methodsfold :: Monoid m => Proxy m -> m #foldMap :: Monoid m => (a -> m) -> Proxy a -> m #foldr :: (a -> b -> b) -> b -> Proxy a -> b #foldr' :: (a -> b -> b) -> b -> Proxy a -> b #foldl :: (b -> a -> b) -> b -> Proxy a -> b #foldl' :: (b -> a -> b) -> b -> Proxy a -> b #foldr1 :: (a -> a -> a) -> Proxy a -> a #foldl1 :: (a -> a -> a) -> Proxy a -> a #toList :: Proxy a -> [a] #null :: Proxy a -> Bool #length :: Proxy a -> Int #elem :: Eq a => a -> Proxy a -> Bool #maximum :: Ord a => Proxy a -> a #minimum :: Ord a => Proxy a -> a #sum :: Num a => Proxy a -> a #product :: Num a => Proxy a -> a # Foldable f => Foldable (Rec1 f) Instance detailsDefined in Data.Foldable Methodsfold :: Monoid m => Rec1 f m -> m #foldMap :: Monoid m => (a -> m) -> Rec1 f a -> m #foldr :: (a -> b -> b) -> b -> Rec1 f a -> b #foldr' :: (a -> b -> b) -> b -> Rec1 f a -> b #foldl :: (b -> a -> b) -> b -> Rec1 f a -> b #foldl' :: (b -> a -> b) -> b -> Rec1 f a -> b #foldr1 :: (a -> a -> a) -> Rec1 f a -> a #foldl1 :: (a -> a -> a) -> Rec1 f a -> a #toList :: Rec1 f a -> [a] #null :: Rec1 f a -> Bool #length :: Rec1 f a -> Int #elem :: Eq a => a -> Rec1 f a -> Bool #maximum :: Ord a => Rec1 f a -> a #minimum :: Ord a => Rec1 f a -> a #sum :: Num a => Rec1 f a -> a #product :: Num a => Rec1 f a -> a # Foldable (URec Char :: * -> *) Instance detailsDefined in Data.Foldable Methodsfold :: Monoid m => URec Char m -> m #foldMap :: Monoid m => (a -> m) -> URec Char a -> m #foldr :: (a -> b -> b) -> b -> URec Char a -> b #foldr' :: (a -> b -> b) -> b -> URec Char a -> b #foldl :: (b -> a -> b) -> b -> URec Char a -> b #foldl' :: (b -> a -> b) -> b -> URec Char a -> b #foldr1 :: (a -> a -> a) -> URec Char a -> a #foldl1 :: (a -> a -> a) -> URec Char a -> a #toList :: URec Char a -> [a] #null :: URec Char a -> Bool #length :: URec Char a -> Int #elem :: Eq a => a -> URec Char a -> Bool #maximum :: Ord a => URec Char a -> a #minimum :: Ord a => URec Char a -> a #sum :: Num a => URec Char a -> a #product :: Num a => URec Char a -> a # Foldable (URec Double :: * -> *) Instance detailsDefined in Data.Foldable Methodsfold :: Monoid m => URec Double m -> m #foldMap :: Monoid m => (a -> m) -> URec Double a -> m #foldr :: (a -> b -> b) -> b -> URec Double a -> b #foldr' :: (a -> b -> b) -> b -> URec Double a -> b #foldl :: (b -> a -> b) -> b -> URec Double a -> b #foldl' :: (b -> a -> b) -> b -> URec Double a -> b #foldr1 :: (a -> a -> a) -> URec Double a -> a #foldl1 :: (a -> a -> a) -> URec Double a -> a #toList :: URec Double a -> [a] #null :: URec Double a -> Bool #length :: URec Double a -> Int #elem :: Eq a => a -> URec Double a -> Bool #maximum :: Ord a => URec Double a -> a #minimum :: Ord a => URec Double a -> a #sum :: Num a => URec Double a -> a #product :: Num a => URec Double a -> a # Foldable (URec Float :: * -> *) Instance detailsDefined in Data.Foldable Methodsfold :: Monoid m => URec Float m -> m #foldMap :: Monoid m => (a -> m) -> URec Float a -> m #foldr :: (a -> b -> b) -> b -> URec Float a -> b #foldr' :: (a -> b -> b) -> b -> URec Float a -> b #foldl :: (b -> a -> b) -> b -> URec Float a -> b #foldl' :: (b -> a -> b) -> b -> URec Float a -> b #foldr1 :: (a -> a -> a) -> URec Float a -> a #foldl1 :: (a -> a -> a) -> URec Float a -> a #toList :: URec Float a -> [a] #null :: URec Float a -> Bool #length :: URec Float a -> Int #elem :: Eq a => a -> URec Float a -> Bool #maximum :: Ord a => URec Float a -> a #minimum :: Ord a => URec Float a -> a #sum :: Num a => URec Float a -> a #product :: Num a => URec Float a -> a # Foldable (URec Int :: * -> *) Instance detailsDefined in Data.Foldable Methodsfold :: Monoid m => URec Int m -> m #foldMap :: Monoid m => (a -> m) -> URec Int a -> m #foldr :: (a -> b -> b) -> b -> URec Int a -> b #foldr' :: (a -> b -> b) -> b -> URec Int a -> b #foldl :: (b -> a -> b) -> b -> URec Int a -> b #foldl' :: (b -> a -> b) -> b -> URec Int a -> b #foldr1 :: (a -> a -> a) -> URec Int a -> a #foldl1 :: (a -> a -> a) -> URec Int a -> a #toList :: URec Int a -> [a] #null :: URec Int a -> Bool #length :: URec Int a -> Int #elem :: Eq a => a -> URec Int a -> Bool #maximum :: Ord a => URec Int a -> a #minimum :: Ord a => URec Int a -> a #sum :: Num a => URec Int a -> a #product :: Num a => URec Int a -> a # Foldable (URec Word :: * -> *) Instance detailsDefined in Data.Foldable Methodsfold :: Monoid m => URec Word m -> m #foldMap :: Monoid m => (a -> m) -> URec Word a -> m #foldr :: (a -> b -> b) -> b -> URec Word a -> b #foldr' :: (a -> b -> b) -> b -> URec Word a -> b #foldl :: (b -> a -> b) -> b -> URec Word a -> b #foldl' :: (b -> a -> b) -> b -> URec Word a -> b #foldr1 :: (a -> a -> a) -> URec Word a -> a #foldl1 :: (a -> a -> a) -> URec Word a -> a #toList :: URec Word a -> [a] #null :: URec Word a -> Bool #length :: URec Word a -> Int #elem :: Eq a => a -> URec Word a -> Bool #maximum :: Ord a => URec Word a -> a #minimum :: Ord a => URec Word a -> a #sum :: Num a => URec Word a -> a #product :: Num a => URec Word a -> a # Foldable (URec (Ptr ()) :: * -> *) Instance detailsDefined in Data.Foldable Methodsfold :: Monoid m => URec (Ptr ()) m -> m #foldMap :: Monoid m => (a -> m) -> URec (Ptr ()) a -> m #foldr :: (a -> b -> b) -> b -> URec (Ptr ()) a -> b #foldr' :: (a -> b -> b) -> b -> URec (Ptr ()) a -> b #foldl :: (b -> a -> b) -> b -> URec (Ptr ()) a -> b #foldl' :: (b -> a -> b) -> b -> URec (Ptr ()) a -> b #foldr1 :: (a -> a -> a) -> URec (Ptr ()) a -> a #foldl1 :: (a -> a -> a) -> URec (Ptr ()) a -> a #toList :: URec (Ptr ()) a -> [a] #null :: URec (Ptr ()) a -> Bool #length :: URec (Ptr ()) a -> Int #elem :: Eq a => a -> URec (Ptr ()) a -> Bool #maximum :: Ord a => URec (Ptr ()) a -> a #minimum :: Ord a => URec (Ptr ()) a -> a #sum :: Num a => URec (Ptr ()) a -> a #product :: Num a => URec (Ptr ()) a -> a # Foldable (Const m :: * -> *) Since: base-4.7.0.0 Instance detailsDefined in Data.Functor.Const Methodsfold :: Monoid m0 => Const m m0 -> m0 #foldMap :: Monoid m0 => (a -> m0) -> Const m a -> m0 #foldr :: (a -> b -> b) -> b -> Const m a -> b #foldr' :: (a -> b -> b) -> b -> Const m a -> b #foldl :: (b -> a -> b) -> b -> Const m a -> b #foldl' :: (b -> a -> b) -> b -> Const m a -> b #foldr1 :: (a -> a -> a) -> Const m a -> a #foldl1 :: (a -> a -> a) -> Const m a -> a #toList :: Const m a -> [a] #null :: Const m a -> Bool #length :: Const m a -> Int #elem :: Eq a => a -> Const m a -> Bool #maximum :: Ord a => Const m a -> a #minimum :: Ord a => Const m a -> a #sum :: Num a => Const m a -> a #product :: Num a => Const m a -> a # Foldable (K1 i c :: * -> *) Instance detailsDefined in Data.Foldable Methodsfold :: Monoid m => K1 i c m -> m #foldMap :: Monoid m => (a -> m) -> K1 i c a -> m #foldr :: (a -> b -> b) -> b -> K1 i c a -> b #foldr' :: (a -> b -> b) -> b -> K1 i c a -> b #foldl :: (b -> a -> b) -> b -> K1 i c a -> b #foldl' :: (b -> a -> b) -> b -> K1 i c a -> b #foldr1 :: (a -> a -> a) -> K1 i c a -> a #foldl1 :: (a -> a -> a) -> K1 i c a -> a #toList :: K1 i c a -> [a] #null :: K1 i c a -> Bool #length :: K1 i c a -> Int #elem :: Eq a => a -> K1 i c a -> Bool #maximum :: Ord a => K1 i c a -> a #minimum :: Ord a => K1 i c a -> a #sum :: Num a => K1 i c a -> a #product :: Num a => K1 i c a -> a # (Foldable f, Foldable g) => Foldable (f :+: g) Instance detailsDefined in Data.Foldable Methodsfold :: Monoid m => (f :+: g) m -> m #foldMap :: Monoid m => (a -> m) -> (f :+: g) a -> m #foldr :: (a -> b -> b) -> b -> (f :+: g) a -> b #foldr' :: (a -> b -> b) -> b -> (f :+: g) a -> b #foldl :: (b -> a -> b) -> b -> (f :+: g) a -> b #foldl' :: (b -> a -> b) -> b -> (f :+: g) a -> b #foldr1 :: (a -> a -> a) -> (f :+: g) a -> a #foldl1 :: (a -> a -> a) -> (f :+: g) a -> a #toList :: (f :+: g) a -> [a] #null :: (f :+: g) a -> Bool #length :: (f :+: g) a -> Int #elem :: Eq a => a -> (f :+: g) a -> Bool #maximum :: Ord a => (f :+: g) a -> a #minimum :: Ord a => (f :+: g) a -> a #sum :: Num a => (f :+: g) a -> a #product :: Num a => (f :+: g) a -> a # (Foldable f, Foldable g) => Foldable (f :*: g) Instance detailsDefined in Data.Foldable Methodsfold :: Monoid m => (f :*: g) m -> m #foldMap :: Monoid m => (a -> m) -> (f :*: g) a -> m #foldr :: (a -> b -> b) -> b -> (f :*: g) a -> b #foldr' :: (a -> b -> b) -> b -> (f :*: g) a -> b #foldl :: (b -> a -> b) -> b -> (f :*: g) a -> b #foldl' :: (b -> a -> b) -> b -> (f :*: g) a -> b #foldr1 :: (a -> a -> a) -> (f :*: g) a -> a #foldl1 :: (a -> a -> a) -> (f :*: g) a -> a #toList :: (f :*: g) a -> [a] #null :: (f :*: g) a -> Bool #length :: (f :*: g) a -> Int #elem :: Eq a => a -> (f :*: g) a -> Bool #maximum :: Ord a => (f :*: g) a -> a #minimum :: Ord a => (f :*: g) a -> a #sum :: Num a => (f :*: g) a -> a #product :: Num a => (f :*: g) a -> a # (Foldable f, Foldable g) => Foldable (Product f g) Since: base-4.9.0.0 Instance detailsDefined in Data.Functor.Product Methodsfold :: Monoid m => Product f g m -> m #foldMap :: Monoid m => (a -> m) -> Product f g a -> m #foldr :: (a -> b -> b) -> b -> Product f g a -> b #foldr' :: (a -> b -> b) -> b -> Product f g a -> b #foldl :: (b -> a -> b) -> b -> Product f g a -> b #foldl' :: (b -> a -> b) -> b -> Product f g a -> b #foldr1 :: (a -> a -> a) -> Product f g a -> a #foldl1 :: (a -> a -> a) -> Product f g a -> a #toList :: Product f g a -> [a] #null :: Product f g a -> Bool #length :: Product f g a -> Int #elem :: Eq a => a -> Product f g a -> Bool #maximum :: Ord a => Product f g a -> a #minimum :: Ord a => Product f g a -> a #sum :: Num a => Product f g a -> a #product :: Num a => Product f g a -> a # (Foldable f, Foldable g) => Foldable (Sum f g) Since: base-4.9.0.0 Instance detailsDefined in Data.Functor.Sum Methodsfold :: Monoid m => Sum f g m -> m #foldMap :: Monoid m => (a -> m) -> Sum f g a -> m #foldr :: (a -> b -> b) -> b -> Sum f g a -> b #foldr' :: (a -> b -> b) -> b -> Sum f g a -> b #foldl :: (b -> a -> b) -> b -> Sum f g a -> b #foldl' :: (b -> a -> b) -> b -> Sum f g a -> b #foldr1 :: (a -> a -> a) -> Sum f g a -> a #foldl1 :: (a -> a -> a) -> Sum f g a -> a #toList :: Sum f g a -> [a] #null :: Sum f g a -> Bool #length :: Sum f g a -> Int #elem :: Eq a => a -> Sum f g a -> Bool #maximum :: Ord a => Sum f g a -> a #minimum :: Ord a => Sum f g a -> a #sum :: Num a => Sum f g a -> a #product :: Num a => Sum f g a -> a # Foldable f => Foldable (M1 i c f) Instance detailsDefined in Data.Foldable Methodsfold :: Monoid m => M1 i c f m -> m #foldMap :: Monoid m => (a -> m) -> M1 i c f a -> m #foldr :: (a -> b -> b) -> b -> M1 i c f a -> b #foldr' :: (a -> b -> b) -> b -> M1 i c f a -> b #foldl :: (b -> a -> b) -> b -> M1 i c f a -> b #foldl' :: (b -> a -> b) -> b -> M1 i c f a -> b #foldr1 :: (a -> a -> a) -> M1 i c f a -> a #foldl1 :: (a -> a -> a) -> M1 i c f a -> a #toList :: M1 i c f a -> [a] #null :: M1 i c f a -> Bool #length :: M1 i c f a -> Int #elem :: Eq a => a -> M1 i c f a -> Bool #maximum :: Ord a => M1 i c f a -> a #minimum :: Ord a => M1 i c f a -> a #sum :: Num a => M1 i c f a -> a #product :: Num a => M1 i c f a -> a # (Foldable f, Foldable g) => Foldable (f :.: g) Instance detailsDefined in Data.Foldable Methodsfold :: Monoid m => (f :.: g) m -> m #foldMap :: Monoid m => (a -> m) -> (f :.: g) a -> m #foldr :: (a -> b -> b) -> b -> (f :.: g) a -> b #foldr' :: (a -> b -> b) -> b -> (f :.: g) a -> b #foldl :: (b -> a -> b) -> b -> (f :.: g) a -> b #foldl' :: (b -> a -> b) -> b -> (f :.: g) a -> b #foldr1 :: (a -> a -> a) -> (f :.: g) a -> a #foldl1 :: (a -> a -> a) -> (f :.: g) a -> a #toList :: (f :.: g) a -> [a] #null :: (f :.: g) a -> Bool #length :: (f :.: g) a -> Int #elem :: Eq a => a -> (f :.: g) a -> Bool #maximum :: Ord a => (f :.: g) a -> a #minimum :: Ord a => (f :.: g) a -> a #sum :: Num a => (f :.: g) a -> a #product :: Num a => (f :.: g) a -> a # (Foldable f, Foldable g) => Foldable (Compose f g) Since: base-4.9.0.0 Instance detailsDefined in Data.Functor.Compose Methodsfold :: Monoid m => Compose f g m -> m #foldMap :: Monoid m => (a -> m) -> Compose f g a -> m #foldr :: (a -> b -> b) -> b -> Compose f g a -> b #foldr' :: (a -> b -> b) -> b -> Compose f g a -> b #foldl :: (b -> a -> b) -> b -> Compose f g a -> b #foldl' :: (b -> a -> b) -> b -> Compose f g a -> b #foldr1 :: (a -> a -> a) -> Compose f g a -> a #foldl1 :: (a -> a -> a) -> Compose f g a -> a #toList :: Compose f g a -> [a] #null :: Compose f g a -> Bool #length :: Compose f g a -> Int #elem :: Eq a => a -> Compose f g a -> Bool #maximum :: Ord a => Compose f g a -> a #minimum :: Ord a => Compose f g a -> a #sum :: Num a => Compose f g a -> a #product :: Num a => Compose f g a -> a # class Num a => Fractional a # Fractional numbers, supporting real division. Minimal complete definition fromRational, (recip | (/)) Instances  Instance detailsDefined in Foreign.C.Types Methods(/) :: CFloat -> CFloat -> CFloat # Instance detailsDefined in Foreign.C.Types Methods Integral a => Fractional (Ratio a) Since: base-2.0.1 Instance detailsDefined in GHC.Real Methods(/) :: Ratio a -> Ratio a -> Ratio a #recip :: Ratio a -> Ratio a # RealFloat a => Fractional (Complex a) Since: base-2.1 Instance detailsDefined in Data.Complex Methods(/) :: Complex a -> Complex a -> Complex a #recip :: Complex a -> Complex a # Fractional a => Fractional (Identity a) Instance detailsDefined in Data.Functor.Identity Methods(/) :: Identity a -> Identity a -> Identity a #recip :: Identity a -> Identity a # Fractional a => Fractional (Const a b) Instance detailsDefined in Data.Functor.Const Methods(/) :: Const a b -> Const a b -> Const a b #recip :: Const a b -> Const a b #fromRational :: Rational -> Const a b # class Functor (f :: * -> *) # The Functor class is used for types that can be mapped over. Instances of Functor should satisfy the following laws: fmap id == id fmap (f . g) == fmap f . fmap g The instances of Functor for lists, Maybe and IO` satisfy these laws. Minimal complete definition fmap Instances  Functor [] Since: base-2.1 Instance detailsDefined in GHC.Base Methodsfmap :: (a -> b) -> [a] -> [b] #(<$) :: a -> [b] -> [a] # Since: base-2.1 Instance detailsDefined in GHC.Base Methodsfmap :: (a -> b) -> Maybe a -> Maybe b #(<$) :: a -> Maybe b -> Maybe a # Since: base-2.1 Instance detailsDefined in GHC.Base Methodsfmap :: (a -> b) -> IO a -> IO b #(<$) :: a -> IO b -> IO a # Instance detailsDefined in Data.Complex Methodsfmap :: (a -> b) -> Complex a -> Complex b #(<$) :: a -> Complex b -> Complex a # Since: base-4.9.0.0 Instance detailsDefined in Data.Semigroup Methodsfmap :: (a -> b) -> Min a -> Min b #(<$) :: a -> Min b -> Min a # Since: base-4.9.0.0 Instance detailsDefined in Data.Semigroup Methodsfmap :: (a -> b) -> Max a -> Max b #(<$) :: a -> Max b -> Max a # Since: base-4.9.0.0 Instance detailsDefined in Data.Semigroup Methodsfmap :: (a -> b) -> First a -> First b #(<$) :: a -> First b -> First a # Since: base-4.9.0.0 Instance detailsDefined in Data.Semigroup Methodsfmap :: (a -> b) -> Last a -> Last b #(<$) :: a -> Last b -> Last a # Since: base-4.9.0.0 Instance detailsDefined in Data.Semigroup Methodsfmap :: (a -> b) -> Option a -> Option b #(<$) :: a -> Option b -> Option a # Instance detailsDefined in Control.Applicative Methodsfmap :: (a -> b) -> ZipList a -> ZipList b #(<$) :: a -> ZipList b -> ZipList a # Since: base-4.8.0.0 Instance detailsDefined in Data.Functor.Identity Methodsfmap :: (a -> b) -> Identity a -> Identity b #(<$) :: a -> Identity b -> Identity a # Since: base-4.6.0.0 Instance detailsDefined in Control.Exception Methodsfmap :: (a -> b) -> Handler a -> Handler b #(<$) :: a -> Handler b -> Handler a # Since: base-4.3.0.0 Instance detailsDefined in GHC.Conc.Sync Methodsfmap :: (a -> b) -> STM a -> STM b #(<$) :: a -> STM b -> STM a # Instance detailsDefined in Data.Monoid Methodsfmap :: (a -> b) -> First a -> First b #(<$) :: a -> First b -> First a # Instance detailsDefined in Data.Monoid Methodsfmap :: (a -> b) -> Last a -> Last b #(<$) :: a -> Last b -> Last a # Since: base-4.8.0.0 Instance detailsDefined in Data.Semigroup.Internal Methodsfmap :: (a -> b) -> Dual a -> Dual b #(<$) :: a -> Dual b -> Dual a # Since: base-4.8.0.0 Instance detailsDefined in Data.Semigroup.Internal Methodsfmap :: (a -> b) -> Sum a -> Sum b #(<$) :: a -> Sum b -> Sum a # Since: base-4.8.0.0 Instance detailsDefined in Data.Semigroup.Internal Methodsfmap :: (a -> b) -> Product a -> Product b #(<$) :: a -> Product b -> Product a # Since: base-2.1 Instance detailsDefined in Text.ParserCombinators.ReadPrec Methodsfmap :: (a -> b) -> ReadPrec a -> ReadPrec b #(<$) :: a -> ReadPrec b -> ReadPrec a # Since: base-2.1 Instance detailsDefined in Text.ParserCombinators.ReadP Methodsfmap :: (a -> b) -> ReadP a -> ReadP b #(<$) :: a -> ReadP b -> ReadP a # Since: base-4.9.0.0 Instance detailsDefined in GHC.Base Methodsfmap :: (a -> b) -> NonEmpty a -> NonEmpty b #(<$) :: a -> NonEmpty b -> NonEmpty a # Instance detailsDefined in Text.ParserCombinators.ReadP Methodsfmap :: (a -> b) -> P a -> P b #(<$) :: a -> P b -> P a # Since: base-3.0 Instance detailsDefined in Data.Either Methodsfmap :: (a0 -> b) -> Either a a0 -> Either a b #(<$) :: a0 -> Either a b -> Either a a0 # Functor ((,) a) Since: base-2.1 Instance detailsDefined in GHC.Base Methodsfmap :: (a0 -> b) -> (a, a0) -> (a, b) #(<$) :: a0 -> (a, b) -> (a, a0) # Functor (ST s) Since: base-2.1 Instance detailsDefined in GHC.ST Methodsfmap :: (a -> b) -> ST s a -> ST s b #(<$) :: a -> ST s b -> ST s a # Functor (Arg a) Since: base-4.9.0.0 Instance detailsDefined in Data.Semigroup Methodsfmap :: (a0 -> b) -> Arg a a0 -> Arg a b #(<$) :: a0 -> Arg a b -> Arg a a0 # Functor (ST s) Since: base-2.1 Instance detailsDefined in Control.Monad.ST.Lazy.Imp Methodsfmap :: (a -> b) -> ST s a -> ST s b #(<$) :: a -> ST s b -> ST s a # Monad m => Functor (WrappedMonad m) Since: base-2.1 Instance detailsDefined in Control.Applicative Methodsfmap :: (a -> b) -> WrappedMonad m a -> WrappedMonad m b #(<$) :: a -> WrappedMonad m b -> WrappedMonad m a # Functor (Proxy :: * -> *) Since: base-4.7.0.0 Instance detailsDefined in Data.Proxy Methodsfmap :: (a -> b) -> Proxy a -> Proxy b #(<$) :: a -> Proxy b -> Proxy a # Arrow a => Functor (WrappedArrow a b) Since: base-2.1 Instance detailsDefined in Control.Applicative Methodsfmap :: (a0 -> b0) -> WrappedArrow a b a0 -> WrappedArrow a b b0 #(<$) :: a0 -> WrappedArrow a b b0 -> WrappedArrow a b a0 # Functor (Const m :: * -> *) Since: base-2.1 Instance detailsDefined in Data.Functor.Const Methodsfmap :: (a -> b) -> Const m a -> Const m b #(<$) :: a -> Const m b -> Const m a # Functor f => Functor (Alt f) Instance detailsDefined in Data.Semigroup.Internal Methodsfmap :: (a -> b) -> Alt f a -> Alt f b #(<$) :: a -> Alt f b -> Alt f a # Functor ((->) r :: * -> *) Since: base-2.1 Instance detailsDefined in GHC.Base Methodsfmap :: (a -> b) -> (r -> a) -> r -> b #(<$) :: a -> (r -> b) -> r -> a # (Functor f, Functor g) => Functor (Product f g) Since: base-4.9.0.0 Instance detailsDefined in Data.Functor.Product Methodsfmap :: (a -> b) -> Product f g a -> Product f g b #(<$) :: a -> Product f g b -> Product f g a # (Functor f, Functor g) => Functor (Sum f g) Since: base-4.9.0.0 Instance detailsDefined in Data.Functor.Sum Methodsfmap :: (a -> b) -> Sum f g a -> Sum f g b #(<$) :: a -> Sum f g b -> Sum f g a # (Functor f, Functor g) => Functor (Compose f g) Since: base-4.9.0.0 Instance detailsDefined in Data.Functor.Compose Methodsfmap :: (a -> b) -> Compose f g a -> Compose f g b #(<\$) :: a -> Compose f g b -> Compose f g a #

class (Real a, Enum a) => Integral a #

Integral numbers, supporting integer division.

Minimal complete definition

Instances
 Since: base-2.0.1 Instance detailsDefined in GHC.Real Methodsquot :: Int -> Int -> Int #rem :: Int -> Int -> Int #div :: I