fay-0.24.0.2: A compiler for Fay, a Haskell subset that compiles to JavaScript.

Safe HaskellSafe
LanguageHaskell98

Fay.Compiler.Prelude

Contents

Description

Re-exports of base functionality. Note that this module is just used inside the compiler. It's not compiled to JavaScript. Based on the base-extended package (c) 2013 Simon Meier, licensed as BSD3.

Synopsis

Documentation

(++) :: [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.

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.

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]

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

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

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

Extract the first component of a pair.

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

Extract the second component of a pair.

otherwise :: Bool #

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

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

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

($) :: (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.

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

general coercion from integral types

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

general coercion to fractional types

class Bounded a where #

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

minBound, maxBound

Methods

minBound :: a #

maxBound :: a #

Instances
Bounded Bool

Since: 2.1

Instance details
Bounded Char

Since: 2.1

Instance details
Bounded Int

Since: 2.1

Instance details

Methods

minBound :: Int #

maxBound :: Int #

Bounded Int8

Since: 2.1

Instance details
Bounded Int16

Since: 2.1

Instance details
Bounded Int32

Since: 2.1

Instance details
Bounded Int64

Since: 2.1

Instance details
Bounded Ordering

Since: 2.1

Instance details
Bounded Word

Since: 2.1

Instance details
Bounded Word8

Since: 2.1

Instance details
Bounded Word16

Since: 2.1

Instance details
Bounded Word32

Since: 2.1

Instance details
Bounded Word64

Since: 2.1

Instance details
Bounded VecCount

Since: 4.10.0.0

Instance details
Bounded VecElem

Since: 4.10.0.0

Instance details
Bounded ()

Since: 2.1

Instance details

Methods

minBound :: () #

maxBound :: () #

Bounded All 
Instance details

Methods

minBound :: All #

maxBound :: All #

Bounded Any 
Instance details

Methods

minBound :: Any #

maxBound :: Any #

Bounded Associativity 
Instance details
Bounded SourceUnpackedness 
Instance details
Bounded SourceStrictness 
Instance details
Bounded DecidedStrictness 
Instance details
Bounded WordPtr 
Instance details
Bounded IntPtr 
Instance details
Bounded GeneralCategory 
Instance details
Bounded XdgDirectory 
Instance details
Bounded FileType 
Instance details
Bounded KnownExtension 
Instance details

Methods

minBound :: KnownExtension #

maxBound :: KnownExtension #

Bounded VarType 
Instance details

Methods

minBound :: VarType #

maxBound :: VarType #

Bounded a => Bounded (Min a) 
Instance details

Methods

minBound :: Min a #

maxBound :: Min a #

Bounded a => Bounded (Max a) 
Instance details

Methods

minBound :: Max a #

maxBound :: Max a #

Bounded a => Bounded (First a) 
Instance details

Methods

minBound :: First a #

maxBound :: First a #

Bounded a => Bounded (Last a) 
Instance details

Methods

minBound :: Last a #

maxBound :: Last a #

Bounded m => Bounded (WrappedMonoid m) 
Instance details
Bounded a => Bounded (Identity a) 
Instance details
Bounded a => Bounded (Dual a) 
Instance details

Methods

minBound :: Dual a #

maxBound :: Dual a #

Bounded a => Bounded (Sum a) 
Instance details

Methods

minBound :: Sum a #

maxBound :: Sum a #

Bounded a => Bounded (Product a) 
Instance details
(Bounded a, Bounded b) => Bounded (a, b)

Since: 2.1

Instance details

Methods

minBound :: (a, b) #

maxBound :: (a, b) #

Bounded (Proxy t) 
Instance details

Methods

minBound :: Proxy t #

maxBound :: Proxy t #

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

Since: 2.1

Instance details

Methods

minBound :: (a, b, c) #

maxBound :: (a, b, c) #

Bounded a => Bounded (Const a b) 
Instance details

Methods

minBound :: Const a b #

maxBound :: Const a b #

Coercible a b => Bounded (Coercion a b)

Since: 4.7.0.0

Instance details

Methods

minBound :: Coercion a b #

maxBound :: Coercion a b #

a ~ b => Bounded (a :~: b)

Since: 4.7.0.0

Instance details

Methods

minBound :: a :~: b #

maxBound :: a :~: b #

Bounded b => Bounded (Tagged s b) 
Instance details

Methods

minBound :: Tagged s b #

maxBound :: Tagged s b #

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

Since: 2.1

Instance details

Methods

minBound :: (a, b, c, d) #

maxBound :: (a, b, c, d) #

a ~~ b => Bounded (a :~~: b)

Since: 4.10.0.0

Instance details

Methods

minBound :: a :~~: b #

maxBound :: a :~~: b #

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

Since: 2.1

Instance details

Methods

minBound :: (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: 2.1

Instance details

Methods

minBound :: (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: 2.1

Instance details

Methods

minBound :: (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: 2.1

Instance details

Methods

minBound :: (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: 2.1

Instance details

Methods

minBound :: (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: 2.1

Instance details

Methods

minBound :: (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: 2.1

Instance details

Methods

minBound :: (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: 2.1

Instance details

Methods

minBound :: (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: 2.1

Instance details

Methods

minBound :: (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: 2.1

Instance details

Methods

minBound :: (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: 2.1

Instance details

Methods

minBound :: (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 where #

Class Enum defines operations on sequentially ordered types.

The enumFrom... methods are used in Haskell's translation of arithmetic sequences.

Instances of Enum may be derived for any enumeration type (types whose constructors have no fields). The nullary constructors are assumed to be numbered left-to-right by fromEnum from 0 through n-1. See Chapter 10 of the Haskell Report for more details.

For any type that is an instance of class Bounded as well as Enum, the following should hold:

   enumFrom     x   = enumFromTo     x maxBound
   enumFromThen x y = enumFromThenTo x y bound
     where
       bound | fromEnum y >= fromEnum x = maxBound
             | otherwise                = minBound

Minimal complete definition

toEnum, fromEnum

Methods

succ :: a -> a #

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

pred :: a -> a #

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

toEnum :: Int -> a #

Convert from an Int.

fromEnum :: 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.

enumFrom :: a -> [a] #

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

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

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

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

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

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

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

Instances
Enum Bool

Since: 2.1

Instance details

Methods

succ :: 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] #

Enum Char

Since: 2.1

Instance details

Methods

succ :: 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] #

Enum Int

Since: 2.1

Instance details

Methods

succ :: 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] #

Enum Int8

Since: 2.1

Instance details

Methods

succ :: 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] #

Enum Int16

Since: 2.1

Instance details
Enum Int32

Since: 2.1

Instance details
Enum Int64

Since: 2.1

Instance details
Enum Integer

Since: 2.1

Instance details
Enum Natural

Since: 4.8.0.0

Instance details
Enum Ordering

Since: 2.1

Instance details
Enum Word

Since: 2.1

Instance details

Methods

succ :: 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] #

Enum Word8

Since: 2.1

Instance details
Enum Word16

Since: 2.1

Instance details
Enum Word32

Since: 2.1

Instance details
Enum Word64

Since: 2.1

Instance details
Enum VecCount

Since: 4.10.0.0

Instance details
Enum VecElem

Since: 4.10.0.0

Instance details
Enum ()

Since: 2.1

Instance details

Methods

succ :: () -> () #

pred :: () -> () #

toEnum :: Int -> () #

fromEnum :: () -> Int #

enumFrom :: () -> [()] #

enumFromThen :: () -> () -> [()] #

enumFromTo :: () -> () -> [()] #

enumFromThenTo :: () -> () -> () -> [()] #

Enum SeekMode 
Instance details
Enum Associativity 
Instance details
Enum SourceUnpackedness 
Instance details
Enum SourceStrictness 
Instance details
Enum DecidedStrictness 
Instance details
Enum WordPtr 
Instance details
Enum IntPtr 
Instance details
Enum IOMode 
Instance details
Enum GeneralCategory 
Instance details
Enum XdgDirectory 
Instance details
Enum FileType 
Instance details
Enum Extension 
Instance details
Enum Message 
Instance details
Enum KnownExtension 
Instance details

Methods

succ :: KnownExtension -> KnownExtension #

pred :: KnownExtension -> KnownExtension #

toEnum :: Int -> KnownExtension #

fromEnum :: KnownExtension -> Int #

enumFrom :: KnownExtension -> [KnownExtension] #

enumFromThen :: KnownExtension -> KnownExtension -> [KnownExtension] #

enumFromTo :: KnownExtension -> KnownExtension -> [KnownExtension] #

enumFromThenTo :: KnownExtension -> KnownExtension -> KnownExtension -> [KnownExtension] #

Enum VarType 
Instance details

Methods

succ :: VarType -> VarType #

pred :: VarType -> VarType #

toEnum :: Int -> VarType #

fromEnum :: VarType -> Int #

enumFrom :: VarType -> [VarType] #

enumFromThen :: VarType -> VarType -> [VarType] #

enumFromTo :: VarType -> VarType -> [VarType] #

enumFromThenTo :: VarType -> VarType -> VarType -> [VarType] #

Enum InfixOp 
Instance details

Methods

succ :: InfixOp -> InfixOp #

pred :: InfixOp -> InfixOp #

toEnum :: Int -> InfixOp #

fromEnum :: InfixOp -> Int #

enumFrom :: InfixOp -> [InfixOp] #

enumFromThen :: InfixOp -> InfixOp -> [InfixOp] #

enumFromTo :: InfixOp -> InfixOp -> [InfixOp] #

enumFromThenTo :: InfixOp -> InfixOp -> InfixOp -> [InfixOp] #

Integral a => Enum (Ratio a)

Since: 2.0.1

Instance details

Methods

succ :: 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: 4.9.0.0

Instance details

Methods

succ :: 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: 4.9.0.0

Instance details

Methods

succ :: 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: 4.9.0.0

Instance details

Methods

succ :: 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: 4.9.0.0

Instance details

Methods

succ :: 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: 4.9.0.0

Instance details
Enum a => Enum (Identity a) 
Instance details
Enum (Proxy s)

Since: 4.7.0.0

Instance details

Methods

succ :: 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 details

Methods

succ :: 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 details

Methods

succ :: 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: 4.7.0.0

Instance details

Methods

succ :: 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: 4.7.0.0

Instance details

Methods

succ :: (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] #

Enum a => Enum (Tagged s a) 
Instance details

Methods

succ :: Tagged s a -> Tagged s a #

pred :: Tagged s a -> Tagged s a #

toEnum :: Int -> Tagged s a #

fromEnum :: Tagged s a -> Int #

enumFrom :: Tagged s a -> [Tagged s a] #

enumFromThen :: Tagged s a -> Tagged s a -> [Tagged s a] #

enumFromTo :: Tagged s a -> Tagged s a -> [Tagged s a] #

enumFromThenTo :: Tagged s a -> Tagged s a -> Tagged s a -> [Tagged s a] #

a ~~ b => Enum (a :~~: b)

Since: 4.10.0.0

Instance details

Methods

succ :: (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 where #

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

Minimal complete definition: either == or /=.

Minimal complete definition

(==) | (/=)

Methods

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

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

Instances
Eq Bool 
Instance details

Methods

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

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

Eq Char 
Instance details

Methods

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

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

Eq Double 
Instance details

Methods

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

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

Eq Float 
Instance details

Methods

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

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

Eq Int 
Instance details

Methods

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

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

Eq Int8

Since: 2.1

Instance details

Methods

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

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

Eq Int16

Since: 2.1

Instance details

Methods

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

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

Eq Int32

Since: 2.1

Instance details

Methods

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

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

Eq Int64

Since: 2.1

Instance details

Methods

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

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

Eq Integer 
Instance details

Methods

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

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

Eq Natural 
Instance details

Methods

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

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

Eq Ordering 
Instance details
Eq Word 
Instance details

Methods

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

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

Eq Word8

Since: 2.1

Instance details

Methods

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

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

Eq Word16

Since: 2.1

Instance details

Methods

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

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

Eq Word32

Since: 2.1

Instance details

Methods

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

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

Eq Word64

Since: 2.1

Instance details

Methods

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

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

Eq SomeTypeRep 
Instance details
Eq Exp 
Instance details

Methods

(==) :: Exp -> Exp -> Bool #

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

Eq Match 
Instance details

Methods

(==) :: Match -> Match -> Bool #

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

Eq Clause 
Instance details

Methods

(==) :: Clause -> Clause -> Bool #

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

Eq Pat 
Instance details

Methods

(==) :: Pat -> Pat -> Bool #

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

Eq Type 
Instance details

Methods

(==) :: Type -> Type -> Bool #

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

Eq Dec 
Instance details

Methods

(==) :: Dec -> Dec -> Bool #

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

Eq Name 
Instance details

Methods

(==) :: Name -> Name -> Bool #

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

Eq FunDep 
Instance details

Methods

(==) :: FunDep -> FunDep -> Bool #

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

Eq InjectivityAnn 
Instance details
Eq Overlap 
Instance details

Methods

(==) :: Overlap -> Overlap -> Bool #

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

Eq DerivStrategy 
Instance details
Eq () 
Instance details

Methods

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

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

Eq TyCon 
Instance details

Methods

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

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

Eq Module 
Instance details

Methods

(==) :: Module -> Module -> Bool #

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

Eq TrName 
Instance details

Methods

(==) :: TrName -> TrName -> Bool #

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

Eq Handle

Since: 4.1.0.0

Instance details

Methods

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

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

Eq BigNat 
Instance details

Methods

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

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

Eq Void

Since: 4.8.0.0

Instance details

Methods

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

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

Eq SpecConstrAnnotation 
Instance details
Eq Constr

Equality of constructors

Since: 4.0.0.0

Instance details

Methods

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

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

Eq DataRep 
Instance details

Methods

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

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

Eq ConstrRep 
Instance details
Eq Fixity 
Instance details

Methods

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

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

Eq Version

Since: 2.1

Instance details

Methods

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

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

Eq HandlePosn

Since: 4.1.0.0

Instance details
Eq ThreadId

Since: 4.2.0.0

Instance details
Eq BlockReason 
Instance details
Eq ThreadStatus 
Instance details
Eq AsyncException 
Instance details
Eq ArrayException 
Instance details
Eq ExitCode 
Instance details
Eq IOErrorType

Since: 4.1.0.0

Instance details
Eq BufferMode 
Instance details
Eq Newline 
Instance details

Methods

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

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

Eq NewlineMode 
Instance details
Eq IODeviceType 
Instance details
Eq SeekMode 
Instance details
Eq CodingProgress 
Instance details
Eq MaskingState 
Instance details
Eq IOException

Since: 4.1.0.0

Instance details
Eq ErrorCall 
Instance details
Eq ArithException 
Instance details
Eq All 
Instance details

Methods

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

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

Eq Any 
Instance details

Methods

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

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

Eq Fixity 
Instance details

Methods

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

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

Eq Associativity 
Instance details
Eq SourceUnpackedness 
Instance details
Eq SourceStrictness 
Instance details
Eq DecidedStrictness 
Instance details
Eq WordPtr 
Instance details

Methods

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

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

Eq IntPtr 
Instance details

Methods

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

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

Eq IOMode 
Instance details

Methods

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

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

Eq Lexeme 
Instance details

Methods

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

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

Eq Number 
Instance details

Methods

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

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

Eq GeneralCategory 
Instance details
Eq SrcLoc 
Instance details

Methods

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

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

Eq ByteString 
Instance details
Eq ByteString 
Instance details
Eq IntSet 
Instance details

Methods

(==) :: IntSet -> IntSet -> Bool #

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

Eq XdgDirectory 
Instance details
Eq FileType 
Instance details
Eq Permissions 
Instance details
Eq Extension 
Instance details
Eq ForeignSrcLang 
Instance details
Eq Message 
Instance details

Methods

(==) :: Message -> Message -> Bool #

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

Eq ParseError 
Instance details
Eq SourcePos 
Instance details
Eq Doc 
Instance details

Methods

(==) :: Doc -> Doc -> Bool #

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

Eq TextDetails 
Instance details
Eq Style 
Instance details

Methods

(==) :: Style -> Style -> Bool #

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

Eq Mode 
Instance details

Methods

(==) :: Mode -> Mode -> Bool #

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

Eq CreateProcess 
Instance details
Eq CmdSpec 
Instance details

Methods

(==) :: CmdSpec -> CmdSpec -> Bool #

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

Eq StdStream 
Instance details
Eq ModName 
Instance details

Methods

(==) :: ModName -> ModName -> Bool #

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

Eq PkgName 
Instance details

Methods

(==) :: PkgName -> PkgName -> Bool #

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

Eq Module 
Instance details

Methods

(==) :: Module -> Module -> Bool #

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

Eq OccName 
Instance details

Methods

(==) :: OccName -> OccName -> Bool #

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

Eq NameFlavour 
Instance details
Eq NameSpace 
Instance details
Eq Loc 
Instance details

Methods

(==) :: Loc -> Loc -> Bool #

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

Eq Info 
Instance details

Methods

(==) :: Info -> Info -> Bool #

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

Eq ModuleInfo 
Instance details
Eq Fixity 
Instance details

Methods

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

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

Eq FixityDirection 
Instance details
Eq Lit 
Instance details

Methods

(==) :: Lit -> Lit -> Bool #

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

Eq Body 
Instance details

Methods

(==) :: Body -> Body -> Bool #

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

Eq Guard 
Instance details

Methods

(==) :: Guard -> Guard -> Bool #

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

Eq Stmt 
Instance details

Methods

(==) :: Stmt -> Stmt -> Bool #

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

Eq Range 
Instance details

Methods

(==) :: Range -> Range -> Bool #

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

Eq DerivClause 
Instance details
Eq TypeFamilyHead 
Instance details
Eq TySynEqn 
Instance details
Eq Foreign 
Instance details

Methods

(==) :: Foreign -> Foreign -> Bool #

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

Eq Callconv 
Instance details
Eq Safety 
Instance details

Methods

(==) :: Safety -> Safety -> Bool #

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

Eq Pragma 
Instance details

Methods

(==) :: Pragma -> Pragma -> Bool #

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

Eq Inline 
Instance details

Methods

(==) :: Inline -> Inline -> Bool #

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

Eq RuleMatch 
Instance details
Eq Phases 
Instance details

Methods

(==) :: Phases -> Phases -> Bool #

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

Eq RuleBndr 
Instance details
Eq AnnTarget 
Instance details
Eq SourceUnpackedness 
Instance details
Eq SourceStrictness 
Instance details
Eq DecidedStrictness 
Instance details
Eq Con 
Instance details

Methods

(==) :: Con -> Con -> Bool #

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

Eq Bang 
Instance details

Methods

(==) :: Bang -> Bang -> Bool #

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

Eq PatSynDir 
Instance details
Eq PatSynArgs 
Instance details
Eq TyVarBndr 
Instance details
Eq FamilyResultSig 
Instance details
Eq TyLit 
Instance details

Methods

(==) :: TyLit -> TyLit -> Bool #

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

Eq Role 
Instance details

Methods

(==) :: Role -> Role -> Bool #

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

Eq AnnLookup 
Instance details
Eq Builder 
Instance details

Methods

(==) :: Builder -> Builder -> Bool #

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

Eq LocalTime 
Instance details
Eq UTCTime 
Instance details

Methods

(==) :: UTCTime -> UTCTime -> Bool #

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

Eq Comment 
Instance details

Methods

(==) :: Comment -> Comment -> Bool #

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

Eq UnknownPragma 
Instance details

Methods

(==) :: UnknownPragma -> UnknownPragma -> Bool #

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

Eq Extension 
Instance details

Methods

(==) :: Extension -> Extension -> Bool #

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

Eq KnownExtension 
Instance details

Methods

(==) :: KnownExtension -> KnownExtension -> Bool #

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

Eq Language 
Instance details

Methods

(==) :: Language -> Language -> Bool #

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

Eq Fixity 
Instance details

Methods

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

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

Eq Token 
Instance details

Methods

(==) :: Token -> Token -> Bool #

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

Eq PPLayout 
Instance details

Methods

(==) :: PPLayout -> PPLayout -> Bool #

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

Eq SrcLoc 
Instance details

Methods

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

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

Eq SrcSpan 
Instance details

Methods

(==) :: SrcSpan -> SrcSpan -> Bool #

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

Eq SrcSpanInfo 
Instance details

Methods

(==) :: SrcSpanInfo -> SrcSpanInfo -> Bool #

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

Eq Boxed 
Instance details

Methods

(==) :: Boxed -> Boxed -> Bool #

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

Eq Tool 
Instance details

Methods

(==) :: Tool -> Tool -> Bool #

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

Eq ExtContext 
Instance details

Methods

(==) :: ExtContext -> ExtContext -> Bool #

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

Eq LexContext 
Instance details

Methods

(==) :: LexContext -> LexContext -> Bool #

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

Eq DotNetTime 
Instance details

Methods

(==) :: DotNetTime -> DotNetTime -> Bool #

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

Eq SumEncoding 
Instance details

Methods

(==) :: SumEncoding -> SumEncoding -> Bool #

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

Eq Value 
Instance details

Methods

(==) :: Value -> Value -> Bool #

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

Eq Pos 
Instance details

Methods

(==) :: Pos -> Pos -> Bool #

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

Eq More 
Instance details

Methods

(==) :: More -> More -> Bool #

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

Eq JSONPathElement 
Instance details

Methods

(==) :: JSONPathElement -> JSONPathElement -> Bool #

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

Eq Scientific 
Instance details

Methods

(==) :: Scientific -> Scientific -> Bool #

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

Eq UUID 
Instance details

Methods

(==) :: UUID -> UUID -> Bool #

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

Eq CondensePolicy 
Instance details

Methods

(==) :: CondensePolicy -> CondensePolicy -> Bool #

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

Eq DelimPolicy 
Instance details

Methods

(==) :: DelimPolicy -> DelimPolicy -> Bool #

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

Eq EndPolicy 
Instance details

Methods

(==) :: EndPolicy -> EndPolicy -> Bool #

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

Eq VarType 
Instance details

Methods

(==) :: VarType -> VarType -> Bool #

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

Eq Content 
Instance details

Methods

(==) :: Content -> Content -> Bool #

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

Eq Pos 
Instance details

Methods

(==) :: Pos -> Pos -> Bool #

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

Eq SerializeContext # 
Instance details
Eq ModulePath # 
Instance details
Eq JsLit # 
Instance details

Methods

(==) :: JsLit -> JsLit -> Bool #

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

Eq JsName # 
Instance details

Methods

(==) :: JsName -> JsName -> Bool #

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

Eq JsExp # 
Instance details

Methods

(==) :: JsExp -> JsExp -> Bool #

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

Eq JsStmt # 
Instance details

Methods

(==) :: JsStmt -> JsStmt -> Bool #

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

Eq UnpackedUUID 
Instance details

Methods

(==) :: UnpackedUUID -> UnpackedUUID -> Bool #

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

Eq ByteArray 
Instance details

Methods

(==) :: ByteArray -> ByteArray -> Bool #

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

Eq Addr 
Instance details

Methods

(==) :: Addr -> Addr -> Bool #

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

Eq AssignOp 
Instance details

Methods

(==) :: AssignOp -> AssignOp -> Bool #

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

Eq InfixOp 
Instance details

Methods

(==) :: InfixOp -> InfixOp -> Bool #

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

Eq PrefixOp 
Instance details

Methods

(==) :: PrefixOp -> PrefixOp -> Bool #

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

Eq UnaryAssignOp 
Instance details

Methods

(==) :: UnaryAssignOp -> UnaryAssignOp -> Bool #

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

Eq a => Eq [a] 
Instance details

Methods

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

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

Eq a => Eq (Maybe a) 
Instance details

Methods

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

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

Eq a => Eq (Ratio a) 
Instance details

Methods

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

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

Eq (StablePtr a)

Since: 2.1

Instance details

Methods

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

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

Eq (Ptr a) 
Instance details

Methods

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

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

Eq (FunPtr a) 
Instance details

Methods

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

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

Eq p => Eq (Par1 p) 
Instance details

Methods

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

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

Eq (ForeignPtr a)

Since: 2.1

Instance details

Methods

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

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

Eq a => Eq (Complex a) 
Instance details

Methods

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

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

Eq a => Eq (Min a) 
Instance details

Methods

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

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

Eq a => Eq (Max a) 
Instance details

Methods

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

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

Eq a => Eq (First a) 
Instance details

Methods

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

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

Eq a => Eq (Last a) 
Instance details

Methods

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

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

Eq m => Eq (WrappedMonoid m) 
Instance details
Eq a => Eq (Option a) 
Instance details

Methods

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

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

Eq a => Eq (ZipList a) 
Instance details

Methods

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

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

Eq a => Eq (Identity a) 
Instance details

Methods

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

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

Eq (TVar a)

Since: 4.8.0.0

Instance details

Methods

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

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

Eq (IORef a)

Pointer equality.

Since: 4.1.0.0

Instance details

Methods

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

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

Eq a => Eq (First a) 
Instance details

Methods

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

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

Eq a => Eq (Last a) 
Instance details

Methods

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

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

Eq a => Eq (Dual a) 
Instance details

Methods

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

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

Eq a => Eq (Sum a) 
Instance details

Methods

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

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

Eq a => Eq (Product a) 
Instance details

Methods

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

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

Eq a => Eq (Down a) 
Instance details

Methods

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

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

Eq (MVar a)

Since: 4.1.0.0

Instance details

Methods

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

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

Eq a => Eq (NonEmpty a) 
Instance details

Methods

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

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

Eq a => Eq (IntMap a) 
Instance details

Methods

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

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

Eq vertex => Eq (SCC vertex)

Since: 0.5.9

Instance details

Methods

(==) :: SCC vertex -> SCC vertex -> Bool #

(/=) :: SCC vertex -> SCC vertex -> Bool #

Eq a => Eq (Tree a) 
Instance details

Methods

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

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

Eq a => Eq (Seq a) 
Instance details

Methods

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

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

Eq a => Eq (ViewL a) 
Instance details

Methods

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

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

Eq a => Eq (ViewR a) 
Instance details

Methods

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

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

Eq a => Eq (Set a) 
Instance details

Methods

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

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

Eq (Doc a) 
Instance details

Methods

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

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

Eq a => Eq (AnnotDetails a) 
Instance details
Eq a => Eq (Span a) 
Instance details

Methods

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

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

Eq a => Eq (ListOf a) 
Instance details

Methods

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

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

Eq l => Eq (ModuleHeadAndImports l) 
Instance details

Methods

(==) :: ModuleHeadAndImports l -> ModuleHeadAndImports l -> Bool #

(/=) :: ModuleHeadAndImports l -> ModuleHeadAndImports l -> Bool #

Eq a => Eq (NonGreedy a) 
Instance details

Methods

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

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

Eq l => Eq (PragmasAndModuleHead l) 
Instance details

Methods

(==) :: PragmasAndModuleHead l -> PragmasAndModuleHead l -> Bool #

(/=) :: PragmasAndModuleHead l -> PragmasAndModuleHead l -> Bool #

Eq l => Eq (PragmasAndModuleName l) 
Instance details

Methods

(==) :: PragmasAndModuleName l -> PragmasAndModuleName l -> Bool #

(/=) :: PragmasAndModuleName l -> PragmasAndModuleName l -> Bool #

Eq a => Eq (Loc a) 
Instance details

Methods

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

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

Eq l => Eq (Activation l) 
Instance details

Methods

(==) :: Activation l -> Activation l -> Bool #

(/=) :: Activation l -> Activation l -> Bool #

Eq l => Eq (Alt l) 
Instance details

Methods

(==) :: Alt l -> Alt l -> Bool #

(/=) :: Alt l -> Alt l -> Bool #

Eq l => Eq (Annotation l) 
Instance details

Methods

(==) :: Annotation l -> Annotation l -> Bool #

(/=) :: Annotation l -> Annotation l -> Bool #

Eq l => Eq (Assoc l) 
Instance details

Methods

(==) :: Assoc l -> Assoc l -> Bool #

(/=) :: Assoc l -> Assoc l -> Bool #

Eq l => Eq (Asst l) 
Instance details

Methods

(==) :: Asst l -> Asst l -> Bool #

(/=) :: Asst l -> Asst l -> Bool #

Eq l => Eq (BangType l) 
Instance details

Methods

(==) :: BangType l -> BangType l -> Bool #

(/=) :: BangType l -> BangType l -> Bool #

Eq l => Eq (Binds l) 
Instance details

Methods

(==) :: Binds l -> Binds l -> Bool #

(/=) :: Binds l -> Binds l -> Bool #

Eq l => Eq (BooleanFormula l) 
Instance details

Methods

(==) :: BooleanFormula l -> BooleanFormula l -> Bool #

(/=) :: BooleanFormula l -> BooleanFormula l -> Bool #

Eq l => Eq (Bracket l) 
Instance details

Methods

(==) :: Bracket l -> Bracket l -> Bool #

(/=) :: Bracket l -> Bracket l -> Bool #

Eq l => Eq (CName l) 
Instance details

Methods

(==) :: CName l -> CName l -> Bool #

(/=) :: CName l -> CName l -> Bool #

Eq l => Eq (CallConv l) 
Instance details

Methods

(==) :: CallConv l -> CallConv l -> Bool #

(/=) :: CallConv l -> CallConv l -> Bool #

Eq l => Eq (ClassDecl l) 
Instance details

Methods

(==) :: ClassDecl l -> ClassDecl l -> Bool #

(/=) :: ClassDecl l -> ClassDecl l -> Bool #

Eq l => Eq (ConDecl l) 
Instance details

Methods

(==) :: ConDecl l -> ConDecl l -> Bool #

(/=) :: ConDecl l -> ConDecl l -> Bool #

Eq l => Eq (Context l) 
Instance details

Methods

(==) :: Context l -> Context l -> Bool #

(/=) :: Context l -> Context l -> Bool #

Eq l => Eq (DataOrNew l) 
Instance details

Methods

(==) :: DataOrNew l -> DataOrNew l -> Bool #

(/=) :: DataOrNew l -> DataOrNew l -> Bool #

Eq l => Eq (Decl l) 
Instance details

Methods

(==) :: Decl l -> Decl l -> Bool #

(/=) :: Decl l -> Decl l -> Bool #

Eq l => Eq (DeclHead l) 
Instance details

Methods

(==) :: DeclHead l -> DeclHead l -> Bool #

(/=) :: DeclHead l -> DeclHead l -> Bool #

Eq l => Eq (DerivStrategy l) 
Instance details

Methods

(==) :: DerivStrategy l -> DerivStrategy l -> Bool #

(/=) :: DerivStrategy l -> DerivStrategy l -> Bool #

Eq l => Eq (Deriving l) 
Instance details

Methods

(==) :: Deriving l -> Deriving l -> Bool #

(/=) :: Deriving l -> Deriving l -> Bool #

Eq l => Eq (EWildcard l) 
Instance details

Methods

(==) :: EWildcard l -> EWildcard l -> Bool #

(/=) :: EWildcard l -> EWildcard l -> Bool #

Eq l => Eq (Exp l) 
Instance details

Methods

(==) :: Exp l -> Exp l -> Bool #

(/=) :: Exp l -> Exp l -> Bool #

Eq l => Eq (ExportSpec l) 
Instance details

Methods

(==) :: ExportSpec l -> ExportSpec l -> Bool #

(/=) :: ExportSpec l -> ExportSpec l -> Bool #

Eq l => Eq (ExportSpecList l) 
Instance details

Methods

(==) :: ExportSpecList l -> ExportSpecList l -> Bool #

(/=) :: ExportSpecList l -> ExportSpecList l -> Bool #

Eq l => Eq (FieldDecl l) 
Instance details

Methods

(==) :: FieldDecl l -> FieldDecl l -> Bool #

(/=) :: FieldDecl l -> FieldDecl l -> Bool #

Eq l => Eq (FieldUpdate l) 
Instance details

Methods

(==) :: FieldUpdate l -> FieldUpdate l -> Bool #

(/=) :: FieldUpdate l -> FieldUpdate l -> Bool #

Eq l => Eq (FunDep l) 
Instance details

Methods

(==) :: FunDep l -> FunDep l -> Bool #

(/=) :: FunDep l -> FunDep l -> Bool #

Eq l => Eq (GadtDecl l) 
Instance details

Methods

(==) :: GadtDecl l -> GadtDecl l -> Bool #

(/=) :: GadtDecl l -> GadtDecl l -> Bool #

Eq l => Eq (GuardedRhs l) 
Instance details

Methods

(==) :: GuardedRhs l -> GuardedRhs l -> Bool #

(/=) :: GuardedRhs l -> GuardedRhs l -> Bool #

Eq l => Eq (IPBind l) 
Instance details

Methods

(==) :: IPBind l -> IPBind l -> Bool #

(/=) :: IPBind l -> IPBind l -> Bool #

Eq l => Eq (IPName l) 
Instance details

Methods

(==) :: IPName l -> IPName l -> Bool #

(/=) :: IPName l -> IPName l -> Bool #

Eq l => Eq (ImportDecl l) 
Instance details

Methods

(==) :: ImportDecl l -> ImportDecl l -> Bool #

(/=) :: ImportDecl l -> ImportDecl l -> Bool #

Eq l => Eq (ImportSpec l) 
Instance details

Methods

(==) :: ImportSpec l -> ImportSpec l -> Bool #

(/=) :: ImportSpec l -> ImportSpec l -> Bool #

Eq l => Eq (ImportSpecList l) 
Instance details

Methods

(==) :: ImportSpecList l -> ImportSpecList l -> Bool #

(/=) :: ImportSpecList l -> ImportSpecList l -> Bool #

Eq l => Eq (InjectivityInfo l) 
Instance details

Methods

(==) :: InjectivityInfo l -> InjectivityInfo l -> Bool #

(/=) :: InjectivityInfo l -> InjectivityInfo l -> Bool #

Eq l => Eq (InstDecl l) 
Instance details

Methods

(==) :: InstDecl l -> InstDecl l -> Bool #

(/=) :: InstDecl l -> InstDecl l -> Bool #

Eq l => Eq (InstHead l) 
Instance details

Methods

(==) :: InstHead l -> InstHead l -> Bool #

(/=) :: InstHead l -> InstHead l -> Bool #

Eq l => Eq (InstRule l) 
Instance details

Methods

(==) :: InstRule l -> InstRule l -> Bool #

(/=) :: InstRule l -> InstRule l -> Bool #

Eq l => Eq (Kind l) 
Instance details

Methods

(==) :: Kind l -> Kind l -> Bool #

(/=) :: Kind l -> Kind l -> Bool #

Eq l => Eq (Literal l) 
Instance details

Methods

(==) :: Literal l -> Literal l -> Bool #

(/=) :: Literal l -> Literal l -> Bool #

Eq l => Eq (Match l) 
Instance details

Methods

(==) :: Match l -> Match l -> Bool #

(/=) :: Match l -> Match l -> Bool #

Eq l => Eq (MaybePromotedName l) 
Instance details

Methods

(==) :: MaybePromotedName l -> MaybePromotedName l -> Bool #

(/=) :: MaybePromotedName l -> MaybePromotedName l -> Bool #

Eq l => Eq (Module l) 
Instance details

Methods

(==) :: Module l -> Module l -> Bool #

(/=) :: Module l -> Module l -> Bool #

Eq l => Eq (ModuleHead l) 
Instance details

Methods

(==) :: ModuleHead l -> ModuleHead l -> Bool #

(/=) :: ModuleHead l -> ModuleHead l -> Bool #

Eq l => Eq (ModuleName l) 
Instance details

Methods

(==) :: ModuleName l -> ModuleName l -> Bool #

(/=) :: ModuleName l -> ModuleName l -> Bool #

Eq l => Eq (ModulePragma l) 
Instance details

Methods

(==) :: ModulePragma l -> ModulePragma l -> Bool #

(/=) :: ModulePragma l -> ModulePragma l -> Bool #

Eq l => Eq (Name l) 
Instance details

Methods

(==) :: Name l -> Name l -> Bool #

(/=) :: Name l -> Name l -> Bool #

Eq l => Eq (Namespace l) 
Instance details

Methods

(==) :: Namespace l -> Namespace l -> Bool #

(/=) :: Namespace l -> Namespace l -> Bool #

Eq l => Eq (Op l) 
Instance details

Methods

(==) :: Op l -> Op l -> Bool #

(/=) :: Op l -> Op l -> Bool #

Eq l => Eq (Overlap l) 
Instance details

Methods

(==) :: Overlap l -> Overlap l -> Bool #

(/=) :: Overlap l -> Overlap l -> Bool #

Eq l => Eq (PXAttr l) 
Instance details

Methods

(==) :: PXAttr l -> PXAttr l -> Bool #

(/=) :: PXAttr l -> PXAttr l -> Bool #

Eq l => Eq (Pat l) 
Instance details

Methods

(==) :: Pat l -> Pat l -> Bool #

(/=) :: Pat l -> Pat l -> Bool #

Eq l => Eq (PatField l) 
Instance details

Methods

(==) :: PatField l -> PatField l -> Bool #

(/=) :: PatField l -> PatField l -> Bool #

Eq l => Eq (PatternSynDirection l) 
Instance details

Methods

(==) :: PatternSynDirection l -> PatternSynDirection l -> Bool #

(/=) :: PatternSynDirection l -> PatternSynDirection l -> Bool #

Eq l => Eq (Promoted l) 
Instance details

Methods

(==) :: Promoted l -> Promoted l -> Bool #

(/=) :: Promoted l -> Promoted l -> Bool #

Eq l => Eq (QName l) 
Instance details

Methods

(==) :: QName l -> QName l -> Bool #

(/=) :: QName l -> QName l -> Bool #

Eq l => Eq (QOp l) 
Instance details

Methods

(==) :: QOp l -> QOp l -> Bool #

(/=) :: QOp l -> QOp l -> Bool #

Eq l => Eq (QualConDecl l) 
Instance details

Methods

(==) :: QualConDecl l -> QualConDecl l -> Bool #

(/=) :: QualConDecl l -> QualConDecl l -> Bool #

Eq l => Eq (QualStmt l) 
Instance details

Methods

(==) :: QualStmt l -> QualStmt l -> Bool #

(/=) :: QualStmt l -> QualStmt l -> Bool #

Eq l => Eq (RPat l) 
Instance details

Methods

(==) :: RPat l -> RPat l -> Bool #

(/=) :: RPat l -> RPat l -> Bool #

Eq l => Eq (RPatOp l) 
Instance details

Methods

(==) :: RPatOp l -> RPatOp l -> Bool #

(/=) :: RPatOp l -> RPatOp l -> Bool #

Eq l => Eq (ResultSig l) 
Instance details

Methods

(==) :: ResultSig l -> ResultSig l -> Bool #

(/=) :: ResultSig l -> ResultSig l -> Bool #

Eq l => Eq (Rhs l) 
Instance details

Methods

(==) :: Rhs l -> Rhs l -> Bool #

(/=) :: Rhs l -> Rhs l -> Bool #

Eq l => Eq (Role l) 
Instance details

Methods

(==) :: Role l -> Role l -> Bool #

(/=) :: Role l -> Role l -> Bool #

Eq l => Eq (Rule l) 
Instance details

Methods

(==) :: Rule l -> Rule l -> Bool #

(/=) :: Rule l -> Rule l -> Bool #

Eq l => Eq (RuleVar l) 
Instance details

Methods

(==) :: RuleVar l -> RuleVar l -> Bool #

(/=) :: RuleVar l -> RuleVar l -> Bool #

Eq l => Eq (Safety l) 
Instance details

Methods

(==) :: Safety l -> Safety l -> Bool #

(/=) :: Safety l -> Safety l -> Bool #

Eq l => Eq (Sign l) 
Instance details

Methods

(==) :: Sign l -> Sign l -> Bool #

(/=) :: Sign l -> Sign l -> Bool #

Eq l => Eq (SpecialCon l) 
Instance details

Methods

(==) :: SpecialCon l -> SpecialCon l -> Bool #

(/=) :: SpecialCon l -> SpecialCon l -> Bool #

Eq l => Eq (Splice l) 
Instance details

Methods

(==) :: Splice l -> Splice l -> Bool #

(/=) :: Splice l -> Splice l -> Bool #

Eq l => Eq (Stmt l) 
Instance details

Methods

(==) :: Stmt l -> Stmt l -> Bool #

(/=) :: Stmt l -> Stmt l -> Bool #

Eq l => Eq (TyVarBind l) 
Instance details

Methods

(==) :: TyVarBind l -> TyVarBind l -> Bool #

(/=) :: TyVarBind l -> TyVarBind l -> Bool #

Eq l => Eq (Type l) 
Instance details

Methods

(==) :: Type l -> Type l -> Bool #

(/=) :: Type l -> Type l -> Bool #

Eq l => Eq (TypeEqn l) 
Instance details

Methods

(==) :: TypeEqn l -> TypeEqn l -> Bool #

(/=) :: TypeEqn l -> TypeEqn l -> Bool #

Eq l => Eq (Unpackedness l) 
Instance details

Methods

(==) :: Unpackedness l -> Unpackedness l -> Bool #

(/=) :: Unpackedness l -> Unpackedness l -> Bool #

Eq l => Eq (WarningText l) 
Instance details

Methods

(==) :: WarningText l -> WarningText l -> Bool #

(/=) :: WarningText l -> WarningText l -> Bool #

Eq l => Eq (XAttr l) 
Instance details

Methods

(==) :: XAttr l -> XAttr l -> Bool #

(/=) :: XAttr l -> XAttr l -> Bool #

Eq l => Eq (XName l) 
Instance details

Methods

(==) :: XName l -> XName l -> Bool #

(/=) :: XName l -> XName l -> Bool #

Eq a => Eq (DList a) 
Instance details

Methods

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

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

Eq (Encoding' a) 
Instance details

Methods

(==) :: Encoding' a -> Encoding' a -> Bool #

(/=) :: Encoding' a -> Encoding' a -> Bool #

Eq a => Eq (Result a) 
Instance details

Methods

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

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

Eq a => Eq (IResult a) 
Instance details

Methods

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

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

Eq a => Eq (Vector a) 
Instance details

Methods

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

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

Eq a => Eq (Array a) 
Instance details

Methods

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

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

Eq a => Eq (HashSet a) 
Instance details

Methods

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

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

(Eq a, Prim a) => Eq (PrimArray a) 
Instance details

Methods

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

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

Eq a => Eq (SmallArray a) 
Instance details

Methods

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

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

(Eq a, PrimUnlifted a) => Eq (UnliftedArray a) 
Instance details

Methods

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

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

(Prim a, Eq a) => Eq (Vector a) 
Instance details

Methods

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

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

(Storable a, Eq a) => Eq (Vector a) 
Instance details

Methods

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

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

Eq a => Eq (Hashed a) 
Instance details

Methods

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

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

Eq a => Eq (Chunk a) 
Instance details

Methods

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

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

Eq a => Eq (JavaScript a) 
Instance details

Methods

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

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

Eq a => Eq (Statement a) 
Instance details

Methods

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

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

Eq a => Eq (Expression a) 
Instance details

Methods

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

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

Eq a => Eq (CaseClause a) 
Instance details

Methods

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

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

Eq a => Eq (CatchClause a) 
Instance details

Methods

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

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

Eq a => Eq (ForInInit a) 
Instance details

Methods

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

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

Eq a => Eq (ForInit a) 
Instance details

Methods

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

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

Eq a => Eq (Id a) 
Instance details

Methods

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

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

Eq a => Eq (LValue a) 
Instance details

Methods

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

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

Eq a => Eq (Prop a) 
Instance details

Methods

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

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

Eq a => Eq (VarDecl a) 
Instance details

Methods

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

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

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

Methods

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

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

Eq (V1 p)

Since: 4.9.0.0

Instance details

Methods

(==) :: V1 p -> V1 p -> Bool #

(/=) :: V1 p -> V1 p -> Bool #

Eq (U1 p)

Since: 4.9.0.0

Instance details

Methods

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

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

Eq (TypeRep a)

Since: 2.1

Instance details

Methods

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

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

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

Methods

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

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

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

Since: 2.1

Instance details

Methods

(==) :: Array i e -> Array i e -> Bool #

(/=) :: Array i e -> Array i e -> Bool #

Eq a => Eq (Arg a b)

Since: 4.9.0.0

Instance details

Methods

(==) :: Arg a b -> Arg a b -> Bool #

(/=) :: Arg a b -> Arg a b -> Bool #

Eq (Proxy s)

Since: 4.7.0.0

Instance details

Methods

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

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

(Eq k, Eq a) => Eq (Map k a) 
Instance details

Methods

(==) :: Map k a -> Map k a -> Bool #

(/=) :: Map k a -> Map k a -> Bool #

(Eq1 m, Eq a) => Eq (ListT m a) 
Instance details

Methods

(==) :: ListT m a -> ListT m a -> Bool #

(/=) :: ListT m a -> ListT m a -> Bool #

(Eq1 m, Eq a) => Eq (MaybeT m a) 
Instance details

Methods

(==) :: MaybeT m a -> MaybeT m a -> Bool #

(/=) :: MaybeT m a -> MaybeT m a -> Bool #

(Eq k, Eq v) => Eq (HashMap k v) 
Instance details

Methods

(==) :: HashMap k v -> HashMap k v -> Bool #

(/=) :: HashMap k v -> HashMap k v -> Bool #

Eq (MutableArray s a) 
Instance details

Methods

(==) :: MutableArray s a -> MutableArray s a -> Bool #

(/=) :: MutableArray s a -> MutableArray s a -> Bool #

(Eq k, Eq v) => Eq (Leaf k v) 
Instance details

Methods

(==) :: Leaf k v -> Leaf k v -> Bool #

(/=) :: Leaf k v -> Leaf k v -> Bool #

Eq (SmallMutableArray s a) 
Instance details

Methods

(==) :: SmallMutableArray s a -> SmallMutableArray s a -> Bool #

(/=) :: SmallMutableArray s a -> SmallMutableArray s a -> Bool #

Eq (MutableUnliftedArray s a) 
Instance details

Methods

(==) :: MutableUnliftedArray s a -> MutableUnliftedArray s a -> Bool #

(/=) :: MutableUnliftedArray s a -> MutableUnliftedArray s a -> Bool #

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

Methods

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

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

Eq (URec (Ptr ()) p) 
Instance details

Methods

(==) :: URec (Ptr ()) p -> URec (Ptr ()) p -> Bool #

(/=) :: URec (Ptr ()) p -> URec (Ptr ()) p -> Bool #

Eq (URec Char p) 
Instance details

Methods

(==) :: URec Char p -> URec Char p -> Bool #

(/=) :: URec Char p -> URec Char p -> Bool #

Eq (URec Double p) 
Instance details

Methods

(==) :: URec Double p -> URec Double p -> Bool #

(/=) :: URec Double p -> URec Double p -> Bool #

Eq (URec Float p) 
Instance details

Methods

(==) :: URec Float p -> URec Float p -> Bool #

(/=) :: URec Float p -> URec Float p -> Bool #

Eq (URec Int p) 
Instance details

Methods

(==) :: URec Int p -> URec Int p -> Bool #

(/=) :: URec Int p -> URec Int p -> Bool #

Eq (URec Word p) 
Instance details

Methods

(==) :: URec Word p -> URec Word p -> Bool #

(/=) :: URec Word p -> URec Word p -> Bool #

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

Methods

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

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

Eq (STArray s i e)

Since: 2.1

Instance details

Methods

(==) :: STArray s i e -> STArray s i e -> Bool #

(/=) :: STArray s i e -> STArray s i e -> Bool #

Eq a => Eq (Const a b) 
Instance details

Methods

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

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

Eq (f a) => Eq (Alt f a) 
Instance details

Methods

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

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

Eq (Coercion a b) 
Instance details

Methods

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

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

Eq (a :~: b) 
Instance details

Methods

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

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

(Eq1 f, Eq a) => Eq (IdentityT f a) 
Instance details

Methods

(==) :: IdentityT f a -> IdentityT f a -> Bool #

(/=) :: IdentityT f a -> IdentityT f a -> Bool #

(Eq e, Eq1 m, Eq a) => Eq (ErrorT e m a) 
Instance details

Methods

(==) :: ErrorT e m a -> ErrorT e m a -> Bool #

(/=) :: ErrorT e m a -> ErrorT e m a -> Bool #

(Eq e, Eq1 m, Eq a) => Eq (ExceptT e m a) 
Instance details

Methods

(==) :: ExceptT e m a -> ExceptT e m a -> Bool #

(/=) :: ExceptT e m a -> ExceptT e m a -> Bool #

(Eq w, Eq1 m, Eq a) => Eq (WriterT w m a) 
Instance details

Methods

(==) :: WriterT w m a -> WriterT w m a -> Bool #

(/=) :: WriterT w m a -> WriterT w m a -> Bool #

(Eq w, Eq1 m, Eq a) => Eq (WriterT w m a) 
Instance details

Methods

(==) :: WriterT w m a -> WriterT w m a -> Bool #

(/=) :: WriterT w m a -> WriterT w m a -> Bool #

Eq b => Eq (Tagged s b) 
Instance details

Methods

(==) :: Tagged s b -> Tagged s b -> Bool #

(/=) :: Tagged s b -> Tagged s b -> Bool #

Eq c => Eq (K1 i c p) 
Instance details

Methods

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

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

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

Methods

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

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

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

Methods

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

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

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

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: 4.9.0.0

Instance details

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: 4.9.0.0

Instance details

Methods

(==) :: Sum f g a -> Sum f g a -> Bool #

(/=) :: Sum f g a -> Sum f g a -> Bool #

Eq (a :~~: b)

Since: 4.10.0.0

Instance details

Methods

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

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

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

Methods

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

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

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

Methods

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

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

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

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: 4.9.0.0

Instance details

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 details

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 details

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 details

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 details

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 details

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 details

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 details

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 details

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 details

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 details

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 where #

Trigonometric and hyperbolic functions and related functions.

Minimal complete definition

pi, exp, log, sin, cos, asin, acos, atan, sinh, cosh, asinh, acosh, atanh

Methods

pi :: a #

log :: a -> a #

sqrt :: a -> a #

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

logBase :: a -> a -> a #

sin :: a -> a #

cos :: a -> a #

tan :: a -> a #

asin :: a -> a #

acos :: a -> a #

atan :: a -> a #

sinh :: a -> a #

cosh :: a -> a #

tanh :: a -> a #

asinh :: a -> a #

acosh :: a -> a #

atanh :: a -> a #

Instances
Floating Double

Since: 2.1

Instance details
Floating Float

Since: 2.1

Instance details
RealFloat a => Floating (Complex a)

Since: 2.1

Instance details

Methods

pi :: 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 details
Floating a => Floating (Const a b) 
Instance details

Methods

pi :: 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 #

Floating a => Floating (Tagged s a) 
Instance details

Methods

pi :: Tagged s a #

exp :: Tagged s a -> Tagged s a #

log :: Tagged s a -> Tagged s a #

sqrt :: Tagged s a -> Tagged s a #

(**) :: Tagged s a -> Tagged s a -> Tagged s a #

logBase :: Tagged s a -> Tagged s a -> Tagged s a #

sin :: Tagged s a -> Tagged s a #

cos :: Tagged s a -> Tagged s a #

tan :: Tagged s a -> Tagged s a #

asin :: Tagged s a -> Tagged s a #

acos :: Tagged s a -> Tagged s a #

atan :: Tagged s a -> Tagged s a #

sinh :: Tagged s a -> Tagged s a #

cosh :: Tagged s a -> Tagged s a #

tanh :: Tagged s a -> Tagged s a #

asinh :: Tagged s a -> Tagged s a #

acosh :: Tagged s a -> Tagged s a #

atanh :: Tagged s a -> Tagged s a #

log1p :: Tagged s a -> Tagged s a #

expm1 :: Tagged s a -> Tagged s a #

log1pexp :: Tagged s a -> Tagged s a #

log1mexp :: Tagged s a -> Tagged s a #

class Num a => Fractional a where #

Fractional numbers, supporting real division.

Minimal complete definition

fromRational, (recip | (/))

Methods

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

fractional division

recip :: a -> a #

reciprocal fraction

fromRational :: 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.

Instances
Fractional Scientific 
Instance details

Methods

(/) :: Scientific -> Scientific -> Scientific #

recip :: Scientific -> Scientific #

fromRational :: Rational -> Scientific #

Integral a => Fractional (Ratio a)

Since: 2.0.1

Instance details

Methods

(/) :: Ratio a -> Ratio a -> Ratio a #

recip :: Ratio a -> Ratio a #

fromRational :: Rational -> Ratio a #

RealFloat a => Fractional (Complex a)

Since: 2.1

Instance details

Methods

(/) :: Complex a -> Complex a -> Complex a #

recip :: Complex a -> Complex a #

fromRational :: Rational -> Complex a #

Fractional a => Fractional (Identity a) 
Instance details
Fractional a => Fractional (Const a b) 
Instance details

Methods

(/) :: Const a b -> Const a b -> Const a b #

recip :: Const a b -> Const a b #

fromRational :: Rational -> Const a b #

Fractional a => Fractional (Tagged s a) 
Instance details

Methods

(/) :: Tagged s a -> Tagged s a -> Tagged s a #

recip :: Tagged s a -> Tagged s a #

fromRational :: Rational -> Tagged s a #

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

Integral numbers, supporting integer division.

Minimal complete definition

quotRem, toInteger

Methods

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

integer division truncated toward zero

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

integer remainder, satisfying

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

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

integer division truncated toward negative infinity

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

simultaneous quot and rem

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

simultaneous div and mod

toInteger :: a -> Integer #

conversion to Integer

Instances
Integral Int

Since: 2.0.1

Instance details

Methods

quot :: Int -> Int -> Int #

rem :: Int -> Int -> Int #

div :: Int -> Int -> Int #

mod :: Int -> Int -> Int #

quotRem :: Int -> Int -> (Int, Int) #

divMod :: Int -> Int -> (Int, Int) #

toInteger :: Int -> Integer #

Integral Int8

Since: 2.1

Instance details

Methods

quot :: Int8 -> Int8 -> Int8 #

rem :: Int8 -> Int8 -> Int8 #

div :: Int8 -> Int8 -> Int8 #

mod :: Int8 -> Int8 -> Int8 #

quotRem :: Int8 -> Int8 -> (Int8, Int8) #

divMod :: Int8 -> Int8 -> (Int8, Int8) #

toInteger :: Int8 -> Integer #

Integral Int16

Since: 2.1

Instance details
Integral Int32

Since: 2.1

Instance details
Integral Int64

Since: 2.1

Instance details
Integral Integer

Since: 2.0.1

Instance details
Integral Natural

Since: 4.8.0.0

Instance details
Integral Word

Since: 2.1

Instance details

Methods

quot :: Word -> Word -> Word #

rem :: Word -> Word -> Word #

div :: Word -> Word -> Word #

mod :: Word -> Word -> Word #

quotRem :: Word -> Word -> (Word, Word) #

divMod :: Word -> Word -> (Word, Word) #

toInteger :: Word -> Integer #

Integral Word8

Since: 2.1

Instance details
Integral Word16

Since: 2.1

Instance details
Integral Word32

Since: 2.1

Instance details
Integral Word64

Since: 2.1

Instance details
Integral WordPtr 
Instance details
Integral IntPtr 
Instance details
Integral a => Integral (Identity a) 
Instance details
Integral a => Integral (Const a b) 
Instance details

Methods

quot :: Const a b -> Const a b -> Const a b #

rem :: Const a b -> Const a b -> Const a b #

div :: Const a b -> Const a b -> Const a b #

mod :: Const a b -> Const a b -> Const a b #

quotRem :: Const a b -> Const a b -> (Const a b, Const a b) #

divMod :: Const a b -> Const a b -> (Const a b, Const a b) #

toInteger :: Const a b -> Integer #

Integral a => Integral (Tagged s a) 
Instance details

Methods

quot :: Tagged s a -> Tagged s a -> Tagged s a #

rem :: Tagged s a -> Tagged s a -> Tagged s a #

div :: Tagged s a -> Tagged s a -> Tagged s a #

mod :: Tagged s a -> Tagged s a -> Tagged s a #

quotRem :: Tagged s a -> Tagged s a -> (Tagged s a, Tagged s a) #

divMod :: Tagged s a -> Tagged s a -> (Tagged s a, Tagged s a) #

toInteger :: Tagged s a -> Integer #

class Applicative m => Monad (m :: * -> *) where #

The Monad class defines the basic operations over a monad, a concept from a branch of mathematics known as category theory. From the perspective of a Haskell programmer, however, it is best to think of a monad as an abstract datatype of actions. Haskell's do expressions provide a convenient syntax for writing monadic expressions.

Instances of Monad should satisfy the following laws:

Furthermore, the Monad and Applicative operations should relate as follows:

The above laws imply:

and that pure and (<*>) satisfy the applicative functor laws.

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

Minimal complete definition

(>>=)

Methods

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

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

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

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

return :: a -> m a #

Inject a value into the monadic type.

fail :: 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.

Instances
Monad []

Since: 2.1

Instance details

Methods

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

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

return :: a -> [a] #

fail :: String -> [a] #

Monad Maybe

Since: 2.1

Instance details

Methods

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

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

return :: a -> Maybe a #

fail :: String -> Maybe a #

Monad IO

Since: 2.1

Instance details

Methods

(>>=) :: IO a -> (a -> IO b) -> IO b #

(>>) :: IO a -> IO b -> IO b #

return :: a -> IO a #

fail :: String -> IO a #

Monad Par1

Since: 4.9.0.0

Instance details

Methods

(>>=) :: Par1 a -> (a -> Par1 b) -> Par1 b #

(>>) :: Par1 a -> Par1 b -> Par1 b #

return :: a -> Par1 a #

fail :: String -> Par1 a #

Monad Q 
Instance details

Methods

(>>=) :: Q a -> (a -> Q b) -> Q b #

(>>) :: Q a -> Q b -> Q b #

return :: a -> Q a #

fail :: String -> Q a #

Monad Complex

Since: 4.9.0.0

Instance details

Methods

(>>=) :: Complex a -> (a -> Complex b) -> Complex b #

(>>) :: Complex a -> Complex b -> Complex b #

return :: a -> Complex a #

fail :: String -> Complex a #

Monad Min

Since: 4.9.0.0

Instance details

Methods

(>>=) :: Min a -> (a -> Min b) -> Min b #

(>>) :: Min a -> Min b -> Min b #

return :: a -> Min a #

fail :: String -> Min a #

Monad Max

Since: 4.9.0.0

Instance details

Methods

(>>=) :: Max a -> (a -> Max b) -> Max b #

(>>) :: Max a -> Max b -> Max b #

return :: a -> Max a #

fail :: String -> Max a #

Monad First

Since: 4.9.0.0

Instance details

Methods

(>>=) :: First a -> (a -> First b) -> First b #

(>>) :: First a -> First b -> First b #

return :: a -> First a #

fail :: String -> First a #

Monad Last

Since: 4.9.0.0

Instance details

Methods

(>>=) :: Last a -> (a -> Last b) -> Last b #

(>>) :: Last a -> Last b -> Last b #

return :: a -> Last a #

fail :: String -> Last a #

Monad Option

Since: 4.9.0.0

Instance details

Methods

(>>=) :: Option a -> (a -> Option b) -> Option b #

(>>) :: Option a -> Option b -> Option b #

return :: a -> Option a #

fail :: String -> Option a #

Monad Identity

Since: 4.8.0.0

Instance details

Methods

(>>=) :: Identity a -> (a -> Identity b) -> Identity b #

(>>) :: Identity a -> Identity b -> Identity b #

return :: a -> Identity a #

fail :: String -> Identity a #

Monad STM

Since: 4.3.0.0

Instance details

Methods

(>>=) :: STM a -> (a -> STM b) -> STM b #

(>>) :: STM a -> STM b -> STM b #

return :: a -> STM a #

fail :: String -> STM a #

Monad First 
Instance details

Methods

(>>=) :: First a -> (a -> First b) -> First b #

(>>) :: First a -> First b -> First b #

return :: a -> First a #

fail :: String -> First a #

Monad Last 
Instance details

Methods

(>>=) :: Last a -> (a -> Last b) -> Last b #

(>>) :: Last a -> Last b -> Last b #

return :: a -> Last a #

fail :: String -> Last a #

Monad Dual

Since: 4.8.0.0

Instance details

Methods

(>>=) :: Dual a -> (a -> Dual b) -> Dual b #

(>>) :: Dual a -> Dual b -> Dual b #

return :: a -> Dual a #

fail :: String -> Dual a #

Monad Sum

Since: 4.8.0.0

Instance details

Methods

(>>=) :: Sum a -> (a -> Sum b) -> Sum b #

(>>) :: Sum a -> Sum b -> Sum b #

return :: a -> Sum a #

fail :: String -> Sum a #

Monad Product

Since: 4.8.0.0

Instance details

Methods

(>>=) :: Product a -> (a -> Product b) -> Product b #

(>>) :: Product a -> Product b -> Product b #

return :: a -> Product a #

fail :: String -> Product a #

Monad Down

Since: 4.11.0.0

Instance details

Methods

(>>=) :: Down a -> (a -> Down b) -> Down b #

(>>) :: Down a -> Down b -> Down b #

return :: a -> Down a #

fail :: String -> Down a #

Monad ReadPrec

Since: 2.1

Instance details

Methods

(>>=) :: ReadPrec a -> (a -> ReadPrec b) -> ReadPrec b #

(>>) :: ReadPrec a -> ReadPrec b -> ReadPrec b #

return :: a -> ReadPrec a #

fail :: String -> ReadPrec a #

Monad ReadP

Since: 2.1

Instance details

Methods

(>>=) :: ReadP a -> (a -> ReadP b) -> ReadP b #

(>>) :: ReadP a -> ReadP b -> ReadP b #

return :: a -> ReadP a #

fail :: String -> ReadP a #

Monad NonEmpty

Since: 4.9.0.0

Instance details

Methods

(>>=) :: NonEmpty a -> (a -> NonEmpty b) -> NonEmpty b #

(>>) :: NonEmpty a -> NonEmpty b -> NonEmpty b #

return :: a -> NonEmpty a #

fail :: String -> NonEmpty a #

Monad Put 
Instance details

Methods

(>>=) :: Put a -> (a -> Put b) -> Put b #

(>>) :: Put a -> Put b -> Put b #

return :: a -> Put a #

fail :: String -> Put a #

Monad Tree 
Instance details

Methods

(>>=) :: Tree a -> (a -> Tree b) -> Tree b #

(>>) :: Tree a -> Tree b -> Tree b #

return :: a -> Tree a #

fail :: String -> Tree a #

Monad Seq 
Instance details

Methods

(>>=) :: Seq a -> (a -> Seq b) -> Seq b #

(>>) :: Seq a -> Seq b -> Seq b #

return :: a -> Seq a #

fail :: String -> Seq a #

Monad ParseResult 
Instance details

Methods

(>>=) :: ParseResult a -> (a -> ParseResult b) -> ParseResult b #

(>>) :: ParseResult a -> ParseResult b -> ParseResult b #

return :: a -> ParseResult a #

fail :: String -> ParseResult a #

Monad P 
Instance details

Methods

(>>=) :: P a -> (a -> P b) -> P b #

(>>) :: P a -> P b -> P b #

return :: a -> P a #

fail :: String -> P a #

Monad P

Since: 2.1

Instance details

Methods

(>>=) :: P a -> (a -> P b) -> P b #

(>>) :: P a -> P b -> P b #

return :: a -> P a #

fail :: String -> P a #

Monad DList 
Instance details

Methods

(>>=) :: DList a -> (a -> DList b) -> DList b #

(>>) :: DList a -> DList b -> DList b #

return :: a -> DList a #

fail :: String -> DList a #

Monad Result 
Instance details

Methods

(>>=) :: Result a -> (a -> Result b) -> Result b #

(>>) :: Result a -> Result b -> Result b #

return :: a -> Result a #

fail :: String -> Result a #

Monad IResult 
Instance details

Methods

(>>=) :: IResult a -> (a -> IResult b) -> IResult b #

(>>) :: IResult a -> IResult b -> IResult b #

return :: a -> IResult a #

fail :: String -> IResult a #

Monad Parser 
Instance details

Methods

(>>=) :: Parser a -> (a -> Parser b) -> Parser b #

(>>) :: Parser a -> Parser b -> Parser b #

return :: a -> Parser a #

fail :: String -> Parser a #

Monad Vector 
Instance details

Methods

(>>=) :: Vector a -> (a -> Vector b) -> Vector b #

(>>) :: Vector a -> Vector b -> Vector b #

return :: a -> Vector a #

fail :: String -> Vector a #

Monad Id 
Instance details

Methods

(>>=) :: Id a -> (a -> Id b) -> Id b #

(>>) :: Id a -> Id b -> Id b #

return :: a -> Id a #

fail :: String -> Id a #

Monad Array 
Instance details

Methods

(>>=) :: Array a -> (a -> Array b) -> Array b #

(>>) :: Array a -> Array b -> Array b #

return :: a -> Array a #

fail :: String -> Array a #

Monad Box 
Instance details

Methods

(>>=) :: Box a -> (a -> Box b) -> Box b #

(>>) :: Box a -> Box b -> Box b #

return :: a -> Box a #

fail :: String -> Box a #

Monad SmallArray 
Instance details

Methods

(>>=) :: SmallArray a -> (a -> SmallArray b) -> SmallArray b #

(>>) :: SmallArray a -> SmallArray b -> SmallArray b #

return :: a -> SmallArray a #

fail :: String -> SmallArray a #

Monad Fay # 
Instance details

Methods

(>>=) :: Fay a -> (a -> Fay b) -> Fay b #

(>>) :: Fay a -> Fay b -> Fay b #

return :: a -> Fay a #

fail :: String -> Fay a #

Monad Compile # 
Instance details

Methods

(>>=) :: Compile a -> (a -> Compile b) -> Compile b #

(>>) :: Compile a -> Compile b -> Compile b #

return :: a -> Compile a #

fail :: String -> Compile a #

Monad EP 
Instance details

Methods

(>>=) :: EP a -> (a -> EP b) -> EP b #

(>>) :: EP a -> EP b -> EP b #

return :: a -> EP a #

fail :: String -> EP a #

Monad (Either e)

Since: 4.4.0.0

Instance details

Methods

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

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

return :: a -> Either e a #

fail :: String -> Either e a #

Monad (U1 :: * -> *)

Since: 4.9.0.0

Instance details

Methods

(>>=) :: U1 a -> (a -> U1 b) -> U1 b #

(>>) :: U1 a -> U1 b -> U1 b #

return :: a -> U1 a #

fail :: String -> U1 a #

Monoid a => Monad ((,) a)

Since: 4.9.0.0

Instance details

Methods

(>>=) :: (a, a0) -> (a0 -> (a, b)) -> (a, b) #

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

return :: a0 -> (a, a0) #

fail :: String -> (a, a0) #

Monad (ST s)

Since: 2.1

Instance details

Methods

(>>=) :: ST s a -> (a -> ST s b) -> ST s b #

(>>) :: ST s a -> ST s b -> ST s b #

return :: a -> ST s a #

fail :: String -> ST s a #

Monad m => Monad (WrappedMonad m) 
Instance details

Methods

(>>=) :: WrappedMonad m a -> (a -> WrappedMonad m b) -> WrappedMonad m b #

(>>) :: WrappedMonad m a -> WrappedMonad m b -> WrappedMonad m b #

return :: a -> WrappedMonad m a #

fail :: String -> WrappedMonad m a #

ArrowApply a => Monad (ArrowMonad a)

Since: 2.1

Instance details

Methods

(>>=) :: ArrowMonad a a0 -> (a0 -> ArrowMonad a b) -> ArrowMonad a b #

(>>) :: ArrowMonad a a0 -> ArrowMonad a b -> ArrowMonad a b #

return :: a0 -> ArrowMonad a a0 #

fail :: String -> ArrowMonad a a0 #

Monad (Proxy :: * -> *)

Since: 4.7.0.0

Instance details

Methods

(>>=) :: Proxy a -> (a -> Proxy b) -> Proxy b #

(>>) :: Proxy a -> Proxy b -> Proxy b #

return :: a -> Proxy a #

fail :: String -> Proxy a #

Monad m => Monad (ListT m) 
Instance details

Methods

(>>=) :: ListT m a -> (a -> ListT m b) -> ListT m b #

(>>) :: ListT m a -> ListT m b -> ListT m b #

return :: a -> ListT m a #

fail :: String -> ListT m a #

Monad m => Monad (MaybeT m) 
Instance details

Methods

(>>=) :: MaybeT m a -> (a -> MaybeT m b) -> MaybeT m b #

(>>) :: MaybeT m a -> MaybeT m b -> MaybeT m b #

return :: a -> MaybeT m a #

fail :: String -> MaybeT m a #

Monad (Lex r) 
Instance details

Methods

(>>=) :: Lex r a -> (a -> Lex r b) -> Lex r b #

(>>) :: Lex r a -> Lex r b -> Lex r b #

return :: a -> Lex r a #

fail :: String -> Lex r a #

Monad (Parser i) 
Instance details

Methods

(>>=) :: Parser i a -> (a -> Parser i b) -> Parser i b #

(>>) :: Parser i a -> Parser i b -> Parser i b #

return :: a -> Parser i a #

fail :: String -> Parser i a #

Monad (DocM s) 
Instance details

Methods

(>>=) :: DocM s a -> (a -> DocM s b) -> DocM s b #

(>>) :: DocM s a -> DocM s b -> DocM s b #

return :: a -> DocM s a #

fail :: String -> DocM s a #

Monad (SetM s) 
Instance details

Methods

(>>=) :: SetM s a -> (a -> SetM s b) -> SetM s b #

(>>) :: SetM s a -> SetM s b -> SetM s b #

return :: a -> SetM s a #

fail :: String -> SetM s a #

Monad f => Monad (Rec1 f)

Since: 4.9.0.0

Instance details

Methods

(>>=) :: Rec1 f a -> (a -> Rec1 f b) -> Rec1 f b #

(>>) :: Rec1 f a -> Rec1 f b -> Rec1 f b #

return :: a -> Rec1 f a #

fail :: String -> Rec1 f a #

Monad f => Monad (Alt f) 
Instance details

Methods

(>>=) :: Alt f a -> (a -> Alt f b) -> Alt f b #

(>>) :: Alt f a -> Alt f b -> Alt f b #

return :: a -> Alt f a #

fail :: String -> Alt f a #

(Applicative f, Monad f) => Monad (WhenMissing f x)

Equivalent to ReaderT k (ReaderT x (MaybeT f)).

Since: 0.5.9

Instance details

Methods

(>>=) :: WhenMissing f x a -> (a -> WhenMissing f x b) -> WhenMissing f x b #

(>>) :: WhenMissing f x a -> WhenMissing f x b -> WhenMissing f x b #

return :: a -> WhenMissing f x a #

fail :: String -> WhenMissing f x a #

Monad m => Monad (IdentityT m) 
Instance details

Methods

(>>=) :: IdentityT m a -> (a -> IdentityT m b) -> IdentityT m b #

(>>) :: IdentityT m a -> IdentityT m b -> IdentityT m b #

return :: a -> IdentityT m a #

fail :: String -> IdentityT m a #

(Monad m, Error e) => Monad (ErrorT e m) 
Instance details

Methods

(>>=) :: ErrorT e m a -> (a -> ErrorT e m b) -> ErrorT e m b #

(>>) :: ErrorT e m a -> ErrorT e m b -> ErrorT e m b #

return :: a -> ErrorT e m a #

fail :: String -> ErrorT e m a #

Monad m => Monad (ExceptT e m) 
Instance details

Methods

(>>=) :: ExceptT e m a -> (a -> ExceptT e m b) -> ExceptT e m b #

(>>) :: ExceptT e m a -> ExceptT e m b -> ExceptT e m b #

return :: a -> ExceptT e m a #

fail :: String -> ExceptT e m a #

Monad m => Monad (StateT s m) 
Instance details

Methods

(>>=) :: StateT s m a -> (a -> StateT s m b) -> StateT s m b #

(>>) :: StateT s m a -> StateT s m b -> StateT s m b #

return :: a -> StateT s m a #

fail :: String -> StateT s m a #

Monad m => Monad (StateT s m) 
Instance details

Methods

(>>=) :: StateT s m a -> (a -> StateT s m b) -> StateT s m b #

(>>) :: StateT s m a -> StateT s m b -> StateT s m b #

return :: a -> StateT s m a #

fail :: String -> StateT s m a #

(Monoid w, Monad m) => Monad (WriterT w m) 
Instance details

Methods

(>>=) :: WriterT w m a -> (a -> WriterT w m b) -> WriterT w m b #

(>>) :: WriterT w m a -> WriterT w m b -> WriterT w m b #

return :: a -> WriterT w m a #

fail :: String -> WriterT w m a #

(Monoid w, Monad m) => Monad (WriterT w m) 
Instance details

Methods

(>>=) :: WriterT w m a -> (a -> WriterT w m b) -> WriterT w m b #

(>>) :: WriterT w m a -> WriterT w m b -> WriterT w m b #

return :: a -> WriterT w m a #

fail :: String -> WriterT w m a #

Monad (Tagged s) 
Instance details

Methods

(>>=) :: Tagged s a -> (a -> Tagged s b) -> Tagged s b #

(>>) :: Tagged s a -> Tagged s b -> Tagged s b #

return :: a -> Tagged s a #

fail :: String -> Tagged s a #

Monad ((->) r :: * -> *)

Since: 2.1

Instance details

Methods

(>>=) :: (r -> a) -> (a -> r -> b) -> r -> b #

(>>) :: (r -> a) -> (r -> b) -> r -> b #

return :: a -> r -> a #

fail :: String -> r -> a #

(Monad f, Monad g) => Monad (f :*: g)

Since: 4.9.0.0

Instance details

Methods

(>>=) :: (f :*: g) a -> (a -> (f :*: g) b) -> (f :*: g) b #

(>>) :: (f :*: g) a -> (f :*: g) b -> (f :*: g) b #

return :: a -> (f :*: g) a #

fail :: String -> (f :*: g) a #

(Monad f, Monad g) => Monad (Product f g)

Since: 4.9.0.0

Instance details

Methods

(>>=) :: Product f g a -> (a -> Product f g b) -> Product f g b #

(>>) :: Product f g a -> Product f g b -> Product f g b #

return :: a -> Product f g a #

fail :: String -> Product f g a #

(Monad f, Applicative f) => Monad (WhenMatched f x y)

Equivalent to ReaderT Key (ReaderT x (ReaderT y (MaybeT f)))

Since: 0.5.9

Instance details

Methods

(>>=) :: WhenMatched f x y a -> (a -> WhenMatched f x y b) -> WhenMatched f x y b #

(>>) :: WhenMatched f x y a -> WhenMatched f x y b -> WhenMatched f x y b #

return :: a -> WhenMatched f x y a #

fail :: String -> WhenMatched f x y a #

(Applicative f, Monad f) => Monad (WhenMissing f k x)

Equivalent to ReaderT k (ReaderT x (MaybeT f)) .

Since: 0.5.9

Instance details

Methods

(>>=) :: WhenMissing f k x a -> (a -> WhenMissing f k x b) -> WhenMissing f k x b #

(>>) :: WhenMissing f k x a -> WhenMissing f k x b -> WhenMissing f k x b #

return :: a -> WhenMissing f k x a #

fail :: String -> WhenMissing f k x a #

Monad (ContT r m) 
Instance details

Methods

(>>=) :: ContT r m a -> (a -> ContT r m b) -> ContT r m b #

(>>) :: ContT r m a -> ContT r m b -> ContT r m b #

return :: a -> ContT r m a #

fail :: String -> ContT r m a #

Monad m => Monad (ReaderT r m) 
Instance details

Methods

(>>=) :: ReaderT r m a -> (a -> ReaderT r m b) -> ReaderT r m b #

(>>) :: ReaderT r m a -> ReaderT r m b -> ReaderT r m b #

return :: a -> ReaderT r m a #

fail :: String -> ReaderT r m a #

Monad (ParsecT s u m) 
Instance details

Methods

(>>=) :: ParsecT s u m a -> (a -> ParsecT s u m b) -> ParsecT s u m b #

(>>) :: ParsecT s u m a -> ParsecT s u m b -> ParsecT s u m b #

return :: a -> ParsecT s u m a #

fail :: String -> ParsecT s u m a #

Monad f => Monad (M1 i c f)

Since: 4.9.0.0

Instance details

Methods

(>>=) :: M1 i c f a -> (a -> M1 i c f b) -> M1 i c f b #

(>>) :: M1 i c f a -> M1 i c f b -> M1 i c f b #

return :: a -> M1 i c f a #

fail :: String -> M1 i c f a #

(Monad f, Applicative f) => Monad (WhenMatched f k x y)

Equivalent to ReaderT k (ReaderT x (ReaderT y (MaybeT f)))

Since: 0.5.9

Instance details

Methods

(>>=) :: WhenMatched f k x y a -> (a -> WhenMatched f k x y b) -> WhenMatched f k x y b #

(>>) :: WhenMatched f k x y a -> WhenMatched f k x y b -> WhenMatched f k x y b #

return :: a -> WhenMatched f k x y a #

fail :: String -> WhenMatched f k x y a #

(Monoid w, Monad m) => Monad (RWST r w s m) 
Instance details

Methods

(>>=) :: RWST r w s m a -> (a -> RWST r w s m b) -> RWST r w s m b #

(>>) :: RWST r w s m a -> RWST r w s m b -> RWST r w s m b #

return :: a -> RWST r w s m a #

fail :: String -> RWST r w s m a #

(Monoid w, Monad m) => Monad (RWST r w s m) 
Instance details

Methods

(>>=) :: RWST r w s m a -> (a -> RWST r w s m b) -> RWST r w s m b #

(>>) :: RWST r w s m a -> RWST r w s m b -> RWST r w s m b #

return :: a -> RWST r w s m a #

fail :: String -> RWST r w s m a #

class Functor (f :: * -> *) where #

The Functor class is used for types that can be mapped over. Instances of Functor should satisfy the following laws:

fmap id  ==  id
fmap (f . g)  ==  fmap f . fmap g

The instances of Functor for lists, Maybe and IO satisfy these laws.

Minimal complete definition

fmap

Methods

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

(<$) :: 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.

Instances
Functor []

Since: 2.1

Instance details

Methods

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

(<$) :: a -> [b] -> [a] #

Functor Maybe

Since: 2.1

Instance details

Methods

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

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

Functor IO

Since: 2.1

Instance details

Methods

fmap :: (a -> b) -> IO a -> IO b #

(<$) :: a -> IO b -> IO a #

Functor Par1 
Instance details

Methods

fmap :: (a -> b) -> Par1 a -> Par1 b #

(<$) :: a -> Par1 b -> Par1 a #

Functor Q 
Instance details

Methods

fmap :: (a -> b) -> Q a -> Q b #

(<$) :: a -> Q b -> Q a #

Functor Complex 
Instance details

Methods

fmap :: (a -> b) -> Complex a -> Complex b #

(<$) :: a -> Complex b -> Complex a #

Functor Min

Since: 4.9.0.0

Instance details

Methods

fmap :: (a -> b) -> Min a -> Min b #

(<$) :: a -> Min b -> Min a #

Functor Max

Since: 4.9.0.0

Instance details

Methods

fmap :: (a -> b) -> Max a -> Max b #

(<$) :: a -> Max b -> Max a #

Functor First

Since: 4.9.0.0

Instance details

Methods

fmap :: (a -> b) -> First a -> First b #

(<$) :: a -> First b -> First a #

Functor Last

Since: 4.9.0.0

Instance details

Methods

fmap :: (a -> b) -> Last a -> Last b #

(<$) :: a -> Last b -> Last a #

Functor Option

Since: 4.9.0.0

Instance details

Methods

fmap :: (a -> b) -> Option a -> Option b #

(<$) :: a -> Option b -> Option a #

Functor ZipList 
Instance details

Methods

fmap :: (a -> b) -> ZipList a -> ZipList b #

(<$) :: a -> ZipList b -> ZipList a #

Functor Identity

Since: 4.8.0.0

Instance details

Methods

fmap :: (a -> b) -> Identity a -> Identity b #

(<$) :: a -> Identity b ->