Safe Haskell	Safe-Inferred
Language	Haskell2010

Incipit.Base

Description

Reexports from base.

Synopsis

class Functor f => Applicative (f :: Type -> Type) where
- pure :: a -> f a
- (<*>) :: f (a -> b) -> f a -> f b
- liftA2 :: (a -> b -> c) -> f a -> f b -> f c
- (*>) :: f a -> f b -> f b
- (<*) :: f a -> f b -> f a
newtype ZipList a = ZipList {
- getZipList :: [a]
}
optional :: Alternative f => f a -> f (Maybe a)
newtype Const a (b :: k) = Const {
- getConst :: a
}
class Applicative f => Alternative (f :: Type -> Type) where
- empty :: f a
- (<|>) :: f a -> f a -> f a
- some :: f a -> f [a]
- many :: f a -> f [a]
liftA3 :: Applicative f => (a -> b -> c -> d) -> f a -> f b -> f c -> f d
(<**>) :: Applicative f => f a -> f (a -> b) -> f b
(&&&) :: Arrow a => a b c -> a b c' -> a b (c, c')
(>>>) :: forall {k} cat (a :: k) (b :: k) (c :: k). Category cat => cat a b -> cat b c -> cat a c
(<<<) :: forall {k} cat (b :: k) (c :: k) (a :: k). Category cat => cat b c -> cat a b -> cat a c
module Control.Concurrent.MVar
class (Typeable e, Show e) => Exception e
data SomeException = Exception e => SomeException e
guard :: Alternative f => Bool -> f ()
join :: Monad m => m (m a) -> m a
class Applicative m => Monad (m :: Type -> Type) where
- (>>=) :: m a -> (a -> m b) -> m b
- (>>) :: m a -> m b -> m b
zipWithM_ :: Applicative m => (a -> b -> m c) -> [a] -> [b] -> m ()
zipWithM :: Applicative m => (a -> b -> m c) -> [a] -> [b] -> m [c]
unless :: Applicative f => Bool -> f () -> f ()
replicateM_ :: Applicative m => Int -> m a -> m ()
replicateM :: Applicative m => Int -> m a -> m [a]
mfilter :: MonadPlus m => (a -> Bool) -> m a -> m a
forever :: Applicative f => f a -> f b
filterM :: Applicative m => (a -> m Bool) -> [a] -> m [a]
(>=>) :: Monad m => (a -> m b) -> (b -> m c) -> a -> m c
(<=<) :: Monad m => (b -> m c) -> (a -> m b) -> a -> m c
(<$!>) :: Monad m => (a -> b) -> m a -> m b
class (Alternative m, Monad m) => MonadPlus (m :: Type -> Type) where
- mzero :: m a
- mplus :: m a -> m a -> m a
when :: Applicative f => Bool -> f () -> f ()
(=<<) :: Monad m => (a -> m b) -> m a -> m b
class Monad m => MonadFail (m :: Type -> Type) where
- fail :: String -> m a
module Control.Monad.IO.Class
class Bifunctor (p :: Type -> Type -> Type) where
- bimap :: (a -> b) -> (c -> d) -> p a c -> p b d
- first :: (a -> b) -> p a c -> p b c
- second :: (b -> c) -> p a b -> p a c
xor :: Bits a => a -> a -> a
toIntegralSized :: (Integral a, Integral b, Bits a, Bits b) => a -> Maybe b
otherwise :: Bool
data Bool
- = False
- | True
bool :: a -> a -> Bool -> a
(&&) :: Bool -> Bool -> Bool
not :: Bool -> Bool
(||) :: Bool -> Bool -> Bool
data Char
chr :: Int -> Char
coerce :: forall {k :: RuntimeRep} (a :: TYPE k) (b :: TYPE k). Coercible a b => a -> b
class a ~R# b => Coercible (a :: k) (b :: k)
module Data.Either
class Eq a where
- (==) :: a -> a -> Bool
- (/=) :: a -> a -> Bool
class Foldable (t :: Type -> Type) where
- fold :: Monoid m => t m -> m
- foldMap :: Monoid m => (a -> m) -> t a -> m
- foldMap' :: Monoid m => (a -> m) -> t a -> m
- foldr :: (a -> b -> b) -> b -> t a -> b
- foldr' :: (a -> b -> b) -> b -> t a -> b
- foldl' :: (b -> a -> b) -> b -> t a -> b
- foldr1 :: (a -> a -> a) -> t a -> a
- foldl1 :: (a -> a -> a) -> t a -> a
- toList :: t a -> [a]
- null :: t a -> Bool
- length :: t a -> Int
- elem :: Eq a => a -> t a -> Bool
- maximum :: Ord a => t a -> a
- minimum :: Ord a => t a -> a
- sum :: Num a => t a -> a
- product :: Num a => t a -> a
traverse_ :: (Foldable t, Applicative f) => (a -> f b) -> t a -> f ()
sequence_ :: (Foldable t, Monad m) => t (m a) -> m ()
sequenceA_ :: (Foldable t, Applicative f) => t (f a) -> f ()
or :: Foldable t => t Bool -> Bool
mapM_ :: (Foldable t, Monad m) => (a -> m b) -> t a -> m ()
for_ :: (Foldable t, Applicative f) => t a -> (a -> f b) -> f ()
forM_ :: (Foldable t, Monad m) => t a -> (a -> m b) -> m ()
foldlM :: (Foldable t, Monad m) => (b -> a -> m b) -> b -> t a -> m b
find :: Foldable t => (a -> Bool) -> t a -> Maybe a
concatMap :: Foldable t => (a -> [b]) -> t a -> [b]
concat :: Foldable t => t [a] -> [a]
asum :: (Foldable t, Alternative f) => t (f a) -> f a
any :: Foldable t => (a -> Bool) -> t a -> Bool
and :: Foldable t => t Bool -> Bool
all :: Foldable t => (a -> Bool) -> t a -> Bool
($) :: forall (r :: RuntimeRep) a (b :: TYPE r). (a -> b) -> a -> b
on :: (b -> b -> c) -> (a -> b) -> a -> a -> c
fix :: (a -> a) -> a
(&) :: a -> (a -> b) -> b
id :: a -> a
flip :: (a -> b -> c) -> b -> a -> c
const :: a -> b -> a
(.) :: (b -> c) -> (a -> b) -> a -> c
class Functor (f :: Type -> Type) where
- fmap :: (a -> b) -> f a -> f b
- (<$) :: a -> f b -> f a
void :: Functor f => f a -> f ()
(<&>) :: Functor f => f a -> (a -> b) -> f b
(<$>) :: Functor f => (a -> b) -> f a -> f b
($>) :: Functor f => f a -> b -> f b
newtype Compose (f :: k -> Type) (g :: k1 -> k) (a :: k1) = Compose {
- getCompose :: f (g a)
}
class Contravariant (f :: Type -> Type) where
- contramap :: (a' -> a) -> f a -> f a'
- (>$) :: b -> f b -> f a
(>$<) :: Contravariant f => (a -> b) -> f b -> f a
newtype Identity a = Identity {
- runIdentity :: a
}
data Int
data Int8
data Int16
data Int32
data Int64
type Type = Type
data Constraint
(++) :: [a] -> [a] -> [a]
filter :: (a -> Bool) -> [a] -> [a]
zip :: [a] -> [b] -> [(a, b)]
map :: (a -> b) -> [a] -> [b]
unfoldr :: (b -> Maybe (a, b)) -> b -> [a]
transpose :: [[a]] -> [[a]]
tails :: [a] -> [[a]]
subsequences :: [a] -> [[a]]
sortOn :: Ord b => (a -> b) -> [a] -> [a]
sortBy :: (a -> a -> Ordering) -> [a] -> [a]
sort :: Ord a => [a] -> [a]
permutations :: [a] -> [[a]]
isPrefixOf :: Eq a => [a] -> [a] -> Bool
intersperse :: a -> [a] -> [a]
intercalate :: [a] -> [[a]] -> [a]
inits :: [a] -> [[a]]
group :: Eq a => [a] -> [[a]]
genericTake :: Integral i => i -> [a] -> [a]
genericSplitAt :: Integral i => i -> [a] -> ([a], [a])
genericReplicate :: Integral i => i -> a -> [a]
genericLength :: Num i => [a] -> i
genericDrop :: Integral i => i -> [a] -> [a]
zipWith :: (a -> b -> c) -> [a] -> [b] -> [c]
zip3 :: [a] -> [b] -> [c] -> [(a, b, c)]
unzip3 :: [(a, b, c)] -> ([a], [b], [c])
unzip :: [(a, b)] -> ([a], [b])
uncons :: [a] -> Maybe (a, [a])
takeWhile :: (a -> Bool) -> [a] -> [a]
take :: Int -> [a] -> [a]
splitAt :: Int -> [a] -> ([a], [a])
span :: (a -> Bool) -> [a] -> ([a], [a])
scanr1 :: (a -> a -> a) -> [a] -> [a]
scanr :: (a -> b -> b) -> b -> [a] -> [b]
scanl1 :: (a -> a -> a) -> [a] -> [a]
scanl' :: (b -> a -> b) -> b -> [a] -> [b]
scanl :: (b -> a -> b) -> b -> [a] -> [b]
reverse :: [a] -> [a]
replicate :: Int -> a -> [a]
repeat :: a -> [a]
iterate :: (a -> a) -> a -> [a]
dropWhile :: (a -> Bool) -> [a] -> [a]
drop :: Int -> [a] -> [a]
break :: (a -> Bool) -> [a] -> ([a], [a])
nonEmpty :: [a] -> Maybe (NonEmpty a)
data NonEmpty a = a :| [a]
data Maybe a
- = Nothing
- | Just a
maybeToList :: Maybe a -> [a]
maybe :: b -> (a -> b) -> Maybe a -> b
mapMaybe :: (a -> Maybe b) -> [a] -> [b]
listToMaybe :: [a] -> Maybe a
isNothing :: Maybe a -> Bool
isJust :: Maybe a -> Bool
fromMaybe :: a -> Maybe a -> a
catMaybes :: [Maybe a] -> [a]
class Semigroup a => Monoid a where
- mempty :: a
- mappend :: a -> a -> a
- mconcat :: [a] -> a
class Eq a => Ord a where
- compare :: a -> a -> Ordering
- (<) :: a -> a -> Bool
- (<=) :: a -> a -> Bool
- (>) :: a -> a -> Bool
- (>=) :: a -> a -> Bool
- max :: a -> a -> a
- min :: a -> a -> a
data Ordering
- = LT
- | EQ
- | GT
newtype Down a = Down {
- getDown :: a
}
comparing :: Ord a => (b -> a) -> b -> b -> Ordering
data Proxy (t :: k) = Proxy
class Semigroup a where
- (<>) :: a -> a -> a
- sconcat :: NonEmpty a -> a
- stimes :: Integral b => b -> a -> a
class (Functor t, Foldable t) => Traversable (t :: Type -> Type) where
- traverse :: Applicative f => (a -> f b) -> t a -> f (t b)
- sequenceA :: Applicative f => t (f a) -> f (t a)
- mapM :: Monad m => (a -> m b) -> t a -> m (t b)
- sequence :: Monad m => t (m a) -> m (t a)
mapAccumR :: Traversable t => (s -> a -> (s, b)) -> s -> t a -> (s, t b)
mapAccumL :: Traversable t => (s -> a -> (s, b)) -> s -> t a -> (s, t b)
forM :: (Traversable t, Monad m) => t a -> (a -> m b) -> m (t b)
for :: (Traversable t, Applicative f) => t a -> (a -> f b) -> f (t b)
fst :: (a, b) -> a
snd :: (a, b) -> b
uncurry :: (a -> b -> c) -> (a, b) -> c
swap :: (a, b) -> (b, a)
curry :: ((a, b) -> c) -> a -> b -> c
class Typeable (a :: k)
data Void
data Word
data Word8
data Word16
data Word32
data Word64
seq :: forall {r :: RuntimeRep} a (b :: TYPE r). a -> b -> b
ord :: Char -> Int
minInt :: Int
maxInt :: Int
($!) :: forall (r :: RuntimeRep) a (b :: TYPE r). (a -> b) -> a -> b
class Bounded a where
- minBound :: a
- maxBound :: a
class Enum a where
- succ :: a -> a
- pred :: a -> a
- toEnum :: Int -> a
- fromEnum :: a -> Int
- enumFrom :: a -> [a]
- enumFromThen :: a -> a -> [a]
- enumFromTo :: a -> a -> [a]
- enumFromThenTo :: a -> a -> a -> [a]
undefined :: forall (r :: RuntimeRep) (a :: TYPE r). HasCallStack => a
error :: forall (r :: RuntimeRep) (a :: TYPE r). HasCallStack => [Char] -> a
data Double = D# Double#
data Float = F# Float#
class Generic a
class Num a where
- (+) :: a -> a -> a
- (-) :: a -> a -> a
- (*) :: a -> a -> a
- negate :: a -> a
- abs :: a -> a
- signum :: a -> a
- fromInteger :: Integer -> a
data Integer
subtract :: Num a => a -> a -> a
class IsLabel (x :: Symbol) a where
- fromLabel :: a
fromIntegral :: (Integral a, Num b) => a -> b
realToFrac :: (Real a, Fractional b) => a -> b
class Num a => Fractional a where
- (/) :: a -> a -> a
- recip :: a -> a
- fromRational :: Rational -> a
class (Real a, Enum a) => Integral a where
- toInteger :: a -> Integer
class (Num a, Ord a) => Real a where
- toRational :: a -> Rational
class (Real a, Fractional a) => RealFrac a where
- properFraction :: Integral b => a -> (b, a)
- truncate :: Integral b => a -> b
- round :: Integral b => a -> b
- ceiling :: Integral b => a -> b
- floor :: Integral b => a -> b
data Ratio a
type Rational = Ratio Integer
odd :: Integral a => a -> Bool
numerator :: Ratio a -> a
lcm :: Integral a => a -> a -> a
gcd :: Integral a => a -> a -> a
even :: Integral a => a -> Bool
denominator :: Ratio a -> a
(^^) :: (Fractional a, Integral b) => a -> b -> a
(^) :: (Num a, Integral b) => a -> b -> a
class Show a
type HasCallStack = ?callStack :: CallStack
class KnownNat (n :: Nat)
class KnownSymbol (n :: Symbol)
data Nat
data Symbol
type family (a :: Nat) + (b :: Nat) :: Nat where ...
type family (a :: Nat) * (b :: Nat) :: Nat where ...
type family (a :: Nat) ^ (b :: Nat) :: Nat where ...
type family (a :: Nat) <=? (b :: Nat) :: Bool where ...
type family (a :: Nat) - (b :: Nat) :: Nat where ...
type family CmpSymbol (a :: Symbol) (b :: Symbol) :: Ordering where ...
type family CmpNat (a :: Nat) (b :: Nat) :: Ordering where ...
type family Div (a :: Nat) (b :: Nat) :: Nat where ...
type family Mod (a :: Nat) (b :: Nat) :: Nat where ...
type family Log2 (a :: Nat) :: Nat where ...
type family TypeError (a :: ErrorMessage) :: b where ...
type family AppendSymbol (a :: Symbol) (b :: Symbol) :: Symbol where ...
data SomeSymbol = KnownSymbol n => SomeSymbol (Proxy n)
pattern ShowType :: t -> ErrorMessage
pattern (:<>:) :: ErrorMessage -> ErrorMessage -> ErrorMessage
pattern (:$$:) :: ErrorMessage -> ErrorMessage -> ErrorMessage
symbolVal' :: forall (n :: Symbol). KnownSymbol n => Proxy# n -> String
symbolVal :: forall (n :: Symbol) proxy. KnownSymbol n => proxy n -> String
someSymbolVal :: String -> SomeSymbol
someNatVal :: Integer -> Maybe SomeNat
sameSymbol :: forall (a :: Symbol) (b :: Symbol) proxy1 proxy2. (KnownSymbol a, KnownSymbol b) => proxy1 a -> proxy2 b -> Maybe (a :~: b)
natVal' :: forall (n :: Nat). KnownNat n => Proxy# n -> Integer
natVal :: forall (n :: Nat) proxy. KnownNat n => proxy n -> Integer
data SomeNat = KnownNat n => SomeNat (Proxy n)
type (<=) (x :: Nat) (y :: Nat) = (x <=? y) ~ 'True
sameNat :: forall (a :: Nat) (b :: Nat) proxy1 proxy2. (KnownNat a, KnownNat b) => proxy1 a -> proxy2 b -> Maybe (a :~: b)
module Incipit.Fixed
module Incipit.Integral
data Natural
print :: Show a => a -> IO ()
data IO a
putStrLn :: String -> IO ()
putStr :: String -> IO ()
type FilePath = String

Documentation

class Functor f => Applicative (f :: Type -> Type) where #

A functor with application, providing operations to

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

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

(<*>) = liftA2 id

liftA2 f x y = f <$> x <*> y

Further, any definition must satisfy the following:

Identity

pure id <*> v = v

Composition

pure (.) <*> u <*> v <*> w = u <*> (v <*> w)

Homomorphism

pure f <*> pure x = pure (f x)

Interchange

u <*> pure y = pure ($ y) <*> u

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

```
u *> v = (id <$ u) <*> v
```
```
u <* v = liftA2 const u v
```

As a consequence of these laws, the Functor instance for f will satisfy

```
fmap f x = pure f <*> x
```

It may be useful to note that supposing

forall x y. p (q x y) = f x . g y

it follows from the above that

liftA2 p (liftA2 q u v) = liftA2 f u . liftA2 g v

If f is also a Monad, it should satisfy

```
pure = return
```

m1 <*> m2 = m1 >>= (x1 -> m2 >>= (x2 -> return (x1 x2)))

```
(*>) = (>>)
```

(which implies that pure and <*> satisfy the applicative functor laws).

Minimal complete definition

pure, ((<*>) | liftA2)

Methods

pure :: a -> f a #

Lift a value.

(<*>) :: f (a -> b) -> f a -> f b infixl 4 #

Sequential application.

A few functors support an implementation of <*> that is more efficient than the default one.

Example

Expand

Used in combination with (<$>), (<*>) can be used to build a record.

>>> data MyState = MyState {arg1 :: Foo, arg2 :: Bar, arg3 :: Baz}

>>> produceFoo :: Applicative f => f Foo

>>> produceBar :: Applicative f => f Bar
>>> produceBaz :: Applicative f => f Baz

>>> mkState :: Applicative f => f MyState
>>> mkState = MyState <$> produceFoo <*> produceBar <*> produceBaz

liftA2 :: (a -> b -> c) -> f a -> f b -> f c #

Lift a binary function to actions.

Some functors support an implementation of liftA2 that is more efficient than the default one. In particular, if fmap is an expensive operation, it is likely better to use liftA2 than to fmap over the structure and then use <*>.

This became a typeclass method in 4.10.0.0. Prior to that, it was a function defined in terms of <*> and fmap.

Example

Expand

>>> liftA2 (,) (Just 3) (Just 5)
Just (3,5)

(*>) :: f a -> f b -> f b infixl 4 #

Sequence actions, discarding the value of the first argument.

Examples

Expand

If used in conjunction with the Applicative instance for Maybe, you can chain Maybe computations, with a possible "early return" in case of Nothing.

>>> Just 2 *> Just 3
Just 3

>>> Nothing *> Just 3
Nothing

Of course a more interesting use case would be to have effectful computations instead of just returning pure values.

>>> import Data.Char
>>> import Text.ParserCombinators.ReadP
>>> let p = string "my name is " *> munch1 isAlpha <* eof
>>> readP_to_S p "my name is Simon"
[("Simon","")]

(<*) :: f a -> f b -> f a infixl 4 #

Sequence actions, discarding the value of the second argument.

Instances

Instances details

Applicative ZipList	f <$> ZipList xs1 <> ... <> ZipList xsN = ZipList (zipWithN f xs1 ... xsN) where `zipWithN` refers to the `zipWith` function of the appropriate arity (`zipWith`, `zipWith3`, `zipWith4`, ...). For example: (\a b c -> stimes c [a, b]) <$> ZipList "abcd" <> ZipList "567" <> ZipList [1..] = ZipList (zipWith3 (\a b c -> stimes c [a, b]) "abcd" "567" [1..]) = ZipList {getZipList = ["a5","b6b6","c7c7c7"]} Since: base-2.1
Instance details Defined in Control.Applicative Methods pure :: a -> ZipList a # (<>) :: ZipList (a -> b) -> ZipList a -> ZipList b # liftA2 :: (a -> b -> c) -> ZipList a -> ZipList b -> ZipList c # (>) :: ZipList a -> ZipList b -> ZipList b # (<*) :: ZipList a -> ZipList b -> ZipList a #
Applicative Identity	Since: base-4.8.0.0
Instance details Defined in Data.Functor.Identity Methods pure :: a -> Identity a # (<>) :: Identity (a -> b) -> Identity a -> Identity b # liftA2 :: (a -> b -> c) -> Identity a -> Identity b -> Identity c # (>) :: Identity a -> Identity b -> Identity b # (<*) :: Identity a -> Identity b -> Identity a #
Applicative First	Since: base-4.8.0.0
Instance details Defined in Data.Monoid Methods pure :: a -> First a # (<>) :: First (a -> b) -> First a -> First b # liftA2 :: (a -> b -> c) -> First a -> First b -> First c # (>) :: First a -> First b -> First b # (<*) :: First a -> First b -> First a #
Applicative Last	Since: base-4.8.0.0
Instance details Defined in Data.Monoid Methods pure :: a -> Last a # (<>) :: Last (a -> b) -> Last a -> Last b # liftA2 :: (a -> b -> c) -> Last a -> Last b -> Last c # (>) :: Last a -> Last b -> Last b # (<*) :: Last a -> Last b -> Last a #
Applicative Down	Since: base-4.11.0.0
Instance details Defined in Data.Ord Methods pure :: a -> Down a # (<>) :: Down (a -> b) -> Down a -> Down b # liftA2 :: (a -> b -> c) -> Down a -> Down b -> Down c # (>) :: Down a -> Down b -> Down b # (<*) :: Down a -> Down b -> Down a #
Applicative First	Since: base-4.9.0.0
Instance details Defined in Data.Semigroup Methods pure :: a -> First a # (<>) :: First (a -> b) -> First a -> First b # liftA2 :: (a -> b -> c) -> First a -> First b -> First c # (>) :: First a -> First b -> First b # (<*) :: First a -> First b -> First a #
Applicative Last	Since: base-4.9.0.0
Instance details Defined in Data.Semigroup Methods pure :: a -> Last a # (<>) :: Last (a -> b) -> Last a -> Last b # liftA2 :: (a -> b -> c) -> Last a -> Last b -> Last c # (>) :: Last a -> Last b -> Last b # (<*) :: Last a -> Last b -> Last a #
Applicative Max	Since: base-4.9.0.0
Instance details Defined in Data.Semigroup Methods pure :: a -> Max a # (<>) :: Max (a -> b) -> Max a -> Max b # liftA2 :: (a -> b -> c) -> Max a -> Max b -> Max c # (>) :: Max a -> Max b -> Max b # (<*) :: Max a -> Max b -> Max a #
Applicative Min	Since: base-4.9.0.0
Instance details Defined in Data.Semigroup Methods pure :: a -> Min a # (<>) :: Min (a -> b) -> Min a -> Min b # liftA2 :: (a -> b -> c) -> Min a -> Min b -> Min c # (>) :: Min a -> Min b -> Min b # (<*) :: Min a -> Min b -> Min a #
Applicative Option	Since: base-4.9.0.0
Instance details Defined in Data.Semigroup Methods pure :: a -> Option a # (<>) :: Option (a -> b) -> Option a -> Option b # liftA2 :: (a -> b -> c) -> Option a -> Option b -> Option c # (>) :: Option a -> Option b -> Option b # (<*) :: Option a -> Option b -> Option a #
Applicative NonEmpty	Since: base-4.9.0.0
Instance details Defined in GHC.Base Methods pure :: a -> NonEmpty a # (<>) :: NonEmpty (a -> b) -> NonEmpty a -> NonEmpty b # liftA2 :: (a -> b -> c) -> NonEmpty a -> NonEmpty b -> NonEmpty c # (>) :: NonEmpty a -> NonEmpty b -> NonEmpty b # (<*) :: NonEmpty a -> NonEmpty b -> NonEmpty a #
Applicative Par1	Since: base-4.9.0.0
Instance details Defined in GHC.Generics Methods pure :: a -> Par1 a # (<>) :: Par1 (a -> b) -> Par1 a -> Par1 b # liftA2 :: (a -> b -> c) -> Par1 a -> Par1 b -> Par1 c # (>) :: Par1 a -> Par1 b -> Par1 b # (<*) :: Par1 a -> Par1 b -> Par1 a #
Applicative P	Since: base-4.5.0.0
Instance details Defined in Text.ParserCombinators.ReadP Methods pure :: a -> P a # (<>) :: P (a -> b) -> P a -> P b # liftA2 :: (a -> b -> c) -> P a -> P b -> P c # (>) :: P a -> P b -> P b # (<*) :: P a -> P b -> P a #
Applicative ReadP	Since: base-4.6.0.0
Instance details Defined in Text.ParserCombinators.ReadP Methods pure :: a -> ReadP a # (<>) :: ReadP (a -> b) -> ReadP a -> ReadP b # liftA2 :: (a -> b -> c) -> ReadP a -> ReadP b -> ReadP c # (>) :: ReadP a -> ReadP b -> ReadP b # (<*) :: ReadP a -> ReadP b -> ReadP a #
Applicative Seq	Since: containers-0.5.4
Instance details Defined in Data.Sequence.Internal Methods pure :: a -> Seq a # (<>) :: Seq (a -> b) -> Seq a -> Seq b # liftA2 :: (a -> b -> c) -> Seq a -> Seq b -> Seq c # (>) :: Seq a -> Seq b -> Seq b # (<*) :: Seq a -> Seq b -> Seq a #
Applicative DList
Instance details Defined in Data.DList.Internal Methods pure :: a -> DList a # (<>) :: DList (a -> b) -> DList a -> DList b # liftA2 :: (a -> b -> c) -> DList a -> DList b -> DList c # (>) :: DList a -> DList b -> DList b # (<*) :: DList a -> DList b -> DList a #
Applicative IO	Since: base-2.1
Instance details Defined in GHC.Base Methods pure :: a -> IO a # (<>) :: IO (a -> b) -> IO a -> IO b # liftA2 :: (a -> b -> c) -> IO a -> IO b -> IO c # (>) :: IO a -> IO b -> IO b # (<*) :: IO a -> IO b -> IO a #
Applicative Q
Instance details Defined in Language.Haskell.TH.Syntax Methods pure :: a -> Q a # (<>) :: Q (a -> b) -> Q a -> Q b # liftA2 :: (a -> b -> c) -> Q a -> Q b -> Q c # (>) :: Q a -> Q b -> Q b # (<*) :: Q a -> Q b -> Q a #
Applicative Maybe	Since: base-2.1
Instance details Defined in GHC.Base Methods pure :: a -> Maybe a # (<>) :: Maybe (a -> b) -> Maybe a -> Maybe b # liftA2 :: (a -> b -> c) -> Maybe a -> Maybe b -> Maybe c # (>) :: Maybe a -> Maybe b -> Maybe b # (<*) :: Maybe a -> Maybe b -> Maybe a #
Applicative Solo	Since: base-4.15
Instance details Defined in GHC.Base Methods pure :: a -> Solo a # (<>) :: Solo (a -> b) -> Solo a -> Solo b # liftA2 :: (a -> b -> c) -> Solo a -> Solo b -> Solo c # (>) :: Solo a -> Solo b -> Solo b # (<*) :: Solo a -> Solo b -> Solo a #
Applicative []	Since: base-2.1
Instance details Defined in GHC.Base Methods pure :: a -> [a] # (<>) :: [a -> b] -> [a] -> [b] # liftA2 :: (a -> b -> c) -> [a] -> [b] -> [c] # (>) :: [a] -> [b] -> [b] # (<*) :: [a] -> [b] -> [a] #
Monad m => Applicative (WrappedMonad m)	Since: base-2.1
Instance details Defined in Control.Applicative Methods pure :: a -> WrappedMonad m a # (<>) :: WrappedMonad m (a -> b) -> WrappedMonad m a -> WrappedMonad m b # liftA2 :: (a -> b -> c) -> WrappedMonad m a -> WrappedMonad m b -> WrappedMonad m c # (>) :: WrappedMonad m a -> WrappedMonad m b -> WrappedMonad m b # (<*) :: WrappedMonad m a -> WrappedMonad m b -> WrappedMonad m a #
Arrow a => Applicative (ArrowMonad a)	Since: base-4.6.0.0
Instance details Defined in Control.Arrow Methods pure :: a0 -> ArrowMonad a a0 # (<>) :: ArrowMonad a (a0 -> b) -> ArrowMonad a a0 -> ArrowMonad a b # liftA2 :: (a0 -> b -> c) -> ArrowMonad a a0 -> ArrowMonad a b -> ArrowMonad a c # (>) :: ArrowMonad a a0 -> ArrowMonad a b -> ArrowMonad a b # (<*) :: ArrowMonad a a0 -> ArrowMonad a b -> ArrowMonad a a0 #
Applicative (Either e)	Since: base-3.0
Instance details Defined in Data.Either Methods pure :: a -> Either e a # (<>) :: Either e (a -> b) -> Either e a -> Either e b # liftA2 :: (a -> b -> c) -> Either e a -> Either e b -> Either e c # (>) :: Either e a -> Either e b -> Either e b # (<*) :: Either e a -> Either e b -> Either e a #
Applicative (Proxy :: Type -> Type)	Since: base-4.7.0.0
Instance details Defined in Data.Proxy Methods pure :: a -> Proxy a # (<>) :: Proxy (a -> b) -> Proxy a -> Proxy b # liftA2 :: (a -> b -> c) -> Proxy a -> Proxy b -> Proxy c # (>) :: Proxy a -> Proxy b -> Proxy b # (<*) :: Proxy a -> Proxy b -> Proxy a #
Applicative (U1 :: Type -> Type)	Since: base-4.9.0.0
Instance details Defined in GHC.Generics Methods pure :: a -> U1 a # (<>) :: U1 (a -> b) -> U1 a -> U1 b # liftA2 :: (a -> b -> c) -> U1 a -> U1 b -> U1 c # (>) :: U1 a -> U1 b -> U1 b # (<*) :: U1 a -> U1 b -> U1 a #
Monoid a => Applicative ((,) a)	For tuples, the `Monoid` constraint on `a` determines how the first values merge. For example, `String`s concatenate: ("hello ", (+15)) <> ("world!", 2002) ("hello world!",2017) Since: base-2.1*
Instance details Defined in GHC.Base Methods pure :: a0 -> (a, a0) # (<>) :: (a, a0 -> b) -> (a, a0) -> (a, b) # liftA2 :: (a0 -> b -> c) -> (a, a0) -> (a, b) -> (a, c) # (>) :: (a, a0) -> (a, b) -> (a, b) # (<*) :: (a, a0) -> (a, b) -> (a, a0) #
Arrow a => Applicative (WrappedArrow a b)	Since: base-2.1
Instance details Defined in Control.Applicative Methods pure :: a0 -> WrappedArrow a b a0 # (<>) :: WrappedArrow a b (a0 -> b0) -> WrappedArrow a b a0 -> WrappedArrow a b b0 # liftA2 :: (a0 -> b0 -> c) -> WrappedArrow a b a0 -> WrappedArrow a b b0 -> WrappedArrow a b c # (>) :: WrappedArrow a b a0 -> WrappedArrow a b b0 -> WrappedArrow a b b0 # (<*) :: WrappedArrow a b a0 -> WrappedArrow a b b0 -> WrappedArrow a b a0 #
Applicative m => Applicative (Kleisli m a)	Since: base-4.14.0.0
Instance details Defined in Control.Arrow Methods pure :: a0 -> Kleisli m a a0 # (<>) :: Kleisli m a (a0 -> b) -> Kleisli m a a0 -> Kleisli m a b # liftA2 :: (a0 -> b -> c) -> Kleisli m a a0 -> Kleisli m a b -> Kleisli m a c # (>) :: Kleisli m a a0 -> Kleisli m a b -> Kleisli m a b # (<*) :: Kleisli m a a0 -> Kleisli m a b -> Kleisli m a a0 #
Monoid m => Applicative (Const m :: Type -> Type)	Since: base-2.0.1
Instance details Defined in Data.Functor.Const Methods pure :: a -> Const m a # (<>) :: Const m (a -> b) -> Const m a -> Const m b # liftA2 :: (a -> b -> c) -> Const m a -> Const m b -> Const m c # (>) :: Const m a -> Const m b -> Const m b # (<*) :: Const m a -> Const m b -> Const m a #
Applicative f => Applicative (Ap f)	Since: base-4.12.0.0
Instance details Defined in Data.Monoid Methods pure :: a -> Ap f a # (<>) :: Ap f (a -> b) -> Ap f a -> Ap f b # liftA2 :: (a -> b -> c) -> Ap f a -> Ap f b -> Ap f c # (>) :: Ap f a -> Ap f b -> Ap f b # (<*) :: Ap f a -> Ap f b -> Ap f a #
Applicative f => Applicative (Rec1 f)	Since: base-4.9.0.0
Instance details Defined in GHC.Generics Methods pure :: a -> Rec1 f a # (<>) :: Rec1 f (a -> b) -> Rec1 f a -> Rec1 f b # liftA2 :: (a -> b -> c) -> Rec1 f a -> Rec1 f b -> Rec1 f c # (>) :: Rec1 f a -> Rec1 f b -> Rec1 f b # (<*) :: Rec1 f a -> Rec1 f b -> Rec1 f a #
(Applicative f, Monad f) => Applicative (WhenMissing f x)	Equivalent to `ReaderT k (ReaderT x (MaybeT f))`. Since: containers-0.5.9
Instance details Defined in Data.IntMap.Internal Methods pure :: a -> WhenMissing f x a # (<>) :: WhenMissing f x (a -> b) -> WhenMissing f x a -> WhenMissing f x b # liftA2 :: (a -> b -> c) -> WhenMissing f x a -> WhenMissing f x b -> WhenMissing f x c # (>) :: WhenMissing f x a -> WhenMissing f x b -> WhenMissing f x b # (<*) :: WhenMissing f x a -> WhenMissing f x b -> WhenMissing f x a #
(Monoid a, Monoid b) => Applicative ((,,) a b)	Since: base-4.14.0.0
Instance details Defined in GHC.Base Methods pure :: a0 -> (a, b, a0) # (<>) :: (a, b, a0 -> b0) -> (a, b, a0) -> (a, b, b0) # liftA2 :: (a0 -> b0 -> c) -> (a, b, a0) -> (a, b, b0) -> (a, b, c) # (>) :: (a, b, a0) -> (a, b, b0) -> (a, b, b0) # (<*) :: (a, b, a0) -> (a, b, b0) -> (a, b, a0) #
(Applicative f, Applicative g) => Applicative (Product f g)	Since: base-4.9.0.0
Instance details Defined in Data.Functor.Product Methods pure :: a -> Product f g a # (<>) :: Product f g (a -> b) -> Product f g a -> Product f g b # liftA2 :: (a -> b -> c) -> Product f g a -> Product f g b -> Product f g c # (>) :: Product f g a -> Product f g b -> Product f g b # (<*) :: Product f g a -> Product f g b -> Product f g a #
(Applicative f, Applicative g) => Applicative (f :*: g)	Since: base-4.9.0.0
Instance details Defined in GHC.Generics Methods pure :: a -> (f :: g) a # (<>) :: (f :: g) (a -> b) -> (f :: g) a -> (f :: g) b # liftA2 :: (a -> b -> c) -> (f :: g) a -> (f :: g) b -> (f :: g) c # (>) :: (f :: g) a -> (f :: g) b -> (f :: g) b # (<) :: (f :: g) a -> (f :: g) b -> (f :: g) a #
Monoid c => Applicative (K1 i c :: Type -> Type)	Since: base-4.12.0.0
Instance details Defined in GHC.Generics Methods pure :: a -> K1 i c a # (<>) :: K1 i c (a -> b) -> K1 i c a -> K1 i c b # liftA2 :: (a -> b -> c0) -> K1 i c a -> K1 i c b -> K1 i c c0 # (>) :: K1 i c a -> K1 i c b -> K1 i c b # (<*) :: K1 i c a -> K1 i c b -> K1 i c a #
(Monad f, Applicative f) => Applicative (WhenMatched f x y)	Equivalent to `ReaderT Key (ReaderT x (ReaderT y (MaybeT f)))` Since: containers-0.5.9
Instance details Defined in Data.IntMap.Internal Methods pure :: a -> WhenMatched f x y a # (<>) :: WhenMatched f x y (a -> b) -> WhenMatched f x y a -> WhenMatched f x y b # liftA2 :: (a -> b -> c) -> WhenMatched f x y a -> WhenMatched f x y b -> WhenMatched f x y c # (>) :: WhenMatched f x y 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 a #
(Applicative f, Monad f) => Applicative (WhenMissing f k x)	Equivalent to `ReaderT k (ReaderT x (MaybeT f))` . Since: containers-0.5.9
Instance details Defined in Data.Map.Internal Methods pure :: a -> WhenMissing f k x a # (<>) :: WhenMissing f k x (a -> b) -> WhenMissing f k x a -> WhenMissing f k x b # liftA2 :: (a -> b -> c) -> WhenMissing f k x a -> WhenMissing f k x b -> WhenMissing f k x c # (>) :: WhenMissing f k x 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 a #
(Monoid a, Monoid b, Monoid c) => Applicative ((,,,) a b c)	Since: base-4.14.0.0
Instance details Defined in GHC.Base Methods pure :: a0 -> (a, b, c, a0) # (<>) :: (a, b, c, a0 -> b0) -> (a, b, c, a0) -> (a, b, c, b0) # liftA2 :: (a0 -> b0 -> c0) -> (a, b, c, a0) -> (a, b, c, b0) -> (a, b, c, c0) # (>) :: (a, b, c, a0) -> (a, b, c, b0) -> (a, b, c, b0) # (<*) :: (a, b, c, a0) -> (a, b, c, b0) -> (a, b, c, a0) #
Applicative ((->) r)	Since: base-2.1
Instance details Defined in GHC.Base Methods pure :: a -> r -> a # (<>) :: (r -> (a -> b)) -> (r -> a) -> r -> b # liftA2 :: (a -> b -> c) -> (r -> a) -> (r -> b) -> r -> c # (>) :: (r -> a) -> (r -> b) -> r -> b # (<*) :: (r -> a) -> (r -> b) -> r -> a #
(Applicative f, Applicative g) => Applicative (Compose f g)	Since: base-4.9.0.0
Instance details Defined in Data.Functor.Compose Methods pure :: a -> Compose f g a # (<>) :: Compose f g (a -> b) -> Compose f g a -> Compose f g b # liftA2 :: (a -> b -> c) -> Compose f g a -> Compose f g b -> Compose f g c # (>) :: Compose f g a -> Compose f g b -> Compose f g b # (<*) :: Compose f g a -> Compose f g b -> Compose f g a #
(Applicative f, Applicative g) => Applicative (f :.: g)	Since: base-4.9.0.0
Instance details Defined in GHC.Generics Methods pure :: a -> (f :.: g) a # (<>) :: (f :.: g) (a -> b) -> (f :.: g) a -> (f :.: g) b # liftA2 :: (a -> b -> c) -> (f :.: g) a -> (f :.: g) b -> (f :.: g) c # (>) :: (f :.: g) a -> (f :.: g) b -> (f :.: g) b # (<*) :: (f :.: g) a -> (f :.: g) b -> (f :.: g) a #
Applicative f => Applicative (M1 i c f)	Since: base-4.9.0.0
Instance details Defined in GHC.Generics Methods pure :: a -> M1 i c f a # (<>) :: M1 i c f (a -> b) -> M1 i c f a -> M1 i c f b # liftA2 :: (a -> b -> c0) -> M1 i c f a -> M1 i c f b -> M1 i c f c0 # (>) :: M1 i c f 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 a #
(Monad f, Applicative f) => Applicative (WhenMatched f k x y)	Equivalent to `ReaderT k (ReaderT x (ReaderT y (MaybeT f)))` Since: containers-0.5.9
Instance details Defined in Data.Map.Internal Methods pure :: a -> WhenMatched f k x y a # (<>) :: WhenMatched f k x y (a -> b) -> WhenMatched f k x y a -> WhenMatched f k x y b # liftA2 :: (a -> b -> c) -> WhenMatched f k x y a -> WhenMatched f k x y b -> WhenMatched f k x y c # (>) :: WhenMatched f k x y 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 a #

newtype ZipList a #

Lists, but with an Applicative functor based on zipping.

Constructors

ZipList
Fields getZipList :: [a]

Instances

Instances details

Foldable ZipList	Since: base-4.9.0.0
Instance details Defined in Control.Applicative Methods fold :: Monoid m => ZipList m -> m # foldMap :: Monoid m => (a -> m) -> ZipList a -> m # foldMap' :: Monoid m => (a -> m) -> ZipList a -> m # foldr :: (a -> b -> b) -> b -> ZipList a -> b # foldr' :: (a -> b -> b) -> b -> ZipList a -> b # foldl :: (b -> a -> b) -> b -> ZipList a -> b # foldl' :: (b -> a -> b) -> b -> ZipList a -> b # foldr1 :: (a -> a -> a) -> ZipList a -> a # foldl1 :: (a -> a -> a) -> ZipList a -> a # toList :: ZipList a -> [a] # null :: ZipList a -> Bool # length :: ZipList a -> Int # elem :: Eq a => a -> ZipList a -> Bool # maximum :: Ord a => ZipList a -> a # minimum :: Ord a => ZipList a -> a # sum :: Num a => ZipList a -> a # product :: Num a => ZipList a -> a #
Traversable ZipList	Since: base-4.9.0.0
Instance details Defined in Data.Traversable Methods traverse :: Applicative f => (a -> f b) -> ZipList a -> f (ZipList b) # sequenceA :: Applicative f => ZipList (f a) -> f (ZipList a) # mapM :: Monad m => (a -> m b) -> ZipList a -> m (ZipList b) # sequence :: Monad m => ZipList (m a) -> m (ZipList a) #
Alternative ZipList	Since: base-4.11.0.0
Instance details Defined in Control.Applicative Methods empty :: ZipList a # (<\|>) :: ZipList a -> ZipList a -> ZipList a # some :: ZipList a -> ZipList [a] # many :: ZipList a -> ZipList [a] #
Applicative ZipList	f <$> ZipList xs1 <> ... <> ZipList xsN = ZipList (zipWithN f xs1 ... xsN) where `zipWithN` refers to the `zipWith` function of the appropriate arity (`zipWith`, `zipWith3`, `zipWith4`, ...). For example: (\a b c -> stimes c [a, b]) <$> ZipList "abcd" <> ZipList "567" <> ZipList [1..] = ZipList (zipWith3 (\a b c -> stimes c [a, b]) "abcd" "567" [1..]) = ZipList {getZipList = ["a5","b6b6","c7c7c7"]} Since: base-2.1
Instance details Defined in Control.Applicative Methods pure :: a -> ZipList a # (<>) :: ZipList (a -> b) -> ZipList a -> ZipList b # liftA2 :: (a -> b -> c) -> ZipList a -> ZipList b -> ZipList c # (>) :: ZipList a -> ZipList b -> ZipList b # (<*) :: ZipList a -> ZipList b -> ZipList a #
Functor ZipList	Since: base-2.1
Instance details Defined in Control.Applicative Methods fmap :: (a -> b) -> ZipList a -> ZipList b # (<$) :: a -> ZipList b -> ZipList a #
IsList (ZipList a)	Since: base-4.15.0.0
Instance details Defined in GHC.Exts Associated Types type Item (ZipList a) # Methods fromList :: [Item (ZipList a)] -> ZipList a # fromListN :: Int -> [Item (ZipList a)] -> ZipList a # toList :: ZipList a -> [Item (ZipList a)] #
Generic (ZipList a)
Instance details Defined in Control.Applicative Associated Types type Rep (ZipList a) :: Type -> Type # Methods from :: ZipList a -> Rep (ZipList a) x # to :: Rep (ZipList a) x -> ZipList a #
Read a => Read (ZipList a)	Since: base-4.7.0.0
Instance details Defined in Control.Applicative Methods readsPrec :: Int -> ReadS (ZipList a) # readList :: ReadS [ZipList a] # readPrec :: ReadPrec (ZipList a) # readListPrec :: ReadPrec [ZipList a] #
Show a => Show (ZipList a)	Since: base-4.7.0.0
Instance details Defined in Control.Applicative Methods showsPrec :: Int -> ZipList a -> ShowS # show :: ZipList a -> String # showList :: [ZipList a] -> ShowS #
Eq a => Eq (ZipList a)	Since: base-4.7.0.0
Instance details Defined in Control.Applicative Methods (==) :: ZipList a -> ZipList a -> Bool # (/=) :: ZipList a -> ZipList a -> Bool #
Ord a => Ord (ZipList a)	Since: base-4.7.0.0
Instance details Defined in Control.Applicative Methods compare :: ZipList a -> ZipList a -> Ordering # (<) :: ZipList a -> ZipList a -> Bool # (<=) :: ZipList a -> ZipList a -> Bool # (>) :: ZipList a -> ZipList a -> Bool # (>=) :: ZipList a -> ZipList a -> Bool # max :: ZipList a -> ZipList a -> ZipList a # min :: ZipList a -> ZipList a -> ZipList a #
Generic1 ZipList
Instance details Defined in Control.Applicative Associated Types type Rep1 ZipList :: k -> Type # Methods from1 :: forall (a :: k). ZipList a -> Rep1 ZipList a # to1 :: forall (a :: k). Rep1 ZipList a -> ZipList a #
type Item (ZipList a)
Instance details Defined in GHC.Exts type Item (ZipList a) = a
type Rep (ZipList a)	Since: base-4.7.0.0
Instance details Defined in Control.Applicative type Rep (ZipList a) = D1 ('MetaData "ZipList" "Control.Applicative" "base" 'True) (C1 ('MetaCons "ZipList" 'PrefixI 'True) (S1 ('MetaSel ('Just "getZipList") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 [a])))
type Rep1 ZipList	Since: base-4.7.0.0
Instance details Defined in Control.Applicative type Rep1 ZipList = D1 ('MetaData "ZipList" "Control.Applicative" "base" 'True) (C1 ('MetaCons "ZipList" 'PrefixI 'True) (S1 ('MetaSel ('Just "getZipList") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec1 [])))

optional :: Alternative f => f a -> f (Maybe a) #

One or none.

It is useful for modelling any computation that is allowed to fail.

Examples

Expand

Using the Alternative instance of Except, the following functions:

>>> canFail = throwError "it failed" :: Except String Int
>>> final = return 42                :: Except String Int

Can be combined by allowing the first function to fail:

>>> runExcept $ canFail *> final
Left "it failed"
>>> runExcept $ optional canFail *> final
Right 42

newtype Const a (b :: k) #

The Const functor.

Constructors

Const
Fields getConst :: a

Instances

Instances details

Generic1 (Const a :: k -> Type)
Instance details Defined in Data.Functor.Const Associated Types type Rep1 (Const a) :: k -> Type # Methods from1 :: forall (a0 :: k0). Const a a0 -> Rep1 (Const a) a0 # to1 :: forall (a0 :: k0). Rep1 (Const a) a0 -> Const a a0 #
Bifunctor (Const :: Type -> Type -> Type)	Since: base-4.8.0.0
Instance details Defined in Data.Bifunctor Methods bimap :: (a -> b) -> (c -> d) -> Const a c -> Const b d # first :: (a -> b) -> Const a c -> Const b c # second :: (b -> c) -> Const a b -> Const a c #
Foldable (Const m :: Type -> Type)	Since: base-4.7.0.0
Instance details Defined in Data.Functor.Const Methods fold :: Monoid m0 => Const m m0 -> m0 # foldMap :: Monoid m0 => (a -> m0) -> Const m a -> m0 # foldMap' :: Monoid m0 => (a -> m0) -> Const m a -> m0 # foldr :: (a -> b -> b) -> b -> Const m a -> b # foldr' :: (a -> b -> b) -> b -> Const m a -> b # foldl :: (b -> a -> b) -> b -> Const m a -> b # foldl' :: (b -> a -> b) -> b -> Const m a -> b # foldr1 :: (a -> a -> a) -> Const m a -> a # foldl1 :: (a -> a -> a) -> Const m a -> a # toList :: Const m a -> [a] # null :: Const m a -> Bool # length :: Const m a -> Int # elem :: Eq a => a -> Const m a -> Bool # maximum :: Ord a => Const m a -> a # minimum :: Ord a => Const m a -> a # sum :: Num a => Const m a -> a # product :: Num a => Const m a -> a #
Contravariant (Const a :: Type -> Type)
Instance details Defined in Data.Functor.Contravariant Methods contramap :: (a' -> a0) -> Const a a0 -> Const a a' # (>$) :: b -> Const a b -> Const a a0 #
Traversable (Const m :: Type -> Type)	Since: base-4.7.0.0
Instance details Defined in Data.Traversable Methods traverse :: Applicative f => (a -> f b) -> Const m a -> f (Const m b) # sequenceA :: Applicative f => Const m (f a) -> f (Const m a) # mapM :: Monad m0 => (a -> m0 b) -> Const m a -> m0 (Const m b) # sequence :: Monad m0 => Const m (m0 a) -> m0 (Const m a) #
Monoid m => Applicative (Const m :: Type -> Type)	Since: base-2.0.1
Instance details Defined in Data.Functor.Const Methods pure :: a -> Const m a # (<>) :: Const m (a -> b) -> Const m a -> Const m b # liftA2 :: (a -> b -> c) -> Const m a -> Const m b -> Const m c # (>) :: Const m a -> Const m b -> Const m b # (<*) :: Const m a -> Const m b -> Const m a #
Functor (Const m :: Type -> Type)	Since: base-2.1
Instance details Defined in Data.Functor.Const Methods fmap :: (a -> b) -> Const m a -> Const m b # (<$) :: a -> Const m b -> Const m a #
Bits a => Bits (Const a b)	Since: base-4.9.0.0
Instance details Defined in Data.Functor.Const Methods (.&.) :: Const a b -> Const a b -> Const a b # (.\|.) :: Const a b -> Const a b -> Const a b # xor :: Const a b -> Const a b -> Const a b # complement :: Const a b -> Const a b # shift :: Const a b -> Int -> Const a b # rotate :: Const a b -> Int -> Const a b # zeroBits :: Const a b # bit :: Int -> Const a b # setBit :: Const a b -> Int -> Const a b # clearBit :: Const a b -> Int -> Const a b # complementBit :: Const a b -> Int -> Const a b # testBit :: Const a b -> Int -> Bool # bitSizeMaybe :: Const a b -> Maybe Int # bitSize :: Const a b -> Int # isSigned :: Const a b -> Bool # shiftL :: Const a b -> Int -> Const a b # unsafeShiftL :: Const a b -> Int -> Const a b # shiftR :: Const a b -> Int -> Const a b # unsafeShiftR :: Const a b -> Int -> Const a b # rotateL :: Const a b -> Int -> Const a b # rotateR :: Const a b -> Int -> Const a b # popCount :: Const a b -> Int #
FiniteBits a => FiniteBits (Const a b)	Since: base-4.9.0.0
Instance details Defined in Data.Functor.Const Methods finiteBitSize :: Const a b -> Int # countLeadingZeros :: Const a b -> Int # countTrailingZeros :: Const a b -> Int #
IsString a => IsString (Const a b)	Since: base-4.9.0.0
Instance details Defined in Data.String Methods fromString :: String -> Const a b #
Storable a => Storable (Const a b)	Since: base-4.9.0.0
Instance details Defined in Data.Functor.Const Methods sizeOf :: Const a b -> Int # alignment :: Const a b -> Int # peekElemOff :: Ptr (Const a b) -> Int -> IO (Const a b) # pokeElemOff :: Ptr (Const a b) -> Int -> Const a b -> IO () # peekByteOff :: Ptr b0 -> Int -> IO (Const a b) # pokeByteOff :: Ptr b0 -> Int -> Const a b -> IO () # peek :: Ptr (Const a b) -> IO (Const a b) # poke :: Ptr (Const a b) -> Const a b -> IO () #
Monoid a => Monoid (Const a b)	Since: base-4.9.0.0
Instance details Defined in Data.Functor.Const Methods mempty :: Const a b # mappend :: Const a b -> Const a b -> Const a b # mconcat :: [Const a b] -> Const a b #
Semigroup a => Semigroup (Const a b)	Since: base-4.9.0.0
Instance details Defined in Data.Functor.Const Methods (<>) :: Const a b -> Const a b -> Const a b # sconcat :: NonEmpty (Const a b) -> Const a b # stimes :: Integral b0 => b0 -> Const a b -> Const a b #
Bounded a => Bounded (Const a b)	Since: base-4.9.0.0
Instance details Defined in Data.Functor.Const Methods minBound :: Const a b # maxBound :: Const a b #
Enum a => Enum (Const a b)	Since: base-4.9.0.0
Instance details Defined in Data.Functor.Const 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] #
Floating a => Floating (Const a b)	Since: base-4.9.0.0
Instance details Defined in Data.Functor.Const 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 #
RealFloat a => RealFloat (Const a b)	Since: base-4.9.0.0
Instance details Defined in Data.Functor.Const Methods floatRadix :: Const a b -> Integer # floatDigits :: Const a b -> Int # floatRange :: Const a b -> (Int, Int) # decodeFloat :: Const a b -> (Integer, Int) # encodeFloat :: Integer -> Int -> Const a b # exponent :: Const a b -> Int # significand :: Const a b -> Const a b # scaleFloat :: Int -> Const a b -> Const a b # isNaN :: Const a b -> Bool # isInfinite :: Const a b -> Bool # isDenormalized :: Const a b -> Bool # isNegativeZero :: Const a b -> Bool # isIEEE :: Const a b -> Bool # atan2 :: Const a b -> Const a b -> Const a b #
Generic (Const a b)
Instance details Defined in Data.Functor.Const Associated Types type Rep (Const a b) :: Type -> Type # Methods from :: Const a b -> Rep (Const a b) x # to :: Rep (Const a b) x -> Const a b #
Ix a => Ix (Const a b)	Since: base-4.9.0.0
Instance details Defined in Data.Functor.Const Methods range :: (Const a b, Const a b) -> [Const a b] # index :: (Const a b, Const a b) -> Const a b -> Int # unsafeIndex :: (Const a b, Const a b) -> Const a b -> Int # inRange :: (Const a b, Const a b) -> Const a b -> Bool # rangeSize :: (Const a b, Const a b) -> Int # unsafeRangeSize :: (Const a b, Const a b) -> Int #
Num a => Num (Const a b)	Since: base-4.9.0.0
Instance details Defined in Data.Functor.Const Methods (+) :: Const a b -> Const a b -> Const a b # (-) :: Const a b -> Const a b -> Const a b # (*) :: Const a b -> Const a b -> Const a b # negate :: Const a b -> Const a b # abs :: Const a b -> Const a b # signum :: Const a b -> Const a b # fromInteger :: Integer -> Const a b #
Read a => Read (Const a b)	This instance would be equivalent to the derived instances of the `Const` newtype if the `getConst` field were removed Since: base-4.8.0.0
Instance details Defined in Data.Functor.Const Methods readsPrec :: Int -> ReadS (Const a b) # readList :: ReadS [Const a b] # readPrec :: ReadPrec (Const a b) # readListPrec :: ReadPrec [Const a b] #
Fractional a => Fractional (Const a b)	Since: base-4.9.0.0
Instance details Defined in Data.Functor.Const Methods (/) :: Const a b -> Const a b -> Const a b # recip :: Const a b -> Const a b # fromRational :: Rational -> Const a b #
Integral a => Integral (Const a b)	Since: base-4.9.0.0
Instance details Defined in Data.Functor.Const 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 #
Real a => Real (Const a b)	Since: base-4.9.0.0
Instance details Defined in Data.Functor.Const Methods toRational :: Const a b -> Rational #
RealFrac a => RealFrac (Const a b)	Since: base-4.9.0.0
Instance details Defined in Data.Functor.Const Methods properFraction :: Integral b0 => Const a b -> (b0, Const a b) # truncate :: Integral b0 => Const a b -> b0 # round :: Integral b0 => Const a b -> b0 # ceiling :: Integral b0 => Const a b -> b0 # floor :: Integral b0 => Const a b -> b0 #
Show a => Show (Const a b)	This instance would be equivalent to the derived instances of the `Const` newtype if the `getConst` field were removed Since: base-4.8.0.0
Instance details Defined in Data.Functor.Const Methods showsPrec :: Int -> Const a b -> ShowS # show :: Const a b -> String # showList :: [Const a b] -> ShowS #
Eq a => Eq (Const a b)	Since: base-4.9.0.0
Instance details Defined in Data.Functor.Const Methods (==) :: Const a b -> Const a b -> Bool # (/=) :: Const a b -> Const a b -> Bool #
Ord a => Ord (Const a b)	Since: base-4.9.0.0
Instance details Defined in Data.Functor.Const Methods compare :: Const a b -> Const a b -> Ordering # (<) :: Const a b -> Const a b -> Bool # (<=) :: Const a b -> Const a b -> Bool # (>) :: Const a b -> Const a b -> Bool # (>=) :: Const a b -> Const a b -> Bool # max :: Const a b -> Const a b -> Const a b # min :: Const a b -> Const a b -> Const a b #
type Rep1 (Const a :: k -> Type)	Since: base-4.9.0.0
Instance details Defined in Data.Functor.Const type Rep1 (Const a :: k -> Type) = D1 ('MetaData "Const" "Data.Functor.Const" "base" 'True) (C1 ('MetaCons "Const" 'PrefixI 'True) (S1 ('MetaSel ('Just "getConst") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 a)))
type Rep (Const a b)	Since: base-4.9.0.0
Instance details Defined in Data.Functor.Const type Rep (Const a b) = D1 ('MetaData "Const" "Data.Functor.Const" "base" 'True) (C1 ('MetaCons "Const" 'PrefixI 'True) (S1 ('MetaSel ('Just "getConst") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 a)))

class Applicative f => Alternative (f :: Type -> Type) where #

A monoid on applicative functors.

If defined, some and many should be the least solutions of the equations:

```
some v = (:) <$> v <*> many v
```
```
many v = some v <|> pure []
```

Minimal complete definition

empty, (<|>)

Methods

empty :: f a #

The identity of <|>

(<|>) :: f a -> f a -> f a infixl 3 #

An associative binary operation

some :: f a -> f [a] #

One or more.

many :: f a -> f [a] #

Zero or more.

Instances

Instances details

Alternative ZipList	Since: base-4.11.0.0
Instance details Defined in Control.Applicative Methods empty :: ZipList a # (<\|>) :: ZipList a -> ZipList a -> ZipList a # some :: ZipList a -> ZipList [a] # many :: ZipList a -> ZipList [a] #
Alternative Option	Since: base-4.9.0.0
Instance details Defined in Data.Semigroup Methods empty :: Option a # (<\|>) :: Option a -> Option a -> Option a # some :: Option a -> Option [a] # many :: Option a -> Option [a] #
Alternative P	Since: base-4.5.0.0
Instance details Defined in Text.ParserCombinators.ReadP Methods empty :: P a # (<\|>) :: P a -> P a -> P a # some :: P a -> P [a] # many :: P a -> P [a] #
Alternative ReadP	Since: base-4.6.0.0
Instance details Defined in Text.ParserCombinators.ReadP Methods empty :: ReadP a # (<\|>) :: ReadP a -> ReadP a -> ReadP a # some :: ReadP a -> ReadP [a] # many :: ReadP a -> ReadP [a] #
Alternative Seq	Since: containers-0.5.4
Instance details Defined in Data.Sequence.Internal Methods empty :: Seq a # (<\|>) :: Seq a -> Seq a -> Seq a # some :: Seq a -> Seq [a] # many :: Seq a -> Seq [a] #
Alternative DList
Instance details Defined in Data.DList.Internal Methods empty :: DList a # (<\|>) :: DList a -> DList a -> DList a # some :: DList a -> DList [a] # many :: DList a -> DList [a] #
Alternative IO	Since: base-4.9.0.0
Instance details Defined in GHC.Base Methods empty :: IO a # (<\|>) :: IO a -> IO a -> IO a # some :: IO a -> IO [a] # many :: IO a -> IO [a] #
Alternative Maybe	Since: base-2.1
Instance details Defined in GHC.Base Methods empty :: Maybe a # (<\|>) :: Maybe a -> Maybe a -> Maybe a # some :: Maybe a -> Maybe [a] # many :: Maybe a -> Maybe [a] #
Alternative []	Since: base-2.1
Instance details Defined in GHC.Base Methods empty :: [a] # (<\|>) :: [a] -> [a] -> [a] # some :: [a] -> [[a]] # many :: [a] -> [[a]] #
MonadPlus m => Alternative (WrappedMonad m)	Since: base-2.1
Instance details Defined in Control.Applicative Methods empty :: WrappedMonad m a # (<\|>) :: WrappedMonad m a -> WrappedMonad m a -> WrappedMonad m a # some :: WrappedMonad m a -> WrappedMonad m [a] # many :: WrappedMonad m a -> WrappedMonad m [a] #
ArrowPlus a => Alternative (ArrowMonad a)	Since: base-4.6.0.0
Instance details Defined in Control.Arrow Methods empty :: ArrowMonad a a0 # (<\|>) :: ArrowMonad a a0 -> ArrowMonad a a0 -> ArrowMonad a a0 # some :: ArrowMonad a a0 -> ArrowMonad a [a0] # many :: ArrowMonad a a0 -> ArrowMonad a [a0] #
Alternative (Proxy :: Type -> Type)	Since: base-4.9.0.0
Instance details Defined in Data.Proxy Methods empty :: Proxy a # (<\|>) :: Proxy a -> Proxy a -> Proxy a # some :: Proxy a -> Proxy [a] # many :: Proxy a -> Proxy [a] #
Alternative (U1 :: Type -> Type)	Since: base-4.9.0.0
Instance details Defined in GHC.Generics Methods empty :: U1 a # (<\|>) :: U1 a -> U1 a -> U1 a # some :: U1 a -> U1 [a] # many :: U1 a -> U1 [a] #
(ArrowZero a, ArrowPlus a) => Alternative (WrappedArrow a b)	Since: base-2.1
Instance details Defined in Control.Applicative Methods empty :: WrappedArrow a b a0 # (<\|>) :: WrappedArrow a b a0 -> WrappedArrow a b a0 -> WrappedArrow a b a0 # some :: WrappedArrow a b a0 -> WrappedArrow a b [a0] # many :: WrappedArrow a b a0 -> WrappedArrow a b [a0] #
Alternative m => Alternative (Kleisli m a)	Since: base-4.14.0.0
Instance details Defined in Control.Arrow Methods empty :: Kleisli m a a0 # (<\|>) :: Kleisli m a a0 -> Kleisli m a a0 -> Kleisli m a a0 # some :: Kleisli m a a0 -> Kleisli m a [a0] # many :: Kleisli m a a0 -> Kleisli m a [a0] #
Alternative f => Alternative (Ap f)	Since: base-4.12.0.0
Instance details Defined in Data.Monoid Methods empty :: Ap f a # (<\|>) :: Ap f a -> Ap f a -> Ap f a # some :: Ap f a -> Ap f [a] # many :: Ap f a -> Ap f [a] #
Alternative f => Alternative (Rec1 f)	Since: base-4.9.0.0
Instance details Defined in GHC.Generics Methods empty :: Rec1 f a # (<\|>) :: Rec1 f a -> Rec1 f a -> Rec1 f a # some :: Rec1 f a -> Rec1 f [a] # many :: Rec1 f a -> Rec1 f [a] #
(Alternative f, Alternative g) => Alternative (Product f g)	Since: base-4.9.0.0
Instance details Defined in Data.Functor.Product Methods empty :: Product f g a # (<\|>) :: Product f g a -> Product f g a -> Product f g a # some :: Product f g a -> Product f g [a] # many :: Product f g a -> Product f g [a] #
(Alternative f, Alternative g) => Alternative (f :*: g)	Since: base-4.9.0.0
Instance details Defined in GHC.Generics Methods empty :: (f :: g) a # (<\|>) :: (f :: g) a -> (f :: g) a -> (f :: g) a # some :: (f :: g) a -> (f :: g) [a] # many :: (f :: g) a -> (f :: g) [a] #
(Alternative f, Applicative g) => Alternative (Compose f g)	Since: base-4.9.0.0
Instance details Defined in Data.Functor.Compose Methods empty :: Compose f g a # (<\|>) :: Compose f g a -> Compose f g a -> Compose f g a # some :: Compose f g a -> Compose f g [a] # many :: Compose f g a -> Compose f g [a] #
(Alternative f, Applicative g) => Alternative (f :.: g)	Since: base-4.9.0.0
Instance details Defined in GHC.Generics Methods empty :: (f :.: g) a # (<\|>) :: (f :.: g) a -> (f :.: g) a -> (f :.: g) a # some :: (f :.: g) a -> (f :.: g) [a] # many :: (f :.: g) a -> (f :.: g) [a] #
Alternative f => Alternative (M1 i c f)	Since: base-4.9.0.0
Instance details Defined in GHC.Generics Methods empty :: M1 i c f a # (<\|>) :: M1 i c f a -> M1 i c f a -> M1 i c f a # some :: M1 i c f a -> M1 i c f [a] # many :: M1 i c f a -> M1 i c f [a] #

liftA3 :: Applicative f => (a -> b -> c -> d) -> f a -> f b -> f c -> f d #

Lift a ternary function to actions.

(<**>) :: Applicative f => f a -> f (a -> b) -> f b infixl 4 #

A variant of <*> with the arguments reversed.

(&&&) :: Arrow a => a b c -> a b c' -> a b (c, c') infixr 3 #

Fanout: send the input to both argument arrows and combine their output.

The default definition may be overridden with a more efficient version if desired.

(>>>) :: forall {k} cat (a :: k) (b :: k) (c :: k). Category cat => cat a b -> cat b c -> cat a c infixr 1 #

Left-to-right composition

(<<<) :: forall {k} cat (b :: k) (c :: k) (a :: k). Category cat => cat b c -> cat a b -> cat a c infixr 1 #

Right-to-left composition

module Control.Concurrent.MVar

class (Typeable e, Show e) => Exception e #

Any type that you wish to throw or catch as an exception must be an instance of the Exception class. The simplest case is a new exception type directly below the root:

data MyException = ThisException | ThatException
    deriving Show

instance Exception MyException

The default method definitions in the Exception class do what we need in this case. You can now throw and catch ThisException and ThatException as exceptions:

*Main> throw ThisException `catch` \e -> putStrLn ("Caught " ++ show (e :: MyException))
Caught ThisException

In more complicated examples, you may wish to define a whole hierarchy of exceptions:

---------------------------------------------------------------------
-- Make the root exception type for all the exceptions in a compiler

data SomeCompilerException = forall e . Exception e => SomeCompilerException e

instance Show SomeCompilerException where
    show (SomeCompilerException e) = show e

instance Exception SomeCompilerException

compilerExceptionToException :: Exception e => e -> SomeException
compilerExceptionToException = toException . SomeCompilerException

compilerExceptionFromException :: Exception e => SomeException -> Maybe e
compilerExceptionFromException x = do
    SomeCompilerException a <- fromException x
    cast a

---------------------------------------------------------------------
-- Make a subhierarchy for exceptions in the frontend of the compiler

data SomeFrontendException = forall e . Exception e => SomeFrontendException e

instance Show SomeFrontendException where
    show (SomeFrontendException e) = show e

instance Exception SomeFrontendException where
    toException = compilerExceptionToException
    fromException = compilerExceptionFromException

frontendExceptionToException :: Exception e => e -> SomeException
frontendExceptionToException = toException . SomeFrontendException

frontendExceptionFromException :: Exception e => SomeException -> Maybe e
frontendExceptionFromException x = do
    SomeFrontendException a <- fromException x
    cast a

---------------------------------------------------------------------
-- Make an exception type for a particular frontend compiler exception

data MismatchedParentheses = MismatchedParentheses
    deriving Show

instance Exception MismatchedParentheses where
    toException   = frontendExceptionToException
    fromException = frontendExceptionFromException

We can now catch a MismatchedParentheses exception as MismatchedParentheses, SomeFrontendException or SomeCompilerException, but not other types, e.g. IOException:

*Main> throw MismatchedParentheses `catch` \e -> putStrLn ("Caught " ++ show (e :: MismatchedParentheses))
Caught MismatchedParentheses
*Main> throw MismatchedParentheses `catch` \e -> putStrLn ("Caught " ++ show (e :: SomeFrontendException))
Caught MismatchedParentheses
*Main> throw MismatchedParentheses `catch` \e -> putStrLn ("Caught " ++ show (e :: SomeCompilerException))
Caught MismatchedParentheses
*Main> throw MismatchedParentheses `catch` \e -> putStrLn ("Caught " ++ show (e :: IOException))
*** Exception: MismatchedParentheses

Instances

Instances details

Exception Void	Since: base-4.8.0.0
Instance details Defined in Data.Void Methods toException :: Void -> SomeException # fromException :: SomeException -> Maybe Void # displayException :: Void -> String #
Exception ArithException	Since: base-4.0.0.0
Instance details Defined in GHC.Exception.Type Methods toException :: ArithException -> SomeException # fromException :: SomeException -> Maybe ArithException # displayException :: ArithException -> String #
Exception SomeException	Since: base-3.0
Instance details Defined in GHC.Exception.Type Methods toException :: SomeException -> SomeException # fromException :: SomeException -> Maybe SomeException # displayException :: SomeException -> String #
Exception UnicodeException
Instance details Defined in Data.Text.Encoding.Error Methods toException :: UnicodeException -> SomeException # fromException :: SomeException -> Maybe UnicodeException # displayException :: UnicodeException -> String #

data SomeException #

The SomeException type is the root of the exception type hierarchy. When an exception of type e is thrown, behind the scenes it is encapsulated in a SomeException.

Constructors

Exception e => SomeException e

Instances

Instances details

Exception SomeException	Since: base-3.0
Instance details Defined in GHC.Exception.Type Methods toException :: SomeException -> SomeException # fromException :: SomeException -> Maybe SomeException # displayException :: SomeException -> String #
Show SomeException	Since: base-3.0
Instance details Defined in GHC.Exception.Type Methods showsPrec :: Int -> SomeException -> ShowS # show :: SomeException -> String # showList :: [SomeException] -> ShowS #

guard :: Alternative f => Bool -> f () #

Conditional failure of Alternative computations. Defined by

guard True  = pure ()
guard False = empty

Examples

Expand

Common uses of guard include conditionally signaling an error in an error monad and conditionally rejecting the current choice in an Alternative-based parser.

As an example of signaling an error in the error monad Maybe, consider a safe division function safeDiv x y that returns Nothing when the denominator y is zero and Just (x `div` y) otherwise. For example:

>>> safeDiv 4 0
Nothing
>>> safeDiv 4 2
Just 2

A definition of safeDiv using guards, but not guard:

safeDiv :: Int -> Int -> Maybe Int
safeDiv x y | y /= 0    = Just (x `div` y)
            | otherwise = Nothing

A definition of safeDiv using guard and Monad do-notation:

safeDiv :: Int -> Int -> Maybe Int
safeDiv x y = do
  guard (y /= 0)
  return (x `div` y)

join :: Monad m => m (m a) -> m a #

The join function is the conventional monad join operator. It is used to remove one level of monadic structure, projecting its bound argument into the outer level.

'join bss' can be understood as the do expression

do bs <- bss
   bs

Examples

Expand

A common use of join is to run an IO computation returned from an STM transaction, since STM transactions can't perform IO directly. Recall that

atomically :: STM a -> IO a

is used to run STM transactions atomically. So, by specializing the types of atomically and join to

atomically :: STM (IO b) -> IO (IO b)
join       :: IO (IO b)  -> IO b

we can compose them as

join . atomically :: STM (IO b) -> IO b

to run an STM transaction and the IO action it returns.

class Applicative m => Monad (m :: Type -> Type) 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:

Left identity: return a >>= k = k a
Right identity: m >>= return = m
Associativity: m >>= (\x -> k x >>= h) = (m >>= k) >>= h

Furthermore, the Monad and Applicative operations should relate as follows:

```
pure = return
```

m1 <*> m2 = m1 >>= (x1 -> m2 >>= (x2 -> return (x1 x2)))

The above laws imply:

```
fmap f xs  =  xs >>= return . f
```
```
(>>) = (*>)
```

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.

'as >>= bs' can be understood as the do expression

do a <- as
   bs a

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

'as >> bs' can be understood as the do expression

do as
   bs

Instances

Instances details

Monad Identity	Since: base-4.8.0.0
Instance details Defined in Data.Functor.Identity Methods (>>=) :: Identity a -> (a -> Identity b) -> Identity b # (>>) :: Identity a -> Identity b -> Identity b # return :: a -> Identity a #
Monad First	Since: base-4.8.0.0
Instance details Defined in Data.Monoid Methods (>>=) :: First a -> (a -> First b) -> First b # (>>) :: First a -> First b -> First b # return :: a -> First a #
Monad Last	Since: base-4.8.0.0
Instance details Defined in Data.Monoid Methods (>>=) :: Last a -> (a -> Last b) -> Last b # (>>) :: Last a -> Last b -> Last b # return :: a -> Last a #
Monad Down	Since: base-4.11.0.0
Instance details Defined in Data.Ord Methods (>>=) :: Down a -> (a -> Down b) -> Down b # (>>) :: Down a -> Down b -> Down b # return :: a -> Down a #
Monad First	Since: base-4.9.0.0
Instance details Defined in Data.Semigroup Methods (>>=) :: First a -> (a -> First b) -> First b # (>>) :: First a -> First b -> First b # return :: a -> First a #
Monad Last	Since: base-4.9.0.0
Instance details Defined in Data.Semigroup Methods (>>=) :: Last a -> (a -> Last b) -> Last b # (>>) :: Last a -> Last b -> Last b # return :: a -> Last a #
Monad Max	Since: base-4.9.0.0
Instance details Defined in Data.Semigroup Methods (>>=) :: Max a -> (a -> Max b) -> Max b # (>>) :: Max a -> Max b -> Max b # return :: a -> Max a #
Monad Min	Since: base-4.9.0.0
Instance details Defined in Data.Semigroup Methods (>>=) :: Min a -> (a -> Min b) -> Min b # (>>) :: Min a -> Min b -> Min b # return :: a -> Min a #
Monad Option	Since: base-4.9.0.0
Instance details Defined in Data.Semigroup Methods (>>=) :: Option a -> (a -> Option b) -> Option b # (>>) :: Option a -> Option b -> Option b # return :: a -> Option a #
Monad NonEmpty	Since: base-4.9.0.0
Instance details Defined in GHC.Base Methods (>>=) :: NonEmpty a -> (a -> NonEmpty b) -> NonEmpty b # (>>) :: NonEmpty a -> NonEmpty b -> NonEmpty b # return :: a -> NonEmpty a #
Monad Par1	Since: base-4.9.0.0
Instance details Defined in GHC.Generics Methods (>>=) :: Par1 a -> (a -> Par1 b) -> Par1 b # (>>) :: Par1 a -> Par1 b -> Par1 b # return :: a -> Par1 a #
Monad P	Since: base-2.1
Instance details Defined in Text.ParserCombinators.ReadP Methods (>>=) :: P a -> (a -> P b) -> P b # (>>) :: P a -> P b -> P b # return :: a -> P a #
Monad ReadP	Since: base-2.1
Instance details Defined in Text.ParserCombinators.ReadP Methods (>>=) :: ReadP a -> (a -> ReadP b) -> ReadP b # (>>) :: ReadP a -> ReadP b -> ReadP b # return :: a -> ReadP a #
Monad Seq
Instance details Defined in Data.Sequence.Internal Methods (>>=) :: Seq a -> (a -> Seq b) -> Seq b # (>>) :: Seq a -> Seq b -> Seq b # return :: a -> Seq a #
Monad DList
Instance details Defined in Data.DList.Internal Methods (>>=) :: DList a -> (a -> DList b) -> DList b # (>>) :: DList a -> DList b -> DList b # return :: a -> DList a #
Monad IO	Since: base-2.1
Instance details Defined in GHC.Base Methods (>>=) :: IO a -> (a -> IO b) -> IO b # (>>) :: IO a -> IO b -> IO b # return :: a -> IO a #
Monad Q
Instance details Defined in Language.Haskell.TH.Syntax Methods (>>=) :: Q a -> (a -> Q b) -> Q b # (>>) :: Q a -> Q b -> Q b # return :: a -> Q a #
Monad Maybe	Since: base-2.1
Instance details Defined in GHC.Base Methods (>>=) :: Maybe a -> (a -> Maybe b) -> Maybe b # (>>) :: Maybe a -> Maybe b -> Maybe b # return :: a -> Maybe a #
Monad Solo	Since: base-4.15
Instance details Defined in GHC.Base Methods (>>=) :: Solo a -> (a -> Solo b) -> Solo b # (>>) :: Solo a -> Solo b -> Solo b # return :: a -> Solo a #
Monad []	Since: base-2.1
Instance details Defined in GHC.Base Methods (>>=) :: [a] -> (a -> [b]) -> [b] # (>>) :: [a] -> [b] -> [b] # return :: a -> [a] #
Monad m => Monad (WrappedMonad m)	Since: base-4.7.0.0
Instance details Defined in Control.Applicative 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 #
ArrowApply a => Monad (ArrowMonad a)	Since: base-2.1
Instance details Defined in Control.Arrow 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 #
Monad (Either e)	Since: base-4.4.0.0
Instance details Defined in Data.Either 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 #
Monad (Proxy :: Type -> Type)	Since: base-4.7.0.0
Instance details Defined in Data.Proxy Methods (>>=) :: Proxy a -> (a -> Proxy b) -> Proxy b # (>>) :: Proxy a -> Proxy b -> Proxy b # return :: a -> Proxy a #
Monad (U1 :: Type -> Type)	Since: base-4.9.0.0
Instance details Defined in GHC.Generics Methods (>>=) :: U1 a -> (a -> U1 b) -> U1 b # (>>) :: U1 a -> U1 b -> U1 b # return :: a -> U1 a #
Monoid a => Monad ((,) a)	Since: base-4.9.0.0
Instance details Defined in GHC.Base Methods (>>=) :: (a, a0) -> (a0 -> (a, b)) -> (a, b) # (>>) :: (a, a0) -> (a, b) -> (a, b) # return :: a0 -> (a, a0) #
Monad m => Monad (Kleisli m a)	Since: base-4.14.0.0
Instance details Defined in Control.Arrow Methods (>>=) :: Kleisli m a a0 -> (a0 -> Kleisli m a b) -> Kleisli m a b # (>>) :: Kleisli m a a0 -> Kleisli m a b -> Kleisli m a b # return :: a0 -> Kleisli m a a0 #
Monad f => Monad (Ap f)	Since: base-4.12.0.0
Instance details Defined in Data.Monoid Methods (>>=) :: Ap f a -> (a -> Ap f b) -> Ap f b # (>>) :: Ap f a -> Ap f b -> Ap f b # return :: a -> Ap f a #
Monad f => Monad (Rec1 f)	Since: base-4.9.0.0
Instance details Defined in GHC.Generics 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 #
(Applicative f, Monad f) => Monad (WhenMissing f x)	Equivalent to `ReaderT k (ReaderT x (MaybeT f))`. Since: containers-0.5.9
Instance details Defined in Data.IntMap.Internal 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 #
(Monoid a, Monoid b) => Monad ((,,) a b)	Since: base-4.14.0.0
Instance details Defined in GHC.Base Methods (>>=) :: (a, b, a0) -> (a0 -> (a, b, b0)) -> (a, b, b0) # (>>) :: (a, b, a0) -> (a, b, b0) -> (a, b, b0) # return :: a0 -> (a, b, a0) #
(Monad f, Monad g) => Monad (Product f g)	Since: base-4.9.0.0
Instance details Defined in Data.Functor.Product 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 #
(Monad f, Monad g) => Monad (f :*: g)	Since: base-4.9.0.0
Instance details Defined in GHC.Generics 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 #
(Monad f, Applicative f) => Monad (WhenMatched f x y)	Equivalent to `ReaderT Key (ReaderT x (ReaderT y (MaybeT f)))` Since: containers-0.5.9
Instance details Defined in Data.IntMap.Internal 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 #
(Applicative f, Monad f) => Monad (WhenMissing f k x)	Equivalent to `ReaderT k (ReaderT x (MaybeT f))` . Since: containers-0.5.9
Instance details Defined in Data.Map.Internal 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 #
(Monoid a, Monoid b, Monoid c) => Monad ((,,,) a b c)	Since: base-4.14.0.0
Instance details Defined in GHC.Base Methods (>>=) :: (a, b, c, a0) -> (a0 -> (a, b, c, b0)) -> (a, b, c, b0) # (>>) :: (a, b, c, a0) -> (a, b, c, b0) -> (a, b, c, b0) # return :: a0 -> (a, b, c, a0) #
Monad ((->) r)	Since: base-2.1
Instance details Defined in GHC.Base Methods (>>=) :: (r -> a) -> (a -> r -> b) -> r -> b # (>>) :: (r -> a) -> (r -> b) -> r -> b # return :: a -> r -> a #
Monad f => Monad (M1 i c f)	Since: base-4.9.0.0
Instance details Defined in GHC.Generics 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 #
(Monad f, Applicative f) => Monad (WhenMatched f k x y)	Equivalent to `ReaderT k (ReaderT x (ReaderT y (MaybeT f)))` Since: containers-0.5.9
Instance details Defined in Data.Map.Internal 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 #

zipWithM_ :: Applicative m => (a -> b -> m c) -> [a] -> [b] -> m () #

zipWithM_ is the extension of zipWithM which ignores the final result.

zipWithM :: Applicative m => (a -> b -> m c) -> [a] -> [b] -> m [c] #

The zipWithM function generalizes zipWith to arbitrary applicative functors.

unless :: Applicative f => Bool -> f () -> f () #

The reverse of when.

replicateM_ :: Applicative m => Int -> m a -> m () #

Like replicateM, but discards the result.

replicateM :: Applicative m => Int -> m a -> m [a] #

replicateM n act performs the action act n times, and then returns the list of results:

Examples

Expand

>>> replicateM 3 (putStrLn "a")
a
a
a

mfilter :: MonadPlus m => (a -> Bool) -> m a -> m a #

Direct MonadPlus equivalent of filter.

Examples

Expand

The filter function is just mfilter specialized to the list monad:

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

An example using mfilter with the Maybe monad:

>>> mfilter odd (Just 1)
Just 1
>>> mfilter odd (Just 2)
Nothing

forever :: Applicative f => f a -> f b #

Repeat an action indefinitely.

Examples

Expand

A common use of forever is to process input from network sockets, Handles, and channels (e.g. MVar and Chan).

For example, here is how we might implement an echo server, using forever both to listen for client connections on a network socket and to echo client input on client connection handles:

echoServer :: Socket -> IO ()
echoServer socket = forever $ do
  client <- accept socket
  forkFinally (echo client) (\_ -> hClose client)
  where
    echo :: Handle -> IO ()
    echo client = forever $
      hGetLine client >>= hPutStrLn client

Note that "forever" isn't necessarily non-terminating. If the action is in a MonadPlus and short-circuits after some number of iterations. then forever actually returns mzero, effectively short-circuiting its caller.

filterM :: Applicative m => (a -> m Bool) -> [a] -> m [a] #

This generalizes the list-based filter function.

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

Left-to-right composition of Kleisli arrows.

'(bs >=> cs) a' can be understood as the do expression

do b <- bs a
   cs b

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

Right-to-left composition of Kleisli arrows. (>=>), with the arguments flipped.

Note how this operator resembles function composition (.):

(.)   ::            (b ->   c) -> (a ->   b) -> a ->   c
(<=<) :: Monad m => (b -> m c) -> (a -> m b) -> a -> m c

(<$!>) :: Monad m => (a -> b) -> m a -> m b infixl 4 #

Strict version of <$>.

Since: base-4.8.0.0

class (Alternative m, Monad m) => MonadPlus (m :: Type -> Type) where #

Monads that also support choice and failure.

Minimal complete definition

Nothing

Methods

mzero :: m a #

The identity of mplus. It should also satisfy the equations

mzero >>= f  =  mzero
v >> mzero   =  mzero

The default definition is

mzero = empty

mplus :: m a -> m a -> m a #

An associative operation. The default definition is

mplus = (<|>)

Instances

Instances details

MonadPlus Option	Since: base-4.9.0.0
Instance details Defined in Data.Semigroup Methods mzero :: Option a # mplus :: Option a -> Option a -> Option a #
MonadPlus P	Since: base-2.1
Instance details Defined in Text.ParserCombinators.ReadP Methods mzero :: P a # mplus :: P a -> P a -> P a #
MonadPlus ReadP	Since: base-2.1
Instance details Defined in Text.ParserCombinators.ReadP Methods mzero :: ReadP a # mplus :: ReadP a -> ReadP a -> ReadP a #
MonadPlus Seq
Instance details Defined in Data.Sequence.Internal Methods mzero :: Seq a # mplus :: Seq a -> Seq a -> Seq a #
MonadPlus DList
Instance details Defined in Data.DList.Internal Methods mzero :: DList a # mplus :: DList a -> DList a -> DList a #
MonadPlus IO	Since: base-4.9.0.0
Instance details Defined in GHC.Base Methods mzero :: IO a # mplus :: IO a -> IO a -> IO a #
MonadPlus Maybe	Since: base-2.1
Instance details Defined in GHC.Base Methods mzero :: Maybe a # mplus :: Maybe a -> Maybe a -> Maybe a #
MonadPlus []	Since: base-2.1
Instance details Defined in GHC.Base Methods mzero :: [a] # mplus :: [a] -> [a] -> [a] #
(ArrowApply a, ArrowPlus a) => MonadPlus (ArrowMonad a)	Since: base-4.6.0.0
Instance details Defined in Control.Arrow Methods mzero :: ArrowMonad a a0 # mplus :: ArrowMonad a a0 -> ArrowMonad a a0 -> ArrowMonad a a0 #
MonadPlus (Proxy :: Type -> Type)	Since: base-4.9.0.0
Instance details Defined in Data.Proxy Methods mzero :: Proxy a # mplus :: Proxy a -> Proxy a -> Proxy a #
MonadPlus (U1 :: Type -> Type)	Since: base-4.9.0.0
Instance details Defined in GHC.Generics Methods mzero :: U1 a # mplus :: U1 a -> U1 a -> U1 a #
MonadPlus m => MonadPlus (Kleisli m a)	Since: base-4.14.0.0
Instance details Defined in Control.Arrow Methods mzero :: Kleisli m a a0 # mplus :: Kleisli m a a0 -> Kleisli m a a0 -> Kleisli m a a0 #
MonadPlus f => MonadPlus (Ap f)	Since: base-4.12.0.0
Instance details Defined in Data.Monoid Methods mzero :: Ap f a # mplus :: Ap f a -> Ap f a -> Ap f a #
MonadPlus f => MonadPlus (Rec1 f)	Since: base-4.9.0.0
Instance details Defined in GHC.Generics Methods mzero :: Rec1 f a # mplus :: Rec1 f a -> Rec1 f a -> Rec1 f a #
(MonadPlus f, MonadPlus g) => MonadPlus (Product f g)	Since: base-4.9.0.0
Instance details Defined in Data.Functor.Product Methods mzero :: Product f g a # mplus :: Product f g a -> Product f g a -> Product f g a #
(MonadPlus f, MonadPlus g) => MonadPlus (f :*: g)	Since: base-4.9.0.0
Instance details Defined in GHC.Generics Methods mzero :: (f :: g) a # mplus :: (f :: g) a -> (f :: g) a -> (f :: g) a #
MonadPlus f => MonadPlus (M1 i c f)	Since: base-4.9.0.0
Instance details Defined in GHC.Generics Methods mzero :: M1 i c f a # mplus :: M1 i c f a -> M1 i c f a -> M1 i c f a #

when :: Applicative f => Bool -> f () -> f () #

Conditional execution of Applicative expressions. For example,

when debug (putStrLn "Debugging")

will output the string Debugging if the Boolean value debug is True, and otherwise do nothing.

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

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

class Monad m => MonadFail (m :: Type -> Type) where #

When a value is bound in do-notation, the pattern on the left hand side of <- might not match. In this case, this class provides a function to recover.

A Monad without a MonadFail instance may only be used in conjunction with pattern that always match, such as newtypes, tuples, data types with only a single data constructor, and irrefutable patterns (~pat).

Instances of MonadFail should satisfy the following law: fail s should be a left zero for >>=,

fail s >>= f  =  fail s

If your Monad is also MonadPlus, a popular definition is

fail _ = mzero

Since: base-4.9.0.0

Methods

fail :: String -> m a #

Instances

Instances details

MonadFail P	Since: base-4.9.0.0
Instance details Defined in Text.ParserCombinators.ReadP Methods fail :: String -> P a #
MonadFail ReadP	Since: base-4.9.0.0
Instance details Defined in Text.ParserCombinators.ReadP Methods fail :: String -> ReadP a #
MonadFail DList
Instance details Defined in Data.DList.Internal Methods fail :: String -> DList a #
MonadFail IO	Since: base-4.9.0.0
Instance details Defined in Control.Monad.Fail Methods fail :: String -> IO a #
MonadFail Q
Instance details Defined in Language.Haskell.TH.Syntax Methods fail :: String -> Q a #
MonadFail Maybe	Since: base-4.9.0.0
Instance details Defined in Control.Monad.Fail Methods fail :: String -> Maybe a #
MonadFail []	Since: base-4.9.0.0
Instance details Defined in Control.Monad.Fail Methods fail :: String -> [a] #
MonadFail f => MonadFail (Ap f)	Since: base-4.12.0.0
Instance details Defined in Data.Monoid Methods fail :: String -> Ap f a #

module Control.Monad.IO.Class

class Bifunctor (p :: Type -> Type -> Type) where #

A bifunctor is a type constructor that takes two type arguments and is a functor in both arguments. That is, unlike with Functor, a type constructor such as Either does not need to be partially applied for a Bifunctor instance, and the methods in this class permit mapping functions over the Left value or the Right value, or both at the same time.

Formally, the class Bifunctor represents a bifunctor from Hask -> Hask.

Intuitively it is a bifunctor where both the first and second arguments are covariant.

You can define a Bifunctor by either defining bimap or by defining both first and second.

If you supply bimap, you should ensure that:

bimap id id ≡ id

If you supply first and second, ensure:

first id ≡ id
second id ≡ id

If you supply both, you should also ensure:

bimap f g ≡ first f . second g

These ensure by parametricity:

bimap  (f . g) (h . i) ≡ bimap f h . bimap g i
first  (f . g) ≡ first  f . first  g
second (f . g) ≡ second f . second g

Since: base-4.8.0.0

Minimal complete definition

bimap | first, second

Methods

bimap :: (a -> b) -> (c -> d) -> p a c -> p b d #

Map over both arguments at the same time.

bimap f g ≡ first f . second g

Examples

Expand

>>> bimap toUpper (+1) ('j', 3)
('J',4)

>>> bimap toUpper (+1) (Left 'j')
Left 'J'

>>> bimap toUpper (+1) (Right 3)
Right 4

first :: (a -> b) -> p a c -> p b c #

Map covariantly over the first argument.

first f ≡ bimap f id

Examples

Expand

>>> first toUpper ('j', 3)
('J',3)

>>> first toUpper (Left 'j')
Left 'J'

second :: (b -> c) -> p a b -> p a c #

Map covariantly over the second argument.

second ≡ bimap id

Examples

Expand

>>> second (+1) ('j', 3)
('j',4)

>>> second (+1) (Right 3)
Right 4

Instances

Instances details

Bifunctor Either	Since: base-4.8.0.0
Instance details Defined in Data.Bifunctor Methods bimap :: (a -> b) -> (c -> d) -> Either a c -> Either b d # first :: (a -> b) -> Either a c -> Either b c # second :: (b -> c) -> Either a b -> Either a c #
Bifunctor Arg	Since: base-4.9.0.0
Instance details Defined in Data.Semigroup Methods bimap :: (a -> b) -> (c -> d) -> Arg a c -> Arg b d # first :: (a -> b) -> Arg a c -> Arg b c # second :: (b -> c) -> Arg a b -> Arg a c #
Bifunctor (,)	Since: base-4.8.0.0
Instance details Defined in Data.Bifunctor Methods bimap :: (a -> b) -> (c -> d) -> (a, c) -> (b, d) # first :: (a -> b) -> (a, c) -> (b, c) # second :: (b -> c) -> (a, b) -> (a, c) #
Bifunctor (Const :: Type -> Type -> Type)	Since: base-4.8.0.0
Instance details Defined in Data.Bifunctor Methods bimap :: (a -> b) -> (c -> d) -> Const a c -> Const b d # first :: (a -> b) -> Const a c -> Const b c # second :: (b -> c) -> Const a b -> Const a c #
Bifunctor ((,,) x1)	Since: base-4.8.0.0
Instance details Defined in Data.Bifunctor Methods bimap :: (a -> b) -> (c -> d) -> (x1, a, c) -> (x1, b, d) # first :: (a -> b) -> (x1, a, c) -> (x1, b, c) # second :: (b -> c) -> (x1, a, b) -> (x1, a, c) #
Bifunctor (K1 i :: Type -> Type -> Type)	Since: base-4.9.0.0
Instance details Defined in Data.Bifunctor Methods bimap :: (a -> b) -> (c -> d) -> K1 i a c -> K1 i b d # first :: (a -> b) -> K1 i a c -> K1 i b c # second :: (b -> c) -> K1 i a b -> K1 i a c #
Bifunctor ((,,,) x1 x2)	Since: base-4.8.0.0
Instance details Defined in Data.Bifunctor Methods bimap :: (a -> b) -> (c -> d) -> (x1, x2, a, c) -> (x1, x2, b, d) # first :: (a -> b) -> (x1, x2, a, c) -> (x1, x2, b, c) # second :: (b -> c) -> (x1, x2, a, b) -> (x1, x2, a, c) #
Bifunctor ((,,,,) x1 x2 x3)	Since: base-4.8.0.0
Instance details Defined in Data.Bifunctor Methods bimap :: (a -> b) -> (c -> d) -> (x1, x2, x3, a, c) -> (x1, x2, x3, b, d) # first :: (a -> b) -> (x1, x2, x3, a, c) -> (x1, x2, x3, b, c) # second :: (b -> c) -> (x1, x2, x3, a, b) -> (x1, x2, x3, a, c) #
Bifunctor ((,,,,,) x1 x2 x3 x4)	Since: base-4.8.0.0
Instance details Defined in Data.Bifunctor Methods bimap :: (a -> b) -> (c -> d) -> (x1, x2, x3, x4, a, c) -> (x1, x2, x3, x4, b, d) # first :: (a -> b) -> (x1, x2, x3, x4, a, c) -> (x1, x2, x3, x4, b, c) # second :: (b -> c) -> (x1, x2, x3, x4, a, b) -> (x1, x2, x3, x4, a, c) #
Bifunctor ((,,,,,,) x1 x2 x3 x4 x5)	Since: base-4.8.0.0
Instance details Defined in Data.Bifunctor Methods bimap :: (a -> b) -> (c -> d) -> (x1, x2, x3, x4, x5, a, c) -> (x1, x2, x3, x4, x5, b, d) # first :: (a -> b) -> (x1, x2, x3, x4, x5, a, c) -> (x1, x2, x3, x4, x5, b, c) # second :: (b -> c) -> (x1, x2, x3, x4, x5, a, b) -> (x1, x2, x3, x4, x5, a, c) #

xor :: Bits a => a -> a -> a infixl 6 #

Bitwise "xor"

toIntegralSized :: (Integral a, Integral b, Bits a, Bits b) => a -> Maybe b #

Attempt to convert an Integral type a to an Integral type b using the size of the types as measured by Bits methods.

A simpler version of this function is:

toIntegral :: (Integral a, Integral b) => a -> Maybe b
toIntegral x
  | toInteger x == y = Just (fromInteger y)
  | otherwise        = Nothing
  where
    y = toInteger x

This version requires going through Integer, which can be inefficient. However, toIntegralSized is optimized to allow GHC to statically determine the relative type sizes (as measured by bitSizeMaybe and isSigned) and avoid going through Integer for many types. (The implementation uses fromIntegral, which is itself optimized with rules for base types but may go through Integer for some type pairs.)

Since: base-4.8.0.0

otherwise :: Bool #

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

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

data Bool #

Constructors

False
True

Instances

Instances details

Bits Bool	Interpret `Bool` as 1-bit bit-field Since: base-4.7.0.0
Instance details Defined in Data.Bits Methods (.&.) :: Bool -> Bool -> Bool # (.\|.) :: Bool -> Bool -> Bool # xor :: Bool -> Bool -> Bool # complement :: Bool -> Bool # shift :: Bool -> Int -> Bool # rotate :: Bool -> Int -> Bool # zeroBits :: Bool # bit :: Int -> Bool # setBit :: Bool -> Int -> Bool # clearBit :: Bool -> Int -> Bool # complementBit :: Bool -> Int -> Bool # testBit :: Bool -> Int -> Bool # bitSizeMaybe :: Bool -> Maybe Int # bitSize :: Bool -> Int # isSigned :: Bool -> Bool # shiftL :: Bool -> Int -> Bool # unsafeShiftL :: Bool -> Int -> Bool # shiftR :: Bool -> Int -> Bool # unsafeShiftR :: Bool -> Int -> Bool # rotateL :: Bool -> Int -> Bool # rotateR :: Bool -> Int -> Bool # popCount :: Bool -> Int #
FiniteBits Bool	Since: base-4.7.0.0
Instance details Defined in Data.Bits Methods finiteBitSize :: Bool -> Int # countLeadingZeros :: Bool -> Int # countTrailingZeros :: Bool -> Int #
Bounded Bool	Since: base-2.1
Instance details Defined in GHC.Enum Methods minBound :: Bool # maxBound :: Bool #
Enum Bool	Since: base-2.1
Instance details Defined in GHC.Enum 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] #
Generic Bool
Instance details Defined in GHC.Generics Associated Types type Rep Bool :: Type -> Type # Methods from :: Bool -> Rep Bool x # to :: Rep Bool x -> Bool #
SingKind Bool	Since: base-4.9.0.0
Instance details Defined in GHC.Generics Associated Types type DemoteRep Bool Methods fromSing :: forall (a :: Bool). Sing a -> DemoteRep Bool
Read Bool	Since: base-2.1
Instance details Defined in GHC.Read Methods readsPrec :: Int -> ReadS Bool # readList :: ReadS [Bool] # readPrec :: ReadPrec Bool # readListPrec :: ReadPrec [Bool] #
Show Bool	Since: base-2.1
Instance details Defined in GHC.Show Methods showsPrec :: Int -> Bool -> ShowS # show :: Bool -> String # showList :: [Bool] -> ShowS #
Eq Bool
Instance details Defined in GHC.Classes Methods (==) :: Bool -> Bool -> Bool # (/=) :: Bool -> Bool -> Bool #
Ord Bool
Instance details Defined in GHC.Classes Methods compare :: Bool -> Bool -> Ordering # (<) :: Bool -> Bool -> Bool # (<=) :: Bool -> Bool -> Bool # (>) :: Bool -> Bool -> Bool # (>=) :: Bool -> Bool -> Bool # max :: Bool -> Bool -> Bool # min :: Bool -> Bool -> Bool #
SingI 'False	Since: base-4.9.0.0
Instance details Defined in GHC.Generics Methods sing :: Sing 'False
SingI 'True	Since: base-4.9.0.0
Instance details Defined in GHC.Generics Methods sing :: Sing 'True
Lift Bool
Instance details Defined in Language.Haskell.TH.Syntax Methods lift :: Quote m => Bool -> m Exp # liftTyped :: forall (m :: Type -> Type). Quote m => Bool -> Code m Bool #
type DemoteRep Bool
Instance details Defined in GHC.Generics type DemoteRep Bool = Bool
type Rep Bool	Since: base-4.6.0.0
Instance details Defined in GHC.Generics type Rep Bool = D1 ('MetaData "Bool" "GHC.Types" "ghc-prim" 'False) (C1 ('MetaCons "False" 'PrefixI 'False) (U1 :: Type -> Type) :+: C1 ('MetaCons "True" 'PrefixI 'False) (U1 :: Type -> Type))
data Sing (a :: Bool)
Instance details Defined in GHC.Generics data Sing (a :: Bool) where STrue :: Sing 'True SFalse :: Sing 'False

bool :: a -> a -> Bool -> a #

Case analysis for the Bool type. bool x y p evaluates to x when p is False, and evaluates to y when p is True.

This is equivalent to if p then y else x; that is, one can think of it as an if-then-else construct with its arguments reordered.

Examples

Expand

Basic usage:

>>> bool "foo" "bar" True
"bar"
>>> bool "foo" "bar" False
"foo"

Confirm that bool x y p and if p then y else x are equivalent:

>>> let p = True; x = "bar"; y = "foo"
>>> bool x y p == if p then y else x
True
>>> let p = False
>>> bool x y p == if p then y else x
True

Since: base-4.7.0.0

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

Boolean "and", lazy in the second argument

not :: Bool -> Bool #

Boolean "not"

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

Boolean "or", lazy in the second argument

data Char #

The character type Char is an enumeration whose values represent Unicode (or equivalently ISO/IEC 10646) code points (i.e. characters, see http://www.unicode.org/ for details). This set extends the ISO 8859-1 (Latin-1) character set (the first 256 characters), which is itself an extension of the ASCII character set (the first 128 characters). A character literal in Haskell has type Char.

To convert a Char to or from the corresponding Int value defined by Unicode, use toEnum and fromEnum from the Enum class respectively (or equivalently ord and chr).

Instances

Instances details

Bounded Char	Since: base-2.1
Instance details Defined in GHC.Enum Methods minBound :: Char # maxBound :: Char #
Enum Char	Since: base-2.1
Instance details Defined in GHC.Enum 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] #
Read Char	Since: base-2.1
Instance details Defined in GHC.Read Methods readsPrec :: Int -> ReadS Char # readList :: ReadS [Char] # readPrec :: ReadPrec Char # readListPrec :: ReadPrec [Char] #
Show Char	Since: base-2.1
Instance details Defined in GHC.Show Methods showsPrec :: Int -> Char -> ShowS # show :: Char -> String # showList :: [Char] -> ShowS #
Eq Char
Instance details Defined in GHC.Classes Methods (==) :: Char -> Char -> Bool # (/=) :: Char -> Char -> Bool #
Ord Char
Instance details Defined in GHC.Classes Methods compare :: Char -> Char -> Ordering # (<) :: Char -> Char -> Bool # (<=) :: Char -> Char -> Bool # (>) :: Char -> Char -> Bool # (>=) :: Char -> Char -> Bool # max :: Char -> Char -> Char # min :: Char -> Char -> Char #
ToLText String Source #
Instance details Defined in Incipit.String.Conversion Methods toLText :: String -> LText Source #
ToString String Source #
Instance details Defined in Incipit.String.Conversion Methods toString :: String -> String Source #
ToText String Source #
Instance details Defined in Incipit.String.Conversion Methods toText :: String -> Text Source #
ConvertUtf8 String ByteString Source #
Instance details Defined in Incipit.String.Conversion Methods encodeUtf8 :: String -> ByteString Source # decodeUtf8 :: ByteString -> String Source # decodeUtf8Strict :: ByteString -> Either UnicodeException String Source #
ConvertUtf8 String ShortByteString Source #	Since: 0.6.0.0
Instance details Defined in Incipit.String.Conversion Methods encodeUtf8 :: String -> ShortByteString Source # decodeUtf8 :: ShortByteString -> String Source # decodeUtf8Strict :: ShortByteString -> Either UnicodeException String Source #
ConvertUtf8 String LByteString Source #	Converting `String` to `ByteString` might be a slow operation. Consider using lazy bytestring at first place.
Instance details Defined in Incipit.String.Conversion Methods encodeUtf8 :: String -> LByteString Source # decodeUtf8 :: LByteString -> String Source # decodeUtf8Strict :: LByteString -> Either UnicodeException String Source #
Lift Char
Instance details Defined in Language.Haskell.TH.Syntax Methods lift :: Quote m => Char -> m Exp # liftTyped :: forall (m :: Type -> Type). Quote m => Char -> Code m Char #
Generic1 (URec Char :: k -> Type)
Instance details Defined in GHC.Generics Associated Types type Rep1 (URec Char) :: k -> Type # Methods from1 :: forall (a :: k0). URec Char a -> Rep1 (URec Char) a # to1 :: forall (a :: k0). Rep1 (URec Char) a -> URec Char a #
Foldable (UChar :: Type -> Type)	Since: base-4.9.0.0
Instance details Defined in Data.Foldable Methods fold :: Monoid m => UChar m -> m # foldMap :: Monoid m => (a -> m) -> UChar a -> m # foldMap' :: Monoid m => (a -> m) -> UChar a -> m # foldr :: (a -> b -> b) -> b -> UChar a -> b # foldr' :: (a -> b -> b) -> b -> UChar a -> b # foldl :: (b -> a -> b) -> b -> UChar a -> b # foldl' :: (b -> a -> b) -> b -> UChar a -> b # foldr1 :: (a -> a -> a) -> UChar a -> a # foldl1 :: (a -> a -> a) -> UChar a -> a # toList :: UChar a -> [a] # null :: UChar a -> Bool # length :: UChar a -> Int # elem :: Eq a => a -> UChar a -> Bool # maximum :: Ord a => UChar a -> a # minimum :: Ord a => UChar a -> a # sum :: Num a => UChar a -> a # product :: Num a => UChar a -> a #
Traversable (UChar :: Type -> Type)	Since: base-4.9.0.0
Instance details Defined in Data.Traversable Methods traverse :: Applicative f => (a -> f b) -> UChar a -> f (UChar b) # sequenceA :: Applicative f => UChar (f a) -> f (UChar a) # mapM :: Monad m => (a -> m b) -> UChar a -> m (UChar b) # sequence :: Monad m => UChar (m a) -> m (UChar a) #
Functor (URec Char :: Type -> Type)	Since: base-4.9.0.0
Instance details Defined in GHC.Generics Methods fmap :: (a -> b) -> URec Char a -> URec Char b # (<$) :: a -> URec Char b -> URec Char a #
Generic (URec Char p)
Instance details Defined in GHC.Generics Associated Types type Rep (URec Char p) :: Type -> Type # Methods from :: URec Char p -> Rep (URec Char p) x # to :: Rep (URec Char p) x -> URec Char p #
Show (URec Char p)	Since: base-4.9.0.0
Instance details Defined in GHC.Generics Methods showsPrec :: Int -> URec Char p -> ShowS # show :: URec Char p -> String # showList :: [URec Char p] -> ShowS #
Eq (URec Char p)	Since: base-4.9.0.0
Instance details Defined in GHC.Generics Methods (==) :: URec Char p -> URec Char p -> Bool # (/=) :: URec Char p -> URec Char p -> Bool #
Ord (URec Char p)	Since: base-4.9.0.0
Instance details Defined in GHC.Generics Methods compare :: URec Char p -> URec Char p -> Ordering # (<) :: URec Char p -> URec Char p -> Bool # (<=) :: URec Char p -> URec Char p -> Bool # (>) :: URec Char p -> URec Char p -> Bool # (>=) :: URec Char p -> URec Char p -> Bool # max :: URec Char p -> URec Char p -> URec Char p # min :: URec Char p -> URec Char p -> URec Char p #
data URec Char (p :: k)	Used for marking occurrences of `Char#` Since: base-4.9.0.0
Instance details Defined in GHC.Generics data URec Char (p :: k) = UChar { uChar# :: Char# }
type Rep1 (URec Char :: k -> Type)	Since: base-4.9.0.0
Instance details Defined in GHC.Generics type Rep1 (URec Char :: k -> Type) = D1 ('MetaData "URec" "GHC.Generics" "base" 'False) (C1 ('MetaCons "UChar" 'PrefixI 'True) (S1 ('MetaSel ('Just "uChar#") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (UChar :: k -> Type)))
type Rep (URec Char p)	Since: base-4.9.0.0
Instance details Defined in GHC.Generics type Rep (URec Char p) = D1 ('MetaData "URec" "GHC.Generics" "base" 'False) (C1 ('MetaCons "UChar" 'PrefixI 'True) (S1 ('MetaSel ('Just "uChar#") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (UChar :: Type -> Type)))

chr :: Int -> Char #

The toEnum method restricted to the type Char.

coerce :: forall {k :: RuntimeRep} (a :: TYPE k) (b :: TYPE k). Coercible a b => a -> b #

The function coerce allows you to safely convert between values of types that have the same representation with no run-time overhead. In the simplest case you can use it instead of a newtype constructor, to go from the newtype's concrete type to the abstract type. But it also works in more complicated settings, e.g. converting a list of newtypes to a list of concrete types.

This function is runtime-representation polymorphic, but the RuntimeRep type argument is marked as Inferred, meaning that it is not available for visible type application. This means the typechecker will accept coerce @Int @Age 42.

class a ~R# b => Coercible (a :: k) (b :: k) #

Coercible is a two-parameter class that has instances for types a and b if the compiler can infer that they have the same representation. This class does not have regular instances; instead they are created on-the-fly during type-checking. Trying to manually declare an instance of Coercible is an error.

Nevertheless one can pretend that the following three kinds of instances exist. First, as a trivial base-case:

instance Coercible a a

Furthermore, for every type constructor there is an instance that allows to coerce under the type constructor. For example, let D be a prototypical type constructor (data or newtype) with three type arguments, which have roles nominal, representational resp. phantom. Then there is an instance of the form

instance Coercible b b' => Coercible (D a b c) (D a b' c')

Note that the nominal type arguments are equal, the representational type arguments can differ, but need to have a Coercible instance themself, and the phantom type arguments can be changed arbitrarily.

The third kind of instance exists for every newtype NT = MkNT T and comes in two variants, namely

instance Coercible a T => Coercible a NT

instance Coercible T b => Coercible NT b

This instance is only usable if the constructor MkNT is in scope.

If, as a library author of a type constructor like Set a, you want to prevent a user of your module to write coerce :: Set T -> Set NT, you need to set the role of Set's type parameter to nominal, by writing

type role Set nominal

For more details about this feature, please refer to Safe Coercions by Joachim Breitner, Richard A. Eisenberg, Simon Peyton Jones and Stephanie Weirich.

Since: ghc-prim-4.7.0.0

module Data.Either

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.

The Haskell Report defines no laws for Eq. However, == is customarily expected to implement an equivalence relationship where two values comparing equal are indistinguishable by "public" functions, with a "public" function being one not allowing to see implementation details. For example, for a type representing non-normalised natural numbers modulo 100, a "public" function doesn't make the difference between 1 and 201. It is expected to have the following properties:

Reflexivity: x == x = True
Symmetry: x == y = y == x
Transitivity: if x == y && y == z = True, then x == z = True
Substitutivity: if x == y = True and f is a "public" function whose return type is an instance of Eq, then f x == f y = True
Negation: x /= y = not (x == y)

Minimal complete definition: either == or /=.

Minimal complete definition

(==) | (/=)

Methods

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

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

Instances

Instances details

Eq SomeTypeRep
Instance details Defined in Data.Typeable.Internal Methods (==) :: SomeTypeRep -> SomeTypeRep -> Bool # (/=) :: SomeTypeRep -> SomeTypeRep -> Bool #
Eq Void	Since: base-4.8.0.0
Instance details Defined in Data.Void Methods (==) :: Void -> Void -> Bool # (/=) :: Void -> Void -> Bool #
Eq ArithException	Since: base-3.0
Instance details Defined in GHC.Exception.Type Methods (==) :: ArithException -> ArithException -> Bool # (/=) :: ArithException -> ArithException -> Bool #
Eq SpecConstrAnnotation	Since: base-4.3.0.0
Instance details Defined in GHC.Exts Methods (==) :: SpecConstrAnnotation -> SpecConstrAnnotation -> Bool # (/=) :: SpecConstrAnnotation -> SpecConstrAnnotation -> Bool #
Eq Associativity	Since: base-4.6.0.0
Instance details Defined in GHC.Generics Methods (==) :: Associativity -> Associativity -> Bool # (/=) :: Associativity -> Associativity -> Bool #
Eq DecidedStrictness	Since: base-4.9.0.0
Instance details Defined in GHC.Generics Methods (==) :: DecidedStrictness -> DecidedStrictness -> Bool # (/=) :: DecidedStrictness -> DecidedStrictness -> Bool #
Eq Fixity	Since: base-4.6.0.0
Instance details Defined in GHC.Generics Methods (==) :: Fixity -> Fixity -> Bool # (/=) :: Fixity -> Fixity -> Bool #
Eq SourceStrictness	Since: base-4.9.0.0
Instance details Defined in GHC.Generics Methods (==) :: SourceStrictness -> SourceStrictness -> Bool # (/=) :: SourceStrictness -> SourceStrictness -> Bool #
Eq SourceUnpackedness	Since: base-4.9.0.0
Instance details Defined in GHC.Generics Methods (==) :: SourceUnpackedness -> SourceUnpackedness -> Bool # (/=) :: SourceUnpackedness -> SourceUnpackedness -> Bool #
Eq MaskingState	Since: base-4.3.0.0
Instance details Defined in GHC.IO Methods (==) :: MaskingState -> MaskingState -> Bool # (/=) :: MaskingState -> MaskingState -> Bool #
Eq Int16	Since: base-2.1
Instance details Defined in GHC.Int Methods (==) :: Int16 -> Int16 -> Bool # (/=) :: Int16 -> Int16 -> Bool #
Eq Int32	Since: base-2.1
Instance details Defined in GHC.Int Methods (==) :: Int32 -> Int32 -> Bool # (/=) :: Int32 -> Int32 -> Bool #
Eq Int64	Since: base-2.1
Instance details Defined in GHC.Int Methods (==) :: Int64 -> Int64 -> Bool # (/=) :: Int64 -> Int64 -> Bool #
Eq Int8	Since: base-2.1
Instance details Defined in GHC.Int Methods (==) :: Int8 -> Int8 -> Bool # (/=) :: Int8 -> Int8 -> Bool #
Eq SrcLoc	Since: base-4.9.0.0
Instance details Defined in GHC.Stack.Types Methods (==) :: SrcLoc -> SrcLoc -> Bool # (/=) :: SrcLoc -> SrcLoc -> Bool #
Eq SomeSymbol	Since: base-4.7.0.0
Instance details Defined in GHC.TypeLits Methods (==) :: SomeSymbol -> SomeSymbol -> Bool # (/=) :: SomeSymbol -> SomeSymbol -> Bool #
Eq SomeNat	Since: base-4.7.0.0
Instance details Defined in GHC.TypeNats Methods (==) :: SomeNat -> SomeNat -> Bool # (/=) :: SomeNat -> SomeNat -> Bool #
Eq Word16	Since: base-2.1
Instance details Defined in GHC.Word Methods (==) :: Word16 -> Word16 -> Bool # (/=) :: Word16 -> Word16 -> Bool #
Eq Word32	Since: base-2.1
Instance details Defined in GHC.Word Methods (==) :: Word32 -> Word32 -> Bool # (/=) :: Word32 -> Word32 -> Bool #
Eq Word64	Since: base-2.1
Instance details Defined in GHC.Word Methods (==) :: Word64 -> Word64 -> Bool # (/=) :: Word64 -> Word64 -> Bool #
Eq ByteString
Instance details Defined in Data.ByteString.Internal Methods (==) :: ByteString -> ByteString -> Bool # (/=) :: ByteString -> ByteString -> Bool #
Eq ByteString
Instance details Defined in Data.ByteString.Lazy.Internal Methods (==) :: ByteString -> ByteString -> Bool # (/=) :: ByteString -> ByteString -> Bool #
Eq ShortByteString
Instance details Defined in Data.ByteString.Short.Internal Methods (==) :: ShortByteString -> ShortByteString -> Bool # (/=) :: ShortByteString -> ShortByteString -> Bool #
Eq IntSet
Instance details Defined in Data.IntSet.Internal Methods (==) :: IntSet -> IntSet -> Bool # (/=) :: IntSet -> IntSet -> Bool #
Eq Relation
Instance details Defined in Data.IntSet.Internal Methods (==) :: Relation -> Relation -> Bool # (/=) :: Relation -> Relation -> Bool #
Eq BigNat
Instance details Defined in GHC.Num.BigNat Methods (==) :: BigNat -> BigNat -> Bool # (/=) :: BigNat -> BigNat -> Bool #
Eq ForeignSrcLang
Instance details Defined in GHC.ForeignSrcLang.Type Methods (==) :: ForeignSrcLang -> ForeignSrcLang -> Bool # (/=) :: ForeignSrcLang -> ForeignSrcLang -> Bool #
Eq Extension
Instance details Defined in GHC.LanguageExtensions.Type Methods (==) :: Extension -> Extension -> Bool # (/=) :: Extension -> Extension -> Bool #
Eq Module
Instance details Defined in GHC.Classes Methods (==) :: Module -> Module -> Bool # (/=) :: Module -> Module -> Bool #
Eq Ordering
Instance details Defined in GHC.Classes Methods (==) :: Ordering -> Ordering -> Bool # (/=) :: Ordering -> Ordering -> Bool #
Eq TrName
Instance details Defined in GHC.Classes Methods (==) :: TrName -> TrName -> Bool # (/=) :: TrName -> TrName -> Bool #
Eq TyCon
Instance details Defined in GHC.Classes Methods (==) :: TyCon -> TyCon -> Bool # (/=) :: TyCon -> TyCon -> Bool #
Eq AnnLookup
Instance details Defined in Language.Haskell.TH.Syntax Methods (==) :: AnnLookup -> AnnLookup -> Bool # (/=) :: AnnLookup -> AnnLookup -> Bool #
Eq AnnTarget
Instance details Defined in Language.Haskell.TH.Syntax Methods (==) :: AnnTarget -> AnnTarget -> Bool # (/=) :: AnnTarget -> AnnTarget -> Bool #
Eq Bang
Instance details Defined in Language.Haskell.TH.Syntax Methods (==) :: Bang -> Bang -> Bool # (/=) :: Bang -> Bang -> Bool #
Eq Body
Instance details Defined in Language.Haskell.TH.Syntax Methods (==) :: Body -> Body -> Bool # (/=) :: Body -> Body -> Bool #
Eq Bytes
Instance details Defined in Language.Haskell.TH.Syntax Methods (==) :: Bytes -> Bytes -> Bool # (/=) :: Bytes -> Bytes -> Bool #
Eq Callconv
Instance details Defined in Language.Haskell.TH.Syntax Methods (==) :: Callconv -> Callconv -> Bool # (/=) :: Callconv -> Callconv -> Bool #
Eq Clause
Instance details Defined in Language.Haskell.TH.Syntax Methods (==) :: Clause -> Clause -> Bool # (/=) :: Clause -> Clause -> Bool #
Eq Con
Instance details Defined in Language.Haskell.TH.Syntax Methods (==) :: Con -> Con -> Bool # (/=) :: Con -> Con -> Bool #
Eq Dec
Instance details Defined in Language.Haskell.TH.Syntax Methods (==) :: Dec -> Dec -> Bool # (/=) :: Dec -> Dec -> Bool #
Eq DecidedStrictness
Instance details Defined in Language.Haskell.TH.Syntax Methods (==) :: DecidedStrictness -> DecidedStrictness -> Bool # (/=) :: DecidedStrictness -> DecidedStrictness -> Bool #
Eq DerivClause
Instance details Defined in Language.Haskell.TH.Syntax Methods (==) :: DerivClause -> DerivClause -> Bool # (/=) :: DerivClause -> DerivClause -> Bool #
Eq DerivStrategy
Instance details Defined in Language.Haskell.TH.Syntax Methods (==) :: DerivStrategy -> DerivStrategy -> Bool # (/=) :: DerivStrategy -> DerivStrategy -> Bool #
Eq Exp
Instance details Defined in Language.Haskell.TH.Syntax Methods (==) :: Exp -> Exp -> Bool # (/=) :: Exp -> Exp -> Bool #
Eq FamilyResultSig
Instance details Defined in Language.Haskell.TH.Syntax Methods (==) :: FamilyResultSig -> FamilyResultSig -> Bool # (/=) :: FamilyResultSig -> FamilyResultSig -> Bool #
Eq Fixity
Instance details Defined in Language.Haskell.TH.Syntax Methods (==) :: Fixity -> Fixity -> Bool # (/=) :: Fixity -> Fixity -> Bool #
Eq FixityDirection
Instance details Defined in Language.Haskell.TH.Syntax Methods (==) :: FixityDirection -> FixityDirection -> Bool # (/=) :: FixityDirection -> FixityDirection -> Bool #
Eq Foreign
Instance details Defined in Language.Haskell.TH.Syntax Methods (==) :: Foreign -> Foreign -> Bool # (/=) :: Foreign -> Foreign -> Bool #
Eq FunDep
Instance details Defined in Language.Haskell.TH.Syntax Methods (==) :: FunDep -> FunDep -> Bool # (/=) :: FunDep -> FunDep -> Bool #
Eq Guard
Instance details Defined in Language.Haskell.TH.Syntax Methods (==) :: Guard -> Guard -> Bool # (/=) :: Guard -> Guard -> Bool #
Eq Info
Instance details Defined in Language.Haskell.TH.Syntax Methods (==) :: Info -> Info -> Bool # (/=) :: Info -> Info -> Bool #
Eq InjectivityAnn
Instance details Defined in Language.Haskell.TH.Syntax Methods (==) :: InjectivityAnn -> InjectivityAnn -> Bool # (/=) :: InjectivityAnn -> InjectivityAnn -> Bool #
Eq Inline
Instance details Defined in Language.Haskell.TH.Syntax Methods (==) :: Inline -> Inline -> Bool # (/=) :: Inline -> Inline -> Bool #
Eq Lit
Instance details Defined in Language.Haskell.TH.Syntax Methods (==) :: Lit -> Lit -> Bool # (/=) :: Lit -> Lit -> Bool #
Eq Loc
Instance details Defined in Language.Haskell.TH.Syntax Methods (==) :: Loc -> Loc -> Bool # (/=) :: Loc -> Loc -> Bool #
Eq Match
Instance details Defined in Language.Haskell.TH.Syntax Methods (==) :: Match -> Match -> Bool # (/=) :: Match -> Match -> Bool #
Eq ModName
Instance details Defined in Language.Haskell.TH.Syntax Methods (==) :: ModName -> ModName -> Bool # (/=) :: ModName -> ModName -> Bool #
Eq Module
Instance details Defined in Language.Haskell.TH.Syntax Methods (==) :: Module -> Module -> Bool # (/=) :: Module -> Module -> Bool #
Eq ModuleInfo
Instance details Defined in Language.Haskell.TH.Syntax Methods (==) :: ModuleInfo -> ModuleInfo -> Bool # (/=) :: ModuleInfo -> ModuleInfo -> Bool #
Eq Name
Instance details Defined in Language.Haskell.TH.Syntax Methods (==) :: Name -> Name -> Bool # (/=) :: Name -> Name -> Bool #
Eq NameFlavour
Instance details Defined in Language.Haskell.TH.Syntax Methods (==) :: NameFlavour -> NameFlavour -> Bool # (/=) :: NameFlavour -> NameFlavour -> Bool #
Eq NameSpace
Instance details Defined in Language.Haskell.TH.Syntax Methods (==) :: NameSpace -> NameSpace -> Bool # (/=) :: NameSpace -> NameSpace -> Bool #
Eq OccName
Instance details Defined in Language.Haskell.TH.Syntax Methods (==) :: OccName -> OccName -> Bool # (/=) :: OccName -> OccName -> Bool #
Eq Overlap
Instance details Defined in Language.Haskell.TH.Syntax Methods (==) :: Overlap -> Overlap -> Bool # (/=) :: Overlap -> Overlap -> Bool #
Eq Pat
Instance details Defined in Language.Haskell.TH.Syntax Methods (==) :: Pat -> Pat -> Bool # (/=) :: Pat -> Pat -> Bool #
Eq PatSynArgs
Instance details Defined in Language.Haskell.TH.Syntax Methods (==) :: PatSynArgs -> PatSynArgs -> Bool # (/=) :: PatSynArgs -> PatSynArgs -> Bool #
Eq PatSynDir
Instance details Defined in Language.Haskell.TH.Syntax Methods (==) :: PatSynDir -> PatSynDir -> Bool # (/=) :: PatSynDir -> PatSynDir -> Bool #
Eq Phases
Instance details Defined in Language.Haskell.TH.Syntax Methods (==) :: Phases -> Phases -> Bool # (/=) :: Phases -> Phases -> Bool #
Eq PkgName
Instance details Defined in Language.Haskell.TH.Syntax Methods (==) :: PkgName -> PkgName -> Bool # (/=) :: PkgName -> PkgName -> Bool #
Eq Pragma
Instance details Defined in Language.Haskell.TH.Syntax Methods (==) :: Pragma -> Pragma -> Bool # (/=) :: Pragma -> Pragma -> Bool #
Eq Range
Instance details Defined in Language.Haskell.TH.Syntax Methods (==) :: Range -> Range -> Bool # (/=) :: Range -> Range -> Bool #
Eq Role
Instance details Defined in Language.Haskell.TH.Syntax Methods (==) :: Role -> Role -> Bool # (/=) :: Role -> Role -> Bool #
Eq RuleBndr
Instance details Defined in Language.Haskell.TH.Syntax Methods (==) :: RuleBndr -> RuleBndr -> Bool # (/=) :: RuleBndr -> RuleBndr -> Bool #
Eq RuleMatch
Instance details Defined in Language.Haskell.TH.Syntax Methods (==) :: RuleMatch -> RuleMatch -> Bool # (/=) :: RuleMatch -> RuleMatch -> Bool #
Eq Safety
Instance details Defined in Language.Haskell.TH.Syntax Methods (==) :: Safety -> Safety -> Bool # (/=) :: Safety -> Safety -> Bool #
Eq SourceStrictness
Instance details Defined in Language.Haskell.TH.Syntax Methods (==) :: SourceStrictness -> SourceStrictness -> Bool # (/=) :: SourceStrictness -> SourceStrictness -> Bool #
Eq SourceUnpackedness
Instance details Defined in Language.Haskell.TH.Syntax Methods (==) :: SourceUnpackedness -> SourceUnpackedness -> Bool # (/=) :: SourceUnpackedness -> SourceUnpackedness -> Bool #
Eq Specificity
Instance details Defined in Language.Haskell.TH.Syntax Methods (==) :: Specificity -> Specificity -> Bool # (/=) :: Specificity -> Specificity -> Bool #
Eq Stmt
Instance details Defined in Language.Haskell.TH.Syntax Methods (==) :: Stmt -> Stmt -> Bool # (/=) :: Stmt -> Stmt -> Bool #
Eq TyLit
Instance details Defined in Language.Haskell.TH.Syntax Methods (==) :: TyLit -> TyLit -> Bool # (/=) :: TyLit -> TyLit -> Bool #
Eq TySynEqn
Instance details Defined in Language.Haskell.TH.Syntax Methods (==) :: TySynEqn -> TySynEqn -> Bool # (/=) :: TySynEqn -> TySynEqn -> Bool #
Eq Type
Instance details Defined in Language.Haskell.TH.Syntax Methods (==) :: Type -> Type -> Bool # (/=) :: Type -> Type -> Bool #
Eq TypeFamilyHead
Instance details Defined in Language.Haskell.TH.Syntax Methods (==) :: TypeFamilyHead -> TypeFamilyHead -> Bool # (/=) :: TypeFamilyHead -> TypeFamilyHead -> Bool #
Eq CodePoint
Instance details Defined in Data.Text.Encoding Methods (==) :: CodePoint -> CodePoint -> Bool # (/=) :: CodePoint -> CodePoint -> Bool #
Eq DecoderState
Instance details Defined in Data.Text.Encoding Methods (==) :: DecoderState -> DecoderState -> Bool # (/=) :: DecoderState -> DecoderState -> Bool #
Eq UnicodeException
Instance details Defined in Data.Text.Encoding.Error Methods (==) :: UnicodeException -> UnicodeException -> Bool # (/=) :: UnicodeException -> UnicodeException -> Bool #
Eq Word8	Since: base-2.1
Instance details Defined in GHC.Word Methods (==) :: Word8 -> Word8 -> Bool # (/=) :: Word8 -> Word8 -> Bool #
Eq Integer
Instance details Defined in GHC.Num.Integer Methods (==) :: Integer -> Integer -> Bool # (/=) :: Integer -> Integer -> Bool #
Eq Natural
Instance details Defined in GHC.Num.Natural Methods (==) :: Natural -> Natural -> Bool # (/=) :: Natural -> Natural -> Bool #
Eq ()
Instance details Defined in GHC.Classes Methods (==) :: () -> () -> Bool # (/=) :: () -> () -> Bool #
Eq Bool
Instance details Defined in GHC.Classes Methods (==) :: Bool -> Bool -> Bool # (/=) :: Bool -> Bool -> Bool #
Eq Char
Instance details Defined in GHC.Classes Methods (==) :: Char -> Char -> Bool # (/=) :: Char -> Char -> Bool #
Eq Double	Note that due to the presence of `NaN`, `Double`'s `Eq` instance does not satisfy reflexivity. `>>>` `0/0 == (0/0 :: Double)`False Also note that `Double`'s `Eq` instance does not satisfy substitutivity: `>>>` `0 == (-0 :: Double)`True `>>>` `recip 0 == recip (-0 :: Double)`False
Instance details Defined in GHC.Classes Methods (==) :: Double -> Double -> Bool # (/=) :: Double -> Double -> Bool #
Eq Float	Note that due to the presence of `NaN`, `Float`'s `Eq` instance does not satisfy reflexivity. `>>>` `0/0 == (0/0 :: Float)`False Also note that `Float`'s `Eq` instance does not satisfy substitutivity: `>>>` `0 == (-0 :: Float)`True `>>>` `recip 0 == recip (-0 :: Float)`False
Instance details Defined in GHC.Classes Methods (==) :: Float -> Float -> Bool # (/=) :: Float -> Float -> Bool #
Eq Int
Instance details Defined in GHC.Classes Methods (==) :: Int -> Int -> Bool # (/=) :: Int -> Int -> Bool #
Eq Word
Instance details Defined in GHC.Classes Methods (==) :: Word -> Word -> Bool # (/=) :: Word -> Word -> Bool #
Eq a => Eq (ZipList a)	Since: base-4.7.0.0
Instance details Defined in Control.Applicative Methods (==) :: ZipList a -> ZipList a -> Bool # (/=) :: ZipList a -> ZipList a -> Bool #
Eq a => Eq (Identity a)	Since: base-4.8.0.0
Instance details Defined in Data.Functor.Identity Methods (==) :: Identity a -> Identity a -> Bool # (/=) :: Identity a -> Identity a -> Bool #
Eq a => Eq (First a)	Since: base-2.1
Instance details Defined in Data.Monoid Methods (==) :: First a -> First a -> Bool # (/=) :: First a -> First a -> Bool #
Eq a => Eq (Last a)	Since: base-2.1
Instance details Defined in Data.Monoid Methods (==) :: Last a -> Last a -> Bool # (/=) :: Last a -> Last a -> Bool #
Eq a => Eq (Down a)	Since: base-4.6.0.0
Instance details Defined in Data.Ord Methods (==) :: Down a -> Down a -> Bool # (/=) :: Down a -> Down a -> Bool #
Eq a => Eq (First a)	Since: base-4.9.0.0
Instance details Defined in Data.Semigroup Methods (==) :: First a -> First a -> Bool # (/=) :: First a -> First a -> Bool #
Eq a => Eq (Last a)	Since: base-4.9.0.0
Instance details Defined in Data.Semigroup Methods (==) :: Last a -> Last a -> Bool # (/=) :: Last a -> Last a -> Bool #
Eq a => Eq (Max a)	Since: base-4.9.0.0
Instance details Defined in Data.Semigroup Methods (==) :: Max a -> Max a -> Bool # (/=) :: Max a -> Max a -> Bool #
Eq a => Eq (Min a)	Since: base-4.9.0.0
Instance details Defined in Data.Semigroup Methods (==) :: Min a -> Min a -> Bool # (/=) :: Min a -> Min a -> Bool #
Eq a => Eq (Option a)	Since: base-4.9.0.0
Instance details Defined in Data.Semigroup Methods (==) :: Option a -> Option a -> Bool # (/=) :: Option a -> Option a -> Bool #
Eq m => Eq (WrappedMonoid m)	Since: base-4.9.0.0
Instance details Defined in Data.Semigroup Methods (==) :: WrappedMonoid m -> WrappedMonoid m -> Bool # (/=) :: WrappedMonoid m -> WrappedMonoid m -> Bool #
Eq a => Eq (NonEmpty a)	Since: base-4.9.0.0
Instance details Defined in GHC.Base Methods (==) :: NonEmpty a -> NonEmpty a -> Bool # (/=) :: NonEmpty a -> NonEmpty a -> Bool #
Eq p => Eq (Par1 p)	Since: base-4.7.0.0
Instance details Defined in GHC.Generics Methods (==) :: Par1 p -> Par1 p -> Bool # (/=) :: Par1 p -> Par1 p -> Bool #
Eq (MVar a)	Since: base-4.1.0.0
Instance details Defined in GHC.MVar Methods (==) :: MVar a -> MVar a -> Bool # (/=) :: MVar a -> MVar a -> Bool #
Eq a => Eq (Ratio a)	Since: base-2.1
Instance details Defined in GHC.Real Methods (==) :: Ratio a -> Ratio a -> Bool # (/=) :: Ratio a -> Ratio a -> Bool #
Eq a => Eq (IntMap a)
Instance details Defined in Data.IntMap.Internal Methods (==) :: IntMap a -> IntMap a -> Bool # (/=) :: IntMap a -> IntMap a -> Bool #
Eq a => Eq (Seq a)
Instance details Defined in Data.Sequence.Internal Methods (==) :: Seq a -> Seq a -> Bool # (/=) :: Seq a -> Seq a -> Bool #
Eq a => Eq (ViewL a)
Instance details Defined in Data.Sequence.Internal Methods (==) :: ViewL a -> ViewL a -> Bool # (/=) :: ViewL a -> ViewL a -> Bool #
Eq a => Eq (ViewR a)
Instance details Defined in Data.Sequence.Internal Methods (==) :: ViewR a -> ViewR a -> Bool # (/=) :: ViewR a -> ViewR a -> Bool #
Eq a => Eq (Set a)
Instance details Defined in Data.Set.Internal Methods (==) :: Set a -> Set a -> Bool # (/=) :: Set a -> Set a -> Bool #
Eq a => Eq (DList a)
Instance details Defined in Data.DList.Internal Methods (==) :: DList a -> DList a -> Bool # (/=) :: DList a -> DList a -> Bool #
Eq flag => Eq (TyVarBndr flag)
Instance details Defined in Language.Haskell.TH.Syntax Methods (==) :: TyVarBndr flag -> TyVarBndr flag -> Bool # (/=) :: TyVarBndr flag -> TyVarBndr flag -> Bool #
Eq a => Eq (Maybe a)	Since: base-2.1
Instance details Defined in GHC.Maybe Methods (==) :: Maybe a -> Maybe a -> Bool # (/=) :: Maybe a -> Maybe a -> Bool #
Eq a => Eq [a]
Instance details Defined in GHC.Classes Methods (==) :: [a] -> [a] -> Bool # (/=) :: [a] -> [a] -> Bool #
(Eq a, Eq b) => Eq (Either a b)	Since: base-2.1
Instance details Defined in Data.Either Methods (==) :: Either a b -> Either a b -> Bool # (/=) :: Either a b -> Either a b -> Bool #
Eq (Fixed a)	Since: base-2.1
Instance details Defined in Data.Fixed Methods (==) :: Fixed a -> Fixed a -> Bool # (/=) :: Fixed a -> Fixed a -> Bool #
Eq (Proxy s)	Since: base-4.7.0.0
Instance details Defined in Data.Proxy Methods (==) :: Proxy s -> Proxy s -> Bool # (/=) :: Proxy s -> Proxy s -> Bool #
Eq a => Eq (Arg a b)	Since: base-4.9.0.0
Instance details Defined in Data.Semigroup Methods (==) :: Arg a b -> Arg a b -> Bool # (/=) :: Arg a b -> Arg a b -> Bool #
Eq (TypeRep a)	Since: base-2.1
Instance details Defined in Data.Typeable.Internal Methods (==) :: TypeRep a -> TypeRep a -> Bool # (/=) :: TypeRep a -> TypeRep a -> Bool #
Eq (U1 p)	Since: base-4.9.0.0
Instance details Defined in GHC.Generics Methods (==) :: U1 p -> U1 p -> Bool # (/=) :: U1 p -> U1 p -> Bool #
Eq (V1 p)	Since: base-4.9.0.0
Instance details Defined in GHC.Generics Methods (==) :: V1 p -> V1 p -> Bool # (/=) :: V1 p -> V1 p -> Bool #
(Eq k, Eq a) => Eq (Map k a)
Instance details Defined in Data.Map.Internal Methods (==) :: Map k a -> Map k a -> Bool # (/=) :: Map k a -> Map k a -> Bool #
(Eq a, Eq b) => Eq (a, b)
Instance details Defined in GHC.Classes Methods (==) :: (a, b) -> (a, b) -> Bool # (/=) :: (a, b) -> (a, b) -> Bool #
Eq a => Eq (Const a b)	Since: base-4.9.0.0
Instance details Defined in Data.Functor.Const Methods (==) :: Const a b -> Const a b -> Bool # (/=) :: Const a b -> Const a b -> Bool #
Eq (f a) => Eq (Ap f a)	Since: base-4.12.0.0
Instance details Defined in Data.Monoid Methods (==) :: Ap f a -> Ap f a -> Bool # (/=) :: Ap f a -> Ap f a -> Bool #
Eq (a :~: b)	Since: base-4.7.0.0
Instance details Defined in Data.Type.Equality Methods (==) :: (a :~: b) -> (a :~: b) -> Bool # (/=) :: (a :~: b) -> (a :~: b) -> Bool #
Eq (f p) => Eq (Rec1 f p)	Since: base-4.7.0.0
Instance details Defined in GHC.Generics Methods (==) :: Rec1 f p -> Rec1 f p -> Bool # (/=) :: Rec1 f p -> Rec1 f p -> Bool #
Eq (URec (Ptr ()) p)	Since: base-4.9.0.0
Instance details Defined in GHC.Generics Methods (==) :: URec (Ptr ()) p -> URec (Ptr ()) p -> Bool # (/=) :: URec (Ptr ()) p -> URec (Ptr ()) p -> Bool #
Eq (URec Char p)	Since: base-4.9.0.0
Instance details Defined in GHC.Generics Methods (==) :: URec Char p -> URec Char p -> Bool # (/=) :: URec Char p -> URec Char p -> Bool #
Eq (URec Double p)	Since: base-4.9.0.0
Instance details Defined in GHC.Generics Methods (==) :: URec Double p -> URec Double p -> Bool # (/=) :: URec Double p -> URec Double p -> Bool #
Eq (URec Float p)
Instance details Defined in GHC.Generics Methods (==) :: URec Float p -> URec Float p -> Bool # (/=) :: URec Float p -> URec Float p -> Bool #
Eq (URec Int p)	Since: base-4.9.0.0
Instance details Defined in GHC.Generics Methods (==) :: URec Int p -> URec Int p -> Bool # (/=) :: URec Int p -> URec Int p -> Bool #
Eq (URec Word p)	Since: base-4.9.0.0
Instance details Defined in GHC.Generics 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 Defined in GHC.Classes Methods (==) :: (a, b, c) -> (a, b, c) -> Bool # (/=) :: (a, b, c) -> (a, b, c) -> Bool #
(Eq1 f, Eq1 g, Eq a) => Eq (Product f g a)	Since: base-4.9.0.0
Instance details Defined in Data.Functor.Product Methods (==) :: Product f g a -> Product f g a -> Bool # (/=) :: Product f g a -> Product f g a -> Bool #
(Eq1 f, Eq1 g, Eq a) => Eq (Sum f g a)	Since: base-4.9.0.0
Instance details Defined in Data.Functor.Sum Methods (==) :: Sum f g a -> Sum f g a -> Bool # (/=) :: Sum f g a -> Sum f g a -> Bool #
Eq (a :~~: b)	Since: base-4.10.0.0
Instance details Defined in Data.Type.Equality Methods (==) :: (a :~~: b) -> (a :~~: b) -> Bool # (/=) :: (a :~~: b) -> (a :~~: b) -> Bool #
(Eq (f p), Eq (g p)) => Eq ((f :*: g) p)	Since: base-4.7.0.0
Instance details Defined in GHC.Generics 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)	Since: base-4.7.0.0
Instance details Defined in GHC.Generics Methods (==) :: (f :+: g) p -> (f :+: g) p -> Bool # (/=) :: (f :+: g) p -> (f :+: g) p -> Bool #
Eq c => Eq (K1 i c p)	Since: base-4.7.0.0
Instance details Defined in GHC.Generics Methods (==) :: K1 i c p -> K1 i c p -> Bool # (/=) :: K1 i c p -> K1 i c p -> Bool #
(Eq a, Eq b, Eq c, Eq d) => Eq (a, b, c, d)
Instance details Defined in GHC.Classes Methods (==) :: (a, b, c, d) -> (a, b, c, d) -> Bool # (/=) :: (a, b, c, d) -> (a, b, c, d) -> Bool #
(Eq1 f, Eq1 g, Eq a) => Eq (Compose f g a)	Since: base-4.9.0.0
Instance details Defined in Data.Functor.Compose Methods (==) :: Compose f g a -> Compose f g a -> Bool # (/=) :: Compose f g a -> Compose f g a -> Bool #
Eq (f (g p)) => Eq ((f :.: g) p)	Since: base-4.7.0.0
Instance details Defined in GHC.Generics Methods (==) :: (f :.: g) p -> (f :.: g) p -> Bool # (/=) :: (f :.: g) p -> (f :.: g) p -> Bool #
Eq (f p) => Eq (M1 i c f p)	Since: base-4.7.0.0
Instance details Defined in GHC.Generics Methods (==) :: M1 i c f p -> M1 i c f p -> Bool # (/=) :: M1 i c f p -> M1 i c f p -> Bool #
(Eq a, Eq b, Eq c, Eq d, Eq e) => Eq (a, b, c, d, e)
Instance details Defined in GHC.Classes Methods (==) :: (a, b, c, d, e) -> (a, b, c, d, e) -> Bool # (/=) :: (a, b, c, d, e) -> (a, b, c, d, e) -> Bool #
(Eq a, Eq b, Eq c, Eq d, Eq e, Eq f) => Eq (a, b, c, d, e, f)
Instance details Defined in GHC.Classes Methods (==) :: (a, b, c, d, e, f) -> (a, b, c, d, e, f) -> Bool # (/=) :: (a, b, c, d, e, f) -> (a, b, c, d, e, f) -> Bool #
(Eq a, Eq b, Eq c, Eq d, Eq e, Eq f, Eq g) => Eq (a, b, c, d, e, f, g)
Instance details Defined in GHC.Classes Methods (==) :: (a, b, c, d, e, f, g) -> (a, b, c, d, e, f, g) -> Bool # (/=) :: (a, b, c, d, e, f, g) -> (a, b, c, d, e, f, g) -> Bool #
(Eq a, Eq b, Eq c, Eq d, Eq e, Eq f, Eq g, Eq h) => Eq (a, b, c, d, e, f, g, h)
Instance details Defined in GHC.Classes Methods (==) :: (a, b, c, d, e, f, g, h) -> (a, b, c, d, e, f, g, h) -> Bool # (/=) :: (a, b, c, d, e, f, g, h) -> (a, b, c, d, e, f, g, h) -> Bool #
(Eq a, Eq b, Eq c, Eq d, Eq e, Eq f, Eq g, Eq h, Eq i) => Eq (a, b, c, d, e, f, g, h, i)
Instance details Defined in GHC.Classes Methods (==) :: (a, b, c, d, e, f, g, h, i) -> (a, b, c, d, e, f, g, h, i) -> Bool # (/=) :: (a, b, c, d, e, f, g, h, i) -> (a, b, c, d, e, f, g, h, i) -> Bool #
(Eq a, Eq b, Eq c, Eq d, Eq e, Eq f, Eq g, Eq h, Eq i, Eq j) => Eq (a, b, c, d, e, f, g, h, i, j)
Instance details Defined in GHC.Classes Methods (==) :: (a, b, c, d, e, f, g, h, i, j) -> (a, b, c, d, e, f, g, h, i, j) -> Bool # (/=) :: (a, b, c, d, e, f, g, h, i, j) -> (a, b, c, d, e, f, g, h, i, j) -> Bool #
(Eq a, Eq b, Eq c, Eq d, Eq e, Eq f, Eq g, Eq h, Eq i, Eq j, Eq k) => Eq (a, b, c, d, e, f, g, h, i, j, k)
Instance details Defined in GHC.Classes Methods (==) :: (a, b, c, d, e, f, g, h, i, j, k) -> (a, b, c, d, e, f, g, h, i, j, k) -> Bool # (/=) :: (a, b, c, d, e, f, g, h, i, j, k) -> (a, b, c, d, e, f, g, h, i, j, k) -> Bool #
(Eq a, Eq b, Eq c, Eq d, Eq e, Eq f, Eq g, Eq h, Eq i, Eq j, Eq k, Eq l) => Eq (a, b, c, d, e, f, g, h, i, j, k, l)
Instance details Defined in GHC.Classes Methods (==) :: (a, b, c, d, e, f, g, h, i, j, k, l) -> (a, b, c, d, e, f, g, h, i, j, k, l) -> Bool # (/=) :: (a, b, c, d, e, f, g, h, i, j, k, l) -> (a, b, c, d, e, f, g, h, i, j, k, l) -> Bool #
(Eq a, Eq b, Eq c, Eq d, Eq e, Eq f, Eq g, Eq h, Eq i, Eq j, Eq k, Eq l, Eq m) => Eq (a, b, c, d, e, f, g, h, i, j, k, l, m)
Instance details Defined in GHC.Classes Methods (==) :: (a, b, c, d, e, f, g, h, i, j, k, l, m) -> (a, b, c, d, e, f, g, h, i, j, k, l, m) -> Bool # (/=) :: (a, b, c, d, e, f, g, h, i, j, k, l, m) -> (a, b, c, d, e, f, g, h, i, j, k, l, m) -> Bool #
(Eq a, Eq b, Eq c, Eq d, Eq e, Eq f, Eq g, Eq h, Eq i, Eq j, Eq k, Eq l, Eq m, Eq n) => Eq (a, b, c, d, e, f, g, h, i, j, k, l, m, n)
Instance details Defined in GHC.Classes Methods (==) :: (a, b, c, d, e, f, g, h, i, j, k, l, m, n) -> (a, b, c, d, e, f, g, h, i, j, k, l, m, n) -> Bool # (/=) :: (a, b, c, d, e, f, g, h, i, j, k, l, m, n) -> (a, b, c, d, e, f, g, h, i, j, k, l, m, n) -> Bool #
(Eq a, Eq b, Eq c, Eq d, Eq e, Eq f, Eq g, Eq h, Eq i, Eq j, Eq k, Eq l, Eq m, Eq n, Eq o) => Eq (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o)
Instance details Defined in GHC.Classes Methods (==) :: (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o) -> (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o) -> Bool # (/=) :: (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o) -> (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o) -> Bool #

class Foldable (t :: Type -> Type) where #

The Foldable class represents data structures that can be reduced to a summary value one element at a time. Strict left-associative folds are a good fit for space-efficient reduction, while lazy right-associative folds are a good fit for corecursive iteration, or for folds that short-circuit after processing an initial subsequence of the structure's elements.

Instances can be derived automatically by enabling the DeriveFoldable extension. For example, a derived instance for a binary tree might be:

{-# LANGUAGE DeriveFoldable #-}
data Tree a = Empty
            | Leaf a
            | Node (Tree a) a (Tree a)
    deriving Foldable

A more detailed description can be found in the Overview section of Data.Foldable.

For the class laws see the Laws section of Data.Foldable.

Minimal complete definition

foldMap | foldr

Methods

fold :: Monoid m => t m -> m #

Given a structure with elements whose type is a Monoid, combine them via the monoid's (<>) operator. This fold is right-associative and lazy in the accumulator. When you need a strict left-associative fold, use foldMap' instead, with id as the map.

Examples

Expand

Basic usage:

>>> fold [[1, 2, 3], [4, 5], [6], []]
[1,2,3,4,5,6]

>>> fold $ Node (Leaf (Sum 1)) (Sum 3) (Leaf (Sum 5))
Sum {getSum = 9}

Folds of unbounded structures do not terminate when the monoid's (<>) operator is strict:

>>> fold (repeat Nothing)
* Hangs forever *

Lazy corecursive folds of unbounded structures are fine:

>>> take 12 $ fold $ map (\i -> [i..i+2]) [0..]
[0,1,2,1,2,3,2,3,4,3,4,5]
>>> sum $ take 4000000 $ fold $ map (\i -> [i..i+2]) [0..]
2666668666666

foldMap :: Monoid m => (a -> m) -> t a -> m #

Map each element of the structure into a monoid, and combine the results with (<>). This fold is right-associative and lazy in the accumulator. For strict left-associative folds consider foldMap' instead.

Examples

Expand

Basic usage:

>>> foldMap Sum [1, 3, 5]
Sum {getSum = 9}

>>> foldMap Product [1, 3, 5]
Product {getProduct = 15}

>>> foldMap (replicate 3) [1, 2, 3]
[1,1,1,2,2,2,3,3,3]

When a Monoid's (<>) is lazy in its second argument, foldMap can return a result even from an unbounded structure. For example, lazy accumulation enables Data.ByteString.Builder to efficiently serialise large data structures and produce the output incrementally:

>>> import qualified Data.ByteString.Lazy as L
>>> import qualified Data.ByteString.Builder as B
>>> let bld :: Int -> B.Builder; bld i = B.intDec i <> B.word8 0x20
>>> let lbs = B.toLazyByteString $ foldMap bld [0..]
>>> L.take 64 lbs
"0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24"

foldMap' :: Monoid m => (a -> m) -> t a -> m #

A left-associative variant of foldMap that is strict in the accumulator. Use this method for strict reduction when partial results are merged via (<>).

Examples

Expand

Define a Monoid over finite bit strings under xor. Use it to strictly compute the xor of a list of Int values.

>>> :set -XGeneralizedNewtypeDeriving
>>> import Data.Bits (Bits, FiniteBits, xor, zeroBits)
>>> import Data.Foldable (foldMap')
>>> import Numeric (showHex)
>>> 
>>> newtype X a = X a deriving (Eq, Bounded, Enum, Bits, FiniteBits)
>>> instance Bits a => Semigroup (X a) where X a <> X b = X (a `xor` b)
>>> instance Bits a => Monoid    (X a) where mempty     = X zeroBits
>>> 
>>> let bits :: [Int]; bits = [0xcafe, 0xfeed, 0xdeaf, 0xbeef, 0x5411]
>>> (\ (X a) -> showString "0x" . showHex a $ "") $ foldMap' X bits
"0x42"

Since: base-4.13.0.0

foldr :: (a -> b -> b) -> b -> t a -> b #

Right-associative fold of a structure, lazy in the accumulator.

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

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

Note that since the head of the resulting expression is produced by an application of the operator to the first element of the list, given an operator lazy in its right argument, foldr can produce a terminating expression from an unbounded list.

For a general Foldable structure this should be semantically identical to,

foldr f z = foldr f z . toList

Examples

Expand

Basic usage:

>>> foldr (||) False [False, True, False]
True

>>> foldr (||) False []
False

>>> foldr (\c acc -> acc ++ [c]) "foo" ['a', 'b', 'c', 'd']
"foodcba"

Infinite structures

⚠️ Applying foldr to infinite structures usually doesn't terminate.

It may still terminate under one of the following conditions:

the folding function is short-circuiting
the folding function is lazy on its second argument

Short-circuiting

(||) short-circuits on True values, so the following terminates because there is a True value finitely far from the left side:

>>> foldr (||) False (True : repeat False)
True

But the following doesn't terminate:

>>> foldr (||) False (repeat False ++ [True])
* Hangs forever *

Laziness in the second argument

Applying foldr to infinite structures terminates when the operator is lazy in its second argument (the initial accumulator is never used in this case, and so could be left undefined, but [] is more clear):

>>> take 5 $ foldr (\i acc -> i : fmap (+3) acc) [] (repeat 1)
[1,4,7,10,13]

foldr' :: (a -> b -> b) -> b -> t a -> b #

Right-associative fold of a structure, strict in the accumulator. This is rarely what you want.

Since: base-4.6.0.0

foldl' :: (b -> a -> b) -> b -> t a -> b #

Left-associative fold of a structure but with strict application of the operator.

This ensures that each step of the fold is forced to Weak Head Normal Form before being applied, avoiding the collection of thunks that would otherwise occur. This is often what you want to strictly reduce a finite structure to a single strict result (e.g. sum).

For a general Foldable structure this should be semantically identical to,

foldl' f z = foldl' f z . toList

Since: base-4.6.0.0

foldr1 :: (a -> a -> a) -> t a -> a #

A variant of foldr that has no base case, and thus may only be applied to non-empty structures.

This function is non-total and will raise a runtime exception if the structure happens to be empty.

Examples

Expand

Basic usage:

>>> foldr1 (+) [1..4]
10

>>> foldr1 (+) []
Exception: Prelude.foldr1: empty list

>>> foldr1 (+) Nothing
*** Exception: foldr1: empty structure

>>> foldr1 (-) [1..4]
-2

>>> foldr1 (&&) [True, False, True, True]
False

>>> foldr1 (||) [False, False, True, True]
True

>>> foldr1 (+) [1..]
* Hangs forever *

foldl1 :: (a -> a -> a) -> t a -> a #

A variant of foldl that has no base case, and thus may only be applied to non-empty structures.

This function is non-total and will raise a runtime exception if the structure happens to be empty.

foldl1 f = foldl1 f . toList

Examples

Expand

Basic usage:

>>> foldl1 (+) [1..4]
10

>>> foldl1 (+) []
*** Exception: Prelude.foldl1: empty list

>>> foldl1 (+) Nothing
*** Exception: foldl1: empty structure

>>> foldl1 (-) [1..4]
-8

>>> foldl1 (&&) [True, False, True, True]
False

>>> foldl1 (||) [False, False, True, True]
True

>>> foldl1 (+) [1..]
* Hangs forever *

toList :: t a -> [a] #

List of elements of a structure, from left to right. If the entire list is intended to be reduced via a fold, just fold the structure directly bypassing the list.

Examples

Expand

Basic usage:

>>> toList Nothing
[]

>>> toList (Just 42)
[42]

>>> toList (Left "foo")
[]

>>> toList (Node (Leaf 5) 17 (Node Empty 12 (Leaf 8)))
[5,17,12,8]

For lists, toList is the identity:

>>> toList [1, 2, 3]
[1,2,3]

Since: base-4.8.0.0

null :: t a -> Bool #

Test whether the structure is empty. The default implementation is Left-associative and lazy in both the initial element and the accumulator. Thus optimised for structures where the first element can be accessed in constant time. Structures where this is not the case should have a non-default implementation.

Examples

Expand

Basic usage:

>>> null []
True

>>> null [1]
False

null is expected to terminate even for infinite structures. The default implementation terminates provided the structure is bounded on the left (there is a leftmost element).

>>> null [1..]
False

Since: base-4.8.0.0

length :: t a -> Int #

Returns the size/length of a finite structure as an Int. The default implementation just counts elements starting with the leftmost. Instances for structures that can compute the element count faster than via element-by-element counting, should provide a specialised implementation.

Examples

Expand

Basic usage:

>>> length []
0

>>> length ['a', 'b', 'c']
3
>>> length [1..]
* Hangs forever *

Since: base-4.8.0.0

elem :: Eq a => a -> t a -> Bool infix 4 #

Does the element occur in the structure?

Note: elem is often used in infix form.

Examples

Expand

Basic usage:

>>> 3 `elem` []
False

>>> 3 `elem` [1,2]
False

>>> 3 `elem` [1,2,3,4,5]
True

For infinite structures, the default implementation of elem terminates if the sought-after value exists at a finite distance from the left side of the structure:

>>> 3 `elem` [1..]
True

>>> 3 `elem` ([4..] ++ [3])
* Hangs forever *

Since: base-4.8.0.0

maximum :: Ord a => t a -> a #

The largest element of a non-empty structure.

This function is non-total and will raise a runtime exception if the structure happens to be empty. A structure that supports random access and maintains its elements in order should provide a specialised implementation to return the maximum in faster than linear time.

Examples

Expand

Basic usage:

>>> maximum [1..10]
10

>>> maximum []
*** Exception: Prelude.maximum: empty list

>>> maximum Nothing
*** Exception: maximum: empty structure

Since: base-4.8.0.0

minimum :: Ord a => t a -> a #

The least element of a non-empty structure.

This function is non-total and will raise a runtime exception if the structure happens to be empty. A structure that supports random access and maintains its elements in order should provide a specialised implementation to return the minimum in faster than linear time.

Examples

Expand

Basic usage:

>>> minimum [1..10]
1

>>> minimum []
*** Exception: Prelude.minimum: empty list

>>> minimum Nothing
*** Exception: minimum: empty structure

Since: base-4.8.0.0

sum :: Num a => t a -> a #

The sum function computes the sum of the numbers of a structure.

Examples

Expand

Basic usage:

>>> sum []
0

>>> sum [42]
42

>>> sum [1..10]
55

>>> sum [4.1, 2.0, 1.7]
7.8

>>> sum [1..]
* Hangs forever *

Since: base-4.8.0.0

product :: Num a => t a -> a #

The product function computes the product of the numbers of a structure.

Examples

Expand

Basic usage:

>>> product []
1

>>> product [42]
42

>>> product [1..10]
3628800

>>> product [4.1, 2.0, 1.7]
13.939999999999998

>>> product [1..]
* Hangs forever *

Since: base-4.8.0.0

Instances

Instances details

Foldable ZipList	Since: base-4.9.0.0
Instance details Defined in Control.Applicative Methods fold :: Monoid m => ZipList m -> m # foldMap :: Monoid m => (a -> m) -> ZipList a -> m # foldMap' :: Monoid m => (a -> m) -> ZipList a -> m # foldr :: (a -> b -> b) -> b -> ZipList a -> b # foldr' :: (a -> b -> b) -> b -> ZipList a -> b # foldl :: (b -> a -> b) -> b -> ZipList a -> b # foldl' :: (b -> a -> b) -> b -> ZipList a -> b # foldr1 :: (a -> a -> a) -> ZipList a -> a # foldl1 :: (a -> a -> a) -> ZipList a -> a # toList :: ZipList a -> [a] # null :: ZipList a -> Bool # length :: ZipList a -> Int # elem :: Eq a => a -> ZipList a -> Bool # maximum :: Ord a => ZipList a -> a # minimum :: Ord a => ZipList a -> a # sum :: Num a => ZipList a -> a # product :: Num a => ZipList a -> a #
Foldable Identity	Since: base-4.8.0.0
Instance details Defined in Data.Functor.Identity Methods fold :: Monoid m => Identity m -> m # foldMap :: Monoid m => (a -> m) -> Identity a -> m # foldMap' :: Monoid m => (a -> m) -> Identity a -> m # foldr :: (a -> b -> b) -> b -> Identity a -> b # foldr' :: (a -> b -> b) -> b -> Identity a -> b # foldl :: (b -> a -> b) -> b -> Identity a -> b # foldl' :: (b -> a -> b) -> b -> Identity a -> b # foldr1 :: (a -> a -> a) -> Identity a -> a # foldl1 :: (a -> a -> a) -> Identity a -> a # toList :: Identity a -> [a] # null :: Identity a -> Bool # length :: Identity a -> Int # elem :: Eq a => a -> Identity a -> Bool # maximum :: Ord a => Identity a -> a # minimum :: Ord a => Identity a -> a # sum :: Num a => Identity a -> a # product :: Num a => Identity a -> a #
Foldable First	Since: base-4.8.0.0
Instance details Defined in Data.Foldable Methods fold :: Monoid m => First m -> m # foldMap :: Monoid m => (a -> m) -> First a -> m # foldMap' :: Monoid m => (a -> m) -> First a -> m # foldr :: (a -> b -> b) -> b -> First a -> b # foldr' :: (a -> b -> b) -> b -> First a -> b # foldl :: (b -> a -> b) -> b -> First a -> b # foldl' :: (b -> a -> b) -> b -> First a -> b # foldr1 :: (a -> a -> a) -> First a -> a # foldl1 :: (a -> a -> a) -> First a -> a # toList :: First a -> [a] # null :: First a -> Bool # length :: First a -> Int # elem :: Eq a => a -> First a -> Bool # maximum :: Ord a => First a -> a # minimum :: Ord a => First a -> a # sum :: Num a => First a -> a # product :: Num a => First a -> a #
Foldable Last	Since: base-4.8.0.0
Instance details Defined in Data.Foldable Methods fold :: Monoid m => Last m -> m # foldMap :: Monoid m => (a -> m) -> Last a -> m # foldMap' :: Monoid m => (a -> m) -> Last a -> m # foldr :: (a -> b -> b) -> b -> Last a -> b # foldr' :: (a -> b -> b) -> b -> Last a -> b # foldl :: (b -> a -> b) -> b -> Last a -> b # foldl' :: (b -> a -> b) -> b -> Last a -> b # foldr1 :: (a -> a -> a) -> Last a -> a # foldl1 :: (a -> a -> a) -> Last a -> a # toList :: Last a -> [a] # null :: Last a -> Bool # length :: Last a -> Int # elem :: Eq a => a -> Last a -> Bool # maximum :: Ord a => Last a -> a # minimum :: Ord a => Last a -> a # sum :: Num a => Last a -> a # product :: Num a => Last a -> a #
Foldable Down	Since: base-4.12.0.0
Instance details Defined in Data.Foldable Methods fold :: Monoid m => Down m -> m # foldMap :: Monoid m => (a -> m) -> Down a -> m # foldMap' :: Monoid m => (a -> m) -> Down a -> m # foldr :: (a -> b -> b) -> b -> Down a -> b # foldr' :: (a -> b -> b) -> b -> Down a -> b # foldl :: (b -> a -> b) -> b -> Down a -> b # foldl' :: (b -> a -> b) -> b -> Down a -> b # foldr1 :: (a -> a -> a) -> Down a -> a # foldl1 :: (a -> a -> a) -> Down a -> a # toList :: Down a -> [a] # null :: Down a -> Bool # length :: Down a -> Int # elem :: Eq a => a -> Down a -> Bool # maximum :: Ord a => Down a -> a # minimum :: Ord a => Down a -> a # sum :: Num a => Down a -> a # product :: Num a => Down a -> a #
Foldable First	Since: base-4.9.0.0
Instance details Defined in Data.Semigroup Methods fold :: Monoid m => First m -> m # foldMap :: Monoid m => (a -> m) -> First a -> m # foldMap' :: Monoid m => (a -> m) -> First a -> m # foldr :: (a -> b -> b) -> b -> First a -> b # foldr' :: (a -> b -> b) -> b -> First a -> b # foldl :: (b -> a -> b) -> b -> First a -> b # foldl' :: (b -> a -> b) -> b -> First a -> b # foldr1 :: (a -> a -> a) -> First a -> a # foldl1 :: (a -> a -> a) -> First a -> a # toList :: First a -> [a] # null :: First a -> Bool # length :: First a -> Int # elem :: Eq a => a -> First a -> Bool # maximum :: Ord a => First a -> a # minimum :: Ord a => First a -> a # sum :: Num a => First a -> a # product :: Num a => First a -> a #
Foldable Last	Since: base-4.9.0.0
Instance details Defined in Data.Semigroup Methods fold :: Monoid m => Last m -> m # foldMap :: Monoid m => (a -> m) -> Last a -> m # foldMap' :: Monoid m => (a -> m) -> Last a -> m # foldr :: (a -> b -> b) -> b -> Last a -> b # foldr' :: (a -> b -> b) -> b -> Last a -> b # foldl :: (b -> a -> b) -> b -> Last a -> b # foldl' :: (b -> a -> b) -> b -> Last a -> b # foldr1 :: (a -> a -> a) -> Last a -> a # foldl1 :: (a -> a -> a) -> Last a -> a # toList :: Last a -> [a] # null :: Last a -> Bool # length :: Last a -> Int # elem :: Eq a => a -> Last a -> Bool # maximum :: Ord a => Last a -> a # minimum :: Ord a => Last a -> a # sum :: Num a => Last a -> a # product :: Num a => Last a -> a #
Foldable Max	Since: base-4.9.0.0
Instance details Defined in Data.Semigroup Methods fold :: Monoid m => Max m -> m # foldMap :: Monoid m => (a -> m) -> Max a -> m # foldMap' :: Monoid m => (a -> m) -> Max a -> m # foldr :: (a -> b -> b) -> b -> Max a -> b # foldr' :: (a -> b -> b) -> b -> Max a -> b # foldl :: (b -> a -> b) -> b -> Max a -> b # foldl' :: (b -> a -> b) -> b -> Max a -> b # foldr1 :: (a -> a -> a) -> Max a -> a # foldl1 :: (a -> a -> a) -> Max a -> a # toList :: Max a -> [a] # null :: Max a -> Bool # length :: Max a -> Int # elem :: Eq a => a -> Max a -> Bool # maximum :: Ord a => Max a -> a # minimum :: Ord a => Max a -> a # sum :: Num a => Max a -> a # product :: Num a => Max a -> a #
Foldable Min	Since: base-4.9.0.0
Instance details Defined in Data.Semigroup Methods fold :: Monoid m => Min m -> m # foldMap :: Monoid m => (a -> m) -> Min a -> m # foldMap' :: Monoid m => (a -> m) -> Min a -> m # foldr :: (a -> b -> b) -> b -> Min a -> b # foldr' :: (a -> b -> b) -> b -> Min a -> b # foldl :: (b -> a -> b) -> b -> Min a -> b # foldl' :: (b -> a -> b) -> b -> Min a -> b # foldr1 :: (a -> a -> a) -> Min a -> a # foldl1 :: (a -> a -> a) -> Min a -> a # toList :: Min a -> [a] # null :: Min a -> Bool # length :: Min a -> Int # elem :: Eq a => a -> Min a -> Bool # maximum :: Ord a => Min a -> a # minimum :: Ord a => Min a -> a # sum :: Num a => Min a -> a # product :: Num a => Min a -> a #
Foldable Option	Since: base-4.9.0.0
Instance details Defined in Data.Semigroup Methods fold :: Monoid m => Option m -> m # foldMap :: Monoid m => (a -> m) -> Option a -> m # foldMap' :: Monoid m => (a -> m) -> Option a -> m # foldr :: (a -> b -> b) -> b -> Option a -> b # foldr' :: (a -> b -> b) -> b -> Option a -> b # foldl :: (b -> a -> b) -> b -> Option a -> b # foldl' :: (b -> a -> b) -> b -> Option a -> b # foldr1 :: (a -> a -> a) -> Option a -> a # foldl1 :: (a -> a -> a) -> Option a -> a # toList :: Option a -> [a] # null :: Option a -> Bool # length :: Option a -> Int # elem :: Eq a => a -> Option a -> Bool # maximum :: Ord a => Option a -> a # minimum :: Ord a => Option a -> a # sum :: Num a => Option a -> a # product :: Num a => Option a -> a #
Foldable Dual	Since: base-4.8.0.0
Instance details Defined in Data.Foldable Methods fold :: Monoid m => Dual m -> m # foldMap :: Monoid m => (a -> m) -> Dual a -> m # foldMap' :: Monoid m => (a -> m) -> Dual a -> m # foldr :: (a -> b -> b) -> b -> Dual a -> b # foldr' :: (a -> b -> b) -> b -> Dual a -> b # foldl :: (b -> a -> b) -> b -> Dual a -> b # foldl' :: (b -> a -> b) -> b -> Dual a -> b # foldr1 :: (a -> a -> a) -> Dual a -> a # foldl1 :: (a -> a -> a) -> Dual a -> a # toList :: Dual a -> [a] # null :: Dual a -> Bool # length :: Dual a -> Int # elem :: Eq a => a -> Dual a -> Bool # maximum :: Ord a => Dual a -> a # minimum :: Ord a => Dual a -> a # sum :: Num a => Dual a -> a # product :: Num a => Dual a -> a #
Foldable Product	Since: base-4.8.0.0
Instance details Defined in Data.Foldable Methods fold :: Monoid m => Product m -> m # foldMap :: Monoid m => (a -> m) -> Product a -> m # foldMap' :: Monoid m => (a -> m) -> Product a -> m # foldr :: (a -> b -> b) -> b -> Product a -> b # foldr' :: (a -> b -> b) -> b -> Product a -> b # foldl :: (b -> a -> b) -> b -> Product a -> b # foldl' :: (b -> a -> b) -> b -> Product a -> b # foldr1 :: (a -> a -> a) -> Product a -> a # foldl1 :: (a -> a -> a) -> Product a -> a # toList :: Product a -> [a] # null :: Product a -> Bool # length :: Product a -> Int # elem :: Eq a => a -> Product a -> Bool # maximum :: Ord a => Product a -> a # minimum :: Ord a => Product a -> a # sum :: Num a => Product a -> a # product :: Num a => Product a -> a #
Foldable Sum	Since: base-4.8.0.0
Instance details Defined in Data.Foldable Methods fold :: Monoid m => Sum m -> m # foldMap :: Monoid m => (a -> m) -> Sum a -> m # foldMap' :: Monoid m => (a -> m) -> Sum a -> m # foldr :: (a -> b -> b) -> b -> Sum a -> b # foldr' :: (a -> b -> b) -> b -> Sum a -> b # foldl :: (b -> a -> b) -> b -> Sum a -> b # foldl' :: (b -> a -> b) -> b -> Sum a -> b # foldr1 :: (a -> a -> a) -> Sum a -> a # foldl1 :: (a -> a -> a) -> Sum a -> a # toList :: Sum a -> [a] # null :: Sum a -> Bool # length :: Sum a -> Int # elem :: Eq a => a -> Sum a -> Bool # maximum :: Ord a => Sum a -> a # minimum :: Ord a => Sum a -> a # sum :: Num a => Sum a -> a # product :: Num a => Sum a -> a #
Foldable NonEmpty	Since: base-4.9.0.0
Instance details Defined in Data.Foldable Methods fold :: Monoid m => NonEmpty m -> m # foldMap :: Monoid m => (a -> m) -> NonEmpty a -> m # foldMap' :: Monoid m => (a -> m) -> NonEmpty a -> m # foldr :: (a -> b -> b) -> b -> NonEmpty a -> b # foldr' :: (a -> b -> b) -> b -> NonEmpty a -> b # foldl :: (b -> a -> b) -> b -> NonEmpty a -> b # foldl' :: (b -> a -> b) -> b -> NonEmpty a -> b # foldr1 :: (a -> a -> a) -> NonEmpty a -> a # foldl1 :: (a -> a -> a) -> NonEmpty a -> a # toList :: NonEmpty a -> [a] # null :: NonEmpty a -> Bool # length :: NonEmpty a -> Int # elem :: Eq a => a -> NonEmpty a -> Bool # maximum :: Ord a => NonEmpty a -> a # minimum :: Ord a => NonEmpty a -> a # sum :: Num a => NonEmpty a -> a # product :: Num a => NonEmpty a -> a #
Foldable Par1	Since: base-4.9.0.0
Instance details Defined in Data.Foldable Methods fold :: Monoid m => Par1 m -> m # foldMap :: Monoid m => (a -> m) -> Par1 a -> m # foldMap' :: Monoid m => (a -> m) -> Par1 a -> m # foldr :: (a -> b -> b) -> b -> Par1 a -> b # foldr' :: (a -> b -> b) -> b -> Par1 a -> b # foldl :: (b -> a -> b) -> b -> Par1 a -> b # foldl' :: (b -> a -> b) -> b -> Par1 a -> b # foldr1 :: (a -> a -> a) -> Par1 a -> a # foldl1 :: (a -> a -> a) -> Par1 a -> a # toList :: Par1 a -> [a] # null :: Par1 a -> Bool # length :: Par1 a -> Int # elem :: Eq a => a -> Par1 a -> Bool # maximum :: Ord a => Par1 a -> a # minimum :: Ord a => Par1 a -> a # sum :: Num a => Par1 a -> a # product :: Num a => Par1 a -> a #
Foldable IntMap	Folds in order of increasing key.
Instance details Defined in Data.IntMap.Internal Methods fold :: Monoid m => IntMap m -> m # foldMap :: Monoid m => (a -> m) -> IntMap a -> m # foldMap' :: Monoid m => (a -> m) -> IntMap a -> m # foldr :: (a -> b -> b) -> b -> IntMap a -> b # foldr' :: (a -> b -> b) -> b -> IntMap a -> b # foldl :: (b -> a -> b) -> b -> IntMap a -> b # foldl' :: (b -> a -> b) -> b -> IntMap a -> b # foldr1 :: (a -> a -> a) -> IntMap a -> a # foldl1 :: (a -> a -> a) -> IntMap a -> a # toList :: IntMap a -> [a] # null :: IntMap a -> Bool # length :: IntMap a -> Int # elem :: Eq a => a -> IntMap a -> Bool # maximum :: Ord a => IntMap a -> a # minimum :: Ord a => IntMap a -> a # sum :: Num a => IntMap a -> a # product :: Num a => IntMap a -> a #
Foldable Digit
Instance details Defined in Data.Sequence.Internal Methods fold :: Monoid m => Digit m -> m # foldMap :: Monoid m => (a -> m) -> Digit a -> m # foldMap' :: Monoid m => (a -> m) -> Digit a -> m # foldr :: (a -> b -> b) -> b -> Digit a -> b # foldr' :: (a -> b -> b) -> b -> Digit a -> b # foldl :: (b -> a -> b) -> b -> Digit a -> b # foldl' :: (b -> a -> b) -> b -> Digit a -> b # foldr1 :: (a -> a -> a) -> Digit a -> a # foldl1 :: (a -> a -> a) -> Digit a -> a # toList :: Digit a -> [a] # null :: Digit a -> Bool # length :: Digit a -> Int # elem :: Eq a => a -> Digit a -> Bool # maximum :: Ord a => Digit a -> a # minimum :: Ord a => Digit a -> a # sum :: Num a => Digit a -> a # product :: Num a => Digit a -> a #
Foldable Elem
Instance details Defined in Data.Sequence.Internal Methods fold :: Monoid m => Elem m -> m # foldMap :: Monoid m => (a -> m) -> Elem a -> m # foldMap' :: Monoid m => (a -> m) -> Elem a -> m # foldr :: (a -> b -> b) -> b -> Elem a -> b # foldr' :: (a -> b -> b) -> b -> Elem a -> b # foldl :: (b -> a -> b) -> b -> Elem a -> b # foldl' :: (b -> a -> b) -> b -> Elem a -> b # foldr1 :: (a -> a -> a) -> Elem a -> a # foldl1 :: (a -> a -> a) -> Elem a -> a # toList :: Elem a -> [a] # null :: Elem a -> Bool # length :: Elem a -> Int # elem :: Eq a => a -> Elem a -> Bool # maximum :: Ord a => Elem a -> a # minimum :: Ord a => Elem a -> a # sum :: Num a => Elem a -> a # product :: Num a => Elem a -> a #
Foldable FingerTree
Instance details Defined in Data.Sequence.Internal Methods fold :: Monoid m => FingerTree m -> m # foldMap :: Monoid m => (a -> m) -> FingerTree a -> m # foldMap' :: Monoid m => (a -> m) -> FingerTree a -> m # foldr :: (a -> b -> b) -> b -> FingerTree a -> b # foldr' :: (a -> b -> b) -> b -> FingerTree a -> b # foldl :: (b -> a -> b) -> b -> FingerTree a -> b # foldl' :: (b -> a -> b) -> b -> FingerTree a -> b # foldr1 :: (a -> a -> a) -> FingerTree a -> a # foldl1 :: (a -> a -> a) -> FingerTree a -> a # toList :: FingerTree a -> [a] # null :: FingerTree a -> Bool # length :: FingerTree a -> Int # elem :: Eq a => a -> FingerTree a -> Bool # maximum :: Ord a => FingerTree a -> a # minimum :: Ord a => FingerTree a -> a # sum :: Num a => FingerTree a -> a # product :: Num a => FingerTree a -> a #
Foldable Node
Instance details Defined in Data.Sequence.Internal Methods fold :: Monoid m => Node m -> m # foldMap :: Monoid m => (a -> m) -> Node a -> m # foldMap' :: Monoid m => (a -> m) -> Node a -> m # foldr :: (a -> b -> b) -> b -> Node a -> b # foldr' :: (a -> b -> b) -> b -> Node a -> b # foldl :: (b -> a -> b) -> b -> Node a -> b # foldl' :: (b -> a -> b) -> b -> Node a -> b # foldr1 :: (a -> a -> a) -> Node a -> a # foldl1 :: (a -> a -> a) -> Node a -> a # toList :: Node a -> [a] # null :: Node a -> Bool # length :: Node a -> Int # elem :: Eq a => a -> Node a -> Bool # maximum :: Ord a => Node a -> a # minimum :: Ord a => Node a -> a # sum :: Num a => Node a -> a # product :: Num a => Node a -> a #
Foldable Seq
Instance details Defined in Data.Sequence.Internal Methods fold :: Monoid m => Seq m -> m # foldMap :: Monoid m => (a -> m) -> Seq a -> m # foldMap' :: Monoid m => (a -> m) -> Seq a -> m # foldr :: (a -> b -> b) -> b -> Seq a -> b # foldr' :: (a -> b -> b) -> b -> Seq a -> b # foldl :: (b -> a -> b) -> b -> Seq a -> b # foldl' :: (b -> a -> b) -> b -> Seq a -> b # foldr1 :: (a -> a -> a) -> Seq a -> a # foldl1 :: (a -> a -> a) -> Seq a -> a # toList :: Seq a -> [a] # null :: Seq a -> Bool # length :: Seq a -> Int # elem :: Eq a => a -> Seq a -> Bool # maximum :: Ord a => Seq a -> a # minimum :: Ord a => Seq a -> a # sum :: Num a => Seq a -> a # product :: Num a => Seq a -> a #
Foldable ViewL
Instance details Defined in Data.Sequence.Internal Methods fold :: Monoid m => ViewL m -> m # foldMap :: Monoid m => (a -> m) -> ViewL a -> m # foldMap' :: Monoid m => (a -> m) -> ViewL a -> m # foldr :: (a -> b -> b) -> b -> ViewL a -> b # foldr' :: (a -> b -> b) -> b -> ViewL a -> b # foldl :: (b -> a -> b) -> b -> ViewL a -> b # foldl' :: (b -> a -> b) -> b -> ViewL a -> b # foldr1 :: (a -> a -> a) -> ViewL a -> a # foldl1 :: (a -> a -> a) -> ViewL a -> a # toList :: ViewL a -> [a] # null :: ViewL a -> Bool # length :: ViewL a -> Int # elem :: Eq a => a -> ViewL a -> Bool # maximum :: Ord a => ViewL a -> a # minimum :: Ord a => ViewL a -> a # sum :: Num a => ViewL a -> a # product :: Num a => ViewL a -> a #
Foldable ViewR
Instance details Defined in Data.Sequence.Internal Methods fold :: Monoid m => ViewR m -> m # foldMap :: Monoid m => (a -> m) -> ViewR a -> m # foldMap' :: Monoid m => (a -> m) -> ViewR a -> m # foldr :: (a -> b -> b) -> b -> ViewR a -> b # foldr' :: (a -> b -> b) -> b -> ViewR a -> b # foldl :: (b -> a -> b) -> b -> ViewR a -> b # foldl' :: (b -> a -> b) -> b -> ViewR a -> b # foldr1 :: (a -> a -> a) -> ViewR a -> a # foldl1 :: (a -> a -> a) -> ViewR a -> a # toList :: ViewR a -> [a] # null :: ViewR a -> Bool # length :: ViewR a -> Int # elem :: Eq a => a -> ViewR a -> Bool # maximum :: Ord a => ViewR a -> a # minimum :: Ord a => ViewR a -> a # sum :: Num a => ViewR a -> a # product :: Num a => ViewR a -> a #
Foldable Set	Folds in order of increasing key.
Instance details Defined in Data.Set.Internal Methods fold :: Monoid m => Set m -> m # foldMap :: Monoid m => (a -> m) -> Set a -> m # foldMap' :: Monoid m => (a -> m) -> Set a -> m # foldr :: (a -> b -> b) -> b -> Set a -> b # foldr' :: (a -> b -> b) -> b -> Set a -> b # foldl :: (b -> a -> b) -> b -> Set a -> b # foldl' :: (b -> a -> b) -> b -> Set a -> b # foldr1 :: (a -> a -> a) -> Set a -> a # foldl1 :: (a -> a -> a) -> Set a -> a # toList :: Set a -> [a] # null :: Set a -> Bool # length :: Set a -> Int # elem :: Eq a => a -> Set a -> Bool # maximum :: Ord a => Set a -> a # minimum :: Ord a => Set a -> a # sum :: Num a => Set a -> a # product :: Num a => Set a -> a #
Foldable DList
Instance details Defined in Data.DList.Internal Methods fold :: Monoid m => DList m -> m # foldMap :: Monoid m => (a -> m) -> DList a -> m # foldMap' :: Monoid m => (a -> m) -> DList a -> m # foldr :: (a -> b -> b) -> b -> DList a -> b # foldr' :: (a -> b -> b) -> b -> DList a -> b # foldl :: (b -> a -> b) -> b -> DList a -> b # foldl' :: (b -> a -> b) -> b -> DList a -> b # foldr1 :: (a -> a -> a) -> DList a -> a # foldl1 :: (a -> a -> a) -> DList a -> a # toList :: DList a -> [a] # null :: DList a -> Bool # length :: DList a -> Int # elem :: Eq a => a -> DList a -> Bool # maximum :: Ord a => DList a -> a # minimum :: Ord a => DList a -> a # sum :: Num a => DList a -> a # product :: Num a => DList a -> a #
Foldable Maybe	Since: base-2.1
Instance details Defined in Data.Foldable Methods fold :: Monoid m => Maybe m -> m # foldMap :: Monoid m => (a -> m) -> Maybe a -> m # foldMap' :: Monoid m => (a -> m) -> Maybe a -> m # foldr :: (a -> b -> b) -> b -> Maybe a -> b # foldr' :: (a -> b -> b) -> b -> Maybe a -> b # foldl :: (b -> a -> b) -> b -> Maybe a -> b # foldl' :: (b -> a -> b) -> b -> Maybe a -> b # foldr1 :: (a -> a -> a) -> Maybe a -> a # foldl1 :: (a -> a -> a) -> Maybe a -> a # toList :: Maybe a -> [a] # null :: Maybe a -> Bool # length :: Maybe a -> Int # elem :: Eq a => a -> Maybe a -> Bool # maximum :: Ord a => Maybe a -> a # minimum :: Ord a => Maybe a -> a # sum :: Num a => Maybe a -> a # product :: Num a => Maybe a -> a #
Foldable Solo	Since: base-4.15
Instance details Defined in Data.Foldable Methods fold :: Monoid m => Solo m -> m # foldMap :: Monoid m => (a -> m) -> Solo a -> m # foldMap' :: Monoid m => (a -> m) -> Solo a -> m # foldr :: (a -> b -> b) -> b -> Solo a -> b # foldr' :: (a -> b -> b) -> b -> Solo a -> b # foldl :: (b -> a -> b) -> b -> Solo a -> b # foldl' :: (b -> a -> b) -> b -> Solo a -> b # foldr1 :: (a -> a -> a) -> Solo a -> a # foldl1 :: (a -> a -> a) -> Solo a -> a # toList :: Solo a -> [a] # null :: Solo a -> Bool # length :: Solo a -> Int # elem :: Eq a => a -> Solo a -> Bool # maximum :: Ord a => Solo a -> a # minimum :: Ord a => Solo a -> a # sum :: Num a => Solo a -> a # product :: Num a => Solo a -> a #
Foldable []	Since: base-2.1
Instance details Defined in Data.Foldable Methods fold :: Monoid m => [m] -> m # foldMap :: Monoid m => (a -> m) -> [a] -> m # foldMap' :: Monoid m => (a -> m) -> [a] -> m # foldr :: (a -> b -> b) -> b -> [a] -> b # foldr' :: (a -> b -> b) -> b -> [a] -> b # foldl :: (b -> a -> b) -> b -> [a] -> b # foldl' :: (b -> a -> b) -> b -> [a] -> b # foldr1 :: (a -> a -> a) -> [a] -> a # foldl1 :: (a -> a -> a) -> [a] -> a # toList :: [a] -> [a] # null :: [a] -> Bool # length :: [a] -> Int # elem :: Eq a => a -> [a] -> Bool # maximum :: Ord a => [a] -> a # minimum :: Ord a => [a] -> a # sum :: Num a => [a] -> a # product :: Num a => [a] -> a #
Foldable (Either a)	Since: base-4.7.0.0
Instance details Defined in Data.Foldable Methods fold :: Monoid m => Either a m -> m # foldMap :: Monoid m => (a0 -> m) -> Either a a0 -> m # foldMap' :: Monoid m => (a0 -> m) -> Either a a0 -> m # foldr :: (a0 -> b -> b) -> b -> Either a a0 -> b # foldr' :: (a0 -> b -> b) -> b -> Either a a0 -> b # foldl :: (b -> a0 -> b) -> b -> Either a a0 -> b # foldl' :: (b -> a0 -> b) -> b -> Either a a0 -> b # foldr1 :: (a0 -> a0 -> a0) -> Either a a0 -> a0 # foldl1 :: (a0 -> a0 -> a0) -> Either a a0 -> a0 # toList :: Either a a0 -> [a0] # null :: Either a a0 -> Bool # length :: Either a a0 -> Int # elem :: Eq a0 => a0 -> Either a a0 -> Bool # maximum :: Ord a0 => Either a a0 -> a0 # minimum :: Ord a0 => Either a a0 -> a0 # sum :: Num a0 => Either a a0 -> a0 # product :: Num a0 => Either a a0 -> a0 #
Foldable (Proxy :: Type -> Type)	Since: base-4.7.0.0
Instance details Defined in Data.Foldable Methods fold :: Monoid m => Proxy m -> m # foldMap :: Monoid m => (a -> m) -> Proxy a -> m # foldMap' :: Monoid m => (a -> m) -> Proxy a -> m # foldr :: (a -> b -> b) -> b -> Proxy a -> b # foldr' :: (a -> b -> b) -> b -> Proxy a -> b # foldl :: (b -> a -> b) -> b -> Proxy a -> b # foldl' :: (b -> a -> b) -> b -> Proxy a -> b # foldr1 :: (a -> a -> a) -> Proxy a -> a # foldl1 :: (a -> a -> a) -> Proxy a -> a # toList :: Proxy a -> [a] # null :: Proxy a -> Bool # length :: Proxy a -> Int # elem :: Eq a => a -> Proxy a -> Bool # maximum :: Ord a => Proxy a -> a # minimum :: Ord a => Proxy a -> a # sum :: Num a => Proxy a -> a # product :: Num a => Proxy a -> a #
Foldable (Arg a)	Since: base-4.9.0.0
Instance details Defined in Data.Semigroup Methods fold :: Monoid m => Arg a m -> m # foldMap :: Monoid m => (a0 -> m) -> Arg a a0 -> m # foldMap' :: Monoid m => (a0 -> m) -> Arg a a0 -> m # foldr :: (a0 -> b -> b) -> b -> Arg a a0 -> b # foldr' :: (a0 -> b -> b) -> b -> Arg a a0 -> b # foldl :: (b -> a0 -> b) -> b -> Arg a a0 -> b # foldl' :: (b -> a0 -> b) -> b -> Arg a a0 -> b # foldr1 :: (a0 -> a0 -> a0) -> Arg a a0 -> a0 # foldl1 :: (a0 -> a0 -> a0) -> Arg a a0 -> a0 # toList :: Arg a a0 -> [a0] # null :: Arg a a0 -> Bool # length :: Arg a a0 -> Int # elem :: Eq a0 => a0 -> Arg a a0 -> Bool # maximum :: Ord a0 => Arg a a0 -> a0 # minimum :: Ord a0 => Arg a a0 -> a0 # sum :: Num a0 => Arg a a0 -> a0 # product :: Num a0 => Arg a a0 -> a0 #
Foldable (Array i)	Since: base-4.8.0.0
Instance details Defined in Data.Foldable Methods fold :: Monoid m => Array i m -> m # foldMap :: Monoid m => (a -> m) -> Array i a -> m # foldMap' :: Monoid m => (a -> m) -> Array i a -> m # foldr :: (a -> b -> b) -> b -> Array i a -> b # foldr' :: (a -> b -> b) -> b -> Array i a -> b # foldl :: (b -> a -> b) -> b -> Array i a -> b # foldl' :: (b -> a -> b) -> b -> Array i a -> b # foldr1 :: (a -> a -> a) -> Array i a -> a # foldl1 :: (a -> a -> a) -> Array i a -> a # toList :: Array i a -> [a] # null :: Array i a -> Bool # length :: Array i a -> Int # elem :: Eq a => a -> Array i a -> Bool # maximum :: Ord a => Array i a -> a # minimum :: Ord a => Array i a -> a # sum :: Num a => Array i a -> a # product :: Num a => Array i a -> a #
Foldable (U1 :: Type -> Type)	Since: base-4.9.0.0
Instance details Defined in Data.Foldable Methods fold :: Monoid m => U1 m -> m # foldMap :: Monoid m => (a -> m) -> U1 a -> m # foldMap' :: Monoid m => (a -> m) -> U1 a -> m # foldr :: (a -> b -> b) -> b -> U1 a -> b # foldr' :: (a -> b -> b) -> b -> U1 a -> b # foldl :: (b -> a -> b) -> b -> U1 a -> b # foldl' :: (b -> a -> b) -> b -> U1 a -> b # foldr1 :: (a -> a -> a) -> U1 a -> a # foldl1 :: (a -> a -> a) -> U1 a -> a # toList :: U1 a -> [a] # null :: U1 a -> Bool # length :: U1 a -> Int # elem :: Eq a => a -> U1 a -> Bool # maximum :: Ord a => U1 a -> a # minimum :: Ord a => U1 a -> a # sum :: Num a => U1 a -> a # product :: Num a => U1 a -> a #
Foldable (UAddr :: Type -> Type)	Since: base-4.9.0.0
Instance details Defined in Data.Foldable Methods fold :: Monoid m => UAddr m -> m # foldMap :: Monoid m => (a -> m) -> UAddr a -> m # foldMap' :: Monoid m => (a -> m) -> UAddr a -> m # foldr :: (a -> b -> b) -> b -> UAddr a -> b # foldr' :: (a -> b -> b) -> b -> UAddr a -> b # foldl :: (b -> a -> b) -> b -> UAddr a -> b # foldl' :: (b -> a -> b) -> b -> UAddr a -> b # foldr1 :: (a -> a -> a) -> UAddr a -> a # foldl1 :: (a -> a -> a) -> UAddr a -> a # toList :: UAddr a -> [a] # null :: UAddr a -> Bool # length :: UAddr a -> Int # elem :: Eq a => a -> UAddr a -> Bool # maximum :: Ord a => UAddr a -> a # minimum :: Ord a => UAddr a -> a # sum :: Num a => UAddr a -> a # product :: Num a => UAddr a -> a #
Foldable (UChar :: Type -> Type)	Since: base-4.9.0.0
Instance details Defined in Data.Foldable Methods fold :: Monoid m => UChar m -> m # foldMap :: Monoid m => (a -> m) -> UChar a -> m # foldMap' :: Monoid m => (a -> m) -> UChar a -> m # foldr :: (a -> b -> b) -> b -> UChar a -> b # foldr' :: (a -> b -> b) -> b -> UChar a -> b # foldl :: (b -> a -> b) -> b -> UChar a -> b # foldl' :: (b -> a -> b) -> b -> UChar a -> b # foldr1 :: (a -> a -> a) -> UChar a -> a # foldl1 :: (a -> a -> a) -> UChar a -> a # toList :: UChar a -> [a] # null :: UChar a -> Bool # length :: UChar a -> Int # elem :: Eq a => a -> UChar a -> Bool # maximum :: Ord a => UChar a -> a # minimum :: Ord a => UChar a -> a # sum :: Num a => UChar a -> a # product :: Num a => UChar a -> a #
Foldable (UDouble :: Type -> Type)	Since: base-4.9.0.0
Instance details Defined in Data.Foldable Methods fold :: Monoid m => UDouble m -> m # foldMap :: Monoid m => (a -> m) -> UDouble a -> m # foldMap' :: Monoid m => (a -> m) -> UDouble a -> m # foldr :: (a -> b -> b) -> b -> UDouble a -> b # foldr' :: (a -> b -> b) -> b -> UDouble a -> b # foldl :: (b -> a -> b) -> b -> UDouble a -> b # foldl' :: (b -> a -> b) -> b -> UDouble a -> b # foldr1 :: (a -> a -> a) -> UDouble a -> a # foldl1 :: (a -> a -> a) -> UDouble a -> a # toList :: UDouble a -> [a] # null :: UDouble a -> Bool # length :: UDouble a -> Int # elem :: Eq a => a -> UDouble a -> Bool # maximum :: Ord a => UDouble a -> a # minimum :: Ord a => UDouble a -> a # sum :: Num a => UDouble a -> a # product :: Num a => UDouble a -> a #
Foldable (UFloat :: Type -> Type)	Since: base-4.9.0.0
Instance details Defined in Data.Foldable Methods fold :: Monoid m => UFloat m -> m # foldMap :: Monoid m => (a -> m) -> UFloat a -> m # foldMap' :: Monoid m => (a -> m) -> UFloat a -> m # foldr :: (a -> b -> b) -> b -> UFloat a -> b # foldr' :: (a -> b -> b) -> b -> UFloat a -> b # foldl :: (b -> a -> b) -> b -> UFloat a -> b # foldl' :: (b -> a -> b) -> b -> UFloat a -> b # foldr1 :: (a -> a -> a) -> UFloat a -> a # foldl1 :: (a -> a -> a) -> UFloat a -> a # toList :: UFloat a -> [a] # null :: UFloat a -> Bool # length :: UFloat a -> Int # elem :: Eq a => a -> UFloat a -> Bool # maximum :: Ord a => UFloat a -> a # minimum :: Ord a => UFloat a -> a # sum :: Num a => UFloat a -> a # product :: Num a => UFloat a -> a #
Foldable (UInt :: Type -> Type)	Since: base-4.9.0.0
Instance details Defined in Data.Foldable Methods fold :: Monoid m => UInt m -> m # foldMap :: Monoid m => (a -> m) -> UInt a -> m # foldMap' :: Monoid m => (a -> m) -> UInt a -> m # foldr :: (a -> b -> b) -> b -> UInt a -> b # foldr' :: (a -> b -> b) -> b -> UInt a -> b # foldl :: (b -> a -> b) -> b -> UInt a -> b # foldl' :: (b -> a -> b) -> b -> UInt a -> b # foldr1 :: (a -> a -> a) -> UInt a -> a # foldl1 :: (a -> a -> a) -> UInt a -> a # toList :: UInt a -> [a] # null :: UInt a -> Bool # length :: UInt a -> Int # elem :: Eq a => a -> UInt a -> Bool # maximum :: Ord a => UInt a -> a # minimum :: Ord a => UInt a -> a # sum :: Num a => UInt a -> a # product :: Num a => UInt a -> a #
Foldable (UWord :: Type -> Type)	Since: base-4.9.0.0
Instance details Defined in Data.Foldable Methods fold :: Monoid m => UWord m -> m # foldMap :: Monoid m => (a -> m) -> UWord a -> m # foldMap' :: Monoid m => (a -> m) -> UWord a -> m # foldr :: (a -> b -> b) -> b -> UWord a -> b # foldr' :: (a -> b -> b) -> b -> UWord a -> b # foldl :: (b -> a -> b) -> b -> UWord a -> b # foldl' :: (b -> a -> b) -> b -> UWord a -> b # foldr1 :: (a -> a -> a) -> UWord a -> a # foldl1 :: (a -> a -> a) -> UWord a -> a # toList :: UWord a -> [a] # null :: UWord a -> Bool # length :: UWord a -> Int # elem :: Eq a => a -> UWord a -> Bool # maximum :: Ord a => UWord a -> a # minimum :: Ord a => UWord a -> a # sum :: Num a => UWord a -> a # product :: Num a => UWord a -> a #
Foldable (V1 :: Type -> Type)	Since: base-4.9.0.0
Instance details Defined in Data.Foldable Methods fold :: Monoid m => V1 m -> m # foldMap :: Monoid m => (a -> m) -> V1 a -> m # foldMap' :: Monoid m => (a -> m) -> V1 a -> m # foldr :: (a -> b -> b) -> b -> V1 a -> b # foldr' :: (a -> b -> b) -> b -> V1 a -> b # foldl :: (b -> a -> b) -> b -> V1 a -> b # foldl' :: (b -> a -> b) -> b -> V1 a -> b # foldr1 :: (a -> a -> a) -> V1 a -> a # foldl1 :: (a -> a -> a) -> V1 a -> a # toList :: V1 a -> [a] # null :: V1 a -> Bool # length :: V1 a -> Int # elem :: Eq a => a -> V1 a -> Bool # maximum :: Ord a => V1 a -> a # minimum :: Ord a => V1 a -> a # sum :: Num a => V1 a -> a # product :: Num a => V1 a -> a #
Foldable (Map k)	Folds in order of increasing key.
Instance details Defined in Data.Map.Internal Methods fold :: Monoid m => Map k m -> m # foldMap :: Monoid m => (a -> m) -> Map k a -> m # foldMap' :: Monoid m => (a -> m) -> Map k a -> m # foldr :: (a -> b -> b) -> b -> Map k a -> b # foldr' :: (a -> b -> b) -> b -> Map k a -> b # foldl :: (b -> a -> b) -> b -> Map k a -> b # foldl' :: (b -> a -> b) -> b -> Map k a -> b # foldr1 :: (a -> a -> a) -> Map k a -> a # foldl1 :: (a -> a -> a) -> Map k a -> a # toList :: Map k a -> [a] # null :: Map k a -> Bool # length :: Map k a -> Int # elem :: Eq a => a -> Map k a -> Bool # maximum :: Ord a => Map k a -> a # minimum :: Ord a => Map k a -> a # sum :: Num a => Map k a -> a # product :: Num a => Map k a -> a #
Foldable ((,) a)	Since: base-4.7.0.0
Instance details Defined in Data.Foldable Methods fold :: Monoid m => (a, m) -> m # foldMap :: Monoid m => (a0 -> m) -> (a, a0) -> m # foldMap' :: Monoid m => (a0 -> m) -> (a, a0) -> m # foldr :: (a0 -> b -> b) -> b -> (a, a0) -> b # foldr' :: (a0 -> b -> b) -> b -> (a, a0) -> b # foldl :: (b -> a0 -> b) -> b -> (a, a0) -> b # foldl' :: (b -> a0 -> b) -> b -> (a, a0) -> b # foldr1 :: (a0 -> a0 -> a0) -> (a, a0) -> a0 # foldl1 :: (a0 -> a0 -> a0) -> (a, a0) -> a0 # toList :: (a, a0) -> [a0] # null :: (a, a0) -> Bool # length :: (a, a0) -> Int # elem :: Eq a0 => a0 -> (a, a0) -> Bool # maximum :: Ord a0 => (a, a0) -> a0 # minimum :: Ord a0 => (a, a0) -> a0 # sum :: Num a0 => (a, a0) -> a0 # product :: Num a0 => (a, a0) -> a0 #
Foldable (Const m :: Type -> Type)	Since: base-4.7.0.0
Instance details Defined in Data.Functor.Const Methods fold :: Monoid m0 => Const m m0 -> m0 # foldMap :: Monoid m0 => (a -> m0) -> Const m a -> m0 # foldMap' :: Monoid m0 => (a -> m0) -> Const m a -> m0 # foldr :: (a -> b -> b) -> b -> Const m a -> b # foldr' :: (a -> b -> b) -> b -> Const m a -> b # foldl :: (b -> a -> b) -> b -> Const m a -> b # foldl' :: (b -> a -> b) -> b -> Const m a -> b # foldr1 :: (a -> a -> a) -> Const m a -> a # foldl1 :: (a -> a -> a) -> Const m a -> a # toList :: Const m a -> [a] # null :: Const m a -> Bool # length :: Const m a -> Int # elem :: Eq a => a -> Const m a -> Bool # maximum :: Ord a => Const m a -> a # minimum :: Ord a => Const m a -> a # sum :: Num a => Const m a -> a # product :: Num a => Const m a -> a #
Foldable f => Foldable (Ap f)	Since: base-4.12.0.0
Instance details Defined in Data.Foldable Methods fold :: Monoid m => Ap f m -> m # foldMap :: Monoid m => (a -> m) -> Ap f a -> m # foldMap' :: Monoid m => (a -> m) -> Ap f a -> m # foldr :: (a -> b -> b) -> b -> Ap f a -> b # foldr' :: (a -> b -> b) -> b -> Ap f a -> b # foldl :: (b -> a -> b) -> b -> Ap f a -> b # foldl' :: (b -> a -> b) -> b -> Ap f a -> b # foldr1 :: (a -> a -> a) -> Ap f a -> a # foldl1 :: (a -> a -> a) -> Ap f a -> a # toList :: Ap f a -> [a] # null :: Ap f a -> Bool # length :: Ap f a -> Int # elem :: Eq a => a -> Ap f a -> Bool # maximum :: Ord a => Ap f a -> a # minimum :: Ord a => Ap f a -> a # sum :: Num a => Ap f a -> a # product :: Num a => Ap f a -> a #
Foldable f => Foldable (Alt f)	Since: base-4.12.0.0
Instance details Defined in Data.Foldable Methods fold :: Monoid m => Alt f m -> m # foldMap :: Monoid m => (a -> m) -> Alt f a -> m # foldMap' :: Monoid m => (a -> m) -> Alt f a -> m # foldr :: (a -> b -> b) -> b -> Alt f a -> b # foldr' :: (a -> b -> b) -> b -> Alt f a -> b # foldl :: (b -> a -> b) -> b -> Alt f a -> b # foldl' :: (b -> a -> b) -> b -> Alt f a -> b # foldr1 :: (a -> a -> a) -> Alt f a -> a # foldl1 :: (a -> a -> a) -> Alt f a -> a # toList :: Alt f a -> [a] # null :: Alt f a -> Bool # length :: Alt f a -> Int # elem :: Eq a => a -> Alt f a -> Bool # maximum :: Ord a => Alt f a -> a # minimum :: Ord a => Alt f a -> a # sum :: Num a => Alt f a -> a # product :: Num a => Alt f a -> a #
Foldable f => Foldable (Rec1 f)	Since: base-4.9.0.0
Instance details Defined in Data.Foldable Methods fold :: Monoid m => Rec1 f m -> m # foldMap :: Monoid m => (a -> m) -> Rec1 f a -> m # foldMap' :: Monoid m => (a -> m) -> Rec1 f a -> m # foldr :: (a -> b -> b) -> b -> Rec1 f a -> b # foldr' :: (a -> b -> b) -> b -> Rec1 f a -> b # foldl :: (b -> a -> b) -> b -> Rec1 f a -> b # foldl' :: (b -> a -> b) -> b -> Rec1 f a -> b # foldr1 :: (a -> a -> a) -> Rec1 f a -> a # foldl1 :: (a -> a -> a) -> Rec1 f a -> a # toList :: Rec1 f a -> [a] # null :: Rec1 f a -> Bool # length :: Rec1 f a -> Int # elem :: Eq a => a -> Rec1 f a -> Bool # maximum :: Ord a => Rec1 f a -> a # minimum :: Ord a => Rec1 f a -> a # sum :: Num a => Rec1 f a -> a # product :: Num a => Rec1 f a -> a #
(Foldable f, Foldable g) => Foldable (Product f g)	Since: base-4.9.0.0
Instance details Defined in Data.Functor.Product Methods fold :: Monoid m => Product f g m -> m # foldMap :: Monoid m => (a -> m) -> Product f g a -> m # foldMap' :: Monoid m => (a -> m) -> Product f g a -> m # foldr :: (a -> b -> b) -> b -> Product f g a -> b # foldr' :: (a -> b -> b) -> b -> Product f g a -> b # foldl :: (b -> a -> b) -> b -> Product f g a -> b # foldl' :: (b -> a -> b) -> b -> Product f g a -> b # foldr1 :: (a -> a -> a) -> Product f g a -> a # foldl1 :: (a -> a -> a) -> Product f g a -> a # toList :: Product f g a -> [a] # null :: Product f g a -> Bool # length :: Product f g a -> Int # elem :: Eq a => a -> Product f g a -> Bool # maximum :: Ord a => Product f g a -> a # minimum :: Ord a => Product f g a -> a # sum :: Num a => Product f g a -> a # product :: Num a => Product f g a -> a #
(Foldable f, Foldable g) => Foldable (Sum f g)	Since: base-4.9.0.0
Instance details Defined in Data.Functor.Sum Methods fold :: Monoid m => Sum f g m -> m # foldMap :: Monoid m => (a -> m) -> Sum f g a -> m # foldMap' :: Monoid m => (a -> m) -> Sum f g a -> m # foldr :: (a -> b -> b) -> b -> Sum f g a -> b # foldr' :: (a -> b -> b) -> b -> Sum f g a -> b # foldl :: (b -> a -> b) -> b -> Sum f g a -> b # foldl' :: (b -> a -> b) -> b -> Sum f g a -> b # foldr1 :: (a -> a -> a) -> Sum f g a -> a # foldl1 :: (a -> a -> a) -> Sum f g a -> a # toList :: Sum f g a -> [a] # null :: Sum f g a -> Bool # length :: Sum f g a -> Int # elem :: Eq a => a -> Sum f g a -> Bool # maximum :: Ord a => Sum f g a -> a # minimum :: Ord a => Sum f g a -> a # sum :: Num a => Sum f g a -> a # product :: Num a => Sum f g a -> a #
(Foldable f, Foldable g) => Foldable (f :*: g)	Since: base-4.9.0.0
Instance details Defined in Data.Foldable Methods fold :: Monoid m => (f :: g) m -> m # foldMap :: Monoid m => (a -> m) -> (f :: g) a -> m # foldMap' :: Monoid m => (a -> m) -> (f :: g) a -> m # foldr :: (a -> b -> b) -> b -> (f :: g) a -> b # foldr' :: (a -> b -> b) -> b -> (f :: g) a -> b # foldl :: (b -> a -> b) -> b -> (f :: g) a -> b # foldl' :: (b -> a -> b) -> b -> (f :: g) a -> b # foldr1 :: (a -> a -> a) -> (f :: g) a -> a # foldl1 :: (a -> a -> a) -> (f :: g) a -> a # toList :: (f :: g) a -> [a] # null :: (f :: g) a -> Bool # length :: (f :: g) a -> Int # elem :: Eq a => a -> (f :: g) a -> Bool # maximum :: Ord a => (f :: g) a -> a # minimum :: Ord a => (f :: g) a -> a # sum :: Num a => (f :: g) a -> a # product :: Num a => (f :*: g) a -> a #
(Foldable f, Foldable g) => Foldable (f :+: g)	Since: base-4.9.0.0
Instance details Defined in Data.Foldable Methods fold :: Monoid m => (f :+: g) m -> m # foldMap :: Monoid m => (a -> m) -> (f :+: g) a -> m # foldMap' :: Monoid m => (a -> m) -> (f :+: g) a -> m # foldr :: (a -> b -> b) -> b -> (f :+: g) a -> b # foldr' :: (a -> b -> b) -> b -> (f :+: g) a -> b # foldl :: (b -> a -> b) -> b -> (f :+: g) a -> b # foldl' :: (b -> a -> b) -> b -> (f :+: g) a -> b # foldr1 :: (a -> a -> a) -> (f :+: g) a -> a # foldl1 :: (a -> a -> a) -> (f :+: g) a -> a # toList :: (f :+: g) a -> [a] # null :: (f :+: g) a -> Bool # length :: (f :+: g) a -> Int # elem :: Eq a => a -> (f :+: g) a -> Bool # maximum :: Ord a => (f :+: g) a -> a # minimum :: Ord a => (f :+: g) a -> a # sum :: Num a => (f :+: g) a -> a # product :: Num a => (f :+: g) a -> a #
Foldable (K1 i c :: Type -> Type)	Since: base-4.9.0.0
Instance details Defined in Data.Foldable Methods fold :: Monoid m => K1 i c m -> m # foldMap :: Monoid m => (a -> m) -> K1 i c a -> m # foldMap' :: Monoid m => (a -> m) -> K1 i c a -> m # foldr :: (a -> b -> b) -> b -> K1 i c a -> b # foldr' :: (a -> b -> b) -> b -> K1 i c a -> b # foldl :: (b -> a -> b) -> b -> K1 i c a -> b # foldl' :: (b -> a -> b) -> b -> K1 i c a -> b # foldr1 :: (a -> a -> a) -> K1 i c a -> a # foldl1 :: (a -> a -> a) -> K1 i c a -> a # toList :: K1 i c a -> [a] # null :: K1 i c a -> Bool # length :: K1 i c a -> Int # elem :: Eq a => a -> K1 i c a -> Bool # maximum :: Ord a => K1 i c a -> a # minimum :: Ord a => K1 i c a -> a # sum :: Num a => K1 i c a -> a # product :: Num a => K1 i c a -> a #
(Foldable f, Foldable g) => Foldable (Compose f g)	Since: base-4.9.0.0
Instance details Defined in Data.Functor.Compose Methods fold :: Monoid m => Compose f g m -> m # foldMap :: Monoid m => (a -> m) -> Compose f g a -> m # foldMap' :: Monoid m => (a -> m) -> Compose f g a -> m # foldr :: (a -> b -> b) -> b -> Compose f g a -> b # foldr' :: (a -> b -> b) -> b -> Compose f g a -> b # foldl :: (b -> a -> b) -> b -> Compose f g a -> b # foldl' :: (b -> a -> b) -> b -> Compose f g a -> b # foldr1 :: (a -> a -> a) -> Compose f g a -> a # foldl1 :: (a -> a -> a) -> Compose f g a -> a # toList :: Compose f g a -> [a] # null :: Compose f g a -> Bool # length :: Compose f g a -> Int # elem :: Eq a => a -> Compose f g a -> Bool # maximum :: Ord a => Compose f g a -> a # minimum :: Ord a => Compose f g a -> a # sum :: Num a => Compose f g a -> a # product :: Num a => Compose f g a -> a #
(Foldable f, Foldable g) => Foldable (f :.: g)	Since: base-4.9.0.0
Instance details Defined in Data.Foldable Methods fold :: Monoid m => (f :.: g) m -> m # foldMap :: Monoid m => (a -> m) -> (f :.: g) a -> m # foldMap' :: Monoid m => (a -> m) -> (f :.: g) a -> m # foldr :: (a -> b -> b) -> b -> (f :.: g) a -> b # foldr' :: (a -> b -> b) -> b -> (f :.: g) a -> b # foldl :: (b -> a -> b) -> b -> (f :.: g) a -> b # foldl' :: (b -> a -> b) -> b -> (f :.: g) a -> b # foldr1 :: (a -> a -> a) -> (f :.: g) a -> a # foldl1 :: (a -> a -> a) -> (f :.: g) a -> a # toList :: (f :.: g) a -> [a] # null :: (f :.: g) a -> Bool # length :: (f :.: g) a -> Int # elem :: Eq a => a -> (f :.: g) a -> Bool # maximum :: Ord a => (f :.: g) a -> a # minimum :: Ord a => (f :.: g) a -> a # sum :: Num a => (f :.: g) a -> a # product :: Num a => (f :.: g) a -> a #
Foldable f => Foldable (M1 i c f)	Since: base-4.9.0.0
Instance details Defined in Data.Foldable Methods fold :: Monoid m => M1 i c f m -> m # foldMap :: Monoid m => (a -> m) -> M1 i c f a -> m # foldMap' :: Monoid m => (a -> m) -> M1 i c f a -> m # foldr :: (a -> b -> b) -> b -> M1 i c f a -> b # foldr' :: (a -> b -> b) -> b -> M1 i c f a -> b # foldl :: (b -> a -> b) -> b -> M1 i c f a -> b # foldl' :: (b -> a -> b) -> b -> M1 i c f a -> b # foldr1 :: (a -> a -> a) -> M1 i c f a -> a # foldl1 :: (a -> a -> a) -> M1 i c f a -> a # toList :: M1 i c f a -> [a] # null :: M1 i c f a -> Bool # length :: M1 i c f a -> Int # elem :: Eq a => a -> M1 i c f a -> Bool # maximum :: Ord a => M1 i c f a -> a # minimum :: Ord a => M1 i c f a -> a # sum :: Num a => M1 i c f a -> a # product :: Num a => M1 i c f a -> a #

traverse_ :: (Foldable t, Applicative f) => (a -> f b) -> t a -> f () #

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

traverse_ is just like mapM_, but generalised to Applicative actions.

Examples

Expand

Basic usage:

>>> traverse_ print ["Hello", "world", "!"]
"Hello"
"world"
"!"

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

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

sequence_ is just like sequenceA_, but specialised to monadic actions.

sequenceA_ :: (Foldable t, Applicative f) => t (f a) -> f () #

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

sequenceA_ is just like sequence_, but generalised to Applicative actions.

Examples

Expand

Basic usage:

>>> sequenceA_ [print "Hello", print "world", print "!"]
"Hello"
"world"
"!"

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

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

Examples

Expand

Basic usage:

>>> or []
False

>>> or [True]
True

>>> or [False]
False

>>> or [True, True, False]
True

>>> or (True : repeat False) -- Infinite list [True,False,False,False,...
True

>>> or (repeat False)
* Hangs forever *

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

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

mapM_ is just like traverse_, but specialised to monadic actions.

for_ :: (Foldable t, Applicative f) => t a -> (a -> f b) -> f () #

for_ is traverse_ with its arguments flipped. For a version that doesn't ignore the results see for. This is forM_ generalised to Applicative actions.

for_ is just like forM_, but generalised to Applicative actions.

Examples

Expand

Basic usage:

>>> for_ [1..4] print
1
2
3
4

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

forM_ is mapM_ with its arguments flipped. For a version that doesn't ignore the results see forM.

forM_ is just like for_, but specialised to monadic actions.

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

Left-to-right monadic fold over the elements of a structure.

Given a structure t with elements (a, b, ..., w, x, y), the result of a fold with an operator function f is equivalent to:

foldlM f z t = do
    aa <- f z a
    bb <- f aa b
    ...
    xx <- f ww x
    yy <- f xx y
    return yy -- Just @return z@ when the structure is empty

For a Monad m, given two functions f1 :: a -> m b and f2 :: b -> m c, their Kleisli composition (f1 >=> f2) :: a -> m c is defined by:

(f1 >=> f2) a = f1 a >>= f2

Another way of thinking about foldlM is that it amounts to an application to z of a Kleisli composition:

foldlM f z t =
    flip f a >=> flip f b >=> ... >=> flip f x >=> flip f y $ z

The monadic effects of foldlM are sequenced from left to right.

If at some step the bind operator (>>=) short-circuits (as with, e.g., mzero in a MonadPlus), the evaluated effects will be from an initial segment of the element sequence. If you want to evaluate the monadic effects in right-to-left order, or perhaps be able to short-circuit after processing a tail of the sequence of elements, you'll need to use foldrM instead.

If the monadic effects don't short-circuit, the outermost application of f is to the rightmost element y, so that, ignoring effects, the result looks like a left fold:

((((z `f` a) `f` b) ... `f` w) `f` x) `f` y

Examples

Expand

Basic usage:

>>> let f a e = do { print e ; return $ e : a }
>>> foldlM f [] [0..3]
0
1
2
3
[3,2,1,0]

find :: Foldable t => (a -> Bool) -> t a -> Maybe a #

The find function takes a predicate and a structure and returns the leftmost element of the structure matching the predicate, or Nothing if there is no such element.

Examples

Expand

Basic usage:

>>> find (> 42) [0, 5..]
Just 45

>>> find (> 12) [1..7]
Nothing

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

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

Examples

Expand

Basic usage:

>>> concatMap (take 3) [[1..], [10..], [100..], [1000..]]
[1,2,3,10,11,12,100,101,102,1000,1001,1002]

>>> concatMap (take 3) (Just [1..])
[1,2,3]

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

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

Examples

Expand

Basic usage:

>>> concat (Just [1, 2, 3])
[1,2,3]

>>> concat (Left 42)
[]

>>> concat [[1, 2, 3], [4, 5], [6], []]
[1,2,3,4,5,6]

asum :: (Foldable t, Alternative f) => t (f a) -> f a #

The sum of a collection of actions, generalizing concat.

asum is just like msum, but generalised to Alternative.

Examples

Expand

Basic usage:

>>> asum [Just "Hello", Nothing, Just "World"]
Just "Hello"

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

Determines whether any element of the structure satisfies the predicate.

Examples

Expand

Basic usage:

>>> any (> 3) []
False

>>> any (> 3) [1,2]
False

>>> any (> 3) [1,2,3,4,5]
True

>>> any (> 3) [1..]
True

>>> any (> 3) [0, -1..]
* Hangs forever *

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

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

Examples

Expand

Basic usage:

>>> and []
True

>>> and [True]
True

>>> and [False]
False

>>> and [True, True, False]
False

>>> and (False : repeat True) -- Infinite list [False,True,True,True,...
False

>>> and (repeat True)
* Hangs forever *

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

Determines whether all elements of the structure satisfy the predicate.

Examples

Expand

Basic usage:

>>> all (> 3) []
True

>>> all (> 3) [1,2]
False

>>> all (> 3) [1,2,3,4,5]
False

>>> all (> 3) [1..]
False

>>> all (> 3) [4..]
* Hangs forever *

($) :: forall (r :: RuntimeRep) a (b :: TYPE r). (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.

Note that ($) is levity-polymorphic in its result type, so that foo $ True where foo :: Bool -> Int# is well-typed.

on :: (b -> b -> c) -> (a -> b) -> a -> a -> c infixl 0 #

on b u x y runs the binary function b on the results of applying unary function u to two arguments x and y. From the opposite perspective, it transforms two inputs and combines the outputs.

((+) `on` f) x y = f x + f y

Typical usage: sortBy (compare `on` fst).

Algebraic properties:

(*) `on` id = (*) -- (if (*) ∉ {⊥, const ⊥})

```
((*) `on` f) `on` g = (*) `on` (f . g)
```
```
flip on f . flip on g = flip on (g . f)
```

fix :: (a -> a) -> a #

fix f is the least fixed point of the function f, i.e. the least defined x such that f x = x.

For example, we can write the factorial function using direct recursion as

>>> let fac n = if n <= 1 then 1 else n * fac (n-1) in fac 5
120

This uses the fact that Haskell’s let introduces recursive bindings. We can rewrite this definition using fix,

>>> fix (\rec n -> if n <= 1 then 1 else n * rec (n-1)) 5
120

Instead of making a recursive call, we introduce a dummy parameter rec; when used within fix, this parameter then refers to fix’s argument, hence the recursion is reintroduced.

(&) :: a -> (a -> b) -> b infixl 1 #

& is a reverse application operator. This provides notational convenience. Its precedence is one higher than that of the forward application operator $, which allows & to be nested in $.

>>> 5 & (+1) & show
"6"

Since: base-4.8.0.0

id :: a -> a #

Identity function.

id x = x

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

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

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

const :: a -> b -> a #

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

>>> const 42 "hello"
42

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

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

Function composition.

class Functor (f :: Type -> Type) where #

A type f is a Functor if it provides a function fmap which, given any types a and b lets you apply any function from (a -> b) to turn an f a into an f b, preserving the structure of f. Furthermore f needs to adhere to the following:

Identity: fmap id == id
Composition: fmap (f . g) == fmap f . fmap g

Note, that the second law follows from the free theorem of the type fmap and the first law, so you need only check that the former condition holds.

Minimal complete definition

fmap

Methods

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

fmap is used to apply a function of type (a -> b) to a value of type f a, where f is a functor, to produce a value of type f b. Note that for any type constructor with more than one parameter (e.g., Either), only the last type parameter can be modified with fmap (e.g., b in `Either a b`).

Some type constructors with two parameters or more have a Bifunctor instance that allows both the last and the penultimate parameters to be mapped over. ==== Examples

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

>>> fmap show Nothing
Nothing
>>> fmap show (Just 3)
Just "3"

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

>>> fmap show (Left 17)
Left 17
>>> fmap show (Right 17)
Right "17"

Double each element of a list:

>>> fmap (*2) [1,2,3]
[2,4,6]

Apply even to the second element of a pair:

>>> fmap even (2,2)
(2,True)

It may seem surprising that the function is only applied to the last element of the tuple compared to the list example above which applies it to every element in the list. To understand, remember that tuples are type constructors with multiple type parameters: a tuple of 3 elements `(a,b,c)` can also be written `(,,) a b c` and its Functor instance is defined for `Functor ((,,) a b)` (i.e., only the third parameter is free to be mapped over with fmap).

It explains why fmap can be used with tuples containing values of different types as in the following example:

>>> fmap even ("hello", 1.0, 4)
("hello",1.0,True)

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

Instances details

Functor ZipList	Since: base-2.1
Instance details Defined in Control.Applicative Methods fmap :: (a -> b) -> ZipList a -> ZipList b # (<$) :: a -> ZipList b -> ZipList a #
Functor Handler	Since: base-4.6.0.0
Instance details Defined in Control.Exception Methods fmap :: (a -> b) -> Handler a -> Handler b # (<$) :: a -> Handler b -> Handler a #
Functor Identity	Since: base-4.8.0.0
Instance details Defined in Data.Functor.Identity Methods fmap :: (a -> b) -> Identity a -> Identity b # (<$) :: a -> Identity b -> Identity a #
Functor First	Since: base-4.8.0.0
Instance details Defined in Data.Monoid Methods fmap :: (a -> b) -> First a -> First b # (<$) :: a -> First b -> First a #
Functor Last	Since: base-4.8.0.0
Instance details Defined in Data.Monoid Methods fmap :: (a -> b) -> Last a -> Last b # (<$) :: a -> Last b -> Last a #
Functor Down	Since: base-4.11.0.0
Instance details Defined in Data.Ord Methods fmap :: (a -> b) -> Down a -> Down b # (<$) :: a -> Down b -> Down a #
Functor First	Since: base-4.9.0.0
Instance details Defined in Data.Semigroup Methods fmap :: (a -> b) -> First a -> First b # (<$) :: a -> First b -> First a #
Functor Last	Since: base-4.9.0.0
Instance details Defined in Data.Semigroup Methods fmap :: (a -> b) -> Last a -> Last b # (<$) :: a -> Last b -> Last a #
Functor Max	Since: base-4.9.0.0
Instance details Defined in Data.Semigroup Methods fmap :: (a -> b) -> Max a -> Max b # (<$) :: a -> Max b -> Max a #
Functor Min	Since: base-4.9.0.0
Instance details Defined in Data.Semigroup Methods fmap :: (a -> b) -> Min a -> Min b # (<$) :: a -> Min b -> Min a #
Functor Option	Since: base-4.9.0.0
Instance details Defined in Data.Semigroup Methods fmap :: (a -> b) -> Option a -> Option b # (<$) :: a -> Option b -> Option a #
Functor NonEmpty	Since: base-4.9.0.0
Instance details Defined in GHC.Base Methods fmap :: (a -> b) -> NonEmpty a -> NonEmpty b # (<$) :: a -> NonEmpty b -> NonEmpty a #
Functor Par1	Since: base-4.9.0.0
Instance details Defined in GHC.Generics Methods fmap :: (a -> b) -> Par1 a -> Par1 b # (<$) :: a -> Par1 b -> Par1 a #
Functor P	Since: base-4.8.0.0
Instance details Defined in Text.ParserCombinators.ReadP Methods fmap :: (a -> b) -> P a -> P b # (<$) :: a -> P b -> P a #
Functor ReadP	Since: base-2.1
Instance details Defined in Text.ParserCombinators.ReadP Methods fmap :: (a -> b) -> ReadP a -> ReadP b # (<$) :: a -> ReadP b -> ReadP a #
Functor IntMap
Instance details Defined in Data.IntMap.Internal Methods fmap :: (a -> b) -> IntMap a -> IntMap b # (<$) :: a -> IntMap b -> IntMap a #
Functor Digit
Instance details Defined in Data.Sequence.Internal Methods fmap :: (a -> b) -> Digit a -> Digit b # (<$) :: a -> Digit b -> Digit a #
Functor Elem
Instance details Defined in Data.Sequence.Internal Methods fmap :: (a -> b) -> Elem a -> Elem b # (<$) :: a -> Elem b -> Elem a #
Functor FingerTree
Instance details Defined in Data.Sequence.Internal Methods fmap :: (a -> b) -> FingerTree a -> FingerTree b # (<$) :: a -> FingerTree b -> FingerTree a #
Functor Node
Instance details Defined in Data.Sequence.Internal Methods fmap :: (a -> b) -> Node a -> Node b # (<$) :: a -> Node b -> Node a #
Functor Seq
Instance details Defined in Data.Sequence.Internal Methods fmap :: (a -> b) -> Seq a -> Seq b # (<$) :: a -> Seq b -> Seq a #
Functor ViewL
Instance details Defined in Data.Sequence.Internal Methods fmap :: (a -> b) -> ViewL a -> ViewL b # (<$) :: a -> ViewL b -> ViewL a #
Functor ViewR
Instance details Defined in Data.Sequence.Internal Methods fmap :: (a -> b) -> ViewR a -> ViewR b # (<$) :: a -> ViewR b -> ViewR a #
Functor DList
Instance details Defined in Data.DList.Internal Methods fmap :: (a -> b) -> DList a -> DList b # (<$) :: a -> DList b -> DList a #
Functor IO	Since: base-2.1
Instance details Defined in GHC.Base Methods fmap :: (a -> b) -> IO a -> IO b # (<$) :: a -> IO b -> IO a #
Functor Q
Instance details Defined in Language.Haskell.TH.Syntax Methods fmap :: (a -> b) -> Q a -> Q b # (<$) :: a -> Q b -> Q a #
Functor TyVarBndr
Instance details Defined in Language.Haskell.TH.Syntax Methods fmap :: (a -> b) -> TyVarBndr a -> TyVarBndr b # (<$) :: a -> TyVarBndr b -> TyVarBndr a #
Functor Maybe	Since: base-2.1
Instance details Defined in GHC.Base Methods fmap :: (a -> b) -> Maybe a -> Maybe b # (<$) :: a -> Maybe b -> Maybe a #
Functor Solo	Since: base-4.15
Instance details Defined in GHC.Base Methods fmap :: (a -> b) -> Solo a -> Solo b # (<$) :: a -> Solo b -> Solo a #
Functor []	Since: base-2.1
Instance details Defined in GHC.Base Methods fmap :: (a -> b) -> [a] -> [b] # (<$) :: a -> [b] -> [a] #
Monad m => Functor (WrappedMonad m)	Since: base-2.1
Instance details Defined in Control.Applicative Methods fmap :: (a -> b) -> WrappedMonad m a -> WrappedMonad m b # (<$) :: a -> WrappedMonad m b -> WrappedMonad m a #
Arrow a => Functor (ArrowMonad a)	Since: base-4.6.0.0
Instance details Defined in Control.Arrow Methods fmap :: (a0 -> b) -> ArrowMonad a a0 -> ArrowMonad a b # (<$) :: a0 -> ArrowMonad a b -> ArrowMonad a a0 #
Functor (Either a)	Since: base-3.0
Instance details Defined in Data.Either Methods fmap :: (a0 -> b) -> Either a a0 -> Either a b # (<$) :: a0 -> Either a b -> Either a a0 #
Functor (Proxy :: Type -> Type)	Since: base-4.7.0.0
Instance details Defined in Data.Proxy Methods fmap :: (a -> b) -> Proxy a -> Proxy b # (<$) :: a -> Proxy b -> Proxy a #
Functor (Arg a)	Since: base-4.9.0.0
Instance details Defined in Data.Semigroup Methods fmap :: (a0 -> b) -> Arg a a0 -> Arg a b # (<$) :: a0 -> Arg a b -> Arg a a0 #
Functor (U1 :: Type -> Type)	Since: base-4.9.0.0
Instance details Defined in GHC.Generics Methods fmap :: (a -> b) -> U1 a -> U1 b # (<$) :: a -> U1 b -> U1 a #
Functor (V1 :: Type -> Type)	Since: base-4.9.0.0
Instance details Defined in GHC.Generics Methods fmap :: (a -> b) -> V1 a -> V1 b # (<$) :: a -> V1 b -> V1 a #
Functor (Map k)
Instance details Defined in Data.Map.Internal Methods fmap :: (a -> b) -> Map k a -> Map k b # (<$) :: a -> Map k b -> Map k a #
Functor ((,) a)	Since: base-2.1
Instance details Defined in GHC.Base Methods fmap :: (a0 -> b) -> (a, a0) -> (a, b) # (<$) :: a0 -> (a, b) -> (a, a0) #
Arrow a => Functor (WrappedArrow a b)	Since: base-2.1
Instance details Defined in Control.Applicative Methods fmap :: (a0 -> b0) -> WrappedArrow a b a0 -> WrappedArrow a b b0 # (<$) :: a0 -> WrappedArrow a b b0 -> WrappedArrow a b a0 #
Functor m => Functor (Kleisli m a)	Since: base-4.14.0.0
Instance details Defined in Control.Arrow Methods fmap :: (a0 -> b) -> Kleisli m a a0 -> Kleisli m a b # (<$) :: a0 -> Kleisli m a b -> Kleisli m a a0 #
Functor (Const m :: Type -> Type)	Since: base-2.1
Instance details Defined in Data.Functor.Const Methods fmap :: (a -> b) -> Const m a -> Const m b # (<$) :: a -> Const m b -> Const m a #
Functor f => Functor (Ap f)	Since: base-4.12.0.0
Instance details Defined in Data.Monoid Methods fmap :: (a -> b) -> Ap f a -> Ap f b # (<$) :: a -> Ap f b -> Ap f a #
Functor f => Functor (Rec1 f)	Since: base-4.9.0.0
Instance details Defined in GHC.Generics Methods fmap :: (a -> b) -> Rec1 f a -> Rec1 f b # (<$) :: a -> Rec1 f b -> Rec1 f a #
Functor (URec (Ptr ()) :: Type -> Type)	Since: base-4.9.0.0
Instance details Defined in GHC.Generics Methods fmap :: (a -> b) -> URec (Ptr ()) a -> URec (Ptr ()) b # (<$) :: a -> URec (Ptr ()) b -> URec (Ptr ()) a #
Functor (URec Char :: Type -> Type)	Since: base-4.9.0.0
Instance details Defined in GHC.Generics Methods fmap :: (a -> b) -> URec Char a -> URec Char b # (<$) :: a -> URec Char b -> URec Char a #
Functor (URec Double :: Type -> Type)	Since: base-4.9.0.0
Instance details Defined in GHC.Generics Methods fmap :: (a -> b) -> URec Double a -> URec Double b # (<$) :: a -> URec Double b -> URec Double a #
Functor (URec Float :: Type -> Type)	Since: base-4.9.0.0
Instance details Defined in GHC.Generics Methods fmap :: (a -> b) -> URec Float a -> URec Float b # (<$) :: a -> URec Float b -> URec Float a #
Functor (URec Int :: Type -> Type)	Since: base-4.9.0.0
Instance details Defined in GHC.Generics Methods fmap :: (a -> b) -> URec Int a -> URec Int b # (<$) :: a -> URec Int b -> URec Int a #
Functor (URec Word :: Type -> Type)	Since: base-4.9.0.0
Instance details Defined in GHC.Generics Methods fmap :: (a -> b) -> URec Word a -> URec Word b # (<$) :: a -> URec Word b -> URec Word a #
(Applicative f, Monad f) => Functor (WhenMissing f x)	Since: containers-0.5.9
Instance details Defined in Data.IntMap.Internal Methods fmap :: (a -> b) -> WhenMissing f x a -> WhenMissing f x b # (<$) :: a -> WhenMissing f x b -> WhenMissing f x a #
Functor ((,,) a b)	Since: base-4.14.0.0
Instance details Defined in GHC.Base Methods fmap :: (a0 -> b0) -> (a, b, a0) -> (a, b, b0) # (<$) :: a0 -> (a, b, b0) -> (a, b, a0) #
(Functor f, Functor g) => Functor (Product f g)	Since: base-4.9.0.0
Instance details Defined in Data.Functor.Product Methods fmap :: (a -> b) -> Product f g a -> Product f g b # (<$) :: a -> Product f g b -> Product f g a #
(Functor f, Functor g) => Functor (Sum f g)	Since: base-4.9.0.0
Instance details Defined in Data.Functor.Sum Methods fmap :: (a -> b) -> Sum f g a -> Sum f g b # (<$) :: a -> Sum f g b -> Sum f g a #
(Functor f, Functor g) => Functor (f :*: g)	Since: base-4.9.0.0
Instance details Defined in GHC.Generics Methods fmap :: (a -> b) -> (f :: g) a -> (f :: g) b # (<$) :: a -> (f :: g) b -> (f :: g) a #
(Functor f, Functor g) => Functor (f :+: g)	Since: base-4.9.0.0
Instance details Defined in GHC.Generics Methods fmap :: (a -> b) -> (f :+: g) a -> (f :+: g) b # (<$) :: a -> (f :+: g) b -> (f :+: g) a #
Functor (K1 i c :: Type -> Type)	Since: base-4.9.0.0
Instance details Defined in GHC.Generics Methods fmap :: (a -> b) -> K1 i c a -> K1 i c b # (<$) :: a -> K1 i c b -> K1 i c a #
Functor f => Functor (WhenMatched f x y)	Since: containers-0.5.9
Instance details Defined in Data.IntMap.Internal Methods fmap :: (a -> b) -> WhenMatched f x y a -> WhenMatched f x y b # (<$) :: a -> WhenMatched f x y b -> WhenMatched f x y a #
(Applicative f, Monad f) => Functor (WhenMissing f k x)	Since: containers-0.5.9
Instance details Defined in Data.Map.Internal Methods fmap :: (a -> b) -> WhenMissing f k x a -> WhenMissing f k x b # (<$) :: a -> WhenMissing f k x b -> WhenMissing f k x a #
Functor ((,,,) a b c)	Since: base-4.14.0.0
Instance details Defined in GHC.Base Methods fmap :: (a0 -> b0) -> (a, b, c, a0) -> (a, b, c, b0) # (<$) :: a0 -> (a, b, c, b0) -> (a, b, c, a0) #
Functor ((->) r)	Since: base-2.1
Instance details Defined in GHC.Base Methods fmap :: (a -> b) -> (r -> a) -> r -> b # (<$) :: a -> (r -> b) -> r -> a #
(Functor f, Functor g) => Functor (Compose f g)	Since: base-4.9.0.0
Instance details Defined in Data.Functor.Compose Methods fmap :: (a -> b) -> Compose f g a -> Compose f g b # (<$) :: a -> Compose f g b -> Compose f g a #
(Functor f, Functor g) => Functor (f :.: g)	Since: base-4.9.0.0
Instance details Defined in GHC.Generics Methods fmap :: (a -> b) -> (f :.: g) a -> (f :.: g) b # (<$) :: a -> (f :.: g) b -> (f :.: g) a #
Functor f => Functor (M1 i c f)	Since: base-4.9.0.0
Instance details Defined in GHC.Generics Methods fmap :: (a -> b) -> M1 i c f a -> M1 i c f b # (<$) :: a -> M1 i c f b -> M1 i c f a #
Functor f => Functor (WhenMatched f k x y)	Since: containers-0.5.9
Instance details Defined in Data.Map.Internal Methods fmap :: (a -> b) -> WhenMatched f k x y a -> WhenMatched f k x y b # (<$) :: a -> WhenMatched f k x y b -> WhenMatched f k x y a #

void :: Functor f => f a -> f () #

void value discards or ignores the result of evaluation, such as the return value of an IO action.

Examples

Expand

Replace the contents of a Maybe Int with unit:

>>> void Nothing
Nothing
>>> void (Just 3)
Just ()

Replace the contents of an Either Int Int with unit, resulting in an Either Int ():

>>> void (Left 8675309)
Left 8675309
>>> void (Right 8675309)
Right ()

Replace every element of a list with unit:

>>> void [1,2,3]
[(),(),()]

Replace the second element of a pair with unit:

>>> void (1,2)
(1,())

Discard the result of an IO action:

>>> mapM print [1,2]
1
2
[(),()]
>>> void $ mapM print [1,2]
1
2

(<&>) :: Functor f => f a -> (a -> b) -> f b infixl 1 #

Flipped version of <$>.

(<&>) = flip fmap

Examples

Expand

Apply (+1) to a list, a Just and a Right:

>>> Just 2 <&> (+1)
Just 3

>>> [1,2,3] <&> (+1)
[2,3,4]

>>> Right 3 <&> (+1)
Right 4

Since: base-4.11.0.0

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

An infix synonym for fmap.

The name of this operator is an allusion to $. Note the similarities between their types:

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

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

Examples

Expand

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

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

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

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

Double each element of a list:

>>> (*2) <$> [1,2,3]
[2,4,6]

Apply even to the second element of a pair:

>>> even <$> (2,2)
(2,True)

($>) :: Functor f => f a -> b -> f b infixl 4 #

Flipped version of <$.

Examples

Expand

Replace the contents of a Maybe Int with a constant String:

>>> Nothing $> "foo"
Nothing
>>> Just 90210 $> "foo"
Just "foo"

Replace the contents of an Either Int Int with a constant String, resulting in an Either Int String:

>>> Left 8675309 $> "foo"
Left 8675309
>>> Right 8675309 $> "foo"
Right "foo"

Replace each element of a list with a constant String:

>>> [1,2,3] $> "foo"
["foo","foo","foo"]

Replace the second element of a pair with a constant String:

>>> (1,2) $> "foo"
(1,"foo")

Since: base-4.7.0.0

newtype Compose (f :: k -> Type) (g :: k1 -> k) (a :: k1) infixr 9 #

Right-to-left composition of functors. The composition of applicative functors is always applicative, but the composition of monads is not always a monad.

Constructors

Compose infixr 9
Fields getCompose :: f (g a)

Instances

Instances details

TestEquality f => TestEquality (Compose f g :: k2 -> Type)	The deduction (via generativity) that if `g x :~: g y` then `x :~: y`. Since: base-4.14.0.0
Instance details Defined in Data.Functor.Compose Methods testEquality :: forall (a :: k) (b :: k). Compose f g a -> Compose f g b -> Maybe (a :~: b) #
Functor f => Generic1 (Compose f g :: k -> Type)
Instance details Defined in Data.Functor.Compose Associated Types type Rep1 (Compose f g) :: k -> Type # Methods from1 :: forall (a :: k0). Compose f g a -> Rep1 (Compose f g) a # to1 :: forall (a :: k0). Rep1 (Compose f g) a -> Compose f g a #
(Foldable f, Foldable g) => Foldable (Compose f g)	Since: base-4.9.0.0
Instance details Defined in Data.Functor.Compose Methods fold :: Monoid m => Compose f g m -> m # foldMap :: Monoid m => (a -> m) -> Compose f g a -> m # foldMap' :: Monoid m => (a -> m) -> Compose f g a -> m # foldr :: (a -> b -> b) -> b -> Compose f g a -> b # foldr' :: (a -> b -> b) -> b -> Compose f g a -> b # foldl :: (b -> a -> b) -> b -> Compose f g a -> b # foldl' :: (b -> a -> b) -> b -> Compose f g a -> b # foldr1 :: (a -> a -> a) -> Compose f g a -> a # foldl1 :: (a -> a -> a) -> Compose f g a -> a # toList :: Compose f g a -> [a] # null :: Compose f g a -> Bool # length :: Compose f g a -> Int # elem :: Eq a => a -> Compose f g a -> Bool # maximum :: Ord a => Compose f g a -> a # minimum :: Ord a => Compose f g a -> a # sum :: Num a => Compose f g a -> a # product :: Num a => Compose f g a -> a #
(Eq1 f, Eq1 g) => Eq1 (Compose f g)	Since: base-4.9.0.0
Instance details Defined in Data.Functor.Compose Methods liftEq :: (a -> b -> Bool) -> Compose f g a -> Compose f g b -> Bool #
(Ord1 f, Ord1 g) => Ord1 (Compose f g)	Since: base-4.9.0.0
Instance details Defined in Data.Functor.Compose Methods liftCompare :: (a -> b -> Ordering) -> Compose f g a -> Compose f g b -> Ordering #
(Read1 f, Read1 g) => Read1 (Compose f g)	Since: base-4.9.0.0
Instance details Defined in Data.Functor.Compose Methods liftReadsPrec :: (Int -> ReadS a) -> ReadS [a] -> Int -> ReadS (Compose f g a) # liftReadList :: (Int -> ReadS a) -> ReadS [a] -> ReadS [Compose f g a] # liftReadPrec :: ReadPrec a -> ReadPrec [a] -> ReadPrec (Compose f g a) # liftReadListPrec :: ReadPrec a -> ReadPrec [a] -> ReadPrec [Compose f g a] #
(Show1 f, Show1 g) => Show1 (Compose f g)	Since: base-4.9.0.0
Instance details Defined in Data.Functor.Compose Methods liftShowsPrec :: (Int -> a -> ShowS) -> ([a] -> ShowS) -> Int -> Compose f g a -> ShowS # liftShowList :: (Int -> a -> ShowS) -> ([a] -> ShowS) -> [Compose f g a] -> ShowS #
(Functor f, Contravariant g) => Contravariant (Compose f g)
Instance details Defined in Data.Functor.Contravariant Methods contramap :: (a' -> a) -> Compose f g a -> Compose f g a' # (>$) :: b -> Compose f g b -> Compose f g a #
(Traversable f, Traversable g) => Traversable (Compose f g)	Since: base-4.9.0.0
Instance details Defined in Data.Functor.Compose Methods traverse :: Applicative f0 => (a -> f0 b) -> Compose f g a -> f0 (Compose f g b) # sequenceA :: Applicative f0 => Compose f g (f0 a) -> f0 (Compose f g a) # mapM :: Monad m => (a -> m b) -> Compose f g a -> m (Compose f g b) # sequence :: Monad m => Compose f g (m a) -> m (Compose f g a) #
(Alternative f, Applicative g) => Alternative (Compose f g)	Since: base-4.9.0.0
Instance details Defined in Data.Functor.Compose Methods empty :: Compose f g a # (<\|>) :: Compose f g a -> Compose f g a -> Compose f g a # some :: Compose f g a -> Compose f g [a] # many :: Compose f g a -> Compose f g [a] #
(Applicative f, Applicative g) => Applicative (Compose f g)	Since: base-4.9.0.0
Instance details Defined in Data.Functor.Compose Methods pure :: a -> Compose f g a # (<>) :: Compose f g (a -> b) -> Compose f g a -> Compose f g b # liftA2 :: (a -> b -> c) -> Compose f g a -> Compose f g b -> Compose f g c # (>) :: Compose f g a -> Compose f g b -> Compose f g b # (<*) :: Compose f g a -> Compose f g b -> Compose f g a #
(Functor f, Functor g) => Functor (Compose f g)	Since: base-4.9.0.0
Instance details Defined in Data.Functor.Compose Methods fmap :: (a -> b) -> Compose f g a -> Compose f g b # (<$) :: a -> Compose f g b -> Compose f g a #
(Typeable a, Typeable f, Typeable g, Typeable k1, Typeable k2, Data (f (g a))) => Data (Compose f g a)	Since: base-4.9.0.0
Instance details Defined in Data.Functor.Compose Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g0. g0 -> c g0) -> Compose f g a -> c (Compose f g a) # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (Compose f g a) # toConstr :: Compose f g a -> Constr # dataTypeOf :: Compose f g a -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (Compose f g a)) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Compose f g a)) # gmapT :: (forall b. Data b => b -> b) -> Compose f g a -> Compose f g a # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Compose f g a -> r # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Compose f g a -> r # gmapQ :: (forall d. Data d => d -> u) -> Compose f g a -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> Compose f g a -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> Compose f g a -> m (Compose f g a) # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Compose f g a -> m (Compose f g a) # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Compose f g a -> m (Compose f g a) #
Generic (Compose f g a)
Instance details Defined in Data.Functor.Compose Associated Types type Rep (Compose f g a) :: Type -> Type # Methods from :: Compose f g a -> Rep (Compose f g a) x # to :: Rep (Compose f g a) x -> Compose f g a #
(Read1 f, Read1 g, Read a) => Read (Compose f g a)	Since: base-4.9.0.0
Instance details Defined in Data.Functor.Compose Methods readsPrec :: Int -> ReadS (Compose f g a) # readList :: ReadS [Compose f g a] # readPrec :: ReadPrec (Compose f g a) # readListPrec :: ReadPrec [Compose f g a] #
(Show1 f, Show1 g, Show a) => Show (Compose f g a)	Since: base-4.9.0.0
Instance details Defined in Data.Functor.Compose Methods showsPrec :: Int -> Compose f g a -> ShowS # show :: Compose f g a -> String # showList :: [Compose f g a] -> ShowS #
(Eq1 f, Eq1 g, Eq a) => Eq (Compose f g a)	Since: base-4.9.0.0
Instance details Defined in Data.Functor.Compose Methods (==) :: Compose f g a -> Compose f g a -> Bool # (/=) :: Compose f g a -> Compose f g a -> Bool #
(Ord1 f, Ord1 g, Ord a) => Ord (Compose f g a)	Since: base-4.9.0.0
Instance details Defined in Data.Functor.Compose Methods compare :: Compose f g a -> Compose f g a -> Ordering # (<) :: Compose f g a -> Compose f g a -> Bool # (<=) :: Compose f g a -> Compose f g a -> Bool # (>) :: Compose f g a -> Compose f g a -> Bool # (>=) :: Compose f g a -> Compose f g a -> Bool # max :: Compose f g a -> Compose f g a -> Compose f g a # min :: Compose f g a -> Compose f g a -> Compose f g a #
type Rep1 (Compose f g :: k -> Type)	Since: base-4.9.0.0
Instance details Defined in Data.Functor.Compose type Rep1 (Compose f g :: k -> Type) = D1 ('MetaData "Compose" "Data.Functor.Compose" "base" 'True) (C1 ('MetaCons "Compose" 'PrefixI 'True) (S1 ('MetaSel ('Just "getCompose") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (f :.: Rec1 g)))
type Rep (Compose f g a)	Since: base-4.9.0.0
Instance details Defined in Data.Functor.Compose type Rep (Compose f g a) = D1 ('MetaData "Compose" "Data.Functor.Compose" "base" 'True) (C1 ('MetaCons "Compose" 'PrefixI 'True) (S1 ('MetaSel ('Just "getCompose") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 (f (g a)))))

class Contravariant (f :: Type -> Type) where #

The class of contravariant functors.

Whereas in Haskell, one can think of a Functor as containing or producing values, a contravariant functor is a functor that can be thought of as consuming values.

As an example, consider the type of predicate functions a -> Bool. One such predicate might be negative x = x < 0, which classifies integers as to whether they are negative. However, given this predicate, we can re-use it in other situations, providing we have a way to map values to integers. For instance, we can use the negative predicate on a person's bank balance to work out if they are currently overdrawn:

newtype Predicate a = Predicate { getPredicate :: a -> Bool }

instance Contravariant Predicate where
  contramap :: (a' -> a) -> (Predicate a -> Predicate a')
  contramap f (Predicate p) = Predicate (p . f)
                                         |   `- First, map the input...
                                         `----- then apply the predicate.

overdrawn :: Predicate Person
overdrawn = contramap personBankBalance negative

Any instance should be subject to the following laws:

Identity: contramap id = id
Composition: contramap (g . f) = contramap f . contramap g

Note, that the second law follows from the free theorem of the type of contramap and the first law, so you need only check that the former condition holds.

Minimal complete definition

contramap

Methods

contramap :: (a' -> a) -> f a -> f a' #

(>$) :: b -> f b -> f a infixl 4 #

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

Instances

Instances details

Contravariant Comparison	A `Comparison` is a `Contravariant` `Functor`, because `contramap` can apply its function argument to each input of the comparison function.
Instance details Defined in Data.Functor.Contravariant Methods contramap :: (a' -> a) -> Comparison a -> Comparison a' # (>$) :: b -> Comparison b -> Comparison a #
Contravariant Equivalence	Equivalence relations are `Contravariant`, because you can apply the contramapped function to each input to the equivalence relation.
Instance details Defined in Data.Functor.Contravariant Methods contramap :: (a' -> a) -> Equivalence a -> Equivalence a' # (>$) :: b -> Equivalence b -> Equivalence a #
Contravariant Predicate	A `Predicate` is a `Contravariant` `Functor`, because `contramap` can apply its function argument to the input of the predicate. Without newtypes `contramap f` equals precomposing with `f` (= `(. f)`). contramap :: (a' -> a) -> (Predicate a -> Predicate a') contramap f (Predicate g) = Predicate (g . f)
Instance details Defined in Data.Functor.Contravariant Methods contramap :: (a' -> a) -> Predicate a -> Predicate a' # (>$) :: b -> Predicate b -> Predicate a #
Contravariant (Op a)
Instance details Defined in Data.Functor.Contravariant Methods contramap :: (a' -> a0) -> Op a a0 -> Op a a' # (>$) :: b -> Op a b -> Op a a0 #
Contravariant (Proxy :: Type -> Type)
Instance details Defined in Data.Functor.Contravariant Methods contramap :: (a' -> a) -> Proxy a -> Proxy a' # (>$) :: b -> Proxy b -> Proxy a #
Contravariant (U1 :: Type -> Type)
Instance details Defined in Data.Functor.Contravariant Methods contramap :: (a' -> a) -> U1 a -> U1 a' # (>$) :: b -> U1 b -> U1 a #
Contravariant (V1 :: Type -> Type)
Instance details Defined in Data.Functor.Contravariant Methods contramap :: (a' -> a) -> V1 a -> V1 a' # (>$) :: b -> V1 b -> V1 a #
Contravariant (Const a :: Type -> Type)
Instance details Defined in Data.Functor.Contravariant Methods contramap :: (a' -> a0) -> Const a a0 -> Const a a' # (>$) :: b -> Const a b -> Const a a0 #
Contravariant f => Contravariant (Alt f)
Instance details Defined in Data.Functor.Contravariant Methods contramap :: (a' -> a) -> Alt f a -> Alt f a' # (>$) :: b -> Alt f b -> Alt f a #
Contravariant f => Contravariant (Rec1 f)
Instance details Defined in Data.Functor.Contravariant Methods contramap :: (a' -> a) -> Rec1 f a -> Rec1 f a' # (>$) :: b -> Rec1 f b -> Rec1 f a #
(Contravariant f, Contravariant g) => Contravariant (Product f g)
Instance details Defined in Data.Functor.Contravariant Methods contramap :: (a' -> a) -> Product f g a -> Product f g a' # (>$) :: b -> Product f g b -> Product f g a #
(Contravariant f, Contravariant g) => Contravariant (Sum f g)
Instance details Defined in Data.Functor.Contravariant Methods contramap :: (a' -> a) -> Sum f g a -> Sum f g a' # (>$) :: b -> Sum f g b -> Sum f g a #
(Contravariant f, Contravariant g) => Contravariant (f :*: g)
Instance details Defined in Data.Functor.Contravariant Methods contramap :: (a' -> a) -> (f :: g) a -> (f :: g) a' # (>$) :: b -> (f :: g) b -> (f :: g) a #
(Contravariant f, Contravariant g) => Contravariant (f :+: g)
Instance details Defined in Data.Functor.Contravariant Methods contramap :: (a' -> a) -> (f :+: g) a -> (f :+: g) a' # (>$) :: b -> (f :+: g) b -> (f :+: g) a #
Contravariant (K1 i c :: Type -> Type)
Instance details Defined in Data.Functor.Contravariant Methods contramap :: (a' -> a) -> K1 i c a -> K1 i c a' # (>$) :: b -> K1 i c b -> K1 i c a #
(Functor f, Contravariant g) => Contravariant (Compose f g)
Instance details Defined in Data.Functor.Contravariant Methods contramap :: (a' -> a) -> Compose f g a -> Compose f g a' # (>$) :: b -> Compose f g b -> Compose f g a #
(Functor f, Contravariant g) => Contravariant (f :.: g)
Instance details Defined in Data.Functor.Contravariant Methods contramap :: (a' -> a) -> (f :.: g) a -> (f :.: g) a' # (>$) :: b -> (f :.: g) b -> (f :.: g) a #
Contravariant f => Contravariant (M1 i c f)
Instance details Defined in Data.Functor.Contravariant Methods contramap :: (a' -> a) -> M1 i c f a -> M1 i c f a' # (>$) :: b -> M1 i c f b -> M1 i c f a #

(>$<) :: Contravariant f => (a -> b) -> f b -> f a infixl 4 #

This is an infix alias for contramap.

newtype Identity a #

Identity functor and monad. (a non-strict monad)

Since: base-4.8.0.0

Constructors

Identity
Fields runIdentity :: a

Instances

Instances details

MonadFix Identity	Since: base-4.8.0.0
Instance details Defined in Data.Functor.Identity Methods mfix :: (a -> Identity a) -> Identity a #
Foldable Identity	Since: base-4.8.0.0
Instance details Defined in Data.Functor.Identity Methods fold :: Monoid m => Identity m -> m # foldMap :: Monoid m => (a -> m) -> Identity a -> m # foldMap' :: Monoid m => (a -> m) -> Identity a -> m # foldr :: (a -> b -> b) -> b -> Identity a -> b # foldr' :: (a -> b -> b) -> b -> Identity a -> b # foldl :: (b -> a -> b) -> b -> Identity a -> b # foldl' :: (b -> a -> b) -> b -> Identity a -> b # foldr1 :: (a -> a -> a) -> Identity a -> a # foldl1 :: (a -> a -> a) -> Identity a -> a # toList :: Identity a -> [a] # null :: Identity a -> Bool # length :: Identity a -> Int # elem :: Eq a => a -> Identity a -> Bool # maximum :: Ord a => Identity a -> a # minimum :: Ord a => Identity a -> a # sum :: Num a => Identity a -> a # product :: Num a => Identity a -> a #
Traversable Identity	Since: base-4.9.0.0
Instance details Defined in Data.Traversable Methods traverse :: Applicative f => (a -> f b) -> Identity a -> f (Identity b) # sequenceA :: Applicative f => Identity (f a) -> f (Identity a) # mapM :: Monad m => (a -> m b) -> Identity a -> m (Identity b) # sequence :: Monad m => Identity (m a) -> m (Identity a) #
Applicative Identity	Since: base-4.8.0.0
Instance details Defined in Data.Functor.Identity Methods pure :: a -> Identity a # (<>) :: Identity (a -> b) -> Identity a -> Identity b # liftA2 :: (a -> b -> c) -> Identity a -> Identity b -> Identity c # (>) :: Identity a -> Identity b -> Identity b # (<*) :: Identity a -> Identity b -> Identity a #
Functor Identity	Since: base-4.8.0.0
Instance details Defined in Data.Functor.Identity Methods fmap :: (a -> b) -> Identity a -> Identity b # (<$) :: a -> Identity b -> Identity a #
Monad Identity	Since: base-4.8.0.0
Instance details Defined in Data.Functor.Identity Methods (>>=) :: Identity a -> (a -> Identity b) -> Identity b # (>>) :: Identity a -> Identity b -> Identity b # return :: a -> Identity a #
Bits a => Bits (Identity a)	Since: base-4.9.0.0
Instance details Defined in Data.Functor.Identity Methods (.&.) :: Identity a -> Identity a -> Identity a # (.\|.) :: Identity a -> Identity a -> Identity a # xor :: Identity a -> Identity a -> Identity a # complement :: Identity a -> Identity a # shift :: Identity a -> Int -> Identity a # rotate :: Identity a -> Int -> Identity a # zeroBits :: Identity a # bit :: Int -> Identity a # setBit :: Identity a -> Int -> Identity a # clearBit :: Identity a -> Int -> Identity a # complementBit :: Identity a -> Int -> Identity a # testBit :: Identity a -> Int -> Bool # bitSizeMaybe :: Identity a -> Maybe Int # bitSize :: Identity a -> Int # isSigned :: Identity a -> Bool # shiftL :: Identity a -> Int -> Identity a # unsafeShiftL :: Identity a -> Int -> Identity a # shiftR :: Identity a -> Int -> Identity a # unsafeShiftR :: Identity a -> Int -> Identity a # rotateL :: Identity a -> Int -> Identity a # rotateR :: Identity a -> Int -> Identity a # popCount :: Identity a -> Int #
FiniteBits a => FiniteBits (Identity a)	Since: base-4.9.0.0
Instance details Defined in Data.Functor.Identity Methods finiteBitSize :: Identity a -> Int # countLeadingZeros :: Identity a -> Int # countTrailingZeros :: Identity a -> Int #
IsString a => IsString (Identity a)	Since: base-4.9.0.0
Instance details Defined in Data.String Methods fromString :: String -> Identity a #
Storable a => Storable (Identity a)	Since: base-4.9.0.0
Instance details Defined in Data.Functor.Identity Methods sizeOf :: Identity a -> Int # alignment :: Identity a -> Int # peekElemOff :: Ptr (Identity a) -> Int -> IO (Identity a) # pokeElemOff :: Ptr (Identity a) -> Int -> Identity a -> IO () # peekByteOff :: Ptr b -> Int -> IO (Identity a) # pokeByteOff :: Ptr b -> Int -> Identity a -> IO () # peek :: Ptr (Identity a) -> IO (Identity a) # poke :: Ptr (Identity a) -> Identity a -> IO () #
Monoid a => Monoid (Identity a)	Since: base-4.9.0.0
Instance details Defined in Data.Functor.Identity Methods mempty :: Identity a # mappend :: Identity a -> Identity a -> Identity a # mconcat :: [Identity a] -> Identity a #
Semigroup a => Semigroup (Identity a)	Since: base-4.9.0.0
Instance details Defined in Data.Functor.Identity Methods (<>) :: Identity a -> Identity a -> Identity a # sconcat :: NonEmpty (Identity a) -> Identity a # stimes :: Integral b => b -> Identity a -> Identity a #
Bounded a => Bounded (Identity a)	Since: base-4.9.0.0
Instance details Defined in Data.Functor.Identity Methods minBound :: Identity a # maxBound :: Identity a #
Enum a => Enum (Identity a)	Since: base-4.9.0.0
Instance details Defined in Data.Functor.Identity Methods succ :: Identity a -> Identity a # pred :: Identity a -> Identity a # toEnum :: Int -> Identity a # fromEnum :: Identity a -> Int # enumFrom :: Identity a -> [Identity a] # enumFromThen :: Identity a -> Identity a -> [Identity a] # enumFromTo :: Identity a -> Identity a -> [Identity a] # enumFromThenTo :: Identity a -> Identity a -> Identity a -> [Identity a] #
Floating a => Floating (Identity a)	Since: base-4.9.0.0
Instance details Defined in Data.Functor.Identity Methods pi :: Identity a # exp :: Identity a -> Identity a # log :: Identity a -> Identity a # sqrt :: Identity a -> Identity a # (**) :: Identity a -> Identity a -> Identity a # logBase :: Identity a -> Identity a -> Identity a # sin :: Identity a -> Identity a # cos :: Identity a -> Identity a # tan :: Identity a -> Identity a # asin :: Identity a -> Identity a # acos :: Identity a -> Identity a # atan :: Identity a -> Identity a # sinh :: Identity a -> Identity a # cosh :: Identity a -> Identity a # tanh :: Identity a -> Identity a # asinh :: Identity a -> Identity a # acosh :: Identity a -> Identity a # atanh :: Identity a -> Identity a # log1p :: Identity a -> Identity a # expm1 :: Identity a -> Identity a # log1pexp :: Identity a -> Identity a # log1mexp :: Identity a -> Identity a #
RealFloat a => RealFloat (Identity a)	Since: base-4.9.0.0
Instance details Defined in Data.Functor.Identity Methods floatRadix :: Identity a -> Integer # floatDigits :: Identity a -> Int # floatRange :: Identity a -> (Int, Int) # decodeFloat :: Identity a -> (Integer, Int) # encodeFloat :: Integer -> Int -> Identity a # exponent :: Identity a -> Int # significand :: Identity a -> Identity a # scaleFloat :: Int -> Identity a -> Identity a # isNaN :: Identity a -> Bool # isInfinite :: Identity a -> Bool # isDenormalized :: Identity a -> Bool # isNegativeZero :: Identity a -> Bool # isIEEE :: Identity a -> Bool # atan2 :: Identity a -> Identity a -> Identity a #
Generic (Identity a)
Instance details Defined in Data.Functor.Identity Associated Types type Rep (Identity a) :: Type -> Type # Methods from :: Identity a -> Rep (Identity a) x # to :: Rep (Identity a) x -> Identity a #
Ix a => Ix (Identity a)	Since: base-4.9.0.0
Instance details Defined in Data.Functor.Identity Methods range :: (Identity a, Identity a) -> [Identity a] # index :: (Identity a, Identity a) -> Identity a -> Int # unsafeIndex :: (Identity a, Identity a) -> Identity a -> Int # inRange :: (Identity a, Identity a) -> Identity a -> Bool # rangeSize :: (Identity a, Identity a) -> Int # unsafeRangeSize :: (Identity a, Identity a) -> Int #
Num a => Num (Identity a)	Since: base-4.9.0.0
Instance details Defined in Data.Functor.Identity Methods (+) :: Identity a -> Identity a -> Identity a # (-) :: Identity a -> Identity a -> Identity a # (*) :: Identity a -> Identity a -> Identity a # negate :: Identity a -> Identity a # abs :: Identity a -> Identity a # signum :: Identity a -> Identity a # fromInteger :: Integer -> Identity a #
Read a => Read (Identity a)	This instance would be equivalent to the derived instances of the `Identity` newtype if the `runIdentity` field were removed Since: base-4.8.0.0
Instance details Defined in Data.Functor.Identity Methods readsPrec :: Int -> ReadS (Identity a) # readList :: ReadS [Identity a] # readPrec :: ReadPrec (Identity a) # readListPrec :: ReadPrec [Identity a] #
Fractional a => Fractional (Identity a)	Since: base-4.9.0.0
Instance details Defined in Data.Functor.Identity Methods (/) :: Identity a -> Identity a -> Identity a # recip :: Identity a -> Identity a # fromRational :: Rational -> Identity a #
Integral a => Integral (Identity a)	Since: base-4.9.0.0
Instance details Defined in Data.Functor.Identity Methods quot :: Identity a -> Identity a -> Identity a # rem :: Identity a -> Identity a -> Identity a # div :: Identity a -> Identity a -> Identity a # mod :: Identity a -> Identity a -> Identity a # quotRem :: Identity a -> Identity a -> (Identity a, Identity a) # divMod :: Identity a -> Identity a -> (Identity a, Identity a) # toInteger :: Identity a -> Integer #
Real a => Real (Identity a)	Since: base-4.9.0.0
Instance details Defined in Data.Functor.Identity Methods toRational :: Identity a -> Rational #
RealFrac a => RealFrac (Identity a)	Since: base-4.9.0.0
Instance details Defined in Data.Functor.Identity Methods properFraction :: Integral b => Identity a -> (b, Identity a) # truncate :: Integral b => Identity a -> b # round :: Integral b => Identity a -> b # ceiling :: Integral b => Identity a -> b # floor :: Integral b => Identity a -> b #
Show a => Show (Identity a)	This instance would be equivalent to the derived instances of the `Identity` newtype if the `runIdentity` field were removed Since: base-4.8.0.0
Instance details Defined in Data.Functor.Identity Methods showsPrec :: Int -> Identity a -> ShowS # show :: Identity a -> String # showList :: [Identity a] -> ShowS #
Eq a => Eq (Identity a)	Since: base-4.8.0.0
Instance details Defined in Data.Functor.Identity Methods (==) :: Identity a -> Identity a -> Bool # (/=) :: Identity a -> Identity a -> Bool #
Ord a => Ord (Identity a)	Since: base-4.8.0.0
Instance details Defined in Data.Functor.Identity Methods compare :: Identity a -> Identity a -> Ordering # (<) :: Identity a -> Identity a -> Bool # (<=) :: Identity a -> Identity a -> Bool # (>) :: Identity a -> Identity a -> Bool # (>=) :: Identity a -> Identity a -> Bool # max :: Identity a -> Identity a -> Identity a # min :: Identity a -> Identity a -> Identity a #
Generic1 Identity
Instance details Defined in Data.Functor.Identity Associated Types type Rep1 Identity :: k -> Type # Methods from1 :: forall (a :: k). Identity a -> Rep1 Identity a # to1 :: forall (a :: k). Rep1 Identity a -> Identity a #
type Rep (Identity a)	Since: base-4.8.0.0
Instance details Defined in Data.Functor.Identity type Rep (Identity a) = D1 ('MetaData "Identity" "Data.Functor.Identity" "base" 'True) (C1 ('MetaCons "Identity" 'PrefixI 'True) (S1 ('MetaSel ('Just "runIdentity") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 a)))
type Rep1 Identity	Since: base-4.8.0.0
Instance details Defined in Data.Functor.Identity type Rep1 Identity = D1 ('MetaData "Identity" "Data.Functor.Identity" "base" 'True) (C1 ('MetaCons "Identity" 'PrefixI 'True) (S1 ('MetaSel ('Just "runIdentity") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) Par1))

data Int #

A fixed-precision integer type with at least the range [-2^29 .. 2^29-1]. The exact range for a given implementation can be determined by using minBound and maxBound from the Bounded class.

Instances

Instances details

Bits Int	Since: base-2.1
Instance details Defined in Data.Bits Methods (.&.) :: Int -> Int -> Int # (.\|.) :: Int -> Int -> Int # xor :: Int -> Int -> Int # complement :: Int -> Int # shift :: Int -> Int -> Int # rotate :: Int -> Int -> Int # zeroBits :: Int # bit :: Int -> Int # setBit :: Int -> Int -> Int # clearBit :: Int -> Int -> Int # complementBit :: Int -> Int -> Int # testBit :: Int -> Int -> Bool # bitSizeMaybe :: Int -> Maybe Int # bitSize :: Int -> Int # isSigned :: Int -> Bool # shiftL :: Int -> Int -> Int # unsafeShiftL :: Int -> Int -> Int # shiftR :: Int -> Int -> Int # unsafeShiftR :: Int -> Int -> Int # rotateL :: Int -> Int -> Int # rotateR :: Int -> Int -> Int # popCount :: Int -> Int #
FiniteBits Int	Since: base-4.6.0.0
Instance details Defined in Data.Bits Methods finiteBitSize :: Int -> Int # countLeadingZeros :: Int -> Int # countTrailingZeros :: Int -> Int #
Bounded Int	Since: base-2.1
Instance details Defined in GHC.Enum Methods minBound :: Int # maxBound :: Int #
Enum Int	Since: base-2.1
Instance details Defined in GHC.Enum 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] #
Num Int	Since: base-2.1
Instance details Defined in GHC.Num Methods (+) :: Int -> Int -> Int # (-) :: Int -> Int -> Int # (*) :: Int -> Int -> Int # negate :: Int -> Int # abs :: Int -> Int # signum :: Int -> Int # fromInteger :: Integer -> Int #
Read Int	Since: base-2.1
Instance details Defined in GHC.Read Methods readsPrec :: Int -> ReadS Int # readList :: ReadS [Int] # readPrec :: ReadPrec Int # readListPrec :: ReadPrec [Int] #
Integral Int	Since: base-2.0.1
Instance details Defined in GHC.Real 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 #
Real Int	Since: base-2.0.1
Instance details Defined in GHC.Real Methods toRational :: Int -> Rational #
Show Int	Since: base-2.1
Instance details Defined in GHC.Show Methods showsPrec :: Int -> Int -> ShowS # show :: Int -> String # showList :: [Int] -> ShowS #
Default Int
Instance details Defined in Data.Default.Class Methods def :: Int #
Eq Int
Instance details Defined in GHC.Classes Methods (==) :: Int -> Int -> Bool # (/=) :: Int -> Int -> Bool #
Ord Int
Instance details Defined in GHC.Classes Methods compare :: Int -> Int -> Ordering # (<) :: Int -> Int -> Bool # (<=) :: Int -> Int -> Bool # (>) :: Int -> Int -> Bool # (>=) :: Int -> Int -> Bool # max :: Int -> Int -> Int # min :: Int -> Int -> Int #
Lift Int
Instance details Defined in Language.Haskell.TH.Syntax Methods lift :: Quote m => Int -> m Exp # liftTyped :: forall (m :: Type -> Type). Quote m => Int -> Code m Int #
Generic1 (URec Int :: k -> Type)
Instance details Defined in GHC.Generics Associated Types type Rep1 (URec Int) :: k -> Type # Methods from1 :: forall (a :: k0). URec Int a -> Rep1 (URec Int) a # to1 :: forall (a :: k0). Rep1 (URec Int) a -> URec Int a #
Foldable (UInt :: Type -> Type)	Since: base-4.9.0.0
Instance details Defined in Data.Foldable Methods fold :: Monoid m => UInt m -> m # foldMap :: Monoid m => (a -> m) -> UInt a -> m # foldMap' :: Monoid m => (a -> m) -> UInt a -> m # foldr :: (a -> b -> b) -> b -> UInt a -> b # foldr' :: (a -> b -> b) -> b -> UInt a -> b # foldl :: (b -> a -> b) -> b -> UInt a -> b # foldl' :: (b -> a -> b) -> b -> UInt a -> b # foldr1 :: (a -> a -> a) -> UInt a -> a # foldl1 :: (a -> a -> a) -> UInt a -> a # toList :: UInt a -> [a] # null :: UInt a -> Bool # length :: UInt a -> Int # elem :: Eq a => a -> UInt a -> Bool # maximum :: Ord a => UInt a -> a # minimum :: Ord a => UInt a -> a # sum :: Num a => UInt a -> a # product :: Num a => UInt a -> a #
Traversable (UInt :: Type -> Type)	Since: base-4.9.0.0
Instance details Defined in Data.Traversable Methods traverse :: Applicative f => (a -> f b) -> UInt a -> f (UInt b) # sequenceA :: Applicative f => UInt (f a) -> f (UInt a) # mapM :: Monad m => (a -> m b) -> UInt a -> m (UInt b) # sequence :: Monad m => UInt (m a) -> m (UInt a) #
Functor (URec Int :: Type -> Type)	Since: base-4.9.0.0
Instance details Defined in GHC.Generics Methods fmap :: (a -> b) -> URec Int a -> URec Int b # (<$) :: a -> URec Int b -> URec Int a #
Generic (URec Int p)
Instance details Defined in GHC.Generics Associated Types type Rep (URec Int p) :: Type -> Type # Methods from :: URec Int p -> Rep (URec Int p) x # to :: Rep (URec Int p) x -> URec Int p #
Show (URec Int p)	Since: base-4.9.0.0
Instance details Defined in GHC.Generics Methods showsPrec :: Int -> URec Int p -> ShowS # show :: URec Int p -> String # showList :: [URec Int p] -> ShowS #
Eq (URec Int p)	Since: base-4.9.0.0
Instance details Defined in GHC.Generics Methods (==) :: URec Int p -> URec Int p -> Bool # (/=) :: URec Int p -> URec Int p -> Bool #
Ord (URec Int p)	Since: base-4.9.0.0
Instance details Defined in GHC.Generics Methods compare :: URec Int p -> URec Int p -> Ordering # (<) :: URec Int p -> URec Int p -> Bool # (<=) :: URec Int p -> URec Int p -> Bool # (>) :: URec Int p -> URec Int p -> Bool # (>=) :: URec Int p -> URec Int p -> Bool # max :: URec Int p -> URec Int p -> URec Int p # min :: URec Int p -> URec Int p -> URec Int p #
data URec Int (p :: k)	Used for marking occurrences of `Int#` Since: base-4.9.0.0
Instance details Defined in GHC.Generics data URec Int (p :: k) = UInt { uInt# :: Int# }
type Rep1 (URec Int :: k -> Type)	Since: base-4.9.0.0
Instance details Defined in GHC.Generics type Rep1 (URec Int :: k -> Type) = D1 ('MetaData "URec" "GHC.Generics" "base" 'False) (C1 ('MetaCons "UInt" 'PrefixI 'True) (S1 ('MetaSel ('Just "uInt#") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (UInt :: k -> Type)))
type Rep (URec Int p)	Since: base-4.9.0.0
Instance details Defined in GHC.Generics type Rep (URec Int p) = D1 ('MetaData "URec" "GHC.Generics" "base" 'False) (C1 ('MetaCons "UInt" 'PrefixI 'True) (S1 ('MetaSel ('Just "uInt#") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (UInt :: Type -> Type)))

data Int8 #

8-bit signed integer type

Instances

Instances details

Bits Int8	Since: base-2.1
Instance details Defined in GHC.Int Methods (.&.) :: Int8 -> Int8 -> Int8 # (.\|.) :: Int8 -> Int8 -> Int8 # xor :: Int8 -> Int8 -> Int8 # complement :: Int8 -> Int8 # shift :: Int8 -> Int -> Int8 # rotate :: Int8 -> Int -> Int8 # zeroBits :: Int8 # bit :: Int -> Int8 # setBit :: Int8 -> Int -> Int8 # clearBit :: Int8 -> Int -> Int8 # complementBit :: Int8 -> Int -> Int8 # testBit :: Int8 -> Int -> Bool # bitSizeMaybe :: Int8 -> Maybe Int # bitSize :: Int8 -> Int # isSigned :: Int8 -> Bool # shiftL :: Int8 -> Int -> Int8 # unsafeShiftL :: Int8 -> Int -> Int8 # shiftR :: Int8 -> Int -> Int8 # unsafeShiftR :: Int8 -> Int -> Int8 # rotateL :: Int8 -> Int -> Int8 # rotateR :: Int8 -> Int -> Int8 # popCount :: Int8 -> Int #
FiniteBits Int8	Since: base-4.6.0.0
Instance details Defined in GHC.Int Methods finiteBitSize :: Int8 -> Int # countLeadingZeros :: Int8 -> Int # countTrailingZeros :: Int8 -> Int #
Bounded Int8	Since: base-2.1
Instance details Defined in GHC.Int Methods minBound :: Int8 # maxBound :: Int8 #
Enum Int8	Since: base-2.1
Instance details Defined in GHC.Int 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] #
Ix Int8	Since: base-2.1
Instance details Defined in GHC.Int Methods range :: (Int8, Int8) -> [Int8] # index :: (Int8, Int8) -> Int8 -> Int # unsafeIndex :: (Int8, Int8) -> Int8 -> Int # inRange :: (Int8, Int8) -> Int8 -> Bool # rangeSize :: (Int8, Int8) -> Int # unsafeRangeSize :: (Int8, Int8) -> Int #
Num Int8	Since: base-2.1
Instance details Defined in GHC.Int Methods (+) :: Int8 -> Int8 -> Int8 # (-) :: Int8 -> Int8 -> Int8 # (*) :: Int8 -> Int8 -> Int8 # negate :: Int8 -> Int8 # abs :: Int8 -> Int8 # signum :: Int8 -> Int8 # fromInteger :: Integer -> Int8 #
Read Int8	Since: base-2.1
Instance details Defined in GHC.Int Methods readsPrec :: Int -> ReadS Int8 # readList :: ReadS [Int8] # readPrec :: ReadPrec Int8 # readListPrec :: ReadPrec [Int8] #
Integral Int8	Since: base-2.1
Instance details Defined in GHC.Int 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 #
Real Int8	Since: base-2.1
Instance details Defined in GHC.Int Methods toRational :: Int8 -> Rational #
Show Int8	Since: base-2.1
Instance details Defined in GHC.Int Methods showsPrec :: Int -> Int8 -> ShowS # show :: Int8 -> String # showList :: [Int8] -> ShowS #
Default Int8
Instance details Defined in Data.Default.Class Methods def :: Int8 #
Eq Int8	Since: base-2.1
Instance details Defined in GHC.Int Methods (==) :: Int8 -> Int8 -> Bool # (/=) :: Int8 -> Int8 -> Bool #
Ord Int8	Since: base-2.1
Instance details Defined in GHC.Int Methods compare :: Int8 -> Int8 -> Ordering # (<) :: Int8 -> Int8 -> Bool # (<=) :: Int8 -> Int8 -> Bool # (>) :: Int8 -> Int8 -> Bool # (>=) :: Int8 -> Int8 -> Bool # max :: Int8 -> Int8 -> Int8 # min :: Int8 -> Int8 -> Int8 #
Lift Int8
Instance details Defined in Language.Haskell.TH.Syntax Methods lift :: Quote m => Int8 -> m Exp # liftTyped :: forall (m :: Type -> Type). Quote m => Int8 -> Code m Int8 #

data Int16 #

16-bit signed integer type

Instances

Instances details

Bits Int16	Since: base-2.1
Instance details Defined in GHC.Int Methods (.&.) :: Int16 -> Int16 -> Int16 # (.\|.) :: Int16 -> Int16 -> Int16 # xor :: Int16 -> Int16 -> Int16 # complement :: Int16 -> Int16 # shift :: Int16 -> Int -> Int16 # rotate :: Int16 -> Int -> Int16 # zeroBits :: Int16 # bit :: Int -> Int16 # setBit :: Int16 -> Int -> Int16 # clearBit :: Int16 -> Int -> Int16 # complementBit :: Int16 -> Int -> Int16 # testBit :: Int16 -> Int -> Bool # bitSizeMaybe :: Int16 -> Maybe Int # bitSize :: Int16 -> Int # isSigned :: Int16 -> Bool # shiftL :: Int16 -> Int -> Int16 # unsafeShiftL :: Int16 -> Int -> Int16 # shiftR :: Int16 -> Int -> Int16 # unsafeShiftR :: Int16 -> Int -> Int16 # rotateL :: Int16 -> Int -> Int16 # rotateR :: Int16 -> Int -> Int16 # popCount :: Int16 -> Int #
FiniteBits Int16	Since: base-4.6.0.0
Instance details Defined in GHC.Int Methods finiteBitSize :: Int16 -> Int # countLeadingZeros :: Int16 -> Int # countTrailingZeros :: Int16 -> Int #
Bounded Int16	Since: base-2.1
Instance details Defined in GHC.Int Methods minBound :: Int16 # maxBound :: Int16 #
Enum Int16	Since: base-2.1
Instance details Defined in GHC.Int Methods succ :: Int16 -> Int16 # pred :: Int16 -> Int16 # toEnum :: Int -> Int16 # fromEnum :: Int16 -> Int # enumFrom :: Int16 -> [Int16] # enumFromThen :: Int16 -> Int16 -> [Int16] # enumFromTo :: Int16 -> Int16 -> [Int16] # enumFromThenTo :: Int16 -> Int16 -> Int16 -> [Int16] #
Ix Int16	Since: base-2.1
Instance details Defined in GHC.Int Methods range :: (Int16, Int16) -> [Int16] # index :: (Int16, Int16) -> Int16 -> Int # unsafeIndex :: (Int16, Int16) -> Int16 -> Int # inRange :: (Int16, Int16) -> Int16 -> Bool # rangeSize :: (Int16, Int16) -> Int # unsafeRangeSize :: (Int16, Int16) -> Int #
Num Int16	Since: base-2.1
Instance details Defined in GHC.Int Methods (+) :: Int16 -> Int16 -> Int16 # (-) :: Int16 -> Int16 -> Int16 # (*) :: Int16 -> Int16 -> Int16 # negate :: Int16 -> Int16 # abs :: Int16 -> Int16 # signum :: Int16 -> Int16 # fromInteger :: Integer -> Int16 #
Read Int16	Since: base-2.1
Instance details Defined in GHC.Int Methods readsPrec :: Int -> ReadS Int16 # readList :: ReadS [Int16] # readPrec :: ReadPrec Int16 # readListPrec :: ReadPrec [Int16] #
Integral Int16	Since: base-2.1
Instance details Defined in GHC.Int Methods quot :: Int16 -> Int16 -> Int16 # rem :: Int16 -> Int16 -> Int16 # div :: Int16 -> Int16 -> Int16 # mod :: Int16 -> Int16 -> Int16 # quotRem :: Int16 -> Int16 -> (Int16, Int16) # divMod :: Int16 -> Int16 -> (Int16, Int16) # toInteger :: Int16 -> Integer #
Real Int16	Since: base-2.1
Instance details Defined in GHC.Int Methods toRational :: Int16 -> Rational #
Show Int16	Since: base-2.1
Instance details Defined in GHC.Int Methods showsPrec :: Int -> Int16 -> ShowS # show :: Int16 -> String # showList :: [Int16] -> ShowS #
Default Int16
Instance details Defined in Data.Default.Class Methods def :: Int16 #
Eq Int16	Since: base-2.1
Instance details Defined in GHC.Int Methods (==) :: Int16 -> Int16 -> Bool # (/=) :: Int16 -> Int16 -> Bool #
Ord Int16	Since: base-2.1
Instance details Defined in GHC.Int Methods compare :: Int16 -> Int16 -> Ordering # (<) :: Int16 -> Int16 -> Bool # (<=) :: Int16 -> Int16 -> Bool # (>) :: Int16 -> Int16 -> Bool # (>=) :: Int16 -> Int16 -> Bool # max :: Int16 -> Int16 -> Int16 # min :: Int16 -> Int16 -> Int16 #
Lift Int16
Instance details Defined in Language.Haskell.TH.Syntax Methods lift :: Quote m => Int16 -> m Exp # liftTyped :: forall (m :: Type -> Type). Quote m => Int16 -> Code m Int16 #

data Int32 #

32-bit signed integer type

Instances

Instances details

Bits Int32	Since: base-2.1
Instance details Defined in GHC.Int Methods (.&.) :: Int32 -> Int32 -> Int32 # (.\|.) :: Int32 -> Int32 -> Int32 # xor :: Int32 -> Int32 -> Int32 # complement :: Int32 -> Int32 # shift :: Int32 -> Int -> Int32 # rotate :: Int32 -> Int -> Int32 # zeroBits :: Int32 # bit :: Int -> Int32 # setBit :: Int32 -> Int -> Int32 # clearBit :: Int32 -> Int -> Int32 # complementBit :: Int32 -> Int -> Int32 # testBit :: Int32 -> Int -> Bool # bitSizeMaybe :: Int32 -> Maybe Int # bitSize :: Int32 -> Int # isSigned :: Int32 -> Bool # shiftL :: Int32 -> Int -> Int32 # unsafeShiftL :: Int32 -> Int -> Int32 # shiftR :: Int32 -> Int -> Int32 # unsafeShiftR :: Int32 -> Int -> Int32 # rotateL :: Int32 -> Int -> Int32 # rotateR :: Int32 -> Int -> Int32 # popCount :: Int32 -> Int #
FiniteBits Int32	Since: base-4.6.0.0
Instance details Defined in GHC.Int Methods finiteBitSize :: Int32 -> Int # countLeadingZeros :: Int32 -> Int # countTrailingZeros :: Int32 -> Int #
Bounded Int32	Since: base-2.1
Instance details Defined in GHC.Int Methods minBound :: Int32 # maxBound :: Int32 #
Enum Int32	Since: base-2.1
Instance details Defined in GHC.Int Methods succ :: Int32 -> Int32 # pred :: Int32 -> Int32 # toEnum :: Int -> Int32 # fromEnum :: Int32 -> Int # enumFrom :: Int32 -> [Int32] # enumFromThen :: Int32 -> Int32 -> [Int32] # enumFromTo :: Int32 -> Int32 -> [Int32] # enumFromThenTo :: Int32 -> Int32 -> Int32 -> [Int32] #
Ix Int32	Since: base-2.1
Instance details Defined in GHC.Int Methods range :: (Int32, Int32) -> [Int32] # index :: (Int32, Int32) -> Int32 -> Int # unsafeIndex :: (Int32, Int32) -> Int32 -> Int # inRange :: (Int32, Int32) -> Int32 -> Bool # rangeSize :: (Int32, Int32) -> Int # unsafeRangeSize :: (Int32, Int32) -> Int #
Num Int32	Since: base-2.1
Instance details Defined in GHC.Int Methods (+) :: Int32 -> Int32 -> Int32 # (-) :: Int32 -> Int32 -> Int32 # (*) :: Int32 -> Int32 -> Int32 # negate :: Int32 -> Int32 # abs :: Int32 -> Int32 # signum :: Int32 -> Int32 # fromInteger :: Integer -> Int32 #
Read Int32	Since: base-2.1
Instance details Defined in GHC.Int Methods readsPrec :: Int -> ReadS Int32 # readList :: ReadS [Int32] # readPrec :: ReadPrec Int32 # readListPrec :: ReadPrec [Int32] #
Integral Int32	Since: base-2.1
Instance details Defined in GHC.Int Methods quot :: Int32 -> Int32 -> Int32 # rem :: Int32 -> Int32 -> Int32 # div :: Int32 -> Int32 -> Int32 # mod :: Int32 -> Int32 -> Int32 # quotRem :: Int32 -> Int32 -> (Int32, Int32) # divMod :: Int32 -> Int32 -> (Int32, Int32) # toInteger :: Int32 -> Integer #
Real Int32	Since: base-2.1
Instance details Defined in GHC.Int Methods toRational :: Int32 -> Rational #
Show Int32	Since: base-2.1
Instance details Defined in GHC.Int Methods showsPrec :: Int -> Int32 -> ShowS # show :: Int32 -> String # showList :: [Int32] -> ShowS #
Default Int32
Instance details Defined in Data.Default.Class Methods def :: Int32 #
Eq Int32	Since: base-2.1
Instance details Defined in GHC.Int Methods (==) :: Int32 -> Int32 -> Bool # (/=) :: Int32 -> Int32 -> Bool #
Ord Int32	Since: base-2.1
Instance details Defined in GHC.Int Methods compare :: Int32 -> Int32 -> Ordering # (<) :: Int32 -> Int32 -> Bool # (<=) :: Int32 -> Int32 -> Bool # (>) :: Int32 -> Int32 -> Bool # (>=) :: Int32 -> Int32 -> Bool # max :: Int32 -> Int32 -> Int32 # min :: Int32 -> Int32 -> Int32 #
Lift Int32
Instance details Defined in Language.Haskell.TH.Syntax Methods lift :: Quote m => Int32 -> m Exp # liftTyped :: forall (m :: Type -> Type). Quote m => Int32 -> Code m Int32 #

data Int64 #

64-bit signed integer type

Instances

Instances details

Bits Int64	Since: base-2.1
Instance details Defined in GHC.Int Methods (.&.) :: Int64 -> Int64 -> Int64 # (.\|.) :: Int64 -> Int64 -> Int64 # xor :: Int64 -> Int64 -> Int64 # complement :: Int64 -> Int64 # shift :: Int64 -> Int -> Int64 # rotate :: Int64 -> Int -> Int64 # zeroBits :: Int64 # bit :: Int -> Int64 # setBit :: Int64 -> Int -> Int64 # clearBit :: Int64 -> Int -> Int64 # complementBit :: Int64 -> Int -> Int64 # testBit :: Int64 -> Int -> Bool # bitSizeMaybe :: Int64 -> Maybe Int # bitSize :: Int64 -> Int # isSigned :: Int64 -> Bool # shiftL :: Int64 -> Int -> Int64 # unsafeShiftL :: Int64 -> Int -> Int64 # shiftR :: Int64 -> Int -> Int64 # unsafeShiftR :: Int64 -> Int -> Int64 # rotateL :: Int64 -> Int -> Int64 # rotateR :: Int64 -> Int -> Int64 # popCount :: Int64 -> Int #
FiniteBits Int64	Since: base-4.6.0.0
Instance details Defined in GHC.Int Methods finiteBitSize :: Int64 -> Int # countLeadingZeros :: Int64 -> Int # countTrailingZeros :: Int64 -> Int #
Bounded Int64	Since: base-2.1
Instance details Defined in GHC.Int Methods minBound :: Int64 # maxBound :: Int64 #
Enum Int64	Since: base-2.1
Instance details Defined in GHC.Int Methods succ :: Int64 -> Int64 # pred :: Int64 -> Int64 # toEnum :: Int -> Int64 # fromEnum :: Int64 -> Int # enumFrom :: Int64 -> [Int64] # enumFromThen :: Int64 -> Int64 -> [Int64] # enumFromTo :: Int64 -> Int64 -> [Int64] # enumFromThenTo :: Int64 -> Int64 -> Int64 -> [Int64] #
Ix Int64	Since: base-2.1
Instance details Defined in GHC.Int Methods range :: (Int64, Int64) -> [Int64] # index :: (Int64, Int64) -> Int64 -> Int # unsafeIndex :: (Int64, Int64) -> Int64 -> Int # inRange :: (Int64, Int64) -> Int64 -> Bool # rangeSize :: (Int64, Int64) -> Int # unsafeRangeSize :: (Int64, Int64) -> Int #
Num Int64	Since: base-2.1
Instance details Defined in GHC.Int Methods (+) :: Int64 -> Int64 -> Int64 # (-) :: Int64 -> Int64 -> Int64 # (*) :: Int64 -> Int64 -> Int64 # negate :: Int64 -> Int64 # abs :: Int64 -> Int64 # signum :: Int64 -> Int64 # fromInteger :: Integer -> Int64 #
Read Int64	Since: base-2.1
Instance details Defined in GHC.Int Methods readsPrec :: Int -> ReadS Int64 # readList :: ReadS [Int64] # readPrec :: ReadPrec Int64 # readListPrec :: ReadPrec [Int64] #
Integral Int64	Since: base-2.1
Instance details Defined in GHC.Int Methods quot :: Int64 -> Int64 -> Int64 # rem :: Int64 -> Int64 -> Int64 # div :: Int64 -> Int64 -> Int64 # mod :: Int64 -> Int64 -> Int64 # quotRem :: Int64 -> Int64 -> (Int64, Int64) # divMod :: Int64 -> Int64 -> (Int64, Int64) # toInteger :: Int64 -> Integer #
Real Int64	Since: base-2.1
Instance details Defined in GHC.Int Methods toRational :: Int64 -> Rational #
Show Int64	Since: base-2.1
Instance details Defined in GHC.Int Methods showsPrec :: Int -> Int64 -> ShowS # show :: Int64 -> String # showList :: [Int64] -> ShowS #
Default Int64
Instance details Defined in Data.Default.Class Methods def :: Int64 #
Eq Int64	Since: base-2.1
Instance details Defined in GHC.Int Methods (==) :: Int64 -> Int64 -> Bool # (/=) :: Int64 -> Int64 -> Bool #
Ord Int64	Since: base-2.1
Instance details Defined in GHC.Int Methods compare :: Int64 -> Int64 -> Ordering # (<) :: Int64 -> Int64 -> Bool # (<=) :: Int64 -> Int64 -> Bool # (>) :: Int64 -> Int64 -> Bool # (>=) :: Int64 -> Int64 -> Bool # max :: Int64 -> Int64 -> Int64 # min :: Int64 -> Int64 -> Int64 #
Lift Int64
Instance details Defined in Language.Haskell.TH.Syntax Methods lift :: Quote m => Int64 -> m Exp # liftTyped :: forall (m :: Type -> Type). Quote m => Int64 -> Code m Int64 #

type Type = Type #

The kind of types with lifted values. For example Int :: Type.

data Constraint #

The kind of constraints, like Show a

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

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

$\mathcal{O}(n)$. 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]

>>> filter odd [1, 2, 3]
[1,3]

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

$\mathcal{O}(\min(m,n))$. zip takes two lists and returns a list of corresponding pairs.

>>> zip [1, 2] ['a', 'b']
[(1, 'a'), (2, 'b')]

If one input list is shorter than the other, excess elements of the longer list are discarded, even if one of the lists is infinite:

>>> zip [1] ['a', 'b']
[(1, 'a')]
>>> zip [1, 2] ['a']
[(1, 'a')]
>>> zip [] [1..]
[]
>>> zip [1..] []
[]

zip is right-lazy:

>>> zip [] _|_
[]
>>> zip _|_ []
_|_

zip is capable of list fusion, but it is restricted to its first list argument and its resulting list.

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

$\mathcal{O}(n)$. 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, ...]

>>> map (+1) [1, 2, 3]
[2,3,4]

unfoldr :: (b -> Maybe (a, b)) -> b -> [a] #

The unfoldr function is a `dual' to foldr: while foldr reduces a list to a summary value, unfoldr builds a list from a seed value. The function takes the element and returns Nothing if it is done producing the list or returns Just (a,b), in which case, a is a prepended to the list and b is used as the next element in a recursive call. For example,

iterate f == unfoldr (\x -> Just (x, f x))

In some cases, unfoldr can undo a foldr operation:

unfoldr f' (foldr f z xs) == xs

if the following holds:

f' (f x y) = Just (x,y)
f' z       = Nothing

A simple use of unfoldr:

>>> unfoldr (\b -> if b == 0 then Nothing else Just (b, b-1)) 10
[10,9,8,7,6,5,4,3,2,1]

transpose :: [[a]] -> [[a]] #

The transpose function transposes the rows and columns of its argument. For example,

>>> transpose [[1,2,3],[4,5,6]]
[[1,4],[2,5],[3,6]]

If some of the rows are shorter than the following rows, their elements are skipped:

>>> transpose [[10,11],[20],[],[30,31,32]]
[[10,20,30],[11,31],[32]]

tails :: [a] -> [[a]] #

$\mathcal{O}(n)$. The tails function returns all final segments of the argument, longest first. For example,

>>> tails "abc"
["abc","bc","c",""]

Note that tails has the following strictness property: tails _|_ = _|_ : _|_

subsequences :: [a] -> [[a]] #

The subsequences function returns the list of all subsequences of the argument.

>>> subsequences "abc"
["","a","b","ab","c","ac","bc","abc"]

sortOn :: Ord b => (a -> b) -> [a] -> [a] #

Sort a list by comparing the results of a key function applied to each element. sortOn f is equivalent to sortBy (comparing f), but has the performance advantage of only evaluating f once for each element in the input list. This is called the decorate-sort-undecorate paradigm, or Schwartzian transform.

Elements are arranged from lowest to highest, keeping duplicates in the order they appeared in the input.

>>> sortOn fst [(2, "world"), (4, "!"), (1, "Hello")]
[(1,"Hello"),(2,"world"),(4,"!")]

Since: base-4.8.0.0

sortBy :: (a -> a -> Ordering) -> [a] -> [a] #

The sortBy function is the non-overloaded version of sort.

>>> sortBy (\(a,_) (b,_) -> compare a b) [(2, "world"), (4, "!"), (1, "Hello")]
[(1,"Hello"),(2,"world"),(4,"!")]

sort :: Ord a => [a] -> [a] #

The sort function implements a stable sorting algorithm. It is a special case of sortBy, which allows the programmer to supply their own comparison function.

Elements are arranged from lowest to highest, keeping duplicates in the order they appeared in the input.

>>> sort [1,6,4,3,2,5]
[1,2,3,4,5,6]

permutations :: [a] -> [[a]] #

The permutations function returns the list of all permutations of the argument.

>>> permutations "abc"
["abc","bac","cba","bca","cab","acb"]

isPrefixOf :: Eq a => [a] -> [a] -> Bool #

$\mathcal{O}(\min(m,n))$. The isPrefixOf function takes two lists and returns True iff the first list is a prefix of the second.

>>> "Hello" `isPrefixOf` "Hello World!"
True

>>> "Hello" `isPrefixOf` "Wello Horld!"
False

intersperse :: a -> [a] -> [a] #

$\mathcal{O}(n)$. The intersperse function takes an element and a list and `intersperses' that element between the elements of the list. For example,

>>> intersperse ',' "abcde"
"a,b,c,d,e"

intercalate :: [a] -> [[a]] -> [a] #

intercalate xs xss is equivalent to (concat (intersperse xs xss)). It inserts the list xs in between the lists in xss and concatenates the result.

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

inits :: [a] -> [[a]] #

The inits function returns all initial segments of the argument, shortest first. For example,

>>> inits "abc"
["","a","ab","abc"]

Note that inits has the following strictness property: inits (xs ++ _|_) = inits xs ++ _|_

In particular, inits _|_ = [] : _|_

group :: Eq a => [a] -> [[a]] #

The group function takes a list and returns a list of lists such that the concatenation of the result is equal to the argument. Moreover, each sublist in the result contains only equal elements. For example,

>>> group "Mississippi"
["M","i","ss","i","ss","i","pp","i"]

It is a special case of groupBy, which allows the programmer to supply their own equality test.

genericTake :: Integral i => i -> [a] -> [a] #

The genericTake function is an overloaded version of take, which accepts any Integral value as the number of elements to take.

genericSplitAt :: Integral i => i -> [a] -> ([a], [a]) #

The genericSplitAt function is an overloaded version of splitAt, which accepts any Integral value as the position at which to split.

genericReplicate :: Integral i => i -> a -> [a] #

The genericReplicate function is an overloaded version of replicate, which accepts any Integral value as the number of repetitions to make.

genericLength :: Num i => [a] -> i #

$\mathcal{O}(n)$. The genericLength function is an overloaded version of length. In particular, instead of returning an Int, it returns any type which is an instance of Num. It is, however, less efficient than length.

>>> genericLength [1, 2, 3] :: Int
3
>>> genericLength [1, 2, 3] :: Float
3.0

genericDrop :: Integral i => i -> [a] -> [a] #

The genericDrop function is an overloaded version of drop, which accepts any Integral value as the number of elements to drop.

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

$\mathcal{O}(\min(m,n))$. zipWith generalises zip by zipping with the function given as the first argument, instead of a tupling function.

zipWith (,) xs ys == zip xs ys
zipWith f [x1,x2,x3..] [y1,y2,y3..] == [f x1 y1, f x2 y2, f x3 y3..]

For example, zipWith (+) is applied to two lists to produce the list of corresponding sums:

>>> zipWith (+) [1, 2, 3] [4, 5, 6]
[5,7,9]

zipWith is right-lazy:

>>> zipWith f [] _|_
[]

zipWith is capable of list fusion, but it is restricted to its first list argument and its resulting list.

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

zip3 takes three lists and returns a list of triples, analogous to zip. It is capable of list fusion, but it is restricted to its first list argument and its resulting list.

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

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

>>> unzip3 []
([],[],[])
>>> unzip3 [(1, 'a', True), (2, 'b', False)]
([1,2],"ab",[True,False])

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

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

>>> unzip []
([],[])
>>> unzip [(1, 'a'), (2, 'b')]
([1,2],"ab")

uncons :: [a] -> Maybe (a, [a]) #

$\mathcal{O}(1)$. Decompose a list into its head and tail.

If the list is empty, returns Nothing.
If the list is non-empty, returns Just (x, xs), where x is the head of the list and xs its tail.

>>> uncons []
Nothing
>>> uncons [1]
Just (1,[])
>>> uncons [1, 2, 3]
Just (1,[2,3])

Since: base-4.8.0.0

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

$\mathcal{O}(n)$. scanr1 is a variant of scanr that has no starting value argument.

>>> scanr1 (+) [1..4]
[10,9,7,4]
>>> scanr1 (+) []
[]
>>> scanr1 (-) [1..4]
[-2,3,-1,4]
>>> scanr1 (&&) [True, False, True, True]
[False,False,True,True]
>>> scanr1 (||) [True, True, False, False]
[True,True,False,False]
>>> force $ scanr1 (+) [1..]
*** Exception: stack overflow

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

$\mathcal{O}(n)$. scanr is the right-to-left dual of scanl. Note that the order of parameters on the accumulating function are reversed compared to scanl. Also note that

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

>>> scanr (+) 0 [1..4]
[10,9,7,4,0]
>>> scanr (+) 42 []
[42]
>>> scanr (-) 100 [1..4]
[98,-97,99,-96,100]
>>> scanr (\nextChar reversedString -> nextChar : reversedString) "foo" ['a', 'b', 'c', 'd']
["abcdfoo","bcdfoo","cdfoo","dfoo","foo"]
>>> force $ scanr (+) 0 [1..]
*** Exception: stack overflow

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

$\mathcal{O}(n)$. scanl1 is a variant of scanl that has no starting value argument:

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

>>> scanl1 (+) [1..4]
[1,3,6,10]
>>> scanl1 (+) []
[]
>>> scanl1 (-) [1..4]
[1,-1,-4,-8]
>>> scanl1 (&&) [True, False, True, True]
[True,False,False,False]
>>> scanl1 (||) [False, False, True, True]
[False,False,True,True]
>>> scanl1 (+) [1..]
* Hangs forever *

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

$\mathcal{O}(n)$. A strict version of scanl.

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

$\mathcal{O}(n)$. scanl is similar to foldl, but returns a list of successive reduced values from the left:

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

Note that

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

>>> scanl (+) 0 [1..4]
[0,1,3,6,10]
>>> scanl (+) 42 []
[42]
>>> scanl (-) 100 [1..4]
[100,99,97,94,90]
>>> scanl (\reversedString nextChar -> nextChar : reversedString) "foo" ['a', 'b', 'c', 'd']
["foo","afoo","bafoo","cbafoo","dcbafoo"]
>>> scanl (+) 0 [1..]
* Hangs forever *

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

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

>>> reverse []
[]
>>> reverse [42]
[42]
>>> reverse [2,5,7]
[7,5,2]
>>> reverse [1..]
* Hangs forever *

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

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

>>> replicate 0 True
[]
>>> replicate (-1) True
[]
>>> replicate 4 True
[True,True,True,True]

repeat :: a -> [a] #

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

>>> take 20 $ repeat 17
[17,17,17,17,17,17,17,17,17...

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

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

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

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

>>> take 10 $ iterate not True
[True,False,True,False...
>>> take 10 $ iterate (+3) 42
[42,45,48,51,54,57,60,63...

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

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

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

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

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

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

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

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

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

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

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

nonEmpty :: [a] -> Maybe (NonEmpty a) #

nonEmpty efficiently turns a normal list into a NonEmpty stream, producing Nothing if the input is empty.

data NonEmpty a #

Non-empty (and non-strict) list type.

Since: base-4.9.0.0

Constructors

a :| [a] infixr 5

Instances

Instances details

Foldable NonEmpty	Since: base-4.9.0.0
Instance details Defined in Data.Foldable Methods fold :: Monoid m => NonEmpty m -> m # foldMap :: Monoid m => (a -> m) -> NonEmpty a -> m # foldMap' :: Monoid m => (a -> m) -> NonEmpty a -> m # foldr :: (a -> b -> b) -> b -> NonEmpty a -> b # foldr' :: (a -> b -> b) -> b -> NonEmpty a -> b # foldl :: (b -> a -> b) -> b -> NonEmpty a -> b # foldl' :: (b -> a -> b) -> b -> NonEmpty a -> b # foldr1 :: (a -> a -> a) -> NonEmpty a -> a # foldl1 :: (a -> a -> a) -> NonEmpty a -> a # toList :: NonEmpty a -> [a] # null :: NonEmpty a -> Bool # length :: NonEmpty a -> Int # elem :: Eq a => a -> NonEmpty a -> Bool # maximum :: Ord a => NonEmpty a -> a # minimum :: Ord a => NonEmpty a -> a # sum :: Num a => NonEmpty a -> a # product :: Num a => NonEmpty a -> a #
Traversable NonEmpty	Since: base-4.9.0.0
Instance details Defined in Data.Traversable Methods traverse :: Applicative f => (a -> f b) -> NonEmpty a -> f (NonEmpty b) # sequenceA :: Applicative f => NonEmpty (f a) -> f (NonEmpty a) # mapM :: Monad m => (a -> m b) -> NonEmpty a -> m (NonEmpty b) # sequence :: Monad m => NonEmpty (m a) -> m (NonEmpty a) #
Applicative NonEmpty	Since: base-4.9.0.0
Instance details Defined in GHC.Base Methods pure :: a -> NonEmpty a # (<>) :: NonEmpty (a -> b) -> NonEmpty a -> NonEmpty b # liftA2 :: (a -> b -> c) -> NonEmpty a -> NonEmpty b -> NonEmpty c # (>) :: NonEmpty a -> NonEmpty b -> NonEmpty b # (<*) :: NonEmpty a -> NonEmpty b -> NonEmpty a #
Functor NonEmpty	Since: base-4.9.0.0
Instance details Defined in GHC.Base Methods fmap :: (a -> b) -> NonEmpty a -> NonEmpty b # (<$) :: a -> NonEmpty b -> NonEmpty a #
Monad NonEmpty	Since: base-4.9.0.0
Instance details Defined in GHC.Base Methods (>>=) :: NonEmpty a -> (a -> NonEmpty b) -> NonEmpty b # (>>) :: NonEmpty a -> NonEmpty b -> NonEmpty b # return :: a -> NonEmpty a #
Lift a => Lift (NonEmpty a :: Type)	Since: template-haskell-2.15.0.0
Instance details Defined in Language.Haskell.TH.Syntax Methods lift :: Quote m => NonEmpty a -> m Exp # liftTyped :: forall (m :: Type -> Type). Quote m => NonEmpty a -> Code m (NonEmpty a) #
Semigroup (NonEmpty a)	Since: base-4.9.0.0
Instance details Defined in GHC.Base Methods (<>) :: NonEmpty a -> NonEmpty a -> NonEmpty a # sconcat :: NonEmpty (NonEmpty a) -> NonEmpty a # stimes :: Integral b => b -> NonEmpty a -> NonEmpty a #
IsList (NonEmpty a)	Since: base-4.9.0.0
Instance details Defined in GHC.Exts Associated Types type Item (NonEmpty a) # Methods fromList :: [Item (NonEmpty a)] -> NonEmpty a # fromListN :: Int -> [Item (NonEmpty a)] -> NonEmpty a # toList :: NonEmpty a -> [Item (NonEmpty a)] #
Generic (NonEmpty a)
Instance details Defined in GHC.Generics Associated Types type Rep (NonEmpty a) :: Type -> Type # Methods from :: NonEmpty a -> Rep (NonEmpty a) x # to :: Rep (NonEmpty a) x -> NonEmpty a #
Read a => Read (NonEmpty a)	Since: base-4.11.0.0
Instance details Defined in GHC.Read Methods readsPrec :: Int -> ReadS (NonEmpty a) # readList :: ReadS [NonEmpty a] # readPrec :: ReadPrec (NonEmpty a) # readListPrec :: ReadPrec [NonEmpty a] #
Show a => Show (NonEmpty a)	Since: base-4.11.0.0
Instance details Defined in GHC.Show Methods showsPrec :: Int -> NonEmpty a -> ShowS # show :: NonEmpty a -> String # showList :: [NonEmpty a] -> ShowS #
Eq a => Eq (NonEmpty a)	Since: base-4.9.0.0
Instance details Defined in GHC.Base Methods (==) :: NonEmpty a -> NonEmpty a -> Bool # (/=) :: NonEmpty a -> NonEmpty a -> Bool #
Ord a => Ord (NonEmpty a)	Since: base-4.9.0.0
Instance details Defined in GHC.Base Methods compare :: NonEmpty a -> NonEmpty a -> Ordering # (<) :: NonEmpty a -> NonEmpty a -> Bool # (<=) :: NonEmpty a -> NonEmpty a -> Bool # (>) :: NonEmpty a -> NonEmpty a -> Bool # (>=) :: NonEmpty a -> NonEmpty a -> Bool # max :: NonEmpty a -> NonEmpty a -> NonEmpty a # min :: NonEmpty a -> NonEmpty a -> NonEmpty a #
Generic1 NonEmpty
Instance details Defined in GHC.Generics Associated Types type Rep1 NonEmpty :: k -> Type # Methods from1 :: forall (a :: k). NonEmpty a -> Rep1 NonEmpty a # to1 :: forall (a :: k). Rep1 NonEmpty a -> NonEmpty a #
type Item (NonEmpty a)
Instance details Defined in GHC.Exts type Item (NonEmpty a) = a
type Rep (NonEmpty a)	Since: base-4.6.0.0
Instance details Defined in GHC.Generics type Rep (NonEmpty a) = D1 ('MetaData "NonEmpty" "GHC.Base" "base" 'False) (C1 ('MetaCons ":\|" ('InfixI 'LeftAssociative 9) 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 a) :*: S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 [a])))
type Rep1 NonEmpty	Since: base-4.6.0.0
Instance details Defined in GHC.Generics type Rep1 NonEmpty = D1 ('MetaData "NonEmpty" "GHC.Base" "base" 'False) (C1 ('MetaCons ":\|" ('InfixI 'LeftAssociative 9) 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) Par1 :*: S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec1 [])))

data Maybe a #

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

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

Constructors

Nothing
Just a

Instances

Instances details

MonadFail Maybe	Since: base-4.9.0.0
Instance details Defined in Control.Monad.Fail Methods fail :: String -> Maybe a #
Foldable Maybe	Since: base-2.1
Instance details Defined in Data.Foldable Methods fold :: Monoid m => Maybe m -> m # foldMap :: Monoid m => (a -> m) -> Maybe a -> m # foldMap' :: Monoid m => (a -> m) -> Maybe a -> m # foldr :: (a -> b -> b) -> b -> Maybe a -> b # foldr' :: (a -> b -> b) -> b -> Maybe a -> b # foldl :: (b -> a -> b) -> b -> Maybe a -> b # foldl' :: (b -> a -> b) -> b -> Maybe a -> b # foldr1 :: (a -> a -> a) -> Maybe a -> a # foldl1 :: (a -> a -> a) -> Maybe a -> a # toList :: Maybe a -> [a] # null :: Maybe a -> Bool # length :: Maybe a -> Int # elem :: Eq a => a -> Maybe a -> Bool # maximum :: Ord a => Maybe a -> a # minimum :: Ord a => Maybe a -> a # sum :: Num a => Maybe a -> a # product :: Num a => Maybe a -> a #
Traversable Maybe	Since: base-2.1
Instance details Defined in Data.Traversable Methods traverse :: Applicative f => (a -> f b) -> Maybe a -> f (Maybe b) # sequenceA :: Applicative f => Maybe (f a) -> f (Maybe a) # mapM :: Monad m => (a -> m b) -> Maybe a -> m (Maybe b) # sequence :: Monad m => Maybe (m a) -> m (Maybe a) #
Alternative Maybe	Since: base-2.1
Instance details Defined in GHC.Base Methods empty :: Maybe a # (<\|>) :: Maybe a -> Maybe a -> Maybe a # some :: Maybe a -> Maybe [a] # many :: Maybe a -> Maybe [a] #
Applicative Maybe	Since: base-2.1
Instance details Defined in GHC.Base Methods pure :: a -> Maybe a # (<>) :: Maybe (a -> b) -> Maybe a -> Maybe b # liftA2 :: (a -> b -> c) -> Maybe a -> Maybe b -> Maybe c # (>) :: Maybe a -> Maybe b -> Maybe b # (<*) :: Maybe a -> Maybe b -> Maybe a #
Functor Maybe	Since: base-2.1
Instance details Defined in GHC.Base Methods fmap :: (a -> b) -> Maybe a -> Maybe b # (<$) :: a -> Maybe b -> Maybe a #
Monad Maybe	Since: base-2.1
Instance details Defined in GHC.Base Methods (>>=) :: Maybe a -> (a -> Maybe b) -> Maybe b # (>>) :: Maybe a -> Maybe b -> Maybe b # return :: a -> Maybe a #
MonadPlus Maybe	Since: base-2.1
Instance details Defined in GHC.Base Methods mzero :: Maybe a # mplus :: Maybe a -> Maybe a -> Maybe a #
Lift a => Lift (Maybe a :: Type)
Instance details Defined in Language.Haskell.TH.Syntax Methods lift :: Quote m => Maybe a -> m Exp # liftTyped :: forall (m :: Type -> Type). Quote m => Maybe a -> Code m (Maybe a) #
Semigroup a => Monoid (Maybe a)	Lift a semigroup into `Maybe` forming a `Monoid` according to http://en.wikipedia.org/wiki/Monoid: "Any semigroup `S` may be turned into a monoid simply by adjoining an element `e` not in `S` and defining `ee = e` and `es = s = se` for all `s ∈ S`." Since 4.11.0: constraint on inner `a` value generalised from `Monoid` to `Semigroup`. Since: base-2.1*
Instance details Defined in GHC.Base Methods mempty :: Maybe a # mappend :: Maybe a -> Maybe a -> Maybe a # mconcat :: [Maybe a] -> Maybe a #
Semigroup a => Semigroup (Maybe a)	Since: base-4.9.0.0
Instance details Defined in GHC.Base Methods (<>) :: Maybe a -> Maybe a -> Maybe a # sconcat :: NonEmpty (Maybe a) -> Maybe a # stimes :: Integral b => b -> Maybe a -> Maybe a #
Generic (Maybe a)
Instance details Defined in GHC.Generics Associated Types type Rep (Maybe a) :: Type -> Type # Methods from :: Maybe a -> Rep (Maybe a) x # to :: Rep (Maybe a) x -> Maybe a #
SingKind a => SingKind (Maybe a)	Since: base-4.9.0.0
Instance details Defined in GHC.Generics Associated Types type DemoteRep (Maybe a) Methods fromSing :: forall (a0 :: Maybe a). Sing a0 -> DemoteRep (Maybe a)
Read a => Read (Maybe a)	Since: base-2.1
Instance details Defined in GHC.Read Methods readsPrec :: Int -> ReadS (Maybe a) # readList :: ReadS [Maybe a] # readPrec :: ReadPrec (Maybe a) # readListPrec :: ReadPrec [Maybe a] #
Show a => Show (Maybe a)	Since: base-2.1
Instance details Defined in GHC.Show Methods showsPrec :: Int -> Maybe a -> ShowS # show :: Maybe a -> String # showList :: [Maybe a] -> ShowS #
Default (Maybe a)
Instance details Defined in Data.Default.Class Methods def :: Maybe a #
Eq a => Eq (Maybe a)	Since: base-2.1
Instance details Defined in GHC.Maybe Methods (==) :: Maybe a -> Maybe a -> Bool # (/=) :: Maybe a -> Maybe a -> Bool #
Ord a => Ord (Maybe a)	Since: base-2.1
Instance details Defined in GHC.Maybe Methods compare :: Maybe a -> Maybe a -> Ordering # (<) :: Maybe a -> Maybe a -> Bool # (<=) :: Maybe a -> Maybe a -> Bool # (>) :: Maybe a -> Maybe a -> Bool # (>=) :: Maybe a -> Maybe a -> Bool # max :: Maybe a -> Maybe a -> Maybe a # min :: Maybe a -> Maybe a -> Maybe a #
Generic1 Maybe
Instance details Defined in GHC.Generics Associated Types type Rep1 Maybe :: k -> Type # Methods from1 :: forall (a :: k). Maybe a -> Rep1 Maybe a # to1 :: forall (a :: k). Rep1 Maybe a -> Maybe a #
SingI ('Nothing :: Maybe a)	Since: base-4.9.0.0
Instance details Defined in GHC.Generics Methods sing :: Sing 'Nothing
SingI a2 => SingI ('Just a2 :: Maybe a1)	Since: base-4.9.0.0
Instance details Defined in GHC.Generics Methods sing :: Sing ('Just a2)
type DemoteRep (Maybe a)
Instance details Defined in GHC.Generics type DemoteRep (Maybe a) = Maybe (DemoteRep a)
type Rep (Maybe a)	Since: base-4.6.0.0
Instance details Defined in GHC.Generics type Rep (Maybe a) = D1 ('MetaData "Maybe" "GHC.Maybe" "base" 'False) (C1 ('MetaCons "Nothing" 'PrefixI 'False) (U1 :: Type -> Type) :+: C1 ('MetaCons "Just" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 a)))
data Sing (b :: Maybe a)
Instance details Defined in GHC.Generics data Sing (b :: Maybe a) where SNothing :: forall {a}. Sing ('Nothing :: Maybe a) SJust :: forall {a} (a1 :: a). Sing a1 -> Sing ('Just a1)
type Rep1 Maybe	Since: base-4.6.0.0
Instance details Defined in GHC.Generics type Rep1 Maybe = D1 ('MetaData "Maybe" "GHC.Maybe" "base" 'False) (C1 ('MetaCons "Nothing" 'PrefixI 'False) (U1 :: Type -> Type) :+: C1 ('MetaCons "Just" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) Par1))

maybeToList :: Maybe a -> [a] #

The maybeToList function returns an empty list when given Nothing or a singleton list when given Just.

Examples

Expand

Basic usage:

>>> maybeToList (Just 7)
[7]

>>> maybeToList Nothing
[]

One can use maybeToList to avoid pattern matching when combined with a function that (safely) works on lists:

>>> import Text.Read ( readMaybe )
>>> sum $ maybeToList (readMaybe "3")
3
>>> sum $ maybeToList (readMaybe "")
0

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

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

Examples

Expand

Basic usage:

>>> maybe False odd (Just 3)
True

>>> maybe False odd Nothing
False

Read an integer from a string using readMaybe. If we succeed, return twice the integer; that is, apply (*2) to it. If instead we fail to parse an integer, return 0 by default:

>>> import Text.Read ( readMaybe )
>>> maybe 0 (*2) (readMaybe "5")
10
>>> maybe 0 (*2) (readMaybe "")
0

Apply show to a Maybe Int. If we have Just n, we want to show the underlying Int n. But if we have Nothing, we return the empty string instead of (for example) "Nothing":

>>> maybe "" show (Just 5)
"5"
>>> maybe "" show Nothing
""

mapMaybe :: (a -> Maybe b) -> [a] -> [b] #

The mapMaybe function is a version of map which can throw out elements. In particular, the functional argument returns something of type Maybe b. If this is Nothing, no element is added on to the result list. If it is Just b, then b is included in the result list.

Examples

Expand

Using mapMaybe f x is a shortcut for catMaybes $ map f x in most cases:

>>> import Text.Read ( readMaybe )
>>> let readMaybeInt = readMaybe :: String -> Maybe Int
>>> mapMaybe readMaybeInt ["1", "Foo", "3"]
[1,3]
>>> catMaybes $ map readMaybeInt ["1", "Foo", "3"]
[1,3]

If we map the Just constructor, the entire list should be returned:

>>> mapMaybe Just [1,2,3]
[1,2,3]

listToMaybe :: [a] -> Maybe a #

The listToMaybe function returns Nothing on an empty list or Just a where a is the first element of the list.

Examples

Expand

Basic usage:

>>> listToMaybe []
Nothing

>>> listToMaybe [9]
Just 9

>>> listToMaybe [1,2,3]
Just 1

Composing maybeToList with listToMaybe should be the identity on singleton/empty lists:

>>> maybeToList $ listToMaybe [5]
[5]
>>> maybeToList $ listToMaybe []
[]

But not on lists with more than one element:

>>> maybeToList $ listToMaybe [1,2,3]
[1]

isNothing :: Maybe a -> Bool #

The isNothing function returns True iff its argument is Nothing.

Examples

Expand

Basic usage:

>>> isNothing (Just 3)
False

>>> isNothing (Just ())
False

>>> isNothing Nothing
True

Only the outer constructor is taken into consideration:

>>> isNothing (Just Nothing)
False

isJust :: Maybe a -> Bool #

The isJust function returns True iff its argument is of the form Just _.

Examples

Expand

Basic usage:

>>> isJust (Just 3)
True

>>> isJust (Just ())
True

>>> isJust Nothing
False

Only the outer constructor is taken into consideration:

>>> isJust (Just Nothing)
True

fromMaybe :: a -> Maybe a -> a #

The fromMaybe function takes a default value and a Maybe value. If the Maybe is Nothing, it returns the default value; otherwise, it returns the value contained in the Maybe.

Examples

Expand

Basic usage:

>>> fromMaybe "" (Just "Hello, World!")
"Hello, World!"

>>> fromMaybe "" Nothing
""

Read an integer from a string using readMaybe. If we fail to parse an integer, we want to return 0 by default:

>>> import Text.Read ( readMaybe )
>>> fromMaybe 0 (readMaybe "5")
5
>>> fromMaybe 0 (readMaybe "")
0

catMaybes :: [Maybe a] -> [a] #

The catMaybes function takes a list of Maybes and returns a list of all the Just values.

Examples

Expand

Basic usage:

>>> catMaybes [Just 1, Nothing, Just 3]
[1,3]

When constructing a list of Maybe values, catMaybes can be used to return all of the "success" results (if the list is the result of a map, then mapMaybe would be more appropriate):

>>> import Text.Read ( readMaybe )
>>> [readMaybe x :: Maybe Int | x <- ["1", "Foo", "3"] ]
[Just 1,Nothing,Just 3]
>>> catMaybes $ [readMaybe x :: Maybe Int | x <- ["1", "Foo", "3"] ]
[1,3]

class Semigroup a => Monoid a where #

The class of monoids (types with an associative binary operation that has an identity). Instances should satisfy the following:

Right identity: x <> mempty = x
Left identity: mempty <> x = x
Associativity: x <> (y <> z) = (x <> y) <> z (Semigroup law)
Concatenation: mconcat = foldr (<>) mempty

The method names refer to the monoid of lists under concatenation, but there are many other instances.

Some types can be viewed as a monoid in more than one way, e.g. both addition and multiplication on numbers. In such cases we often define newtypes and make those instances of Monoid, e.g. Sum and Product.

NOTE: Semigroup is a superclass of Monoid since base-4.11.0.0.

Minimal complete definition

mempty

Methods

mempty :: a #

Identity of mappend

>>> "Hello world" <> mempty
"Hello world"

mappend :: a -> a -> a #

An associative operation

NOTE: This method is redundant and has the default implementation mappend = (<>) since base-4.11.0.0. Should it be implemented manually, since mappend is a synonym for (<>), it is expected that the two functions are defined the same way. In a future GHC release mappend will be removed from Monoid.

mconcat :: [a] -> a #

Fold a list using the monoid.

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

>>> mconcat ["Hello", " ", "Haskell", "!"]
"Hello Haskell!"

Instances

Instances details

Monoid ByteString
Instance details Defined in Data.ByteString.Internal Methods mempty :: ByteString # mappend :: ByteString -> ByteString -> ByteString # mconcat :: [ByteString] -> ByteString #
Monoid ByteString
Instance details Defined in Data.ByteString.Lazy.Internal Methods mempty :: ByteString # mappend :: ByteString -> ByteString -> ByteString # mconcat :: [ByteString] -> ByteString #
Monoid ShortByteString
Instance details Defined in Data.ByteString.Short.Internal Methods mempty :: ShortByteString # mappend :: ShortByteString -> ShortByteString -> ShortByteString # mconcat :: [ShortByteString] -> ShortByteString #
Monoid IntSet
Instance details Defined in Data.IntSet.Internal Methods mempty :: IntSet # mappend :: IntSet -> IntSet -> IntSet # mconcat :: [IntSet] -> IntSet #
Monoid Ordering	Since: base-2.1
Instance details Defined in GHC.Base Methods mempty :: Ordering # mappend :: Ordering -> Ordering -> Ordering # mconcat :: [Ordering] -> Ordering #
Monoid ()	Since: base-2.1
Instance details Defined in GHC.Base Methods mempty :: () # mappend :: () -> () -> () # mconcat :: [()] -> () #
Monoid (Comparison a)	`mempty` on comparisons always returns `EQ`. Without newtypes this equals `pure (pure EQ)`. mempty :: Comparison a mempty = Comparison _ _ -> EQ
Instance details Defined in Data.Functor.Contravariant Methods mempty :: Comparison a # mappend :: Comparison a -> Comparison a -> Comparison a # mconcat :: [Comparison a] -> Comparison a #
Monoid (Equivalence a)	`mempty` on equivalences always returns `True`. Without newtypes this equals `pure (pure True)`. mempty :: Equivalence a mempty = Equivalence _ _ -> True
Instance details Defined in Data.Functor.Contravariant Methods mempty :: Equivalence a # mappend :: Equivalence a -> Equivalence a -> Equivalence a # mconcat :: [Equivalence a] -> Equivalence a #
Monoid (Predicate a)	`mempty` on predicates always returns `True`. Without newtypes this equals `pure True`. mempty :: Predicate a mempty = _ -> True
Instance details Defined in Data.Functor.Contravariant Methods mempty :: Predicate a # mappend :: Predicate a -> Predicate a -> Predicate a # mconcat :: [Predicate a] -> Predicate a #
Monoid a => Monoid (Identity a)	Since: base-4.9.0.0
Instance details Defined in Data.Functor.Identity Methods mempty :: Identity a # mappend :: Identity a -> Identity a -> Identity a # mconcat :: [Identity a] -> Identity a #
Monoid (First a)	Since: base-2.1
Instance details Defined in Data.Monoid Methods mempty :: First a # mappend :: First a -> First a -> First a # mconcat :: [First a] -> First a #
Monoid (Last a)	Since: base-2.1
Instance details Defined in Data.Monoid Methods mempty :: Last a # mappend :: Last a -> Last a -> Last a # mconcat :: [Last a] -> Last a #
Monoid a => Monoid (Down a)	Since: base-4.11.0.0
Instance details Defined in Data.Ord Methods mempty :: Down a # mappend :: Down a -> Down a -> Down a # mconcat :: [Down a] -> Down a #
(Ord a, Bounded a) => Monoid (Max a)	Since: base-4.9.0.0
Instance details Defined in Data.Semigroup Methods mempty :: Max a # mappend :: Max a -> Max a -> Max a # mconcat :: [Max a] -> Max a #
(Ord a, Bounded a) => Monoid (Min a)	Since: base-4.9.0.0
Instance details Defined in Data.Semigroup Methods mempty :: Min a # mappend :: Min a -> Min a -> Min a # mconcat :: [Min a] -> Min a #
Semigroup a => Monoid (Option a)	Since: base-4.9.0.0
Instance details Defined in Data.Semigroup Methods mempty :: Option a # mappend :: Option a -> Option a -> Option a # mconcat :: [Option a] -> Option a #
Monoid m => Monoid (WrappedMonoid m)	Since: base-4.9.0.0
Instance details Defined in Data.Semigroup Methods mempty :: WrappedMonoid m # mappend :: WrappedMonoid m -> WrappedMonoid m -> WrappedMonoid m # mconcat :: [WrappedMonoid m] -> WrappedMonoid m #
Monoid p => Monoid (Par1 p)	Since: base-4.12.0.0
Instance details Defined in GHC.Generics Methods mempty :: Par1 p # mappend :: Par1 p -> Par1 p -> Par1 p # mconcat :: [Par1 p] -> Par1 p #
Monoid (IntMap a)
Instance details Defined in Data.IntMap.Internal Methods mempty :: IntMap a # mappend :: IntMap a -> IntMap a -> IntMap a # mconcat :: [IntMap a] -> IntMap a #
Monoid (Seq a)
Instance details Defined in Data.Sequence.Internal Methods mempty :: Seq a # mappend :: Seq a -> Seq a -> Seq a # mconcat :: [Seq a] -> Seq a #
Monoid (MergeSet a)
Instance details Defined in Data.Set.Internal Methods mempty :: MergeSet a # mappend :: MergeSet a -> MergeSet a -> MergeSet a # mconcat :: [MergeSet a] -> MergeSet a #
Ord a => Monoid (Set a)
Instance details Defined in Data.Set.Internal Methods mempty :: Set a # mappend :: Set a -> Set a -> Set a # mconcat :: [Set a] -> Set a #
Monoid (DList a)
Instance details Defined in Data.DList.Internal Methods mempty :: DList a # mappend :: DList a -> DList a -> DList a # mconcat :: [DList a] -> DList a #
Monoid a => Monoid (IO a)	Since: base-4.9.0.0
Instance details Defined in GHC.Base Methods mempty :: IO a # mappend :: IO a -> IO a -> IO a # mconcat :: [IO a] -> IO a #
Monoid a => Monoid (Q a)	Since: template-haskell-2.17.0.0
Instance details Defined in Language.Haskell.TH.Syntax Methods mempty :: Q a # mappend :: Q a -> Q a -> Q a # mconcat :: [Q a] -> Q a #
Semigroup a => Monoid (Maybe a)	Lift a semigroup into `Maybe` forming a `Monoid` according to http://en.wikipedia.org/wiki/Monoid: "Any semigroup `S` may be turned into a monoid simply by adjoining an element `e` not in `S` and defining `ee = e` and `es = s = se` for all `s ∈ S`." Since 4.11.0: constraint on inner `a` value generalised from `Monoid` to `Semigroup`. Since: base-2.1*
Instance details Defined in GHC.Base Methods mempty :: Maybe a # mappend :: Maybe a -> Maybe a -> Maybe a # mconcat :: [Maybe a] -> Maybe a #
Monoid a => Monoid (a)	Since: base-4.15
Instance details Defined in GHC.Base Methods mempty :: (a) # mappend :: (a) -> (a) -> (a) # mconcat :: [(a)] -> (a) #
Monoid [a]	Since: base-2.1
Instance details Defined in GHC.Base Methods mempty :: [a] # mappend :: [a] -> [a] -> [a] # mconcat :: [[a]] -> [a] #
Monoid a => Monoid (Op a b)	`mempty @(Op a b)` without newtypes is `mempty @(b->a)` = `_ -> mempty`. mempty :: Op a b mempty = Op _ -> mempty
Instance details Defined in Data.Functor.Contravariant Methods mempty :: Op a b # mappend :: Op a b -> Op a b -> Op a b # mconcat :: [Op a b] -> Op a b #
Monoid (Proxy s)	Since: base-4.7.0.0
Instance details Defined in Data.Proxy Methods mempty :: Proxy s # mappend :: Proxy s -> Proxy s -> Proxy s # mconcat :: [Proxy s] -> Proxy s #
Monoid (U1 p)	Since: base-4.12.0.0
Instance details Defined in GHC.Generics Methods mempty :: U1 p # mappend :: U1 p -> U1 p -> U1 p # mconcat :: [U1 p] -> U1 p #
Ord k => Monoid (Map k v)
Instance details Defined in Data.Map.Internal Methods mempty :: Map k v # mappend :: Map k v -> Map k v -> Map k v # mconcat :: [Map k v] -> Map k v #
Monoid b => Monoid (a -> b)	Since: base-2.1
Instance details Defined in GHC.Base Methods mempty :: a -> b # mappend :: (a -> b) -> (a -> b) -> a -> b # mconcat :: [a -> b] -> a -> b #
(Monoid a, Monoid b) => Monoid (a, b)	Since: base-2.1
Instance details Defined in GHC.Base Methods mempty :: (a, b) # mappend :: (a, b) -> (a, b) -> (a, b) # mconcat :: [(a, b)] -> (a, b) #
Monoid a => Monoid (Const a b)	Since: base-4.9.0.0
Instance details Defined in Data.Functor.Const Methods mempty :: Const a b # mappend :: Const a b -> Const a b -> Const a b # mconcat :: [Const a b] -> Const a b #
(Applicative f, Monoid a) => Monoid (Ap f a)	Since: base-4.12.0.0
Instance details Defined in Data.Monoid Methods mempty :: Ap f a # mappend :: Ap f a -> Ap f a -> Ap f a # mconcat :: [Ap f a] -> Ap f a #
Monoid (f p) => Monoid (Rec1 f p)	Since: base-4.12.0.0
Instance details Defined in GHC.Generics Methods mempty :: Rec1 f p # mappend :: Rec1 f p -> Rec1 f p -> Rec1 f p # mconcat :: [Rec1 f p] -> Rec1 f p #
(Monoid a, Monoid b, Monoid c) => Monoid (a, b, c)	Since: base-2.1
Instance details Defined in GHC.Base Methods mempty :: (a, b, c) # mappend :: (a, b, c) -> (a, b, c) -> (a, b, c) # mconcat :: [(a, b, c)] -> (a, b, c) #
(Monoid (f p), Monoid (g p)) => Monoid ((f :*: g) p)	Since: base-4.12.0.0
Instance details Defined in GHC.Generics Methods mempty :: (f :: g) p # mappend :: (f :: g) p -> (f :: g) p -> (f :: g) p # mconcat :: [(f :: g) p] -> (f :: g) p #
Monoid c => Monoid (K1 i c p)	Since: base-4.12.0.0
Instance details Defined in GHC.Generics Methods mempty :: K1 i c p # mappend :: K1 i c p -> K1 i c p -> K1 i c p # mconcat :: [K1 i c p] -> K1 i c p #
(Monoid a, Monoid b, Monoid c, Monoid d) => Monoid (a, b, c, d)	Since: base-2.1
Instance details Defined in GHC.Base Methods mempty :: (a, b, c, d) # mappend :: (a, b, c, d) -> (a, b, c, d) -> (a, b, c, d) # mconcat :: [(a, b, c, d)] -> (a, b, c, d) #
Monoid (f (g p)) => Monoid ((f :.: g) p)	Since: base-4.12.0.0
Instance details Defined in GHC.Generics Methods mempty :: (f :.: g) p # mappend :: (f :.: g) p -> (f :.: g) p -> (f :.: g) p # mconcat :: [(f :.: g) p] -> (f :.: g) p #
Monoid (f p) => Monoid (M1 i c f p)	Since: base-4.12.0.0
Instance details Defined in GHC.Generics Methods mempty :: M1 i c f p # mappend :: M1 i c f p -> M1 i c f p -> M1 i c f p # mconcat :: [M1 i c f p] -> M1 i c f p #
(Monoid a, Monoid b, Monoid c, Monoid d, Monoid e) => Monoid (a, b, c, d, e)	Since: base-2.1
Instance details Defined in GHC.Base Methods mempty :: (a, b, c, d, e) # mappend :: (a, b, c, d, e) -> (a, b, c, d, e) -> (a, b, c, d, e) # mconcat :: [(a, b, c, d, e)] -> (a, b, c, d, e) #

class Eq a => Ord a where #

The Ord class is used for totally ordered datatypes.

Instances of Ord can be derived for any user-defined datatype whose constituent types are in Ord. The declared order of the constructors in the data declaration determines the ordering in derived Ord instances. The Ordering datatype allows a single comparison to determine the precise ordering of two objects.

The Haskell Report defines no laws for Ord. However, <= is customarily expected to implement a non-strict partial order and have the following properties:

Transitivity: if x <= y && y <= z = True, then x <= z = True
Reflexivity: x <= x = True
Antisymmetry: if x <= y && y <= x = True, then x == y = True

Note that the following operator interactions are expected to hold:

x >= y = y <= x
x < y = x <= y && x /= y
x > y = y < x
x < y = compare x y == LT
x > y = compare x y == GT
x == y = compare x y == EQ
min x y == if x <= y then x else y = True
max x y == if x >= y then x else y = True

Note that (7.) and (8.) do not require min and max to return either of their arguments. The result is merely required to equal one of the arguments in terms of (==).

Minimal complete definition: either compare or <=. Using compare can be more efficient for complex types.

Minimal complete definition

compare | (<=)

Methods

compare :: a -> a -> Ordering #

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

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

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

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

max :: a -> a -> a #

min :: a -> a -> a #

Instances

Instances details

Ord SomeTypeRep
Instance details Defined in Data.Typeable.Internal Methods compare :: SomeTypeRep -> SomeTypeRep -> Ordering # (<) :: SomeTypeRep -> SomeTypeRep -> Bool # (<=) :: SomeTypeRep -> SomeTypeRep -> Bool # (>) :: SomeTypeRep -> SomeTypeRep -> Bool # (>=) :: SomeTypeRep -> SomeTypeRep -> Bool # max :: SomeTypeRep -> SomeTypeRep -> SomeTypeRep # min :: SomeTypeRep -> SomeTypeRep -> SomeTypeRep #
Ord Void	Since: base-4.8.0.0
Instance details Defined in Data.Void Methods compare :: Void -> Void -> Ordering # (<) :: Void -> Void -> Bool # (<=) :: Void -> Void -> Bool # (>) :: Void -> Void -> Bool # (>=) :: Void -> Void -> Bool # max :: Void -> Void -> Void # min :: Void -> Void -> Void #
Ord ArithException	Since: base-3.0
Instance details Defined in GHC.Exception.Type Methods compare :: ArithException -> ArithException -> Ordering # (<) :: ArithException -> ArithException -> Bool # (<=) :: ArithException -> ArithException -> Bool # (>) :: ArithException -> ArithException -> Bool # (>=) :: ArithException -> ArithException -> Bool # max :: ArithException -> ArithException -> ArithException # min :: ArithException -> ArithException -> ArithException #
Ord Associativity	Since: base-4.6.0.0
Instance details Defined in GHC.Generics Methods compare :: Associativity -> Associativity -> Ordering # (<) :: Associativity -> Associativity -> Bool # (<=) :: Associativity -> Associativity -> Bool # (>) :: Associativity -> Associativity -> Bool # (>=) :: Associativity -> Associativity -> Bool # max :: Associativity -> Associativity -> Associativity # min :: Associativity -> Associativity -> Associativity #
Ord DecidedStrictness	Since: base-4.9.0.0
Instance details Defined in GHC.Generics Methods compare :: DecidedStrictness -> DecidedStrictness -> Ordering # (<) :: DecidedStrictness -> DecidedStrictness -> Bool # (<=) :: DecidedStrictness -> DecidedStrictness -> Bool # (>) :: DecidedStrictness -> DecidedStrictness -> Bool # (>=) :: DecidedStrictness -> DecidedStrictness -> Bool # max :: DecidedStrictness -> DecidedStrictness -> DecidedStrictness # min :: DecidedStrictness -> DecidedStrictness -> DecidedStrictness #
Ord Fixity	Since: base-4.6.0.0
Instance details Defined in GHC.Generics Methods compare :: Fixity -> Fixity -> Ordering # (<) :: Fixity -> Fixity -> Bool # (<=) :: Fixity -> Fixity -> Bool # (>) :: Fixity -> Fixity -> Bool # (>=) :: Fixity -> Fixity -> Bool # max :: Fixity -> Fixity -> Fixity # min :: Fixity -> Fixity -> Fixity #
Ord SourceStrictness	Since: base-4.9.0.0
Instance details Defined in GHC.Generics Methods compare :: SourceStrictness -> SourceStrictness -> Ordering # (<) :: SourceStrictness -> SourceStrictness -> Bool # (<=) :: SourceStrictness -> SourceStrictness -> Bool # (>) :: SourceStrictness -> SourceStrictness -> Bool # (>=) :: SourceStrictness -> SourceStrictness -> Bool # max :: SourceStrictness -> SourceStrictness -> SourceStrictness # min :: SourceStrictness -> SourceStrictness -> SourceStrictness #
Ord SourceUnpackedness	Since: base-4.9.0.0
Instance details Defined in GHC.Generics Methods compare :: SourceUnpackedness -> SourceUnpackedness -> Ordering # (<) :: SourceUnpackedness -> SourceUnpackedness -> Bool # (<=) :: SourceUnpackedness -> SourceUnpackedness -> Bool # (>) :: SourceUnpackedness -> SourceUnpackedness -> Bool # (>=) :: SourceUnpackedness -> SourceUnpackedness -> Bool # max :: SourceUnpackedness -> SourceUnpackedness -> SourceUnpackedness # min :: SourceUnpackedness -> SourceUnpackedness -> SourceUnpackedness #
Ord Int16	Since: base-2.1
Instance details Defined in GHC.Int Methods compare :: Int16 -> Int16 -> Ordering # (<) :: Int16 -> Int16 -> Bool # (<=) :: Int16 -> Int16 -> Bool # (>) :: Int16 -> Int16 -> Bool # (>=) :: Int16 -> Int16 -> Bool # max :: Int16 -> Int16 -> Int16 # min :: Int16 -> Int16 -> Int16 #
Ord Int32	Since: base-2.1
Instance details Defined in GHC.Int Methods compare :: Int32 -> Int32 -> Ordering # (<) :: Int32 -> Int32 -> Bool # (<=) :: Int32 -> Int32 -> Bool # (>) :: Int32 -> Int32 -> Bool # (>=) :: Int32 -> Int32 -> Bool # max :: Int32 -> Int32 -> Int32 # min :: Int32 -> Int32 -> Int32 #
Ord Int64	Since: base-2.1
Instance details Defined in GHC.Int Methods compare :: Int64 -> Int64 -> Ordering # (<) :: Int64 -> Int64 -> Bool # (<=) :: Int64 -> Int64 -> Bool # (>) :: Int64 -> Int64 -> Bool # (>=) :: Int64 -> Int64 -> Bool # max :: Int64 -> Int64 -> Int64 # min :: Int64 -> Int64 -> Int64 #
Ord Int8	Since: base-2.1
Instance details Defined in GHC.Int Methods compare :: Int8 -> Int8 -> Ordering # (<) :: Int8 -> Int8 -> Bool # (<=) :: Int8 -> Int8 -> Bool # (>) :: Int8 -> Int8 -> Bool # (>=) :: Int8 -> Int8 -> Bool # max :: Int8 -> Int8 -> Int8 # min :: Int8 -> Int8 -> Int8 #
Ord SomeSymbol	Since: base-4.7.0.0
Instance details Defined in GHC.TypeLits Methods compare :: SomeSymbol -> SomeSymbol -> Ordering # (<) :: SomeSymbol -> SomeSymbol -> Bool # (<=) :: SomeSymbol -> SomeSymbol -> Bool # (>) :: SomeSymbol -> SomeSymbol -> Bool # (>=) :: SomeSymbol -> SomeSymbol -> Bool # max :: SomeSymbol -> SomeSymbol -> SomeSymbol # min :: SomeSymbol -> SomeSymbol -> SomeSymbol #
Ord SomeNat	Since: base-4.7.0.0
Instance details Defined in GHC.TypeNats Methods compare :: SomeNat -> SomeNat -> Ordering # (<) :: SomeNat -> SomeNat -> Bool # (<=) :: SomeNat -> SomeNat -> Bool # (>) :: SomeNat -> SomeNat -> Bool # (>=) :: SomeNat -> SomeNat -> Bool # max :: SomeNat -> SomeNat -> SomeNat # min :: SomeNat -> SomeNat -> SomeNat #
Ord Word16	Since: base-2.1
Instance details Defined in GHC.Word Methods compare :: Word16 -> Word16 -> Ordering # (<) :: Word16 -> Word16 -> Bool # (<=) :: Word16 -> Word16 -> Bool # (>) :: Word16 -> Word16 -> Bool # (>=) :: Word16 -> Word16 -> Bool # max :: Word16 -> Word16 -> Word16 # min :: Word16 -> Word16 -> Word16 #
Ord Word32	Since: base-2.1
Instance details Defined in GHC.Word Methods compare :: Word32 -> Word32 -> Ordering # (<) :: Word32 -> Word32 -> Bool # (<=) :: Word32 -> Word32 -> Bool # (>) :: Word32 -> Word32 -> Bool # (>=) :: Word32 -> Word32 -> Bool # max :: Word32 -> Word32 -> Word32 # min :: Word32 -> Word32 -> Word32 #
Ord Word64	Since: base-2.1
Instance details Defined in GHC.Word Methods compare :: Word64 -> Word64 -> Ordering # (<) :: Word64 -> Word64 -> Bool # (<=) :: Word64 -> Word64 -> Bool # (>) :: Word64 -> Word64 -> Bool # (>=) :: Word64 -> Word64 -> Bool # max :: Word64 -> Word64 -> Word64 # min :: Word64 -> Word64 -> Word64 #
Ord ByteString
Instance details Defined in Data.ByteString.Internal Methods compare :: ByteString -> ByteString -> Ordering # (<) :: ByteString -> ByteString -> Bool # (<=) :: ByteString -> ByteString -> Bool # (>) :: ByteString -> ByteString -> Bool # (>=) :: ByteString -> ByteString -> Bool # max :: ByteString -> ByteString -> ByteString # min :: ByteString -> ByteString -> ByteString #
Ord ByteString
Instance details Defined in Data.ByteString.Lazy.Internal Methods compare :: ByteString -> ByteString -> Ordering # (<) :: ByteString -> ByteString -> Bool # (<=) :: ByteString -> ByteString -> Bool # (>) :: ByteString -> ByteString -> Bool # (>=) :: ByteString -> ByteString -> Bool # max :: ByteString -> ByteString -> ByteString # min :: ByteString -> ByteString -> ByteString #
Ord ShortByteString
Instance details Defined in Data.ByteString.Short.Internal Methods compare :: ShortByteString -> ShortByteString -> Ordering # (<) :: ShortByteString -> ShortByteString -> Bool # (<=) :: ShortByteString -> ShortByteString -> Bool # (>) :: ShortByteString -> ShortByteString -> Bool # (>=) :: ShortByteString -> ShortByteString -> Bool # max :: ShortByteString -> ShortByteString -> ShortByteString # min :: ShortByteString -> ShortByteString -> ShortByteString #
Ord IntSet
Instance details Defined in Data.IntSet.Internal Methods compare :: IntSet -> IntSet -> Ordering # (<) :: IntSet -> IntSet -> Bool # (<=) :: IntSet -> IntSet -> Bool # (>) :: IntSet -> IntSet -> Bool # (>=) :: IntSet -> IntSet -> Bool # max :: IntSet -> IntSet -> IntSet # min :: IntSet -> IntSet -> IntSet #
Ord BigNat
Instance details Defined in GHC.Num.BigNat Methods compare :: BigNat -> BigNat -> Ordering # (<) :: BigNat -> BigNat -> Bool # (<=) :: BigNat -> BigNat -> Bool # (>) :: BigNat -> BigNat -> Bool # (>=) :: BigNat -> BigNat -> Bool # max :: BigNat -> BigNat -> BigNat # min :: BigNat -> BigNat -> BigNat #
Ord Extension
Instance details Defined in GHC.LanguageExtensions.Type Methods compare :: Extension -> Extension -> Ordering # (<) :: Extension -> Extension -> Bool # (<=) :: Extension -> Extension -> Bool # (>) :: Extension -> Extension -> Bool # (>=) :: Extension -> Extension -> Bool # max :: Extension -> Extension -> Extension # min :: Extension -> Extension -> Extension #
Ord Ordering
Instance details Defined in GHC.Classes Methods compare :: Ordering -> Ordering -> Ordering # (<) :: Ordering -> Ordering -> Bool # (<=) :: Ordering -> Ordering -> Bool # (>) :: Ordering -> Ordering -> Bool # (>=) :: Ordering -> Ordering -> Bool # max :: Ordering -> Ordering -> Ordering # min :: Ordering -> Ordering -> Ordering #
Ord TyCon
Instance details Defined in GHC.Classes Methods compare :: TyCon -> TyCon -> Ordering # (<) :: TyCon -> TyCon -> Bool # (<=) :: TyCon -> TyCon -> Bool # (>) :: TyCon -> TyCon -> Bool # (>=) :: TyCon -> TyCon -> Bool # max :: TyCon -> TyCon -> TyCon # min :: TyCon -> TyCon -> TyCon #
Ord AnnLookup
Instance details Defined in Language.Haskell.TH.Syntax Methods compare :: AnnLookup -> AnnLookup -> Ordering # (<) :: AnnLookup -> AnnLookup -> Bool # (<=) :: AnnLookup -> AnnLookup -> Bool # (>) :: AnnLookup -> AnnLookup -> Bool # (>=) :: AnnLookup -> AnnLookup -> Bool # max :: AnnLookup -> AnnLookup -> AnnLookup # min :: AnnLookup -> AnnLookup -> AnnLookup #
Ord AnnTarget
Instance details Defined in Language.Haskell.TH.Syntax Methods compare :: AnnTarget -> AnnTarget -> Ordering # (<) :: AnnTarget -> AnnTarget -> Bool # (<=) :: AnnTarget -> AnnTarget -> Bool # (>) :: AnnTarget -> AnnTarget -> Bool # (>=) :: AnnTarget -> AnnTarget -> Bool # max :: AnnTarget -> AnnTarget -> AnnTarget # min :: AnnTarget -> AnnTarget -> AnnTarget #
Ord Bang
Instance details Defined in Language.Haskell.TH.Syntax Methods compare :: Bang -> Bang -> Ordering # (<) :: Bang -> Bang -> Bool # (<=) :: Bang -> Bang -> Bool # (>) :: Bang -> Bang -> Bool # (>=) :: Bang -> Bang -> Bool # max :: Bang -> Bang -> Bang # min :: Bang -> Bang -> Bang #
Ord Body
Instance details Defined in Language.Haskell.TH.Syntax Methods compare :: Body -> Body -> Ordering # (<) :: Body -> Body -> Bool # (<=) :: Body -> Body -> Bool # (>) :: Body -> Body -> Bool # (>=) :: Body -> Body -> Bool # max :: Body -> Body -> Body # min :: Body -> Body -> Body #
Ord Bytes
Instance details Defined in Language.Haskell.TH.Syntax Methods compare :: Bytes -> Bytes -> Ordering # (<) :: Bytes -> Bytes -> Bool # (<=) :: Bytes -> Bytes -> Bool # (>) :: Bytes -> Bytes -> Bool # (>=) :: Bytes -> Bytes -> Bool # max :: Bytes -> Bytes -> Bytes # min :: Bytes -> Bytes -> Bytes #
Ord Callconv
Instance details Defined in Language.Haskell.TH.Syntax Methods compare :: Callconv -> Callconv -> Ordering # (<) :: Callconv -> Callconv -> Bool # (<=) :: Callconv -> Callconv -> Bool # (>) :: Callconv -> Callconv -> Bool # (>=) :: Callconv -> Callconv -> Bool # max :: Callconv -> Callconv -> Callconv # min :: Callconv -> Callconv -> Callconv #
Ord Clause
Instance details Defined in Language.Haskell.TH.Syntax Methods compare :: Clause -> Clause -> Ordering # (<) :: Clause -> Clause -> Bool # (<=) :: Clause -> Clause -> Bool # (>) :: Clause -> Clause -> Bool # (>=) :: Clause -> Clause -> Bool # max :: Clause -> Clause -> Clause # min :: Clause -> Clause -> Clause #
Ord Con
Instance details Defined in Language.Haskell.TH.Syntax Methods compare :: Con -> Con -> Ordering # (<) :: Con -> Con -> Bool # (<=) :: Con -> Con -> Bool # (>) :: Con -> Con -> Bool # (>=) :: Con -> Con -> Bool # max :: Con -> Con -> Con # min :: Con -> Con -> Con #
Ord Dec
Instance details Defined in Language.Haskell.TH.Syntax Methods compare :: Dec -> Dec -> Ordering # (<) :: Dec -> Dec -> Bool # (<=) :: Dec -> Dec -> Bool # (>) :: Dec -> Dec -> Bool # (>=) :: Dec -> Dec -> Bool # max :: Dec -> Dec -> Dec # min :: Dec -> Dec -> Dec #
Ord DecidedStrictness
Instance details Defined in Language.Haskell.TH.Syntax Methods compare :: DecidedStrictness -> DecidedStrictness -> Ordering # (<) :: DecidedStrictness -> DecidedStrictness -> Bool # (<=) :: DecidedStrictness -> DecidedStrictness -> Bool # (>) :: DecidedStrictness -> DecidedStrictness -> Bool # (>=) :: DecidedStrictness -> DecidedStrictness -> Bool # max :: DecidedStrictness -> DecidedStrictness -> DecidedStrictness # min :: DecidedStrictness -> DecidedStrictness -> DecidedStrictness #
Ord DerivClause
Instance details Defined in Language.Haskell.TH.Syntax Methods compare :: DerivClause -> DerivClause -> Ordering # (<) :: DerivClause -> DerivClause -> Bool # (<=) :: DerivClause -> DerivClause -> Bool # (>) :: DerivClause -> DerivClause -> Bool # (>=) :: DerivClause -> DerivClause -> Bool # max :: DerivClause -> DerivClause -> DerivClause # min :: DerivClause -> DerivClause -> DerivClause #
Ord DerivStrategy
Instance details Defined in Language.Haskell.TH.Syntax Methods compare :: DerivStrategy -> DerivStrategy -> Ordering # (<) :: DerivStrategy -> DerivStrategy -> Bool # (<=) :: DerivStrategy -> DerivStrategy -> Bool # (>) :: DerivStrategy -> DerivStrategy -> Bool # (>=) :: DerivStrategy -> DerivStrategy -> Bool # max :: DerivStrategy -> DerivStrategy -> DerivStrategy # min :: DerivStrategy -> DerivStrategy -> DerivStrategy #
Ord Exp
Instance details Defined in Language.Haskell.TH.Syntax Methods compare :: Exp -> Exp -> Ordering # (<) :: Exp -> Exp -> Bool # (<=) :: Exp -> Exp -> Bool # (>) :: Exp -> Exp -> Bool # (>=) :: Exp -> Exp -> Bool # max :: Exp -> Exp -> Exp # min :: Exp -> Exp -> Exp #
Ord FamilyResultSig
Instance details Defined in Language.Haskell.TH.Syntax Methods compare :: FamilyResultSig -> FamilyResultSig -> Ordering # (<) :: FamilyResultSig -> FamilyResultSig -> Bool # (<=) :: FamilyResultSig -> FamilyResultSig -> Bool # (>) :: FamilyResultSig -> FamilyResultSig -> Bool # (>=) :: FamilyResultSig -> FamilyResultSig -> Bool # max :: FamilyResultSig -> FamilyResultSig -> FamilyResultSig # min :: FamilyResultSig -> FamilyResultSig -> FamilyResultSig #
Ord Fixity
Instance details Defined in Language.Haskell.TH.Syntax Methods compare :: Fixity -> Fixity -> Ordering # (<) :: Fixity -> Fixity -> Bool # (<=) :: Fixity -> Fixity -> Bool # (>) :: Fixity -> Fixity -> Bool # (>=) :: Fixity -> Fixity -> Bool # max :: Fixity -> Fixity -> Fixity # min :: Fixity -> Fixity -> Fixity #
Ord FixityDirection
Instance details Defined in Language.Haskell.TH.Syntax Methods compare :: FixityDirection -> FixityDirection -> Ordering # (<) :: FixityDirection -> FixityDirection -> Bool # (<=) :: FixityDirection -> FixityDirection -> Bool # (>) :: FixityDirection -> FixityDirection -> Bool # (>=) :: FixityDirection -> FixityDirection -> Bool # max :: FixityDirection -> FixityDirection -> FixityDirection # min :: FixityDirection -> FixityDirection -> FixityDirection #
Ord Foreign
Instance details Defined in Language.Haskell.TH.Syntax Methods compare :: Foreign -> Foreign -> Ordering # (<) :: Foreign -> Foreign -> Bool # (<=) :: Foreign -> Foreign -> Bool # (>) :: Foreign -> Foreign -> Bool # (>=) :: Foreign -> Foreign -> Bool # max :: Foreign -> Foreign -> Foreign # min :: Foreign -> Foreign -> Foreign #
Ord FunDep
Instance details Defined in Language.Haskell.TH.Syntax Methods compare :: FunDep -> FunDep -> Ordering # (<) :: FunDep -> FunDep -> Bool # (<=) :: FunDep -> FunDep -> Bool # (>) :: FunDep -> FunDep -> Bool # (>=) :: FunDep -> FunDep -> Bool # max :: FunDep -> FunDep -> FunDep # min :: FunDep -> FunDep -> FunDep #
Ord Guard
Instance details Defined in Language.Haskell.TH.Syntax Methods compare :: Guard -> Guard -> Ordering # (<) :: Guard -> Guard -> Bool # (<=) :: Guard -> Guard -> Bool # (>) :: Guard -> Guard -> Bool # (>=) :: Guard -> Guard -> Bool # max :: Guard -> Guard -> Guard # min :: Guard -> Guard -> Guard #
Ord Info
Instance details Defined in Language.Haskell.TH.Syntax Methods compare :: Info -> Info -> Ordering # (<) :: Info -> Info -> Bool # (<=) :: Info -> Info -> Bool # (>) :: Info -> Info -> Bool # (>=) :: Info -> Info -> Bool # max :: Info -> Info -> Info # min :: Info -> Info -> Info #
Ord InjectivityAnn
Instance details Defined in Language.Haskell.TH.Syntax Methods compare :: InjectivityAnn -> InjectivityAnn -> Ordering # (<) :: InjectivityAnn -> InjectivityAnn -> Bool # (<=) :: InjectivityAnn -> InjectivityAnn -> Bool # (>) :: InjectivityAnn -> InjectivityAnn -> Bool # (>=) :: InjectivityAnn -> InjectivityAnn -> Bool # max :: InjectivityAnn -> InjectivityAnn -> InjectivityAnn # min :: InjectivityAnn -> InjectivityAnn -> InjectivityAnn #
Ord Inline
Instance details Defined in Language.Haskell.TH.Syntax Methods compare :: Inline -> Inline -> Ordering # (<) :: Inline -> Inline -> Bool # (<=) :: Inline -> Inline -> Bool # (>) :: Inline -> Inline -> Bool # (>=) :: Inline -> Inline -> Bool # max :: Inline -> Inline -> Inline # min :: Inline -> Inline -> Inline #
Ord Lit
Instance details Defined in Language.Haskell.TH.Syntax Methods compare :: Lit -> Lit -> Ordering # (<) :: Lit -> Lit -> Bool # (<=) :: Lit -> Lit -> Bool # (>) :: Lit -> Lit -> Bool # (>=) :: Lit -> Lit -> Bool # max :: Lit -> Lit -> Lit # min :: Lit -> Lit -> Lit #
Ord Loc
Instance details Defined in Language.Haskell.TH.Syntax Methods compare :: Loc -> Loc -> Ordering # (<) :: Loc -> Loc -> Bool # (<=) :: Loc -> Loc -> Bool # (>) :: Loc -> Loc -> Bool # (>=) :: Loc -> Loc -> Bool # max :: Loc -> Loc -> Loc # min :: Loc -> Loc -> Loc #
Ord Match
Instance details Defined in Language.Haskell.TH.Syntax Methods compare :: Match -> Match -> Ordering # (<) :: Match -> Match -> Bool # (<=) :: Match -> Match -> Bool # (>) :: Match -> Match -> Bool # (>=) :: Match -> Match -> Bool # max :: Match -> Match -> Match # min :: Match -> Match -> Match #
Ord ModName
Instance details Defined in Language.Haskell.TH.Syntax Methods compare :: ModName -> ModName -> Ordering # (<) :: ModName -> ModName -> Bool # (<=) :: ModName -> ModName -> Bool # (>) :: ModName -> ModName -> Bool # (>=) :: ModName -> ModName -> Bool # max :: ModName -> ModName -> ModName # min :: ModName -> ModName -> ModName #
Ord Module
Instance details Defined in Language.Haskell.TH.Syntax Methods compare :: Module -> Module -> Ordering # (<) :: Module -> Module -> Bool # (<=) :: Module -> Module -> Bool # (>) :: Module -> Module -> Bool # (>=) :: Module -> Module -> Bool # max :: Module -> Module -> Module # min :: Module -> Module -> Module #
Ord ModuleInfo
Instance details Defined in Language.Haskell.TH.Syntax Methods compare :: ModuleInfo -> ModuleInfo -> Ordering # (<) :: ModuleInfo -> ModuleInfo -> Bool # (<=) :: ModuleInfo -> ModuleInfo -> Bool # (>) :: ModuleInfo -> ModuleInfo -> Bool # (>=) :: ModuleInfo -> ModuleInfo -> Bool # max :: ModuleInfo -> ModuleInfo -> ModuleInfo # min :: ModuleInfo -> ModuleInfo -> ModuleInfo #
Ord Name
Instance details Defined in Language.Haskell.TH.Syntax Methods compare :: Name -> Name -> Ordering # (<) :: Name -> Name -> Bool # (<=) :: Name -> Name -> Bool # (>) :: Name -> Name -> Bool # (>=) :: Name -> Name -> Bool # max :: Name -> Name -> Name # min :: Name -> Name -> Name #
Ord NameFlavour
Instance details Defined in Language.Haskell.TH.Syntax Methods compare :: NameFlavour -> NameFlavour -> Ordering # (<) :: NameFlavour -> NameFlavour -> Bool # (<=) :: NameFlavour -> NameFlavour -> Bool # (>) :: NameFlavour -> NameFlavour -> Bool # (>=) :: NameFlavour -> NameFlavour -> Bool # max :: NameFlavour -> NameFlavour -> NameFlavour # min :: NameFlavour -> NameFlavour -> NameFlavour #
Ord NameSpace
Instance details Defined in Language.Haskell.TH.Syntax Methods compare :: NameSpace -> NameSpace -> Ordering # (<) :: NameSpace -> NameSpace -> Bool # (<=) :: NameSpace -> NameSpace -> Bool # (>) :: NameSpace -> NameSpace -> Bool # (>=) :: NameSpace -> NameSpace -> Bool # max :: NameSpace -> NameSpace -> NameSpace # min :: NameSpace -> NameSpace -> NameSpace #
Ord OccName
Instance details Defined in Language.Haskell.TH.Syntax Methods compare :: OccName -> OccName -> Ordering # (<) :: OccName -> OccName -> Bool # (<=) :: OccName -> OccName -> Bool # (>) :: OccName -> OccName -> Bool # (>=) :: OccName -> OccName -> Bool # max :: OccName -> OccName -> OccName # min :: OccName -> OccName -> OccName #
Ord Overlap
Instance details Defined in Language.Haskell.TH.Syntax Methods compare :: Overlap -> Overlap -> Ordering # (<) :: Overlap -> Overlap -> Bool # (<=) :: Overlap -> Overlap -> Bool # (>) :: Overlap -> Overlap -> Bool # (>=) :: Overlap -> Overlap -> Bool # max :: Overlap -> Overlap -> Overlap # min :: Overlap -> Overlap -> Overlap #
Ord Pat
Instance details Defined in Language.Haskell.TH.Syntax Methods compare :: Pat -> Pat -> Ordering # (<) :: Pat -> Pat -> Bool # (<=) :: Pat -> Pat -> Bool # (>) :: Pat -> Pat -> Bool # (>=) :: Pat -> Pat -> Bool # max :: Pat -> Pat -> Pat # min :: Pat -> Pat -> Pat #
Ord PatSynArgs
Instance details Defined in Language.Haskell.TH.Syntax Methods compare :: PatSynArgs -> PatSynArgs -> Ordering # (<) :: PatSynArgs -> PatSynArgs -> Bool # (<=) :: PatSynArgs -> PatSynArgs -> Bool # (>) :: PatSynArgs -> PatSynArgs -> Bool # (>=) :: PatSynArgs -> PatSynArgs -> Bool # max :: PatSynArgs -> PatSynArgs -> PatSynArgs # min :: PatSynArgs -> PatSynArgs -> PatSynArgs #
Ord PatSynDir
Instance details Defined in Language.Haskell.TH.Syntax Methods compare :: PatSynDir -> PatSynDir -> Ordering # (<) :: PatSynDir -> PatSynDir -> Bool # (<=) :: PatSynDir -> PatSynDir -> Bool # (>) :: PatSynDir -> PatSynDir -> Bool # (>=) :: PatSynDir -> PatSynDir -> Bool # max :: PatSynDir -> PatSynDir -> PatSynDir # min :: PatSynDir -> PatSynDir -> PatSynDir #
Ord Phases
Instance details Defined in Language.Haskell.TH.Syntax Methods compare :: Phases -> Phases -> Ordering # (<) :: Phases -> Phases -> Bool # (<=) :: Phases -> Phases -> Bool # (>) :: Phases -> Phases -> Bool # (>=) :: Phases -> Phases -> Bool # max :: Phases -> Phases -> Phases # min :: Phases -> Phases -> Phases #
Ord PkgName
Instance details Defined in Language.Haskell.TH.Syntax Methods compare :: PkgName -> PkgName -> Ordering # (<) :: PkgName -> PkgName -> Bool # (<=) :: PkgName -> PkgName -> Bool # (>) :: PkgName -> PkgName -> Bool # (>=) :: PkgName -> PkgName -> Bool # max :: PkgName -> PkgName -> PkgName # min :: PkgName -> PkgName -> PkgName #
Ord Pragma
Instance details Defined in Language.Haskell.TH.Syntax Methods compare :: Pragma -> Pragma -> Ordering # (<) :: Pragma -> Pragma -> Bool # (<=) :: Pragma -> Pragma -> Bool # (>) :: Pragma -> Pragma -> Bool # (>=) :: Pragma -> Pragma -> Bool # max :: Pragma -> Pragma -> Pragma # min :: Pragma -> Pragma -> Pragma #
Ord Range
Instance details Defined in Language.Haskell.TH.Syntax Methods compare :: Range -> Range -> Ordering # (<) :: Range -> Range -> Bool # (<=) :: Range -> Range -> Bool # (>) :: Range -> Range -> Bool # (>=) :: Range -> Range -> Bool # max :: Range -> Range -> Range # min :: Range -> Range -> Range #
Ord Role
Instance details Defined in Language.Haskell.TH.Syntax Methods compare :: Role -> Role -> Ordering # (<) :: Role -> Role -> Bool # (<=) :: Role -> Role -> Bool # (>) :: Role -> Role -> Bool # (>=) :: Role -> Role -> Bool # max :: Role -> Role -> Role # min :: Role -> Role -> Role #
Ord RuleBndr
Instance details Defined in Language.Haskell.TH.Syntax Methods compare :: RuleBndr -> RuleBndr -> Ordering # (<) :: RuleBndr -> RuleBndr -> Bool # (<=) :: RuleBndr -> RuleBndr -> Bool # (>) :: RuleBndr -> RuleBndr -> Bool # (>=) :: RuleBndr -> RuleBndr -> Bool # max :: RuleBndr -> RuleBndr -> RuleBndr # min :: RuleBndr -> RuleBndr -> RuleBndr #
Ord RuleMatch
Instance details Defined in Language.Haskell.TH.Syntax Methods compare :: RuleMatch -> RuleMatch -> Ordering # (<) :: RuleMatch -> RuleMatch -> Bool # (<=) :: RuleMatch -> RuleMatch -> Bool # (>) :: RuleMatch -> RuleMatch -> Bool # (>=) :: RuleMatch -> RuleMatch -> Bool # max :: RuleMatch -> RuleMatch -> RuleMatch # min :: RuleMatch -> RuleMatch -> RuleMatch #
Ord Safety
Instance details Defined in Language.Haskell.TH.Syntax Methods compare :: Safety -> Safety -> Ordering # (<) :: Safety -> Safety -> Bool # (<=) :: Safety -> Safety -> Bool # (>) :: Safety -> Safety -> Bool # (>=) :: Safety -> Safety -> Bool # max :: Safety -> Safety -> Safety # min :: Safety -> Safety -> Safety #
Ord SourceStrictness
Instance details Defined in Language.Haskell.TH.Syntax Methods compare :: SourceStrictness -> SourceStrictness -> Ordering # (<) :: SourceStrictness -> SourceStrictness -> Bool # (<=) :: SourceStrictness -> SourceStrictness -> Bool # (>) :: SourceStrictness -> SourceStrictness -> Bool # (>=) :: SourceStrictness -> SourceStrictness -> Bool # max :: SourceStrictness -> SourceStrictness -> SourceStrictness # min :: SourceStrictness -> SourceStrictness -> SourceStrictness #
Ord SourceUnpackedness
Instance details Defined in Language.Haskell.TH.Syntax Methods compare :: SourceUnpackedness -> SourceUnpackedness -> Ordering # (<) :: SourceUnpackedness -> SourceUnpackedness -> Bool # (<=) :: SourceUnpackedness -> SourceUnpackedness -> Bool # (>) :: SourceUnpackedness -> SourceUnpackedness -> Bool # (>=) :: SourceUnpackedness -> SourceUnpackedness -> Bool # max :: SourceUnpackedness -> SourceUnpackedness -> SourceUnpackedness # min :: SourceUnpackedness -> SourceUnpackedness -> SourceUnpackedness #
Ord Specificity
Instance details Defined in Language.Haskell.TH.Syntax Methods compare :: Specificity -> Specificity -> Ordering # (<) :: Specificity -> Specificity -> Bool # (<=) :: Specificity -> Specificity -> Bool # (>) :: Specificity -> Specificity -> Bool # (>=) :: Specificity -> Specificity -> Bool # max :: Specificity -> Specificity -> Specificity # min :: Specificity -> Specificity -> Specificity #
Ord Stmt
Instance details Defined in Language.Haskell.TH.Syntax Methods compare :: Stmt -> Stmt -> Ordering # (<) :: Stmt -> Stmt -> Bool # (<=) :: Stmt -> Stmt -> Bool # (>) :: Stmt -> Stmt -> Bool # (>=) :: Stmt -> Stmt -> Bool # max :: Stmt -> Stmt -> Stmt # min :: Stmt -> Stmt -> Stmt #
Ord TyLit
Instance details Defined in Language.Haskell.TH.Syntax Methods compare :: TyLit -> TyLit -> Ordering # (<) :: TyLit -> TyLit -> Bool # (<=) :: TyLit -> TyLit -> Bool # (>) :: TyLit -> TyLit -> Bool # (>=) :: TyLit -> TyLit -> Bool # max :: TyLit -> TyLit -> TyLit # min :: TyLit -> TyLit -> TyLit #
Ord TySynEqn
Instance details Defined in Language.Haskell.TH.Syntax Methods compare :: TySynEqn -> TySynEqn -> Ordering # (<) :: TySynEqn -> TySynEqn -> Bool # (<=) :: TySynEqn -> TySynEqn -> Bool # (>) :: TySynEqn -> TySynEqn -> Bool # (>=) :: TySynEqn -> TySynEqn -> Bool # max :: TySynEqn -> TySynEqn -> TySynEqn # min :: TySynEqn -> TySynEqn -> TySynEqn #
Ord Type
Instance details Defined in Language.Haskell.TH.Syntax Methods compare :: Type -> Type -> Ordering # (<) :: Type -> Type -> Bool # (<=) :: Type -> Type -> Bool # (>) :: Type -> Type -> Bool # (>=) :: Type -> Type -> Bool # max :: Type -> Type -> Type # min :: Type -> Type -> Type #
Ord TypeFamilyHead
Instance details Defined in Language.Haskell.TH.Syntax Methods compare :: TypeFamilyHead -> TypeFamilyHead -> Ordering # (<) :: TypeFamilyHead -> TypeFamilyHead -> Bool # (<=) :: TypeFamilyHead -> TypeFamilyHead -> Bool # (>) :: TypeFamilyHead -> TypeFamilyHead -> Bool # (>=) :: TypeFamilyHead -> TypeFamilyHead -> Bool # max :: TypeFamilyHead -> TypeFamilyHead -> TypeFamilyHead # min :: TypeFamilyHead -> TypeFamilyHead -> TypeFamilyHead #
Ord Word8	Since: base-2.1
Instance details Defined in GHC.Word Methods compare :: Word8 -> Word8 -> Ordering # (<) :: Word8 -> Word8 -> Bool # (<=) :: Word8 -> Word8 -> Bool # (>) :: Word8 -> Word8 -> Bool # (>=) :: Word8 -> Word8 -> Bool # max :: Word8 -> Word8 -> Word8 # min :: Word8 -> Word8 -> Word8 #
Ord Integer
Instance details Defined in GHC.Num.Integer Methods compare :: Integer -> Integer -> Ordering # (<) :: Integer -> Integer -> Bool # (<=) :: Integer -> Integer -> Bool # (>) :: Integer -> Integer -> Bool # (>=) :: Integer -> Integer -> Bool # max :: Integer -> Integer -> Integer # min :: Integer -> Integer -> Integer #
Ord Natural
Instance details Defined in GHC.Num.Natural Methods compare :: Natural -> Natural -> Ordering # (<) :: Natural -> Natural -> Bool # (<=) :: Natural -> Natural -> Bool # (>) :: Natural -> Natural -> Bool # (>=) :: Natural -> Natural -> Bool # max :: Natural -> Natural -> Natural # min :: Natural -> Natural -> Natural #
Ord ()
Instance details Defined in GHC.Classes Methods compare :: () -> () -> Ordering # (<) :: () -> () -> Bool # (<=) :: () -> () -> Bool # (>) :: () -> () -> Bool # (>=) :: () -> () -> Bool # max :: () -> () -> () # min :: () -> () -> () #
Ord Bool
Instance details Defined in GHC.Classes Methods compare :: Bool -> Bool -> Ordering # (<) :: Bool -> Bool -> Bool # (<=) :: Bool -> Bool -> Bool # (>) :: Bool -> Bool -> Bool # (>=) :: Bool -> Bool -> Bool # max :: Bool -> Bool -> Bool # min :: Bool -> Bool -> Bool #
Ord Char
Instance details Defined in GHC.Classes Methods compare :: Char -> Char -> Ordering # (<) :: Char -> Char -> Bool # (<=) :: Char -> Char -> Bool # (>) :: Char -> Char -> Bool # (>=) :: Char -> Char -> Bool # max :: Char -> Char -> Char # min :: Char -> Char -> Char #
Ord Double	Note that due to the presence of `NaN`, `Double`'s `Ord` instance does not satisfy reflexivity. `>>>` `0/0 <= (0/0 :: Double)`False Also note that, due to the same, `Ord`'s operator interactions are not respected by `Double`'s instance: `>>>` `(0/0 :: Double) > 1`False `>>>` `compare (0/0 :: Double) 1`GT
Instance details Defined in GHC.Classes Methods compare :: Double -> Double -> Ordering # (<) :: Double -> Double -> Bool # (<=) :: Double -> Double -> Bool # (>) :: Double -> Double -> Bool # (>=) :: Double -> Double -> Bool # max :: Double -> Double -> Double # min :: Double -> Double -> Double #
Ord Float	Note that due to the presence of `NaN`, `Float`'s `Ord` instance does not satisfy reflexivity. `>>>` `0/0 <= (0/0 :: Float)`False Also note that, due to the same, `Ord`'s operator interactions are not respected by `Float`'s instance: `>>>` `(0/0 :: Float) > 1`False `>>>` `compare (0/0 :: Float) 1`GT
Instance details Defined in GHC.Classes Methods compare :: Float -> Float -> Ordering # (<) :: Float -> Float -> Bool # (<=) :: Float -> Float -> Bool # (>) :: Float -> Float -> Bool # (>=) :: Float -> Float -> Bool # max :: Float -> Float -> Float # min :: Float -> Float -> Float #
Ord Int
Instance details Defined in GHC.Classes Methods compare :: Int -> Int -> Ordering # (<) :: Int -> Int -> Bool # (<=) :: Int -> Int -> Bool # (>) :: Int -> Int -> Bool # (>=) :: Int -> Int -> Bool # max :: Int -> Int -> Int # min :: Int -> Int -> Int #
Ord Word
Instance details Defined in GHC.Classes Methods compare :: Word -> Word -> Ordering # (<) :: Word -> Word -> Bool # (<=) :: Word -> Word -> Bool # (>) :: Word -> Word -> Bool # (>=) :: Word -> Word -> Bool # max :: Word -> Word -> Word # min :: Word -> Word -> Word #
Ord a => Ord (ZipList a)	Since: base-4.7.0.0
Instance details Defined in Control.Applicative Methods compare :: ZipList a -> ZipList a -> Ordering # (<) :: ZipList a -> ZipList a -> Bool # (<=) :: ZipList a -> ZipList a -> Bool # (>) :: ZipList a -> ZipList a -> Bool # (>=) :: ZipList a -> ZipList a -> Bool # max :: ZipList a -> ZipList a -> ZipList a # min :: ZipList a -> ZipList a -> ZipList a #
Ord a => Ord (Identity a)	Since: base-4.8.0.0
Instance details Defined in Data.Functor.Identity Methods compare :: Identity a -> Identity a -> Ordering # (<) :: Identity a -> Identity a -> Bool # (<=) :: Identity a -> Identity a -> Bool # (>) :: Identity a -> Identity a -> Bool # (>=) :: Identity a -> Identity a -> Bool # max :: Identity a -> Identity a -> Identity a # min :: Identity a -> Identity a -> Identity a #
Ord a => Ord (First a)	Since: base-2.1
Instance details Defined in Data.Monoid Methods compare :: First a -> First a -> Ordering # (<) :: First a -> First a -> Bool # (<=) :: First a -> First a -> Bool # (>) :: First a -> First a -> Bool # (>=) :: First a -> First a -> Bool # max :: First a -> First a -> First a # min :: First a -> First a -> First a #
Ord a => Ord (Last a)	Since: base-2.1
Instance details Defined in Data.Monoid Methods compare :: Last a -> Last a -> Ordering # (<) :: Last a -> Last a -> Bool # (<=) :: Last a -> Last a -> Bool # (>) :: Last a -> Last a -> Bool # (>=) :: Last a -> Last a -> Bool # max :: Last a -> Last a -> Last a # min :: Last a -> Last a -> Last a #
Ord a => Ord (Down a)	Since: base-4.6.0.0
Instance details Defined in Data.Ord Methods compare :: Down a -> Down a -> Ordering # (<) :: Down a -> Down a -> Bool # (<=) :: Down a -> Down a -> Bool # (>) :: Down a -> Down a -> Bool # (>=) :: Down a -> Down a -> Bool # max :: Down a -> Down a -> Down a # min :: Down a -> Down a -> Down a #
Ord a => Ord (First a)	Since: base-4.9.0.0
Instance details Defined in Data.Semigroup Methods compare :: First a -> First a -> Ordering # (<) :: First a -> First a -> Bool # (<=) :: First a -> First a -> Bool # (>) :: First a -> First a -> Bool # (>=) :: First a -> First a -> Bool # max :: First a -> First a -> First a # min :: First a -> First a -> First a #
Ord a => Ord (Last a)	Since: base-4.9.0.0
Instance details Defined in Data.Semigroup Methods compare :: Last a -> Last a -> Ordering # (<) :: Last a -> Last a -> Bool # (<=) :: Last a -> Last a -> Bool # (>) :: Last a -> Last a -> Bool # (>=) :: Last a -> Last a -> Bool # max :: Last a -> Last a -> Last a # min :: Last a -> Last a -> Last a #
Ord a => Ord (Max a)	Since: base-4.9.0.0
Instance details Defined in Data.Semigroup Methods compare :: Max a -> Max a -> Ordering # (<) :: Max a -> Max a -> Bool # (<=) :: Max a -> Max a -> Bool # (>) :: Max a -> Max a -> Bool # (>=) :: Max a -> Max a -> Bool # max :: Max a -> Max a -> Max a # min :: Max a -> Max a -> Max a #
Ord a => Ord (Min a)	Since: base-4.9.0.0
Instance details Defined in Data.Semigroup Methods compare :: Min a -> Min a -> Ordering # (<) :: Min a -> Min a -> Bool # (<=) :: Min a -> Min a -> Bool # (>) :: Min a -> Min a -> Bool # (>=) :: Min a -> Min a -> Bool # max :: Min a -> Min a -> Min a # min :: Min a -> Min a -> Min a #
Ord a => Ord (Option a)	Since: base-4.9.0.0
Instance details Defined in Data.Semigroup Methods compare :: Option a -> Option a -> Ordering # (<) :: Option a -> Option a -> Bool # (<=) :: Option a -> Option a -> Bool # (>) :: Option a -> Option a -> Bool # (>=) :: Option a -> Option a -> Bool # max :: Option a -> Option a -> Option a # min :: Option a -> Option a -> Option a #
Ord m => Ord (WrappedMonoid m)	Since: base-4.9.0.0
Instance details Defined in Data.Semigroup Methods compare :: WrappedMonoid m -> WrappedMonoid m -> Ordering # (<) :: WrappedMonoid m -> WrappedMonoid m -> Bool # (<=) :: WrappedMonoid m -> WrappedMonoid m -> Bool # (>) :: WrappedMonoid m -> WrappedMonoid m -> Bool # (>=) :: WrappedMonoid m -> WrappedMonoid m -> Bool # max :: WrappedMonoid m -> WrappedMonoid m -> WrappedMonoid m # min :: WrappedMonoid m -> WrappedMonoid m -> WrappedMonoid m #
Ord a => Ord (NonEmpty a)	Since: base-4.9.0.0
Instance details Defined in GHC.Base Methods compare :: NonEmpty a -> NonEmpty a -> Ordering # (<) :: NonEmpty a -> NonEmpty a -> Bool # (<=) :: NonEmpty a -> NonEmpty a -> Bool # (>) :: NonEmpty a -> NonEmpty a -> Bool # (>=) :: NonEmpty a -> NonEmpty a -> Bool # max :: NonEmpty a -> NonEmpty a -> NonEmpty a # min :: NonEmpty a -> NonEmpty a -> NonEmpty a #
Ord p => Ord (Par1 p)	Since: base-4.7.0.0
Instance details Defined in GHC.Generics Methods compare :: Par1 p -> Par1 p -> Ordering # (<) :: Par1 p -> Par1 p -> Bool # (<=) :: Par1 p -> Par1 p -> Bool # (>) :: Par1 p -> Par1 p -> Bool # (>=) :: Par1 p -> Par1 p -> Bool # max :: Par1 p -> Par1 p -> Par1 p # min :: Par1 p -> Par1 p -> Par1 p #
Integral a => Ord (Ratio a)	Since: base-2.0.1
Instance details Defined in GHC.Real Methods compare :: Ratio a -> Ratio a -> Ordering # (<) :: Ratio a -> Ratio a -> Bool # (<=) :: Ratio a -> Ratio a -> Bool # (>) :: Ratio a -> Ratio a -> Bool # (>=) :: Ratio a -> Ratio a -> Bool # max :: Ratio a -> Ratio a -> Ratio a # min :: Ratio a -> Ratio a -> Ratio a #
Ord a => Ord (IntMap a)
Instance details Defined in Data.IntMap.Internal Methods compare :: IntMap a -> IntMap a -> Ordering # (<) :: IntMap a -> IntMap a -> Bool # (<=) :: IntMap a -> IntMap a -> Bool # (>) :: IntMap a -> IntMap a -> Bool # (>=) :: IntMap a -> IntMap a -> Bool # max :: IntMap a -> IntMap a -> IntMap a # min :: IntMap a -> IntMap a -> IntMap a #
Ord a => Ord (Seq a)
Instance details Defined in Data.Sequence.Internal Methods compare :: Seq a -> Seq a -> Ordering # (<) :: Seq a -> Seq a -> Bool # (<=) :: Seq a -> Seq a -> Bool # (>) :: Seq a -> Seq a -> Bool # (>=) :: Seq a -> Seq a -> Bool # max :: Seq a -> Seq a -> Seq a # min :: Seq a -> Seq a -> Seq a #
Ord a => Ord (ViewL a)
Instance details Defined in Data.Sequence.Internal Methods compare :: ViewL a -> ViewL a -> Ordering # (<) :: ViewL a -> ViewL a -> Bool # (<=) :: ViewL a -> ViewL a -> Bool # (>) :: ViewL a -> ViewL a -> Bool # (>=) :: ViewL a -> ViewL a -> Bool # max :: ViewL a -> ViewL a -> ViewL a # min :: ViewL a -> ViewL a -> ViewL a #
Ord a => Ord (ViewR a)
Instance details Defined in Data.Sequence.Internal Methods compare :: ViewR a -> ViewR a -> Ordering # (<) :: ViewR a -> ViewR a -> Bool # (<=) :: ViewR a -> ViewR a -> Bool # (>) :: ViewR a -> ViewR a -> Bool # (>=) :: ViewR a -> ViewR a -> Bool # max :: ViewR a -> ViewR a -> ViewR a # min :: ViewR a -> ViewR a -> ViewR a #
Ord a => Ord (Set a)
Instance details Defined in Data.Set.Internal Methods compare :: Set a -> Set a -> Ordering # (<) :: Set a -> Set a -> Bool # (<=) :: Set a -> Set a -> Bool # (>) :: Set a -> Set a -> Bool # (>=) :: Set a -> Set a -> Bool # max :: Set a -> Set a -> Set a # min :: Set a -> Set a -> Set a #
Ord a => Ord (DList a)
Instance details Defined in Data.DList.Internal Methods compare :: DList a -> DList a -> Ordering # (<) :: DList a -> DList a -> Bool # (<=) :: DList a -> DList a -> Bool # (>) :: DList a -> DList a -> Bool # (>=) :: DList a -> DList a -> Bool # max :: DList a -> DList a -> DList a # min :: DList a -> DList a -> DList a #
Ord flag => Ord (TyVarBndr flag)
Instance details Defined in Language.Haskell.TH.Syntax Methods compare :: TyVarBndr flag -> TyVarBndr flag -> Ordering # (<) :: TyVarBndr flag -> TyVarBndr flag -> Bool # (<=) :: TyVarBndr flag -> TyVarBndr flag -> Bool # (>) :: TyVarBndr flag -> TyVarBndr flag -> Bool # (>=) :: TyVarBndr flag -> TyVarBndr flag -> Bool # max :: TyVarBndr flag -> TyVarBndr flag -> TyVarBndr flag # min :: TyVarBndr flag -> TyVarBndr flag -> TyVarBndr flag #
Ord a => Ord (Maybe a)	Since: base-2.1
Instance details Defined in GHC.Maybe Methods compare :: Maybe a -> Maybe a -> Ordering # (<) :: Maybe a -> Maybe a -> Bool # (<=) :: Maybe a -> Maybe a -> Bool # (>) :: Maybe a -> Maybe a -> Bool # (>=) :: Maybe a -> Maybe a -> Bool # max :: Maybe a -> Maybe a -> Maybe a # min :: Maybe a -> Maybe a -> Maybe a #
Ord a => Ord [a]
Instance details Defined in GHC.Classes Methods compare :: [a] -> [a] -> Ordering # (<) :: [a] -> [a] -> Bool # (<=) :: [a] -> [a] -> Bool # (>) :: [a] -> [a] -> Bool # (>=) :: [a] -> [a] -> Bool # max :: [a] -> [a] -> [a] # min :: [a] -> [a] -> [a] #
(Ord a, Ord b) => Ord (Either a b)	Since: base-2.1
Instance details Defined in Data.Either Methods compare :: Either a b -> Either a b -> Ordering # (<) :: Either a b -> Either a b -> Bool # (<=) :: Either a b -> Either a b -> Bool # (>) :: Either a b -> Either a b -> Bool # (>=) :: Either a b -> Either a b -> Bool # max :: Either a b -> Either a b -> Either a b # min :: Either a b -> Either a b -> Either a b #
Ord (Fixed a)	Since: base-2.1
Instance details Defined in Data.Fixed Methods compare :: Fixed a -> Fixed a -> Ordering # (<) :: Fixed a -> Fixed a -> Bool # (<=) :: Fixed a -> Fixed a -> Bool # (>) :: Fixed a -> Fixed a -> Bool # (>=) :: Fixed a -> Fixed a -> Bool # max :: Fixed a -> Fixed a -> Fixed a # min :: Fixed a -> Fixed a -> Fixed a #
Ord (Proxy s)	Since: base-4.7.0.0
Instance details Defined in Data.Proxy Methods compare :: Proxy s -> Proxy s -> Ordering # (<) :: Proxy s -> Proxy s -> Bool # (<=) :: Proxy s -> Proxy s -> Bool # (>) :: Proxy s -> Proxy s -> Bool # (>=) :: Proxy s -> Proxy s -> Bool # max :: Proxy s -> Proxy s -> Proxy s # min :: Proxy s -> Proxy s -> Proxy s #
Ord a => Ord (Arg a b)	Since: base-4.9.0.0
Instance details Defined in Data.Semigroup Methods compare :: Arg a b -> Arg a b -> Ordering # (<) :: Arg a b -> Arg a b -> Bool # (<=) :: Arg a b -> Arg a b -> Bool # (>) :: Arg a b -> Arg a b -> Bool # (>=) :: Arg a b -> Arg a b -> Bool # max :: Arg a b -> Arg a b -> Arg a b # min :: Arg a b -> Arg a b -> Arg a b #
Ord (TypeRep a)	Since: base-4.4.0.0
Instance details Defined in Data.Typeable.Internal Methods compare :: TypeRep a -> TypeRep a -> Ordering # (<) :: TypeRep a -> TypeRep a -> Bool # (<=) :: TypeRep a -> TypeRep a -> Bool # (>) :: TypeRep a -> TypeRep a -> Bool # (>=) :: TypeRep a -> TypeRep a -> Bool # max :: TypeRep a -> TypeRep a -> TypeRep a # min :: TypeRep a -> TypeRep a -> TypeRep a #
Ord (U1 p)	Since: base-4.7.0.0
Instance details Defined in GHC.Generics Methods compare :: U1 p -> U1 p -> Ordering # (<) :: U1 p -> U1 p -> Bool # (<=) :: U1 p -> U1 p -> Bool # (>) :: U1 p -> U1 p -> Bool # (>=) :: U1 p -> U1 p -> Bool # max :: U1 p -> U1 p -> U1 p # min :: U1 p -> U1 p -> U1 p #
Ord (V1 p)	Since: base-4.9.0.0
Instance details Defined in GHC.Generics Methods compare :: V1 p -> V1 p -> Ordering # (<) :: V1 p -> V1 p -> Bool # (<=) :: V1 p -> V1 p -> Bool # (>) :: V1 p -> V1 p -> Bool # (>=) :: V1 p -> V1 p -> Bool # max :: V1 p -> V1 p -> V1 p # min :: V1 p -> V1 p -> V1 p #
(Ord k, Ord v) => Ord (Map k v)
Instance details Defined in Data.Map.Internal Methods compare :: Map k v -> Map k v -> Ordering # (<) :: Map k v -> Map k v -> Bool # (<=) :: Map k v -> Map k v -> Bool # (>) :: Map k v -> Map k v -> Bool # (>=) :: Map k v -> Map k v -> Bool # max :: Map k v -> Map k v -> Map k v # min :: Map k v -> Map k v -> Map k v #
(Ord a, Ord b) => Ord (a, b)
Instance details Defined in GHC.Classes Methods compare :: (a, b) -> (a, b) -> Ordering # (<) :: (a, b) -> (a, b) -> Bool # (<=) :: (a, b) -> (a, b) -> Bool # (>) :: (a, b) -> (a, b) -> Bool # (>=) :: (a, b) -> (a, b) -> Bool # max :: (a, b) -> (a, b) -> (a, b) # min :: (a, b) -> (a, b) -> (a, b) #
Ord a => Ord (Const a b)	Since: base-4.9.0.0
Instance details Defined in Data.Functor.Const Methods compare :: Const a b -> Const a b -> Ordering # (<) :: Const a b -> Const a b -> Bool # (<=) :: Const a b -> Const a b -> Bool # (>) :: Const a b -> Const a b -> Bool # (>=) :: Const a b -> Const a b -> Bool # max :: Const a b -> Const a b -> Const a b # min :: Const a b -> Const a b -> Const a b #
Ord (f a) => Ord (Ap f a)	Since: base-4.12.0.0
Instance details Defined in Data.Monoid Methods compare :: Ap f a -> Ap f a -> Ordering # (<) :: Ap f a -> Ap f a -> Bool # (<=) :: Ap f a -> Ap f a -> Bool # (>) :: Ap f a -> Ap f a -> Bool # (>=) :: Ap f a -> Ap f a -> Bool # max :: Ap f a -> Ap f a -> Ap f a # min :: Ap f a -> Ap f a -> Ap f a #
Ord (a :~: b)	Since: base-4.7.0.0
Instance details Defined in Data.Type.Equality Methods compare :: (a :~: b) -> (a :~: b) -> Ordering # (<) :: (a :~: b) -> (a :~: b) -> Bool # (<=) :: (a :~: b) -> (a :~: b) -> Bool # (>) :: (a :~: b) -> (a :~: b) -> Bool # (>=) :: (a :~: b) -> (a :~: b) -> Bool # max :: (a :~: b) -> (a :~: b) -> a :~: b # min :: (a :~: b) -> (a :~: b) -> a :~: b #
Ord (f p) => Ord (Rec1 f p)	Since: base-4.7.0.0
Instance details Defined in GHC.Generics Methods compare :: Rec1 f p -> Rec1 f p -> Ordering # (<) :: Rec1 f p -> Rec1 f p -> Bool # (<=) :: Rec1 f p -> Rec1 f p -> Bool # (>) :: Rec1 f p -> Rec1 f p -> Bool # (>=) :: Rec1 f p -> Rec1 f p -> Bool # max :: Rec1 f p -> Rec1 f p -> Rec1 f p # min :: Rec1 f p -> Rec1 f p -> Rec1 f p #
Ord (URec (Ptr ()) p)	Since: base-4.9.0.0
Instance details Defined in GHC.Generics Methods compare :: URec (Ptr ()) p -> URec (Ptr ()) p -> Ordering # (<) :: URec (Ptr ()) p -> URec (Ptr ()) p -> Bool # (<=) :: URec (Ptr ()) p -> URec (Ptr ()) p -> Bool # (>) :: URec (Ptr ()) p -> URec (Ptr ()) p -> Bool # (>=) :: URec (Ptr ()) p -> URec (Ptr ()) p -> Bool # max :: URec (Ptr ()) p -> URec (Ptr ()) p -> URec (Ptr ()) p # min :: URec (Ptr ()) p -> URec (Ptr ()) p -> URec (Ptr ()) p #
Ord (URec Char p)	Since: base-4.9.0.0
Instance details Defined in GHC.Generics Methods compare :: URec Char p -> URec Char p -> Ordering # (<) :: URec Char p -> URec Char p -> Bool # (<=) :: URec Char p -> URec Char p -> Bool # (>) :: URec Char p -> URec Char p -> Bool # (>=) :: URec Char p -> URec Char p -> Bool # max :: URec Char p -> URec Char p -> URec Char p # min :: URec Char p -> URec Char p -> URec Char p #
Ord (URec Double p)	Since: base-4.9.0.0
Instance details Defined in GHC.Generics Methods compare :: URec Double p -> URec Double p -> Ordering # (<) :: URec Double p -> URec Double p -> Bool # (<=) :: URec Double p -> URec Double p -> Bool # (>) :: URec Double p -> URec Double p -> Bool # (>=) :: URec Double p -> URec Double p -> Bool # max :: URec Double p -> URec Double p -> URec Double p # min :: URec Double p -> URec Double p -> URec Double p #
Ord (URec Float p)
Instance details Defined in GHC.Generics Methods compare :: URec Float p -> URec Float p -> Ordering # (<) :: URec Float p -> URec Float p -> Bool # (<=) :: URec Float p -> URec Float p -> Bool # (>) :: URec Float p -> URec Float p -> Bool # (>=) :: URec Float p -> URec Float p -> Bool # max :: URec Float p -> URec Float p -> URec Float p # min :: URec Float p -> URec Float p -> URec Float p #
Ord (URec Int p)	Since: base-4.9.0.0
Instance details Defined in GHC.Generics Methods compare :: URec Int p -> URec Int p -> Ordering # (<) :: URec Int p -> URec Int p -> Bool # (<=) :: URec Int p -> URec Int p -> Bool # (>) :: URec Int p -> URec Int p -> Bool # (>=) :: URec Int p -> URec Int p -> Bool # max :: URec Int p -> URec Int p -> URec Int p # min :: URec Int p -> URec Int p -> URec Int p #
Ord (URec Word p)	Since: base-4.9.0.0
Instance details Defined in GHC.Generics Methods compare :: URec Word p -> URec Word p -> Ordering # (<) :: URec Word p -> URec Word p -> Bool # (<=) :: URec Word p -> URec Word p -> Bool # (>) :: URec Word p -> URec Word p -> Bool # (>=) :: URec Word p -> URec Word p -> Bool # max :: URec Word p -> URec Word p -> URec Word p # min :: URec Word p -> URec Word p -> URec Word p #
(Ord a, Ord b, Ord c) => Ord (a, b, c)
Instance details Defined in GHC.Classes Methods compare :: (a, b, c) -> (a, b, c) -> Ordering # (<) :: (a, b, c) -> (a, b, c) -> Bool # (<=) :: (a, b, c) -> (a, b, c) -> Bool # (>) :: (a, b, c) -> (a, b, c) -> Bool # (>=) :: (a, b, c) -> (a, b, c) -> Bool # max :: (a, b, c) -> (a, b, c) -> (a, b, c) # min :: (a, b, c) -> (a, b, c) -> (a, b, c) #
(Ord1 f, Ord1 g, Ord a) => Ord (Product f g a)	Since: base-4.9.0.0
Instance details Defined in Data.Functor.Product Methods compare :: Product f g a -> Product f g a -> Ordering # (<) :: Product f g a -> Product f g a -> Bool # (<=) :: Product f g a -> Product f g a -> Bool # (>) :: Product f g a -> Product f g a -> Bool # (>=) :: Product f g a -> Product f g a -> Bool # max :: Product f g a -> Product f g a -> Product f g a # min :: Product f g a -> Product f g a -> Product f g a #
(Ord1 f, Ord1 g, Ord a) => Ord (Sum f g a)	Since: base-4.9.0.0
Instance details Defined in Data.Functor.Sum Methods compare :: Sum f g a -> Sum f g a -> Ordering # (<) :: Sum f g a -> Sum f g a -> Bool # (<=) :: Sum f g a -> Sum f g a -> Bool # (>) :: Sum f g a -> Sum f g a -> Bool # (>=) :: Sum f g a -> Sum f g a -> Bool # max :: Sum f g a -> Sum f g a -> Sum f g a # min :: Sum f g a -> Sum f g a -> Sum f g a #
Ord (a :~~: b)	Since: base-4.10.0.0
Instance details Defined in Data.Type.Equality Methods compare :: (a :~~: b) -> (a :~~: b) -> Ordering # (<) :: (a :~~: b) -> (a :~~: b) -> Bool # (<=) :: (a :~~: b) -> (a :~~: b) -> Bool # (>) :: (a :~~: b) -> (a :~~: b) -> Bool # (>=) :: (a :~~: b) -> (a :~~: b) -> Bool # max :: (a :~~: b) -> (a :~~: b) -> a :~~: b # min :: (a :~~: b) -> (a :~~: b) -> a :~~: b #
(Ord (f p), Ord (g p)) => Ord ((f :*: g) p)	Since: base-4.7.0.0
Instance details Defined in GHC.Generics Methods compare :: (f :: g) p -> (f :: g) p -> Ordering # (<) :: (f :: g) p -> (f :: g) p -> Bool # (<=) :: (f :: g) p -> (f :: g) p -> Bool # (>) :: (f :: g) p -> (f :: g) p -> Bool # (>=) :: (f :: g) p -> (f :: g) p -> Bool # max :: (f :: g) p -> (f :: g) p -> (f :: g) p # min :: (f :: g) p -> (f :: g) p -> (f :: g) p #
(Ord (f p), Ord (g p)) => Ord ((f :+: g) p)	Since: base-4.7.0.0
Instance details Defined in GHC.Generics Methods compare :: (f :+: g) p -> (f :+: g) p -> Ordering # (<) :: (f :+: g) p -> (f :+: g) p -> Bool # (<=) :: (f :+: g) p -> (f :+: g) p -> Bool # (>) :: (f :+: g) p -> (f :+: g) p -> Bool # (>=) :: (f :+: g) p -> (f :+: g) p -> Bool # max :: (f :+: g) p -> (f :+: g) p -> (f :+: g) p # min :: (f :+: g) p -> (f :+: g) p -> (f :+: g) p #
Ord c => Ord (K1 i c p)	Since: base-4.7.0.0
Instance details Defined in GHC.Generics Methods compare :: K1 i c p -> K1 i c p -> Ordering # (<) :: K1 i c p -> K1 i c p -> Bool # (<=) :: K1 i c p -> K1 i c p -> Bool # (>) :: K1 i c p -> K1 i c p -> Bool # (>=) :: K1 i c p -> K1 i c p -> Bool # max :: K1 i c p -> K1 i c p -> K1 i c p # min :: K1 i c p -> K1 i c p -> K1 i c p #
(Ord a, Ord b, Ord c, Ord d) => Ord (a, b, c, d)
Instance details Defined in GHC.Classes Methods compare :: (a, b, c, d) -> (a, b, c, d) -> Ordering # (<) :: (a, b, c, d) -> (a, b, c, d) -> Bool # (<=) :: (a, b, c, d) -> (a, b, c, d) -> Bool # (>) :: (a, b, c, d) -> (a, b, c, d) -> Bool # (>=) :: (a, b, c, d) -> (a, b, c, d) -> Bool # max :: (a, b, c, d) -> (a, b, c, d) -> (a, b, c, d) # min :: (a, b, c, d) -> (a, b, c, d) -> (a, b, c, d) #
(Ord1 f, Ord1 g, Ord a) => Ord (Compose f g a)	Since: base-4.9.0.0
Instance details Defined in Data.Functor.Compose Methods compare :: Compose f g a -> Compose f g a -> Ordering # (<) :: Compose f g a -> Compose f g a -> Bool # (<=) :: Compose f g a -> Compose f g a -> Bool # (>) :: Compose f g a -> Compose f g a -> Bool # (>=) :: Compose f g a -> Compose f g a -> Bool # max :: Compose f g a -> Compose f g a -> Compose f g a # min :: Compose f g a -> Compose f g a -> Compose f g a #
Ord (f (g p)) => Ord ((f :.: g) p)	Since: base-4.7.0.0
Instance details Defined in GHC.Generics Methods compare :: (f :.: g) p -> (f :.: g) p -> Ordering # (<) :: (f :.: g) p -> (f :.: g) p -> Bool # (<=) :: (f :.: g) p -> (f :.: g) p -> Bool # (>) :: (f :.: g) p -> (f :.: g) p -> Bool # (>=) :: (f :.: g) p -> (f :.: g) p -> Bool # max :: (f :.: g) p -> (f :.: g) p -> (f :.: g) p # min :: (f :.: g) p -> (f :.: g) p -> (f :.: g) p #
Ord (f p) => Ord (M1 i c f p)	Since: base-4.7.0.0
Instance details Defined in GHC.Generics Methods compare :: M1 i c f p -> M1 i c f p -> Ordering # (<) :: M1 i c f p -> M1 i c f p -> Bool # (<=) :: M1 i c f p -> M1 i c f p -> Bool # (>) :: M1 i c f p -> M1 i c f p -> Bool # (>=) :: M1 i c f p -> M1 i c f p -> Bool # max :: M1 i c f p -> M1 i c f p -> M1 i c f p # min :: M1 i c f p -> M1 i c f p -> M1 i c f p #
(Ord a, Ord b, Ord c, Ord d, Ord e) => Ord (a, b, c, d, e)
Instance details Defined in GHC.Classes Methods compare :: (a, b, c, d, e) -> (a, b, c, d, e) -> Ordering # (<) :: (a, b, c, d, e) -> (a, b, c, d, e) -> Bool # (<=) :: (a, b, c, d, e) -> (a, b, c, d, e) -> Bool # (>) :: (a, b, c, d, e) -> (a, b, c, d, e) -> Bool # (>=) :: (a, b, c, d, e) -> (a, b, c, d, e) -> Bool # max :: (a, b, c, d, e) -> (a, b, c, d, e) -> (a, b, c, d, e) # min :: (a, b, c, d, e) -> (a, b, c, d, e) -> (a, b, c, d, e) #
(Ord a, Ord b, Ord c, Ord d, Ord e, Ord f) => Ord (a, b, c, d, e, f)
Instance details Defined in GHC.Classes Methods compare :: (a, b, c, d, e, f) -> (a, b, c, d, e, f) -> Ordering # (<) :: (a, b, c, d, e, f) -> (a, b, c, d, e, f) -> Bool # (<=) :: (a, b, c, d, e, f) -> (a, b, c, d, e, f) -> Bool # (>) :: (a, b, c, d, e, f) -> (a, b, c, d, e, f) -> Bool # (>=) :: (a, b, c, d, e, f) -> (a, b, c, d, e, f) -> Bool # max :: (a, b, c, d, e, f) -> (a, b, c, d, e, f) -> (a, b, c, d, e, f) # min :: (a, b, c, d, e, f) -> (a, b, c, d, e, f) -> (a, b, c, d, e, f) #
(Ord a, Ord b, Ord c, Ord d, Ord e, Ord f, Ord g) => Ord (a, b, c, d, e, f, g)
Instance details Defined in GHC.Classes Methods compare :: (a, b, c, d, e, f, g) -> (a, b, c, d, e, f, g) -> Ordering # (<) :: (a, b, c, d, e, f, g) -> (a, b, c, d, e, f, g) -> Bool # (<=) :: (a, b, c, d, e, f, g) -> (a, b, c, d, e, f, g) -> Bool # (>) :: (a, b, c, d, e, f, g) -> (a, b, c, d, e, f, g) -> Bool # (>=) :: (a, b, c, d, e, f, g) -> (a, b, c, d, e, f, g) -> Bool # max :: (a, b, c, d, e, f, g) -> (a, b, c, d, e, f, g) -> (a, b, c, d, e, f, g) # min :: (a, b, c, d, e, f, g) -> (a, b, c, d, e, f, g) -> (a, b, c, d, e, f, g) #
(Ord a, Ord b, Ord c, Ord d, Ord e, Ord f, Ord g, Ord h) => Ord (a, b, c, d, e, f, g, h)
Instance details Defined in GHC.Classes Methods compare :: (a, b, c, d, e, f, g, h) -> (a, b, c, d, e, f, g, h) -> Ordering # (<) :: (a, b, c, d, e, f, g, h) -> (a, b, c, d, e, f, g, h) -> Bool # (<=) :: (a, b, c, d, e, f, g, h) -> (a, b, c, d, e, f, g, h) -> Bool # (>) :: (a, b, c, d, e, f, g, h) -> (a, b, c, d, e, f, g, h) -> Bool # (>=) :: (a, b, c, d, e, f, g, h) -> (a, b, c, d, e, f, g, h) -> Bool # max :: (a, b, c, d, e, f, g, h) -> (a, b, c, d, e, f, g, h) -> (a, b, c, d, e, f, g, h) # min :: (a, b, c, d, e, f, g, h) -> (a, b, c, d, e, f, g, h) -> (a, b, c, d, e, f, g, h) #
(Ord a, Ord b, Ord c, Ord d, Ord e, Ord f, Ord g, Ord h, Ord i) => Ord (a, b, c, d, e, f, g, h, i)
Instance details Defined in GHC.Classes Methods compare :: (a, b, c, d, e, f, g, h, i) -> (a, b, c, d, e, f, g, h, i) -> Ordering # (<) :: (a, b, c, d, e, f, g, h, i) -> (a, b, c, d, e, f, g, h, i) -> Bool # (<=) :: (a, b, c, d, e, f, g, h, i) -> (a, b, c, d, e, f, g, h, i) -> Bool # (>) :: (a, b, c, d, e, f, g, h, i) -> (a, b, c, d, e, f, g, h, i) -> Bool # (>=) :: (a, b, c, d, e, f, g, h, i) -> (a, b, c, d, e, f, g, h, i) -> Bool # max :: (a, b, c, d, e, f, g, h, i) -> (a, b, c, d, e, f, g, h, i) -> (a, b, c, d, e, f, g, h, i) # min :: (a, b, c, d, e, f, g, h, i) -> (a, b, c, d, e, f, g, h, i) -> (a, b, c, d, e, f, g, h, i) #
(Ord a, Ord b, Ord c, Ord d, Ord e, Ord f, Ord g, Ord h, Ord i, Ord j) => Ord (a, b, c, d, e, f, g, h, i, j)
Instance details Defined in GHC.Classes Methods compare :: (a, b, c, d, e, f, g, h, i, j) -> (a, b, c, d, e, f, g, h, i, j) -> Ordering # (<) :: (a, b, c, d, e, f, g, h, i, j) -> (a, b, c, d, e, f, g, h, i, j) -> Bool # (<=) :: (a, b, c, d, e, f, g, h, i, j) -> (a, b, c, d, e, f, g, h, i, j) -> Bool # (>) :: (a, b, c, d, e, f, g, h, i, j) -> (a, b, c, d, e, f, g, h, i, j) -> Bool # (>=) :: (a, b, c, d, e, f, g, h, i, j) -> (a, b, c, d, e, f, g, h, i, j) -> Bool # max :: (a, b, c, d, e, f, g, h, i, j) -> (a, b, c, d, e, f, g, h, i, j) -> (a, b, c, d, e, f, g, h, i, j) # min :: (a, b, c, d, e, f, g, h, i, j) -> (a, b, c, d, e, f, g, h, i, j) -> (a, b, c, d, e, f, g, h, i, j) #
(Ord a, Ord b, Ord c, Ord d, Ord e, Ord f, Ord g, Ord h, Ord i, Ord j, Ord k) => Ord (a, b, c, d, e, f, g, h, i, j, k)
Instance details Defined in GHC.Classes Methods compare :: (a, b, c, d, e, f, g, h, i, j, k) -> (a, b, c, d, e, f, g, h, i, j, k) -> Ordering # (<) :: (a, b, c, d, e, f, g, h, i, j, k) -> (a, b, c, d, e, f, g, h, i, j, k) -> Bool # (<=) :: (a, b, c, d, e, f, g, h, i, j, k) -> (a, b, c, d, e, f, g, h, i, j, k) -> Bool # (>) :: (a, b, c, d, e, f, g, h, i, j, k) -> (a, b, c, d, e, f, g, h, i, j, k) -> Bool # (>=) :: (a, b, c, d, e, f, g, h, i, j, k) -> (a, b, c, d, e, f, g, h, i, j, k) -> Bool # max :: (a, b, c, d, e, f, g, h, i, j, k) -> (a, b, c, d, e, f, g, h, i, j, k) -> (a, b, c, d, e, f, g, h, i, j, k) # min :: (a, b, c, d, e, f, g, h, i, j, k) -> (a, b, c, d, e, f, g, h, i, j, k) -> (a, b, c, d, e, f, g, h, i, j, k) #
(Ord a, Ord b, Ord c, Ord d, Ord e, Ord f, Ord g, Ord h, Ord i, Ord j, Ord k, Ord l) => Ord (a, b, c, d, e, f, g, h, i, j, k, l)
Instance details Defined in GHC.Classes Methods compare :: (a, b, c, d, e, f, g, h, i, j, k, l) -> (a, b, c, d, e, f, g, h, i, j, k, l) -> Ordering # (<) :: (a, b, c, d, e, f, g, h, i, j, k, l) -> (a, b, c, d, e, f, g, h, i, j, k, l) -> Bool # (<=) :: (a, b, c, d, e, f, g, h, i, j, k, l) -> (a, b, c, d, e, f, g, h, i, j, k, l) -> Bool # (>) :: (a, b, c, d, e, f, g, h, i, j, k, l) -> (a, b, c, d, e, f, g, h, i, j, k, l) -> Bool # (>=) :: (a, b, c, d, e, f, g, h, i, j, k, l) -> (a, b, c, d, e, f, g, h, i, j, k, l) -> Bool # max :: (a, b, c, d, e, f, g, h, i, j, k, l) -> (a, b, c, d, e, f, g, h, i, j, k, l) -> (a, b, c, d, e, f, g, h, i, j, k, l) # min :: (a, b, c, d, e, f, g, h, i, j, k, l) -> (a, b, c, d, e, f, g, h, i, j, k, l) -> (a, b, c, d, e, f, g, h, i, j, k, l) #
(Ord a, Ord b, Ord c, Ord d, Ord e, Ord f, Ord g, Ord h, Ord i, Ord j, Ord k, Ord l, Ord m) => Ord (a, b, c, d, e, f, g, h, i, j, k, l, m)
Instance details Defined in GHC.Classes Methods compare :: (a, b, c, d, e, f, g, h, i, j, k, l, m) -> (a, b, c, d, e, f, g, h, i, j, k, l, m) -> Ordering # (<) :: (a, b, c, d, e, f, g, h, i, j, k, l, m) -> (a, b, c, d, e, f, g, h, i, j, k, l, m) -> Bool # (<=) :: (a, b, c, d, e, f, g, h, i, j, k, l, m) -> (a, b, c, d, e, f, g, h, i, j, k, l, m) -> Bool # (>) :: (a, b, c, d, e, f, g, h, i, j, k, l, m) -> (a, b, c, d, e, f, g, h, i, j, k, l, m) -> Bool # (>=) :: (a, b, c, d, e, f, g, h, i, j, k, l, m) -> (a, b, c, d, e, f, g, h, i, j, k, l, m) -> Bool # max :: (a, b, c, d, e, f, g, h, i, j, k, l, m) -> (a, b, c, d, e, f, g, h, i, j, k, l, m) -> (a, b, c, d, e, f, g, h, i, j, k, l, m) # min :: (a, b, c, d, e, f, g, h, i, j, k, l, m) -> (a, b, c, d, e, f, g, h, i, j, k, l, m) -> (a, b, c, d, e, f, g, h, i, j, k, l, m) #
(Ord a, Ord b, Ord c, Ord d, Ord e, Ord f, Ord g, Ord h, Ord i, Ord j, Ord k, Ord l, Ord m, Ord n) => Ord (a, b, c, d, e, f, g, h, i, j, k, l, m, n)
Instance details Defined in GHC.Classes Methods compare :: (a, b, c, d, e, f, g, h, i, j, k, l, m, n) -> (a, b, c, d, e, f, g, h, i, j, k, l, m, n) -> Ordering # (<) :: (a, b, c, d, e, f, g, h, i, j, k, l, m, n) -> (a, b, c, d, e, f, g, h, i, j, k, l, m, n) -> Bool # (<=) :: (a, b, c, d, e, f, g, h, i, j, k, l, m, n) -> (a, b, c, d, e, f, g, h, i, j, k, l, m, n) -> Bool # (>) :: (a, b, c, d, e, f, g, h, i, j, k, l, m, n) -> (a, b, c, d, e, f, g, h, i, j, k, l, m, n) -> Bool # (>=) :: (a, b, c, d, e, f, g, h, i, j, k, l, m, n) -> (a, b, c, d, e, f, g, h, i, j, k, l, m, n) -> Bool # max :: (a, b, c, d, e, f, g, h, i, j, k, l, m, n) -> (a, b, c, d, e, f, g, h, i, j, k, l, m, n) -> (a, b, c, d, e, f, g, h, i, j, k, l, m, n) # min :: (a, b, c, d, e, f, g, h, i, j, k, l, m, n) -> (a, b, c, d, e, f, g, h, i, j, k, l, m, n) -> (a, b, c, d, e, f, g, h, i, j, k, l, m, n) #
(Ord a, Ord b, Ord c, Ord d, Ord e, Ord f, Ord g, Ord h, Ord i, Ord j, Ord k, Ord l, Ord m, Ord n, Ord o) => Ord (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o)
Instance details Defined in GHC.Classes Methods compare :: (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o) -> (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o) -> Ordering # (<) :: (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o) -> (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o) -> Bool # (<=) :: (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o) -> (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o) -> Bool # (>) :: (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o) -> (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o) -> Bool # (>=) :: (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o) -> (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o) -> Bool # max :: (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o) -> (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o) -> (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o) # min :: (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o) -> (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o) -> (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o) #

data Ordering #

Constructors

LT
EQ
GT

Instances

Instances details

Monoid Ordering	Since: base-2.1
Instance details Defined in GHC.Base Methods mempty :: Ordering # mappend :: Ordering -> Ordering -> Ordering # mconcat :: [Ordering] -> Ordering #
Semigroup Ordering	Since: base-4.9.0.0
Instance details Defined in GHC.Base Methods (<>) :: Ordering -> Ordering -> Ordering # sconcat :: NonEmpty Ordering -> Ordering # stimes :: Integral b => b -> Ordering -> Ordering #
Bounded Ordering	Since: base-2.1
Instance details Defined in GHC.Enum Methods minBound :: Ordering # maxBound :: Ordering #
Enum Ordering	Since: base-2.1
Instance details Defined in GHC.Enum Methods succ :: Ordering -> Ordering # pred :: Ordering -> Ordering # toEnum :: Int -> Ordering # fromEnum :: Ordering -> Int # enumFrom :: Ordering -> [Ordering] # enumFromThen :: Ordering -> Ordering -> [Ordering] # enumFromTo :: Ordering -> Ordering -> [Ordering] # enumFromThenTo :: Ordering -> Ordering -> Ordering -> [Ordering] #
Generic Ordering
Instance details Defined in GHC.Generics Associated Types type Rep Ordering :: Type -> Type # Methods from :: Ordering -> Rep Ordering x # to :: Rep Ordering x -> Ordering #
Read Ordering	Since: base-2.1
Instance details Defined in GHC.Read Methods readsPrec :: Int -> ReadS Ordering # readList :: ReadS [Ordering] # readPrec :: ReadPrec Ordering # readListPrec :: ReadPrec [Ordering] #
Show Ordering	Since: base-2.1
Instance details Defined in GHC.Show Methods showsPrec :: Int -> Ordering -> ShowS # show :: Ordering -> String # showList :: [Ordering] -> ShowS #
Default Ordering
Instance details Defined in Data.Default.Class Methods def :: Ordering #
Eq Ordering
Instance details Defined in GHC.Classes Methods (==) :: Ordering -> Ordering -> Bool # (/=) :: Ordering -> Ordering -> Bool #
Ord Ordering
Instance details Defined in GHC.Classes Methods compare :: Ordering -> Ordering -> Ordering # (<) :: Ordering -> Ordering -> Bool # (<=) :: Ordering -> Ordering -> Bool # (>) :: Ordering -> Ordering -> Bool # (>=) :: Ordering -> Ordering -> Bool # max :: Ordering -> Ordering -> Ordering # min :: Ordering -> Ordering -> Ordering #
type Rep Ordering	Since: base-4.6.0.0
Instance details Defined in GHC.Generics type Rep Ordering = D1 ('MetaData "Ordering" "GHC.Types" "ghc-prim" 'False) (C1 ('MetaCons "LT" 'PrefixI 'False) (U1 :: Type -> Type) :+: (C1 ('MetaCons "EQ" 'PrefixI 'False) (U1 :: Type -> Type) :+: C1 ('MetaCons "GT" 'PrefixI 'False) (U1 :: Type -> Type)))

newtype Down a #

The Down type allows you to reverse sort order conveniently. A value of type Down a contains a value of type a (represented as Down a).

If a has an Ord instance associated with it then comparing two values thus wrapped will give you the opposite of their normal sort order. This is particularly useful when sorting in generalised list comprehensions, as in: then sortWith by Down x.

>>> compare True False
GT

>>> compare (Down True) (Down False)
LT

If a has a Bounded instance then the wrapped instance also respects the reversed ordering by exchanging the values of minBound and maxBound.

>>> minBound :: Int
-9223372036854775808

>>> minBound :: Down Int
Down 9223372036854775807

All other instances of Down a behave as they do for a.

Since: base-4.6.0.0

Constructors

Down
Fields getDown :: a Since: base-4.14.0.0

Instances

Instances details

Foldable Down	Since: base-4.12.0.0
Instance details Defined in Data.Foldable Methods fold :: Monoid m => Down m -> m # foldMap :: Monoid m => (a -> m) -> Down a -> m # foldMap' :: Monoid m => (a -> m) -> Down a -> m # foldr :: (a -> b -> b) -> b -> Down a -> b # foldr' :: (a -> b -> b) -> b -> Down a -> b # foldl :: (b -> a -> b) -> b -> Down a -> b # foldl' :: (b -> a -> b) -> b -> Down a -> b # foldr1 :: (a -> a -> a) -> Down a -> a # foldl1 :: (a -> a -> a) -> Down a -> a # toList :: Down a -> [a] # null :: Down a -> Bool # length :: Down a -> Int # elem :: Eq a => a -> Down a -> Bool # maximum :: Ord a => Down a -> a # minimum :: Ord a => Down a -> a # sum :: Num a => Down a -> a # product :: Num a => Down a -> a #
Traversable Down	Since: base-4.12.0.0
Instance details Defined in Data.Traversable Methods traverse :: Applicative f => (a -> f b) -> Down a -> f (Down b) # sequenceA :: Applicative f => Down (f a) -> f (Down a) # mapM :: Monad m => (a -> m b) -> Down a -> m (Down b) # sequence :: Monad m => Down (m a) -> m (Down a) #
Applicative Down	Since: base-4.11.0.0
Instance details Defined in Data.Ord Methods pure :: a -> Down a # (<>) :: Down (a -> b) -> Down a -> Down b # liftA2 :: (a -> b -> c) -> Down a -> Down b -> Down c # (>) :: Down a -> Down b -> Down b # (<*) :: Down a -> Down b -> Down a #
Functor Down	Since: base-4.11.0.0
Instance details Defined in Data.Ord Methods fmap :: (a -> b) -> Down a -> Down b # (<$) :: a -> Down b -> Down a #
Monad Down	Since: base-4.11.0.0
Instance details Defined in Data.Ord Methods (>>=) :: Down a -> (a -> Down b) -> Down b # (>>) :: Down a -> Down b -> Down b # return :: a -> Down a #
Bits a => Bits (Down a)	Since: base-4.14.0.0
Instance details Defined in Data.Ord Methods (.&.) :: Down a -> Down a -> Down a # (.\|.) :: Down a -> Down a -> Down a # xor :: Down a -> Down a -> Down a # complement :: Down a -> Down a # shift :: Down a -> Int -> Down a # rotate :: Down a -> Int -> Down a # zeroBits :: Down a # bit :: Int -> Down a # setBit :: Down a -> Int -> Down a # clearBit :: Down a -> Int -> Down a # complementBit :: Down a -> Int -> Down a # testBit :: Down a -> Int -> Bool # bitSizeMaybe :: Down a -> Maybe Int # bitSize :: Down a -> Int # isSigned :: Down a -> Bool # shiftL :: Down a -> Int -> Down a # unsafeShiftL :: Down a -> Int -> Down a # shiftR :: Down a -> Int -> Down a # unsafeShiftR :: Down a -> Int -> Down a # rotateL :: Down a -> Int -> Down a # rotateR :: Down a -> Int -> Down a # popCount :: Down a -> Int #
FiniteBits a => FiniteBits (Down a)	Since: base-4.14.0.0
Instance details Defined in Data.Ord Methods finiteBitSize :: Down a -> Int # countLeadingZeros :: Down a -> Int # countTrailingZeros :: Down a -> Int #
Storable a => Storable (Down a)	Since: base-4.14.0.0
Instance details Defined in Data.Ord Methods sizeOf :: Down a -> Int # alignment :: Down a -> Int # peekElemOff :: Ptr (Down a) -> Int -> IO (Down a) # pokeElemOff :: Ptr (Down a) -> Int -> Down a -> IO () # peekByteOff :: Ptr b -> Int -> IO (Down a) # pokeByteOff :: Ptr b -> Int -> Down a -> IO () # peek :: Ptr (Down a) -> IO (Down a) # poke :: Ptr (Down a) -> Down a -> IO () #
Monoid a => Monoid (Down a)	Since: base-4.11.0.0
Instance details Defined in Data.Ord Methods mempty :: Down a # mappend :: Down a -> Down a -> Down a # mconcat :: [Down a] -> Down a #
Semigroup a => Semigroup (Down a)	Since: base-4.11.0.0
Instance details Defined in Data.Ord Methods (<>) :: Down a -> Down a -> Down a # sconcat :: NonEmpty (Down a) -> Down a # stimes :: Integral b => b -> Down a -> Down a #
Bounded a => Bounded (Down a)	Swaps `minBound` and `maxBound` of the underlying type. Since: base-4.14.0.0
Instance details Defined in Data.Ord Methods minBound :: Down a # maxBound :: Down a #
Floating a => Floating (Down a)	Since: base-4.14.0.0
Instance details Defined in Data.Ord Methods pi :: Down a # exp :: Down a -> Down a # log :: Down a -> Down a # sqrt :: Down a -> Down a # (**) :: Down a -> Down a -> Down a # logBase :: Down a -> Down a -> Down a # sin :: Down a -> Down a # cos :: Down a -> Down a # tan :: Down a -> Down a # asin :: Down a -> Down a # acos :: Down a -> Down a # atan :: Down a -> Down a # sinh :: Down a -> Down a # cosh :: Down a -> Down a # tanh :: Down a -> Down a # asinh :: Down a -> Down a # acosh :: Down a -> Down a # atanh :: Down a -> Down a # log1p :: Down a -> Down a # expm1 :: Down a -> Down a # log1pexp :: Down a -> Down a # log1mexp :: Down a -> Down a #
RealFloat a => RealFloat (Down a)	Since: base-4.14.0.0
Instance details Defined in Data.Ord Methods floatRadix :: Down a -> Integer # floatDigits :: Down a -> Int # floatRange :: Down a -> (Int, Int) # decodeFloat :: Down a -> (Integer, Int) # encodeFloat :: Integer -> Int -> Down a # exponent :: Down a -> Int # significand :: Down a -> Down a # scaleFloat :: Int -> Down a -> Down a # isNaN :: Down a -> Bool # isInfinite :: Down a -> Bool # isDenormalized :: Down a -> Bool # isNegativeZero :: Down a -> Bool # isIEEE :: Down a -> Bool # atan2 :: Down a -> Down a -> Down a #
Generic (Down a)
Instance details Defined in GHC.Generics Associated Types type Rep (Down a) :: Type -> Type # Methods from :: Down a -> Rep (Down a) x # to :: Rep (Down a) x -> Down a #
Ix a => Ix (Down a)	Since: base-4.14.0.0
Instance details Defined in Data.Ord Methods range :: (Down a, Down a) -> [Down a] # index :: (Down a, Down a) -> Down a -> Int # unsafeIndex :: (Down a, Down a) -> Down a -> Int # inRange :: (Down a, Down a) -> Down a -> Bool # rangeSize :: (Down a, Down a) -> Int # unsafeRangeSize :: (Down a, Down a) -> Int #
Num a => Num (Down a)	Since: base-4.11.0.0
Instance details Defined in Data.Ord Methods (+) :: Down a -> Down a -> Down a # (-) :: Down a -> Down a -> Down a # (*) :: Down a -> Down a -> Down a # negate :: Down a -> Down a # abs :: Down a -> Down a # signum :: Down a -> Down a # fromInteger :: Integer -> Down a #
Read a => Read (Down a)	This instance would be equivalent to the derived instances of the `Down` newtype if the `getDown` field were removed Since: base-4.7.0.0
Instance details Defined in Data.Ord Methods readsPrec :: Int -> ReadS (Down a) # readList :: ReadS [Down a] # readPrec :: ReadPrec (Down a) # readListPrec :: ReadPrec [Down a] #
Fractional a => Fractional (Down a)	Since: base-4.14.0.0
Instance details Defined in Data.Ord Methods (/) :: Down a -> Down a -> Down a # recip :: Down a -> Down a # fromRational :: Rational -> Down a #
Real a => Real (Down a)	Since: base-4.14.0.0
Instance details Defined in Data.Ord Methods toRational :: Down a -> Rational #
RealFrac a => RealFrac (Down a)	Since: base-4.14.0.0
Instance details Defined in Data.Ord Methods properFraction :: Integral b => Down a -> (b, Down a) # truncate :: Integral b => Down a -> b # round :: Integral b => Down a -> b # ceiling :: Integral b => Down a -> b # floor :: Integral b => Down a -> b #
Show a => Show (Down a)	This instance would be equivalent to the derived instances of the `Down` newtype if the `getDown` field were removed Since: base-4.7.0.0
Instance details Defined in Data.Ord Methods showsPrec :: Int -> Down a -> ShowS # show :: Down a -> String # showList :: [Down a] -> ShowS #
Eq a => Eq (Down a)	Since: base-4.6.0.0
Instance details Defined in Data.Ord Methods (==) :: Down a -> Down a -> Bool # (/=) :: Down a -> Down a -> Bool #
Ord a => Ord (Down a)	Since: base-4.6.0.0
Instance details Defined in Data.Ord Methods compare :: Down a -> Down a -> Ordering # (<) :: Down a -> Down a -> Bool # (<=) :: Down a -> Down a -> Bool # (>) :: Down a -> Down a -> Bool # (>=) :: Down a -> Down a -> Bool # max :: Down a -> Down a -> Down a # min :: Down a -> Down a -> Down a #
Generic1 Down
Instance details Defined in GHC.Generics Associated Types type Rep1 Down :: k -> Type # Methods from1 :: forall (a :: k). Down a -> Rep1 Down a # to1 :: forall (a :: k). Rep1 Down a -> Down a #
type Rep (Down a)	Since: base-4.12.0.0
Instance details Defined in GHC.Generics type Rep (Down a) = D1 ('MetaData "Down" "Data.Ord" "base" 'True) (C1 ('MetaCons "Down" 'PrefixI 'True) (S1 ('MetaSel ('Just "getDown") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 a)))
type Rep1 Down	Since: base-4.12.0.0
Instance details Defined in GHC.Generics type Rep1 Down = D1 ('MetaData "Down" "Data.Ord" "base" 'True) (C1 ('MetaCons "Down" 'PrefixI 'True) (S1 ('MetaSel ('Just "getDown") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) Par1))

comparing :: Ord a => (b -> a) -> b -> b -> Ordering #

comparing p x y = compare (p x) (p y)

Useful combinator for use in conjunction with the xxxBy family of functions from Data.List, for example:

  ... sortBy (comparing fst) ...

data Proxy (t :: k) #

Proxy is a type that holds no data, but has a phantom parameter of arbitrary type (or even kind). Its use is to provide type information, even though there is no value available of that type (or it may be too costly to create one).

Historically, Proxy :: Proxy a is a safer alternative to the undefined :: a idiom.

>>> Proxy :: Proxy (Void, Int -> Int)
Proxy

Proxy can even hold types of higher kinds,

>>> Proxy :: Proxy Either
Proxy

>>> Proxy :: Proxy Functor
Proxy

>>> Proxy :: Proxy complicatedStructure
Proxy

Constructors

Proxy

Instances

Instances details

Generic1 (Proxy :: k -> Type)
Instance details Defined in GHC.Generics Associated Types type Rep1 Proxy :: k -> Type # Methods from1 :: forall (a :: k0). Proxy a -> Rep1 Proxy a # to1 :: forall (a :: k0). Rep1 Proxy a -> Proxy a #
Foldable (Proxy :: Type -> Type)	Since: base-4.7.0.0
Instance details Defined in Data.Foldable Methods fold :: Monoid m => Proxy m -> m # foldMap :: Monoid m => (a -> m) -> Proxy a -> m # foldMap' :: Monoid m => (a -> m) -> Proxy a -> m # foldr :: (a -> b -> b) -> b -> Proxy a -> b # foldr' :: (a -> b -> b) -> b -> Proxy a -> b # foldl :: (b -> a -> b) -> b -> Proxy a -> b # foldl' :: (b -> a -> b) -> b -> Proxy a -> b # foldr1 :: (a -> a -> a) -> Proxy a -> a # foldl1 :: (a -> a -> a) -> Proxy a -> a # toList :: Proxy a -> [a] # null :: Proxy a -> Bool # length :: Proxy a -> Int # elem :: Eq a => a -> Proxy a -> Bool # maximum :: Ord a => Proxy a -> a # minimum :: Ord a => Proxy a -> a # sum :: Num a => Proxy a -> a # product :: Num a => Proxy a -> a #
Contravariant (Proxy :: Type -> Type)
Instance details Defined in Data.Functor.Contravariant Methods contramap :: (a' -> a) -> Proxy a -> Proxy a' # (>$) :: b -> Proxy b -> Proxy a #
Traversable (Proxy :: Type -> Type)	Since: base-4.7.0.0
Instance details Defined in Data.Traversable Methods traverse :: Applicative f => (a -> f b) -> Proxy a -> f (Proxy b) # sequenceA :: Applicative f => Proxy (f a) -> f (Proxy a) # mapM :: Monad m => (a -> m b) -> Proxy a -> m (Proxy b) # sequence :: Monad m => Proxy (m a) -> m (Proxy a) #
Alternative (Proxy :: Type -> Type)	Since: base-4.9.0.0
Instance details Defined in Data.Proxy Methods empty :: Proxy a # (<\|>) :: Proxy a -> Proxy a -> Proxy a # some :: Proxy a -> Proxy [a] # many :: Proxy a -> Proxy [a] #
Applicative (Proxy :: Type -> Type)	Since: base-4.7.0.0
Instance details Defined in Data.Proxy Methods pure :: a -> Proxy a # (<>) :: Proxy (a -> b) -> Proxy a -> Proxy b # liftA2 :: (a -> b -> c) -> Proxy a -> Proxy b -> Proxy c # (>) :: Proxy a -> Proxy b -> Proxy b # (<*) :: Proxy a -> Proxy b -> Proxy a #
Functor (Proxy :: Type -> Type)	Since: base-4.7.0.0
Instance details Defined in Data.Proxy Methods fmap :: (a -> b) -> Proxy a -> Proxy b # (<$) :: a -> Proxy b -> Proxy a #
Monad (Proxy :: Type -> Type)	Since: base-4.7.0.0
Instance details Defined in Data.Proxy Methods (>>=) :: Proxy a -> (a -> Proxy b) -> Proxy b # (>>) :: Proxy a -> Proxy b -> Proxy b # return :: a -> Proxy a #
MonadPlus (Proxy :: Type -> Type)	Since: base-4.9.0.0
Instance details Defined in Data.Proxy Methods mzero :: Proxy a # mplus :: Proxy a -> Proxy a -> Proxy a #
Monoid (Proxy s)	Since: base-4.7.0.0
Instance details Defined in Data.Proxy Methods mempty :: Proxy s # mappend :: Proxy s -> Proxy s -> Proxy s # mconcat :: [Proxy s] -> Proxy s #
Semigroup (Proxy s)	Since: base-4.9.0.0
Instance details Defined in Data.Proxy Methods (<>) :: Proxy s -> Proxy s -> Proxy s # sconcat :: NonEmpty (Proxy s) -> Proxy s # stimes :: Integral b => b -> Proxy s -> Proxy s #
Bounded (Proxy t)	Since: base-4.7.0.0
Instance details Defined in Data.Proxy Methods minBound :: Proxy t # maxBound :: Proxy t #
Enum (Proxy s)	Since: base-4.7.0.0
Instance details Defined in Data.Proxy 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] #
Generic (Proxy t)
Instance details Defined in GHC.Generics Associated Types type Rep (Proxy t) :: Type -> Type # Methods from :: Proxy t -> Rep (Proxy t) x # to :: Rep (Proxy t) x -> Proxy t #
Ix (Proxy s)	Since: base-4.7.0.0
Instance details Defined in Data.Proxy Methods range :: (Proxy s, Proxy s) -> [Proxy s] # index :: (Proxy s, Proxy s) -> Proxy s -> Int # unsafeIndex :: (Proxy s, Proxy s) -> Proxy s -> Int # inRange :: (Proxy s, Proxy s) -> Proxy s -> Bool # rangeSize :: (Proxy s, Proxy s) -> Int # unsafeRangeSize :: (Proxy s, Proxy s) -> Int #
Read (Proxy t)	Since: base-4.7.0.0
Instance details Defined in Data.Proxy Methods readsPrec :: Int -> ReadS (Proxy t) # readList :: ReadS [Proxy t] # readPrec :: ReadPrec (Proxy t) # readListPrec :: ReadPrec [Proxy t] #
Show (Proxy s)	Since: base-4.7.0.0
Instance details Defined in Data.Proxy Methods showsPrec :: Int -> Proxy s -> ShowS # show :: Proxy s -> String # showList :: [Proxy s] -> ShowS #
Eq (Proxy s)	Since: base-4.7.0.0
Instance details Defined in Data.Proxy Methods (==) :: Proxy s -> Proxy s -> Bool # (/=) :: Proxy s -> Proxy s -> Bool #
Ord (Proxy s)	Since: base-4.7.0.0
Instance details Defined in Data.Proxy Methods compare :: Proxy s -> Proxy s -> Ordering # (<) :: Proxy s -> Proxy s -> Bool # (<=) :: Proxy s -> Proxy s -> Bool # (>) :: Proxy s -> Proxy s -> Bool # (>=) :: Proxy s -> Proxy s -> Bool # max :: Proxy s -> Proxy s -> Proxy s # min :: Proxy s -> Proxy s -> Proxy s #
type Rep1 (Proxy :: k -> Type)	Since: base-4.6.0.0
Instance details Defined in GHC.Generics type Rep1 (Proxy :: k -> Type) = D1 ('MetaData "Proxy" "Data.Proxy" "base" 'False) (C1 ('MetaCons "Proxy" 'PrefixI 'False) (U1 :: k -> Type))
type Rep (Proxy t)	Since: base-4.6.0.0
Instance details Defined in GHC.Generics type Rep (Proxy t) = D1 ('MetaData "Proxy" "Data.Proxy" "base" 'False) (C1 ('MetaCons "Proxy" 'PrefixI 'False) (U1 :: Type -> Type))

class Semigroup a where #

The class of semigroups (types with an associative binary operation).

Instances should satisfy the following:

Associativity: x <> (y <> z) = (x <> y) <> z

Since: base-4.9.0.0

Minimal complete definition

(<>)

Methods

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

An associative operation.

>>> [1,2,3] <> [4,5,6]
[1,2,3,4,5,6]

sconcat :: NonEmpty a -> a #

Reduce a non-empty list with <>

The default definition should be sufficient, but this can be overridden for efficiency.

>>> import Data.List.NonEmpty (NonEmpty (..))
>>> sconcat $ "Hello" :| [" ", "Haskell", "!"]
"Hello Haskell!"

stimes :: Integral b => b -> a -> a #

Repeat a value n times.

Given that this works on a Semigroup it is allowed to fail if you request 0 or fewer repetitions, and the default definition will do so.

By making this a member of the class, idempotent semigroups and monoids can upgrade this to execute in $\mathcal{O}(1)$ by picking stimes = stimesIdempotent or stimes = stimesIdempotentMonoid respectively.

>>> stimes 4 [1]
[1,1,1,1]

Instances

Instances details

Semigroup Void	Since: base-4.9.0.0
Instance details Defined in Data.Void Methods (<>) :: Void -> Void -> Void # sconcat :: NonEmpty Void -> Void # stimes :: Integral b => b -> Void -> Void #
Semigroup ByteString
Instance details Defined in Data.ByteString.Internal Methods (<>) :: ByteString -> ByteString -> ByteString # sconcat :: NonEmpty ByteString -> ByteString # stimes :: Integral b => b -> ByteString -> ByteString #
Semigroup ByteString
Instance details Defined in Data.ByteString.Lazy.Internal Methods (<>) :: ByteString -> ByteString -> ByteString # sconcat :: NonEmpty ByteString -> ByteString # stimes :: Integral b => b -> ByteString -> ByteString #
Semigroup ShortByteString
Instance details Defined in Data.ByteString.Short.Internal Methods (<>) :: ShortByteString -> ShortByteString -> ShortByteString # sconcat :: NonEmpty ShortByteString -> ShortByteString # stimes :: Integral b => b -> ShortByteString -> ShortByteString #
Semigroup IntSet	Since: containers-0.5.7
Instance details Defined in Data.IntSet.Internal Methods (<>) :: IntSet -> IntSet -> IntSet # sconcat :: NonEmpty IntSet -> IntSet # stimes :: Integral b => b -> IntSet -> IntSet #
Semigroup Ordering	Since: base-4.9.0.0
Instance details Defined in GHC.Base Methods (<>) :: Ordering -> Ordering -> Ordering # sconcat :: NonEmpty Ordering -> Ordering # stimes :: Integral b => b -> Ordering -> Ordering #
Semigroup ()	Since: base-4.9.0.0
Instance details Defined in GHC.Base Methods (<>) :: () -> () -> () # sconcat :: NonEmpty () -> () # stimes :: Integral b => b -> () -> () #
Semigroup (Comparison a)	`(<>)` on comparisons combines results with `(<>) @Ordering`. Without newtypes this equals `liftA2 (liftA2 (<>))`. (<>) :: Comparison a -> Comparison a -> Comparison a Comparison cmp <> Comparison cmp' = Comparison a a' -> cmp a a' <> cmp a a'
Instance details Defined in Data.Functor.Contravariant Methods (<>) :: Comparison a -> Comparison a -> Comparison a # sconcat :: NonEmpty (Comparison a) -> Comparison a # stimes :: Integral b => b -> Comparison a -> Comparison a #
Semigroup (Equivalence a)	`(<>)` on equivalences uses logical conjunction `(&&)` on the results. Without newtypes this equals `liftA2 (liftA2 (&&))`. (<>) :: Equivalence a -> Equivalence a -> Equivalence a Equivalence equiv <> Equivalence equiv' = Equivalence a b -> equiv a b && equiv a b
Instance details Defined in Data.Functor.Contravariant Methods (<>) :: Equivalence a -> Equivalence a -> Equivalence a # sconcat :: NonEmpty (Equivalence a) -> Equivalence a # stimes :: Integral b => b -> Equivalence a -> Equivalence a #
Semigroup (Predicate a)	`(<>)` on predicates uses logical conjunction `(&&)` on the results. Without newtypes this equals `liftA2 (&&)`. (<>) :: Predicate a -> Predicate a -> Predicate a Predicate pred <> Predicate pred' = Predicate a -> pred a && pred' a
Instance details Defined in Data.Functor.Contravariant Methods (<>) :: Predicate a -> Predicate a -> Predicate a # sconcat :: NonEmpty (Predicate a) -> Predicate a # stimes :: Integral b => b -> Predicate a -> Predicate a #
Semigroup a => Semigroup (Identity a)	Since: base-4.9.0.0
Instance details Defined in Data.Functor.Identity Methods (<>) :: Identity a -> Identity a -> Identity a # sconcat :: NonEmpty (Identity a) -> Identity a # stimes :: Integral b => b -> Identity a -> Identity a #
Semigroup (First a)	Since: base-4.9.0.0
Instance details Defined in Data.Monoid Methods (<>) :: First a -> First a -> First a # sconcat :: NonEmpty (First a) -> First a # stimes :: Integral b => b -> First a -> First a #
Semigroup (Last a)	Since: base-4.9.0.0
Instance details Defined in Data.Monoid Methods (<>) :: Last a -> Last a -> Last a # sconcat :: NonEmpty (Last a) -> Last a # stimes :: Integral b => b -> Last a -> Last a #
Semigroup a => Semigroup (Down a)	Since: base-4.11.0.0
Instance details Defined in Data.Ord Methods (<>) :: Down a -> Down a -> Down a # sconcat :: NonEmpty (Down a) -> Down a # stimes :: Integral b => b -> Down a -> Down a #
Semigroup (First a)	Since: base-4.9.0.0
Instance details Defined in Data.Semigroup Methods (<>) :: First a -> First a -> First a # sconcat :: NonEmpty (First a) -> First a # stimes :: Integral b => b -> First a -> First a #
Semigroup (Last a)	Since: base-4.9.0.0
Instance details Defined in Data.Semigroup Methods (<>) :: Last a -> Last a -> Last a # sconcat :: NonEmpty (Last a) -> Last a # stimes :: Integral b => b -> Last a -> Last a #
Ord a => Semigroup (Max a)	Since: base-4.9.0.0
Instance details Defined in Data.Semigroup Methods (<>) :: Max a -> Max a -> Max a # sconcat :: NonEmpty (Max a) -> Max a # stimes :: Integral b => b -> Max a -> Max a #
Ord a => Semigroup (Min a)	Since: base-4.9.0.0
Instance details Defined in Data.Semigroup Methods (<>) :: Min a -> Min a -> Min a # sconcat :: NonEmpty (Min a) -> Min a # stimes :: Integral b => b -> Min a -> Min a #
Semigroup a => Semigroup (Option a)	Since: base-4.9.0.0
Instance details Defined in Data.Semigroup Methods (<>) :: Option a -> Option a -> Option a # sconcat :: NonEmpty (Option a) -> Option a # stimes :: Integral b => b -> Option a -> Option a #
Monoid m => Semigroup (WrappedMonoid m)	Since: base-4.9.0.0
Instance details Defined in Data.Semigroup Methods (<>) :: WrappedMonoid m -> WrappedMonoid m -> WrappedMonoid m # sconcat :: NonEmpty (WrappedMonoid m) -> WrappedMonoid m # stimes :: Integral b => b -> WrappedMonoid m -> WrappedMonoid m #
Semigroup (NonEmpty a)	Since: base-4.9.0.0
Instance details Defined in GHC.Base Methods (<>) :: NonEmpty a -> NonEmpty a -> NonEmpty a # sconcat :: NonEmpty (NonEmpty a) -> NonEmpty a # stimes :: Integral b => b -> NonEmpty a -> NonEmpty a #
Semigroup p => Semigroup (Par1 p)	Since: base-4.12.0.0
Instance details Defined in GHC.Generics Methods (<>) :: Par1 p -> Par1 p -> Par1 p # sconcat :: NonEmpty (Par1 p) -> Par1 p # stimes :: Integral b => b -> Par1 p -> Par1 p #
Semigroup (IntMap a)	Since: containers-0.5.7
Instance details Defined in Data.IntMap.Internal Methods (<>) :: IntMap a -> IntMap a -> IntMap a # sconcat :: NonEmpty (IntMap a) -> IntMap a # stimes :: Integral b => b -> IntMap a -> IntMap a #
Semigroup (Seq a)	Since: containers-0.5.7
Instance details Defined in Data.Sequence.Internal Methods (<>) :: Seq a -> Seq a -> Seq a # sconcat :: NonEmpty (Seq a) -> Seq a # stimes :: Integral b => b -> Seq a -> Seq a #
Semigroup (MergeSet a)
Instance details Defined in Data.Set.Internal Methods (<>) :: MergeSet a -> MergeSet a -> MergeSet a # sconcat :: NonEmpty (MergeSet a) -> MergeSet a # stimes :: Integral b => b -> MergeSet a -> MergeSet a #
Ord a => Semigroup (Set a)	Since: containers-0.5.7
Instance details Defined in Data.Set.Internal Methods (<>) :: Set a -> Set a -> Set a # sconcat :: NonEmpty (Set a) -> Set a # stimes :: Integral b => b -> Set a -> Set a #
Semigroup (DList a)
Instance details Defined in Data.DList.Internal Methods (<>) :: DList a -> DList a -> DList a # sconcat :: NonEmpty (DList a) -> DList a # stimes :: Integral b => b -> DList a -> DList a #
Semigroup a => Semigroup (IO a)	Since: base-4.10.0.0
Instance details Defined in GHC.Base Methods (<>) :: IO a -> IO a -> IO a # sconcat :: NonEmpty (IO a) -> IO a # stimes :: Integral b => b -> IO a -> IO a #
Semigroup a => Semigroup (Q a)	Since: template-haskell-2.17.0.0
Instance details Defined in Language.Haskell.TH.Syntax Methods (<>) :: Q a -> Q a -> Q a # sconcat :: NonEmpty (Q a) -> Q a # stimes :: Integral b => b -> Q a -> Q a #
Semigroup a => Semigroup (Maybe a)	Since: base-4.9.0.0
Instance details Defined in GHC.Base Methods (<>) :: Maybe a -> Maybe a -> Maybe a # sconcat :: NonEmpty (Maybe a) -> Maybe a # stimes :: Integral b => b -> Maybe a -> Maybe a #
Semigroup a => Semigroup (a)	Since: base-4.15
Instance details Defined in GHC.Base Methods (<>) :: (a) -> (a) -> (a) # sconcat :: NonEmpty (a) -> (a) # stimes :: Integral b => b -> (a) -> (a) #
Semigroup [a]	Since: base-4.9.0.0
Instance details Defined in GHC.Base Methods (<>) :: [a] -> [a] -> [a] # sconcat :: NonEmpty [a] -> [a] # stimes :: Integral b => b -> [a] -> [a] #
Semigroup (Either a b)	Since: base-4.9.0.0
Instance details Defined in Data.Either Methods (<>) :: Either a b -> Either a b -> Either a b # sconcat :: NonEmpty (Either a b) -> Either a b # stimes :: Integral b0 => b0 -> Either a b -> Either a b #
Semigroup a => Semigroup (Op a b)	`(<>) @(Op a b)` without newtypes is `(<>) @(b->a)` = `liftA2 (<>)`. This lifts the `Semigroup` operation `(<>)` over the output of `a`. (<>) :: Op a b -> Op a b -> Op a b Op f <> Op g = Op a -> f a <> g a
Instance details Defined in Data.Functor.Contravariant Methods (<>) :: Op a b -> Op a b -> Op a b # sconcat :: NonEmpty (Op a b) -> Op a b # stimes :: Integral b0 => b0 -> Op a b -> Op a b #
Semigroup (Proxy s)	Since: base-4.9.0.0
Instance details Defined in Data.Proxy Methods (<>) :: Proxy s -> Proxy s -> Proxy s # sconcat :: NonEmpty (Proxy s) -> Proxy s # stimes :: Integral b => b -> Proxy s -> Proxy s #
Semigroup (U1 p)	Since: base-4.12.0.0
Instance details Defined in GHC.Generics Methods (<>) :: U1 p -> U1 p -> U1 p # sconcat :: NonEmpty (U1 p) -> U1 p # stimes :: Integral b => b -> U1 p -> U1 p #
Semigroup (V1 p)	Since: base-4.12.0.0
Instance details Defined in GHC.Generics Methods (<>) :: V1 p -> V1 p -> V1 p # sconcat :: NonEmpty (V1 p) -> V1 p # stimes :: Integral b => b -> V1 p -> V1 p #
Ord k => Semigroup (Map k v)
Instance details Defined in Data.Map.Internal Methods (<>) :: Map k v -> Map k v -> Map k v # sconcat :: NonEmpty (Map k v) -> Map k v # stimes :: Integral b => b -> Map k v -> Map k v #
Semigroup b => Semigroup (a -> b)	Since: base-4.9.0.0
Instance details Defined in GHC.Base Methods (<>) :: (a -> b) -> (a -> b) -> a -> b # sconcat :: NonEmpty (a -> b) -> a -> b # stimes :: Integral b0 => b0 -> (a -> b) -> a -> b #
(Semigroup a, Semigroup b) => Semigroup (a, b)	Since: base-4.9.0.0
Instance details Defined in GHC.Base Methods (<>) :: (a, b) -> (a, b) -> (a, b) # sconcat :: NonEmpty (a, b) -> (a, b) # stimes :: Integral b0 => b0 -> (a, b) -> (a, b) #
Semigroup a => Semigroup (Const a b)	Since: base-4.9.0.0
Instance details Defined in Data.Functor.Const Methods (<>) :: Const a b -> Const a b -> Const a b # sconcat :: NonEmpty (Const a b) -> Const a b # stimes :: Integral b0 => b0 -> Const a b -> Const a b #
(Applicative f, Semigroup a) => Semigroup (Ap f a)	Since: base-4.12.0.0
Instance details Defined in Data.Monoid Methods (<>) :: Ap f a -> Ap f a -> Ap f a # sconcat :: NonEmpty (Ap f a) -> Ap f a # stimes :: Integral b => b -> Ap f a -> Ap f a #
Semigroup (f p) => Semigroup (Rec1 f p)	Since: base-4.12.0.0
Instance details Defined in GHC.Generics Methods (<>) :: Rec1 f p -> Rec1 f p -> Rec1 f p # sconcat :: NonEmpty (Rec1 f p) -> Rec1 f p # stimes :: Integral b => b -> Rec1 f p -> Rec1 f p #
(Semigroup a, Semigroup b, Semigroup c) => Semigroup (a, b, c)	Since: base-4.9.0.0
Instance details Defined in GHC.Base Methods (<>) :: (a, b, c) -> (a, b, c) -> (a, b, c) # sconcat :: NonEmpty (a, b, c) -> (a, b, c) # stimes :: Integral b0 => b0 -> (a, b, c) -> (a, b, c) #
(Semigroup (f p), Semigroup (g p)) => Semigroup ((f :*: g) p)	Since: base-4.12.0.0
Instance details Defined in GHC.Generics Methods (<>) :: (f :: g) p -> (f :: g) p -> (f :: g) p # sconcat :: NonEmpty ((f :: g) p) -> (f :: g) p # stimes :: Integral b => b -> (f :: g) p -> (f :*: g) p #
Semigroup c => Semigroup (K1 i c p)	Since: base-4.12.0.0
Instance details Defined in GHC.Generics Methods (<>) :: K1 i c p -> K1 i c p -> K1 i c p # sconcat :: NonEmpty (K1 i c p) -> K1 i c p # stimes :: Integral b => b -> K1 i c p -> K1 i c p #
(Semigroup a, Semigroup b, Semigroup c, Semigroup d) => Semigroup (a, b, c, d)	Since: base-4.9.0.0
Instance details Defined in GHC.Base Methods (<>) :: (a, b, c, d) -> (a, b, c, d) -> (a, b, c, d) # sconcat :: NonEmpty (a, b, c, d) -> (a, b, c, d) # stimes :: Integral b0 => b0 -> (a, b, c, d) -> (a, b, c, d) #
Semigroup (f (g p)) => Semigroup ((f :.: g) p)	Since: base-4.12.0.0
Instance details Defined in GHC.Generics Methods (<>) :: (f :.: g) p -> (f :.: g) p -> (f :.: g) p # sconcat :: NonEmpty ((f :.: g) p) -> (f :.: g) p # stimes :: Integral b => b -> (f :.: g) p -> (f :.: g) p #
Semigroup (f p) => Semigroup (M1 i c f p)	Since: base-4.12.0.0
Instance details Defined in GHC.Generics Methods (<>) :: M1 i c f p -> M1 i c f p -> M1 i c f p # sconcat :: NonEmpty (M1 i c f p) -> M1 i c f p # stimes :: Integral b => b -> M1 i c f p -> M1 i c f p #
(Semigroup a, Semigroup b, Semigroup c, Semigroup d, Semigroup e) => Semigroup (a, b, c, d, e)	Since: base-4.9.0.0
Instance details Defined in GHC.Base Methods (<>) :: (a, b, c, d, e) -> (a, b, c, d, e) -> (a, b, c, d, e) # sconcat :: NonEmpty (a, b, c, d, e) -> (a, b, c, d, e) # stimes :: Integral b0 => b0 -> (a, b, c, d, e) -> (a, b, c, d, e) #

class (Functor t, Foldable t) => Traversable (t :: Type -> Type) where #

Functors representing data structures that can be transformed to structures of the same shape by performing an Applicative (or, therefore, Monad) action on each element from left to right.

A more detailed description of what same shape means, the various methods, how traversals are constructed, and example advanced use-cases can be found in the Overview section of Data.Traversable.

For the class laws see the Laws section of Data.Traversable.

Minimal complete definition

traverse | sequenceA

Methods

traverse :: Applicative f => (a -> f b) -> t a -> f (t b) #

Map each element of a structure to an action, evaluate these actions from left to right, and collect the results. For a version that ignores the results see traverse_.

Examples

Expand

Basic usage:

In the first two examples we show each evaluated action mapping to the output structure.

>>> traverse Just [1,2,3,4]
Just [1,2,3,4]

>>> traverse id [Right 1, Right 2, Right 3, Right 4]
Right [1,2,3,4]

In the next examples, we show that Nothing and Left values short circuit the created structure.

>>> traverse (const Nothing) [1,2,3,4]
Nothing

>>> traverse (\x -> if odd x then Just x else Nothing)  [1,2,3,4]
Nothing

>>> traverse id [Right 1, Right 2, Right 3, Right 4, Left 0]
Left 0

sequenceA :: Applicative f => t (f a) -> f (t a) #

Evaluate each action in the structure from left to right, and collect the results. For a version that ignores the results see sequenceA_.

Examples

Expand

Basic usage:

For the first two examples we show sequenceA fully evaluating a a structure and collecting the results.

>>> sequenceA [Just 1, Just 2, Just 3]
Just [1,2,3]

>>> sequenceA [Right 1, Right 2, Right 3]
Right [1,2,3]

The next two example show Nothing and Just will short circuit the resulting structure if present in the input. For more context, check the Traversable instances for Either and Maybe.

>>> sequenceA [Just 1, Just 2, Just 3, Nothing]
Nothing

>>> sequenceA [Right 1, Right 2, Right 3, Left 4]
Left 4

mapM :: Monad m => (a -> m b) -> t a -> m (t b) #

Map each element of a structure to a monadic action, evaluate these actions from left to right, and collect the results. For a version that ignores the results see mapM_.

Examples

Expand

mapM is literally a traverse with a type signature restricted to Monad. Its implementation may be more efficient due to additional power of Monad.

sequence :: Monad m => t (m a) -> m (t a) #

Evaluate each monadic action in the structure from left to right, and collect the results. For a version that ignores the results see sequence_.

Examples

Expand

Basic usage:

The first two examples are instances where the input and and output of sequence are isomorphic.

>>> sequence $ Right [1,2,3,4]
[Right 1,Right 2,Right 3,Right 4]

>>> sequence $ [Right 1,Right 2,Right 3,Right 4]
Right [1,2,3,4]

The following examples demonstrate short circuit behavior for sequence.

>>> sequence $ Left [1,2,3,4]
Left [1,2,3,4]

>>> sequence $ [Left 0, Right 1,Right 2,Right 3,Right 4]
Left 0

Instances

Instances details

Traversable ZipList	Since: base-4.9.0.0
Instance details Defined in Data.Traversable Methods traverse :: Applicative f => (a -> f b) -> ZipList a -> f (ZipList b) # sequenceA :: Applicative f => ZipList (f a) -> f (ZipList a) # mapM :: Monad m => (a -> m b) -> ZipList a -> m (ZipList b) # sequence :: Monad m => ZipList (m a) -> m (ZipList a) #
Traversable Identity	Since: base-4.9.0.0
Instance details Defined in Data.Traversable Methods traverse :: Applicative f => (a -> f b) -> Identity a -> f (Identity b) # sequenceA :: Applicative f => Identity (f a) -> f (Identity a) # mapM :: Monad m => (a -> m b) -> Identity a -> m (Identity b) # sequence :: Monad m => Identity (m a) -> m (Identity a) #
Traversable First	Since: base-4.8.0.0
Instance details Defined in Data.Traversable Methods traverse :: Applicative f => (a -> f b) -> First a -> f (First b) # sequenceA :: Applicative f => First (f a) -> f (First a) # mapM :: Monad m => (a -> m b) -> First a -> m (First b) # sequence :: Monad m => First (m a) -> m (First a) #
Traversable Last	Since: base-4.8.0.0
Instance details Defined in Data.Traversable Methods traverse :: Applicative f => (a -> f b) -> Last a -> f (Last b) # sequenceA :: Applicative f => Last (f a) -> f (Last a) # mapM :: Monad m => (a -> m b) -> Last a -> m (Last b) # sequence :: Monad m => Last (m a) -> m (Last a) #
Traversable Down	Since: base-4.12.0.0
Instance details Defined in Data.Traversable Methods traverse :: Applicative f => (a -> f b) -> Down a -> f (Down b) # sequenceA :: Applicative f => Down (f a) -> f (Down a) # mapM :: Monad m => (a -> m b) -> Down a -> m (Down b) # sequence :: Monad m => Down (m a) -> m (Down a) #
Traversable First	Since: base-4.9.0.0
Instance details Defined in Data.Semigroup Methods traverse :: Applicative f => (a -> f b) -> First a -> f (First b) # sequenceA :: Applicative f => First (f a) -> f (First a) # mapM :: Monad m => (a -> m b) -> First a -> m (First b) # sequence :: Monad m => First (m a) -> m (First a) #
Traversable Last	Since: base-4.9.0.0
Instance details Defined in Data.Semigroup Methods traverse :: Applicative f => (a -> f b) -> Last a -> f (Last b) # sequenceA :: Applicative f => Last (f a) -> f (Last a) # mapM :: Monad m => (a -> m b) -> Last a -> m (Last b) # sequence :: Monad m => Last (m a) -> m (Last a) #
Traversable Max	Since: base-4.9.0.0
Instance details Defined in Data.Semigroup Methods traverse :: Applicative f => (a -> f b) -> Max a -> f (Max b) # sequenceA :: Applicative f => Max (f a) -> f (Max a) # mapM :: Monad m => (a -> m b) -> Max a -> m (Max b) # sequence :: Monad m => Max (m a) -> m (Max a) #
Traversable Min	Since: base-4.9.0.0
Instance details Defined in Data.Semigroup Methods traverse :: Applicative f => (a -> f b) -> Min a -> f (Min b) # sequenceA :: Applicative f => Min (f a) -> f (Min a) # mapM :: Monad m => (a -> m b) -> Min a -> m (Min b) # sequence :: Monad m => Min (m a) -> m (Min a) #
Traversable Option	Since: base-4.9.0.0
Instance details Defined in Data.Semigroup Methods traverse :: Applicative f => (a -> f b) -> Option a -> f (Option b) # sequenceA :: Applicative f => Option (f a) -> f (Option a) # mapM :: Monad m => (a -> m b) -> Option a -> m (Option b) # sequence :: Monad m => Option (m a) -> m (Option a) #
Traversable Dual	Since: base-4.8.0.0
Instance details Defined in Data.Traversable Methods traverse :: Applicative f => (a -> f b) -> Dual a -> f (Dual b) # sequenceA :: Applicative f => Dual (f a) -> f (Dual a) # mapM :: Monad m => (a -> m b) -> Dual a -> m (Dual b) # sequence :: Monad m => Dual (m a) -> m (Dual a) #
Traversable Product	Since: base-4.8.0.0
Instance details Defined in Data.Traversable Methods traverse :: Applicative f => (a -> f b) -> Product a -> f (Product b) # sequenceA :: Applicative f => Product (f a) -> f (Product a) # mapM :: Monad m => (a -> m b) -> Product a -> m (Product b) # sequence :: Monad m => Product (m a) -> m (Product a) #
Traversable Sum	Since: base-4.8.0.0
Instance details Defined in Data.Traversable Methods traverse :: Applicative f => (a -> f b) -> Sum a -> f (Sum b) # sequenceA :: Applicative f => Sum (f a) -> f (Sum a) # mapM :: Monad m => (a -> m b) -> Sum a -> m (Sum b) # sequence :: Monad m => Sum (m a) -> m (Sum a) #
Traversable NonEmpty	Since: base-4.9.0.0
Instance details Defined in Data.Traversable Methods traverse :: Applicative f => (a -> f b) -> NonEmpty a -> f (NonEmpty b) # sequenceA :: Applicative f => NonEmpty (f a) -> f (NonEmpty a) # mapM :: Monad m => (a -> m b) -> NonEmpty a -> m (NonEmpty b) # sequence :: Monad m => NonEmpty (m a) -> m (NonEmpty a) #
Traversable Par1	Since: base-4.9.0.0
Instance details Defined in Data.Traversable Methods traverse :: Applicative f => (a -> f b) -> Par1 a -> f (Par1 b) # sequenceA :: Applicative f => Par1 (f a) -> f (Par1 a) # mapM :: Monad m => (a -> m b) -> Par1 a -> m (Par1 b) # sequence :: Monad m => Par1 (m a) -> m (Par1 a) #
Traversable IntMap	Traverses in order of increasing key.
Instance details Defined in Data.IntMap.Internal Methods traverse :: Applicative f => (a -> f b) -> IntMap a -> f (IntMap b) # sequenceA :: Applicative f => IntMap (f a) -> f (IntMap a) # mapM :: Monad m => (a -> m b) -> IntMap a -> m (IntMap b) # sequence :: Monad m => IntMap (m a) -> m (IntMap a) #
Traversable Digit
Instance details Defined in Data.Sequence.Internal Methods traverse :: Applicative f => (a -> f b) -> Digit a -> f (Digit b) # sequenceA :: Applicative f => Digit (f a) -> f (Digit a) # mapM :: Monad m => (a -> m b) -> Digit a -> m (Digit b) # sequence :: Monad m => Digit (m a) -> m (Digit a) #
Traversable Elem
Instance details Defined in Data.Sequence.Internal Methods traverse :: Applicative f => (a -> f b) -> Elem a -> f (Elem b) # sequenceA :: Applicative f => Elem (f a) -> f (Elem a) # mapM :: Monad m => (a -> m b) -> Elem a -> m (Elem b) # sequence :: Monad m => Elem (m a) -> m (Elem a) #
Traversable FingerTree
Instance details Defined in Data.Sequence.Internal Methods traverse :: Applicative f => (a -> f b) -> FingerTree a -> f (FingerTree b) # sequenceA :: Applicative f => FingerTree (f a) -> f (FingerTree a) # mapM :: Monad m => (a -> m b) -> FingerTree a -> m (FingerTree b) # sequence :: Monad m => FingerTree (m a) -> m (FingerTree a) #
Traversable Node
Instance details Defined in Data.Sequence.Internal Methods traverse :: Applicative f => (a -> f b) -> Node a -> f (Node b) # sequenceA :: Applicative f => Node (f a) -> f (Node a) # mapM :: Monad m => (a -> m b) -> Node a -> m (Node b) # sequence :: Monad m => Node (m a) -> m (Node a) #
Traversable Seq
Instance details Defined in Data.Sequence.Internal Methods traverse :: Applicative f => (a -> f b) -> Seq a -> f (Seq b) # sequenceA :: Applicative f => Seq (f a) -> f (Seq a) # mapM :: Monad m => (a -> m b) -> Seq a -> m (Seq b) # sequence :: Monad m => Seq (m a) -> m (Seq a) #
Traversable ViewL
Instance details Defined in Data.Sequence.Internal Methods traverse :: Applicative f => (a -> f b) -> ViewL a -> f (ViewL b) # sequenceA :: Applicative f => ViewL (f a) -> f (ViewL a) # mapM :: Monad m => (a -> m b) -> ViewL a -> m (ViewL b) # sequence :: Monad m => ViewL (m a) -> m (ViewL a) #
Traversable ViewR
Instance details Defined in Data.Sequence.Internal Methods traverse :: Applicative f => (a -> f b) -> ViewR a -> f (ViewR b) # sequenceA :: Applicative f => ViewR (f a) -> f (ViewR a) # mapM :: Monad m => (a -> m b) -> ViewR a -> m (ViewR b) # sequence :: Monad m => ViewR (m a) -> m (ViewR a) #
Traversable DList
Instance details Defined in Data.DList.Internal Methods traverse :: Applicative f => (a -> f b) -> DList a -> f (DList b) # sequenceA :: Applicative f => DList (f a) -> f (DList a) # mapM :: Monad m => (a -> m b) -> DList a -> m (DList b) # sequence :: Monad m => DList (m a) -> m (DList a) #
Traversable Maybe	Since: base-2.1
Instance details Defined in Data.Traversable Methods traverse :: Applicative f => (a -> f b) -> Maybe a -> f (Maybe b) # sequenceA :: Applicative f => Maybe (f a) -> f (Maybe a) # mapM :: Monad m => (a -> m b) -> Maybe a -> m (Maybe b) # sequence :: Monad m => Maybe (m a) -> m (Maybe a) #
Traversable Solo	Since: base-4.15
Instance details Defined in Data.Traversable Methods traverse :: Applicative f => (a -> f b) -> Solo a -> f (Solo b) # sequenceA :: Applicative f => Solo (f a) -> f (Solo a) # mapM :: Monad m => (a -> m b) -> Solo a -> m (Solo b) # sequence :: Monad m => Solo (m a) -> m (Solo a) #
Traversable []	Since: base-2.1
Instance details Defined in Data.Traversable Methods traverse :: Applicative f => (a -> f b) -> [a] -> f [b] # sequenceA :: Applicative f => [f a] -> f [a] # mapM :: Monad m => (a -> m b) -> [a] -> m [b] # sequence :: Monad m => [m a] -> m [a] #
Traversable (Either a)	Since: base-4.7.0.0
Instance details Defined in Data.Traversable Methods traverse :: Applicative f => (a0 -> f b) -> Either a a0 -> f (Either a b) # sequenceA :: Applicative f => Either a (f a0) -> f (Either a a0) # mapM :: Monad m => (a0 -> m b) -> Either a a0 -> m (Either a b) # sequence :: Monad m => Either a (m a0) -> m (Either a a0) #
Traversable (Proxy :: Type -> Type)	Since: base-4.7.0.0
Instance details Defined in Data.Traversable Methods traverse :: Applicative f => (a -> f b) -> Proxy a -> f (Proxy b) # sequenceA :: Applicative f => Proxy (f a) -> f (Proxy a) # mapM :: Monad m => (a -> m b) -> Proxy a -> m (Proxy b) # sequence :: Monad m => Proxy (m a) -> m (Proxy a) #
Traversable (Arg a)	Since: base-4.9.0.0
Instance details Defined in Data.Semigroup Methods traverse :: Applicative f => (a0 -> f b) -> Arg a a0 -> f (Arg a b) # sequenceA :: Applicative f => Arg a (f a0) -> f (Arg a a0) # mapM :: Monad m => (a0 -> m b) -> Arg a a0 -> m (Arg a b) # sequence :: Monad m => Arg a (m a0) -> m (Arg a a0) #
Ix i => Traversable (Array i)	Since: base-2.1
Instance details Defined in Data.Traversable Methods traverse :: Applicative f => (a -> f b) -> Array i a -> f (Array i b) # sequenceA :: Applicative f => Array i (f a) -> f (Array i a) # mapM :: Monad m => (a -> m b) -> Array i a -> m (Array i b) # sequence :: Monad m => Array i (m a) -> m (Array i a) #
Traversable (U1 :: Type -> Type)	Since: base-4.9.0.0
Instance details Defined in Data.Traversable Methods traverse :: Applicative f => (a -> f b) -> U1 a -> f (U1 b) # sequenceA :: Applicative f => U1 (f a) -> f (U1 a) # mapM :: Monad m => (a -> m b) -> U1 a -> m (U1 b) # sequence :: Monad m => U1 (m a) -> m (U1 a) #
Traversable (UAddr :: Type -> Type)	Since: base-4.9.0.0
Instance details Defined in Data.Traversable Methods traverse :: Applicative f => (a -> f b) -> UAddr a -> f (UAddr b) # sequenceA :: Applicative f => UAddr (f a) -> f (UAddr a) # mapM :: Monad m => (a -> m b) -> UAddr a -> m (UAddr b) # sequence :: Monad m => UAddr (m a) -> m (UAddr a) #
Traversable (UChar :: Type -> Type)	Since: base-4.9.0.0
Instance details Defined in Data.Traversable Methods traverse :: Applicative f => (a -> f b) -> UChar a -> f (UChar b) # sequenceA :: Applicative f => UChar (f a) -> f (UChar a) # mapM :: Monad m => (a -> m b) -> UChar a -> m (UChar b) # sequence :: Monad m => UChar (m a) -> m (UChar a) #
Traversable (UDouble :: Type -> Type)	Since: base-4.9.0.0
Instance details Defined in Data.Traversable Methods traverse :: Applicative f => (a -> f b) -> UDouble a -> f (UDouble b) # sequenceA :: Applicative f => UDouble (f a) -> f (UDouble a) # mapM :: Monad m => (a -> m b) -> UDouble a -> m (UDouble b) # sequence :: Monad m => UDouble (m a) -> m (UDouble a) #
Traversable (UFloat :: Type -> Type)	Since: base-4.9.0.0
Instance details Defined in Data.Traversable Methods traverse :: Applicative f => (a -> f b) -> UFloat a -> f (UFloat b) # sequenceA :: Applicative f => UFloat (f a) -> f (UFloat a) # mapM :: Monad m => (a -> m b) -> UFloat a -> m (UFloat b) # sequence :: Monad m => UFloat (m a) -> m (UFloat a) #
Traversable (UInt :: Type -> Type)	Since: base-4.9.0.0
Instance details Defined in Data.Traversable Methods traverse :: Applicative f => (a -> f b) -> UInt a -> f (UInt b) # sequenceA :: Applicative f => UInt (f a) -> f (UInt a) # mapM :: Monad m => (a -> m b) -> UInt a -> m (UInt b) # sequence :: Monad m => UInt (m a) -> m (UInt a) #
Traversable (UWord :: Type -> Type)	Since: base-4.9.0.0
Instance details Defined in Data.Traversable Methods traverse :: Applicative f => (a -> f b) -> UWord a -> f (UWord b) # sequenceA :: Applicative f => UWord (f a) -> f (UWord a) # mapM :: Monad m => (a -> m b) -> UWord a -> m (UWord b) # sequence :: Monad m => UWord (m a) -> m (UWord a) #
Traversable (V1 :: Type -> Type)	Since: base-4.9.0.0
Instance details Defined in Data.Traversable Methods traverse :: Applicative f => (a -> f b) -> V1 a -> f (V1 b) # sequenceA :: Applicative f => V1 (f a) -> f (V1 a) # mapM :: Monad m => (a -> m b) -> V1 a -> m (V1 b) # sequence :: Monad m => V1 (m a) -> m (V1 a) #
Traversable (Map k)	Traverses in order of increasing key.
Instance details Defined in Data.Map.Internal Methods traverse :: Applicative f => (a -> f b) -> Map k a -> f (Map k b) # sequenceA :: Applicative f => Map k (f a) -> f (Map k a) # mapM :: Monad m => (a -> m b) -> Map k a -> m (Map k b) # sequence :: Monad m => Map k (m a) -> m (Map k a) #
Traversable ((,) a)	Since: base-4.7.0.0
Instance details Defined in Data.Traversable Methods traverse :: Applicative f => (a0 -> f b) -> (a, a0) -> f (a, b) # sequenceA :: Applicative f => (a, f a0) -> f (a, a0) # mapM :: Monad m => (a0 -> m b) -> (a, a0) -> m (a, b) # sequence :: Monad m => (a, m a0) -> m (a, a0) #
Traversable (Const m :: Type -> Type)	Since: base-4.7.0.0
Instance details Defined in Data.Traversable Methods traverse :: Applicative f => (a -> f b) -> Const m a -> f (Const m b) # sequenceA :: Applicative f => Const m (f a) -> f (Const m a) # mapM :: Monad m0 => (a -> m0 b) -> Const m a -> m0 (Const m b) # sequence :: Monad m0 => Const m (m0 a) -> m0 (Const m a) #
Traversable f => Traversable (Ap f)	Since: base-4.12.0.0
Instance details Defined in Data.Traversable Methods traverse :: Applicative f0 => (a -> f0 b) -> Ap f a -> f0 (Ap f b) # sequenceA :: Applicative f0 => Ap f (f0 a) -> f0 (Ap f a) # mapM :: Monad m => (a -> m b) -> Ap f a -> m (Ap f b) # sequence :: Monad m => Ap f (m a) -> m (Ap f a) #
Traversable f => Traversable (Alt f)	Since: base-4.12.0.0
Instance details Defined in Data.Traversable Methods traverse :: Applicative f0 => (a -> f0 b) -> Alt f a -> f0 (Alt f b) # sequenceA :: Applicative f0 => Alt f (f0 a) -> f0 (Alt f a) # mapM :: Monad m => (a -> m b) -> Alt f a -> m (Alt f b) # sequence :: Monad m => Alt f (m a) -> m (Alt f a) #
Traversable f => Traversable (Rec1 f)	Since: base-4.9.0.0
Instance details Defined in Data.Traversable Methods traverse :: Applicative f0 => (a -> f0 b) -> Rec1 f a -> f0 (Rec1 f b) # sequenceA :: Applicative f0 => Rec1 f (f0 a) -> f0 (Rec1 f a) # mapM :: Monad m => (a -> m b) -> Rec1 f a -> m (Rec1 f b) # sequence :: Monad m => Rec1 f (m a) -> m (Rec1 f a) #
(Traversable f, Traversable g) => Traversable (Product f g)	Since: base-4.9.0.0
Instance details Defined in Data.Functor.Product Methods traverse :: Applicative f0 => (a -> f0 b) -> Product f g a -> f0 (Product f g b) # sequenceA :: Applicative f0 => Product f g (f0 a) -> f0 (Product f g a) # mapM :: Monad m => (a -> m b) -> Product f g a -> m (Product f g b) # sequence :: Monad m => Product f g (m a) -> m (Product f g a) #
(Traversable f, Traversable g) => Traversable (Sum f g)	Since: base-4.9.0.0
Instance details Defined in Data.Functor.Sum Methods traverse :: Applicative f0 => (a -> f0 b) -> Sum f g a -> f0 (Sum f g b) # sequenceA :: Applicative f0 => Sum f g (f0 a) -> f0 (Sum f g a) # mapM :: Monad m => (a -> m b) -> Sum f g a -> m (Sum f g b) # sequence :: Monad m => Sum f g (m a) -> m (Sum f g a) #
(Traversable f, Traversable g) => Traversable (f :*: g)	Since: base-4.9.0.0
Instance details Defined in Data.Traversable Methods traverse :: Applicative f0 => (a -> f0 b) -> (f :: g) a -> f0 ((f :: g) b) # sequenceA :: Applicative f0 => (f :: g) (f0 a) -> f0 ((f :: g) a) # mapM :: Monad m => (a -> m b) -> (f :: g) a -> m ((f :: g) b) # sequence :: Monad m => (f :: g) (m a) -> m ((f :: g) a) #
(Traversable f, Traversable g) => Traversable (f :+: g)	Since: base-4.9.0.0
Instance details Defined in Data.Traversable Methods traverse :: Applicative f0 => (a -> f0 b) -> (f :+: g) a -> f0 ((f :+: g) b) # sequenceA :: Applicative f0 => (f :+: g) (f0 a) -> f0 ((f :+: g) a) # mapM :: Monad m => (a -> m b) -> (f :+: g) a -> m ((f :+: g) b) # sequence :: Monad m => (f :+: g) (m a) -> m ((f :+: g) a) #
Traversable (K1 i c :: Type -> Type)	Since: base-4.9.0.0
Instance details Defined in Data.Traversable Methods traverse :: Applicative f => (a -> f b) -> K1 i c a -> f (K1 i c b) # sequenceA :: Applicative f => K1 i c (f a) -> f (K1 i c a) # mapM :: Monad m => (a -> m b) -> K1 i c a -> m (K1 i c b) # sequence :: Monad m => K1 i c (m a) -> m (K1 i c a) #
(Traversable f, Traversable g) => Traversable (Compose f g)	Since: base-4.9.0.0
Instance details Defined in Data.Functor.Compose Methods traverse :: Applicative f0 => (a -> f0 b) -> Compose f g a -> f0 (Compose f g b) # sequenceA :: Applicative f0 => Compose f g (f0 a) -> f0 (Compose f g a) # mapM :: Monad m => (a -> m b) -> Compose f g a -> m (Compose f g b) # sequence :: Monad m => Compose f g (m a) -> m (Compose f g a) #
(Traversable f, Traversable g) => Traversable (f :.: g)	Since: base-4.9.0.0
Instance details Defined in Data.Traversable Methods traverse :: Applicative f0 => (a -> f0 b) -> (f :.: g) a -> f0 ((f :.: g) b) # sequenceA :: Applicative f0 => (f :.: g) (f0 a) -> f0 ((f :.: g) a) # mapM :: Monad m => (a -> m b) -> (f :.: g) a -> m ((f :.: g) b) # sequence :: Monad m => (f :.: g) (m a) -> m ((f :.: g) a) #
Traversable f => Traversable (M1 i c f)	Since: base-4.9.0.0
Instance details Defined in Data.Traversable Methods traverse :: Applicative f0 => (a -> f0 b) -> M1 i c f a -> f0 (M1 i c f b) # sequenceA :: Applicative f0 => M1 i c f (f0 a) -> f0 (M1 i c f a) # mapM :: Monad m => (a -> m b) -> M1 i c f a -> m (M1 i c f b) # sequence :: Monad m => M1 i c f (m a) -> m (M1 i c f a) #

mapAccumR :: Traversable t => (s -> a -> (s, b)) -> s -> t a -> (s, t b) #

The mapAccumR function behaves like a combination of fmap and foldr; it applies a function to each element of a structure, passing an accumulating parameter from right to left, and returning a final value of this accumulator together with the new structure.

Examples

Expand

Basic usage:

>>> mapAccumR (\a b -> (a + b, a)) 0 [1..10]
(55,[54,52,49,45,40,34,27,19,10,0])

>>> mapAccumR (\a b -> (a <> show b, a)) "0" [1..5]
("054321",["05432","0543","054","05","0"])

mapAccumL :: Traversable t => (s -> a -> (s, b)) -> s -> t a -> (s, t b) #

The mapAccumL function behaves like a combination of fmap and foldl; it applies a function to each element of a structure, passing an accumulating parameter from left to right, and returning a final value of this accumulator together with the new structure.

Examples

Expand

Basic usage:

>>> mapAccumL (\a b -> (a + b, a)) 0 [1..10]
(55,[0,1,3,6,10,15,21,28,36,45])

>>> mapAccumL (\a b -> (a <> show b, a)) "0" [1..5]
("012345",["0","01","012","0123","01234"])

forM :: (Traversable t, Monad m) => t a -> (a -> m b) -> m (t b) #

forM is mapM with its arguments flipped. For a version that ignores the results see forM_.

for :: (Traversable t, Applicative f) => t a -> (a -> f b) -> f (t b) #

for is traverse with its arguments flipped. For a version that ignores the results see for_.

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

Extract the first component of a pair.

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

Extract the second component of a pair.

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

uncurry converts a curried function to a function on pairs.

Examples

Expand

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

>>> uncurry ($) (show, 1)
"1"

>>> map (uncurry max) [(1,2), (3,4), (6,8)]
[2,4,8]

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

Swap the components of a pair.

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

curry converts an uncurried function to a curried function.

Examples

Expand

>>> curry fst 1 2
1

class Typeable (a :: k) #

The class Typeable allows a concrete representation of a type to be calculated.

Minimal complete definition

typeRep#

data Void #

Uninhabited data type

Since: base-4.8.0.0

Instances

Instances details

Data Void	Since: base-4.8.0.0
Instance details Defined in Data.Void Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Void -> c Void # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Void # toConstr :: Void -> Constr # dataTypeOf :: Void -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c Void) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Void) # gmapT :: (forall b. Data b => b -> b) -> Void -> Void # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Void -> r # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Void -> r # gmapQ :: (forall d. Data d => d -> u) -> Void -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> Void -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> Void -> m Void # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Void -> m Void # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Void -> m Void #
Semigroup Void	Since: base-4.9.0.0
Instance details Defined in Data.Void Methods (<>) :: Void -> Void -> Void # sconcat :: NonEmpty Void -> Void # stimes :: Integral b => b -> Void -> Void #
Exception Void	Since: base-4.8.0.0
Instance details Defined in Data.Void Methods toException :: Void -> SomeException # fromException :: SomeException -> Maybe Void # displayException :: Void -> String #
Generic Void
Instance details Defined in Data.Void Associated Types type Rep Void :: Type -> Type # Methods from :: Void -> Rep Void x # to :: Rep Void x -> Void #
Ix Void	Since: base-4.8.0.0
Instance details Defined in Data.Void Methods range :: (Void, Void) -> [Void] # index :: (Void, Void) -> Void -> Int # unsafeIndex :: (Void, Void) -> Void -> Int # inRange :: (Void, Void) -> Void -> Bool # rangeSize :: (Void, Void) -> Int # unsafeRangeSize :: (Void, Void) -> Int #
Read Void	Reading a `Void` value is always a parse error, considering `Void` as a data type with no constructors. Since: base-4.8.0.0
Instance details Defined in Data.Void Methods readsPrec :: Int -> ReadS Void # readList :: ReadS [Void] # readPrec :: ReadPrec Void # readListPrec :: ReadPrec [Void] #
Show Void	Since: base-4.8.0.0
Instance details Defined in Data.Void Methods showsPrec :: Int -> Void -> ShowS # show :: Void -> String # showList :: [Void] -> ShowS #
Eq Void	Since: base-4.8.0.0
Instance details Defined in Data.Void Methods (==) :: Void -> Void -> Bool # (/=) :: Void -> Void -> Bool #
Ord Void	Since: base-4.8.0.0
Instance details Defined in Data.Void Methods compare :: Void -> Void -> Ordering # (<) :: Void -> Void -> Bool # (<=) :: Void -> Void -> Bool # (>) :: Void -> Void -> Bool # (>=) :: Void -> Void -> Bool # max :: Void -> Void -> Void # min :: Void -> Void -> Void #
Lift Void	Since: template-haskell-2.15.0.0
Instance details Defined in Language.Haskell.TH.Syntax Methods lift :: Quote m => Void -> m Exp # liftTyped :: forall (m :: Type -> Type). Quote m => Void -> Code m Void #
type Rep Void	Since: base-4.8.0.0
Instance details Defined in Data.Void type Rep Void = D1 ('MetaData "Void" "Data.Void" "base" 'False) (V1 :: Type -> Type)

data Word #

A Word is an unsigned integral type, with the same size as Int.

Instances

Instances details

Bits Word	Since: base-2.1
Instance details Defined in Data.Bits Methods (.&.) :: Word -> Word -> Word # (.\|.) :: Word -> Word -> Word # xor :: Word -> Word -> Word # complement :: Word -> Word # shift :: Word -> Int -> Word # rotate :: Word -> Int -> Word # zeroBits :: Word # bit :: Int -> Word # setBit :: Word -> Int -> Word # clearBit :: Word -> Int -> Word # complementBit :: Word -> Int -> Word # testBit :: Word -> Int -> Bool # bitSizeMaybe :: Word -> Maybe Int # bitSize :: Word -> Int # isSigned :: Word -> Bool # shiftL :: Word -> Int -> Word # unsafeShiftL :: Word -> Int -> Word # shiftR :: Word -> Int -> Word # unsafeShiftR :: Word -> Int -> Word # rotateL :: Word -> Int -> Word # rotateR :: Word -> Int -> Word # popCount :: Word -> Int #
FiniteBits Word	Since: base-4.6.0.0
Instance details Defined in Data.Bits Methods finiteBitSize :: Word -> Int # countLeadingZeros :: Word -> Int # countTrailingZeros :: Word -> Int #
Bounded Word	Since: base-2.1
Instance details Defined in GHC.Enum Methods minBound :: Word # maxBound :: Word #
Enum Word	Since: base-2.1
Instance details Defined in GHC.Enum 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] #
Num Word	Since: base-2.1
Instance details Defined in GHC.Num Methods (+) :: Word -> Word -> Word # (-) :: Word -> Word -> Word # (*) :: Word -> Word -> Word # negate :: Word -> Word # abs :: Word -> Word # signum :: Word -> Word # fromInteger :: Integer -> Word #
Read Word	Since: base-4.5.0.0
Instance details Defined in GHC.Read Methods readsPrec :: Int -> ReadS Word # readList :: ReadS [Word] # readPrec :: ReadPrec Word # readListPrec :: ReadPrec [Word] #
Integral Word	Since: base-2.1
Instance details Defined in GHC.Real 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 #
Real Word	Since: base-2.1
Instance details Defined in GHC.Real Methods toRational :: Word -> Rational #
Show Word	Since: base-2.1
Instance details Defined in GHC.Show Methods showsPrec :: Int -> Word -> ShowS # show :: Word -> String # showList :: [Word] -> ShowS #
Default Word
Instance details Defined in Data.Default.Class Methods def :: Word #
Eq Word
Instance details Defined in GHC.Classes Methods (==) :: Word -> Word -> Bool # (/=) :: Word -> Word -> Bool #
Ord Word
Instance details Defined in GHC.Classes Methods compare :: Word -> Word -> Ordering # (<) :: Word -> Word -> Bool # (<=) :: Word -> Word -> Bool # (>) :: Word -> Word -> Bool # (>=) :: Word -> Word -> Bool # max :: Word -> Word -> Word # min :: Word -> Word -> Word #
Lift Word
Instance details Defined in Language.Haskell.TH.Syntax Methods lift :: Quote m => Word -> m Exp # liftTyped :: forall (m :: Type -> Type). Quote m => Word -> Code m Word #
Generic1 (URec Word :: k -> Type)
Instance details Defined in GHC.Generics Associated Types type Rep1 (URec Word) :: k -> Type # Methods from1 :: forall (a :: k0). URec Word a -> Rep1 (URec Word) a # to1 :: forall (a :: k0). Rep1 (URec Word) a -> URec Word a #
Foldable (UWord :: Type -> Type)	Since: base-4.9.0.0
Instance details Defined in Data.Foldable Methods fold :: Monoid m => UWord m -> m # foldMap :: Monoid m => (a -> m) -> UWord a -> m # foldMap' :: Monoid m => (a -> m) -> UWord a -> m # foldr :: (a -> b -> b) -> b -> UWord a -> b # foldr' :: (a -> b -> b) -> b -> UWord a -> b # foldl :: (b -> a -> b) -> b -> UWord a -> b # foldl' :: (b -> a -> b) -> b -> UWord a -> b # foldr1 :: (a -> a -> a) -> UWord a -> a # foldl1 :: (a -> a -> a) -> UWord a -> a # toList :: UWord a -> [a] # null :: UWord a -> Bool # length :: UWord a -> Int # elem :: Eq a => a -> UWord a -> Bool # maximum :: Ord a => UWord a -> a # minimum :: Ord a => UWord a -> a # sum :: Num a => UWord a -> a # product :: Num a => UWord a -> a #
Traversable (UWord :: Type -> Type)	Since: base-4.9.0.0
Instance details Defined in Data.Traversable Methods traverse :: Applicative f => (a -> f b) -> UWord a -> f (UWord b) # sequenceA :: Applicative f => UWord (f a) -> f (UWord a) # mapM :: Monad m => (a -> m b) -> UWord a -> m (UWord b) # sequence :: Monad m => UWord (m a) -> m (UWord a) #
Functor (URec Word :: Type -> Type)	Since: base-4.9.0.0
Instance details Defined in GHC.Generics Methods fmap :: (a -> b) -> URec Word a -> URec Word b # (<$) :: a -> URec Word b -> URec Word a #
Generic (URec Word p)
Instance details Defined in GHC.Generics Associated Types type Rep (URec Word p) :: Type -> Type # Methods from :: URec Word p -> Rep (URec Word p) x # to :: Rep (URec Word p) x -> URec Word p #
Show (URec Word p)	Since: base-4.9.0.0
Instance details Defined in GHC.Generics Methods showsPrec :: Int -> URec Word p -> ShowS # show :: URec Word p -> String # showList :: [URec Word p] -> ShowS #
Eq (URec Word p)	Since: base-4.9.0.0
Instance details Defined in GHC.Generics Methods (==) :: URec Word p -> URec Word p -> Bool # (/=) :: URec Word p -> URec Word p -> Bool #
Ord (URec Word p)	Since: base-4.9.0.0
Instance details Defined in GHC.Generics Methods compare :: URec Word p -> URec Word p -> Ordering # (<) :: URec Word p -> URec Word p -> Bool # (<=) :: URec Word p -> URec Word p -> Bool # (>) :: URec Word p -> URec Word p -> Bool # (>=) :: URec Word p -> URec Word p -> Bool # max :: URec Word p -> URec Word p -> URec Word p # min :: URec Word p -> URec Word p -> URec Word p #
data URec Word (p :: k)	Used for marking occurrences of `Word#` Since: base-4.9.0.0
Instance details Defined in GHC.Generics data URec Word (p :: k) = UWord { uWord# :: Word# }
type Rep1 (URec Word :: k -> Type)	Since: base-4.9.0.0
Instance details Defined in GHC.Generics type Rep1 (URec Word :: k -> Type) = D1 ('MetaData "URec" "GHC.Generics" "base" 'False) (C1 ('MetaCons "UWord" 'PrefixI 'True) (S1 ('MetaSel ('Just "uWord#") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (UWord :: k -> Type)))
type Rep (URec Word p)	Since: base-4.9.0.0
Instance details Defined in GHC.Generics type Rep (URec Word p) = D1 ('MetaData "URec" "GHC.Generics" "base" 'False) (C1 ('MetaCons "UWord" 'PrefixI 'True) (S1 ('MetaSel ('Just "uWord#") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (UWord :: Type -> Type)))

data Word8 #

8-bit unsigned integer type

Instances

Instances details

Bits Word8	Since: base-2.1
Instance details Defined in GHC.Word Methods (.&.) :: Word8 -> Word8 -> Word8 # (.\|.) :: Word8 -> Word8 -> Word8 # xor :: Word8 -> Word8 -> Word8 # complement :: Word8 -> Word8 # shift :: Word8 -> Int -> Word8 # rotate :: Word8 -> Int -> Word8 # zeroBits :: Word8 # bit :: Int -> Word8 # setBit :: Word8 -> Int -> Word8 # clearBit :: Word8 -> Int -> Word8 # complementBit :: Word8 -> Int -> Word8 # testBit :: Word8 -> Int -> Bool # bitSizeMaybe :: Word8 -> Maybe Int # bitSize :: Word8 -> Int # isSigned :: Word8 -> Bool # shiftL :: Word8 -> Int -> Word8 # unsafeShiftL :: Word8 -> Int -> Word8 # shiftR :: Word8 -> Int -> Word8 # unsafeShiftR :: Word8 -> Int -> Word8 # rotateL :: Word8 -> Int -> Word8 # rotateR :: Word8 -> Int -> Word8 # popCount :: Word8 -> Int #
FiniteBits Word8	Since: base-4.6.0.0
Instance details Defined in GHC.Word Methods finiteBitSize :: Word8 -> Int # countLeadingZeros :: Word8 -> Int # countTrailingZeros :: Word8 -> Int #
Bounded Word8	Since: base-2.1
Instance details Defined in GHC.Word Methods minBound :: Word8 # maxBound :: Word8 #
Enum Word8	Since: base-2.1
Instance details Defined in GHC.Word Methods succ :: Word8 -> Word8 # pred :: Word8 -> Word8 # toEnum :: Int -> Word8 # fromEnum :: Word8 -> Int # enumFrom :: Word8 -> [Word8] # enumFromThen :: Word8 -> Word8 -> [Word8] # enumFromTo :: Word8 -> Word8 -> [Word8] # enumFromThenTo :: Word8 -> Word8 -> Word8 -> [Word8] #
Ix Word8	Since: base-2.1
Instance details Defined in GHC.Word Methods range :: (Word8, Word8) -> [Word8] # index :: (Word8, Word8) -> Word8 -> Int # unsafeIndex :: (Word8, Word8) -> Word8 -> Int # inRange :: (Word8, Word8) -> Word8 -> Bool # rangeSize :: (Word8, Word8) -> Int # unsafeRangeSize :: (Word8, Word8) -> Int #
Num Word8	Since: base-2.1
Instance details Defined in GHC.Word Methods (+) :: Word8 -> Word8 -> Word8 # (-) :: Word8 -> Word8 -> Word8 # (*) :: Word8 -> Word8 -> Word8 # negate :: Word8 -> Word8 # abs :: Word8 -> Word8 # signum :: Word8 -> Word8 # fromInteger :: Integer -> Word8 #
Read Word8	Since: base-2.1
Instance details Defined in GHC.Read Methods readsPrec :: Int -> ReadS Word8 # readList :: ReadS [Word8] # readPrec :: ReadPrec Word8 # readListPrec :: ReadPrec [Word8] #
Integral Word8	Since: base-2.1
Instance details Defined in GHC.Word Methods quot :: Word8 -> Word8 -> Word8 # rem :: Word8 -> Word8 -> Word8 # div :: Word8 -> Word8 -> Word8 # mod :: Word8 -> Word8 -> Word8 # quotRem :: Word8 -> Word8 -> (Word8, Word8) # divMod :: Word8 -> Word8 -> (Word8, Word8) # toInteger :: Word8 -> Integer #
Real Word8	Since: base-2.1
Instance details Defined in GHC.Word Methods toRational :: Word8 -> Rational #
Show Word8	Since: base-2.1
Instance details Defined in GHC.Word Methods showsPrec :: Int -> Word8 -> ShowS # show :: Word8 -> String # showList :: [Word8] -> ShowS #
Default Word8
Instance details Defined in Data.Default.Class Methods def :: Word8 #
Eq Word8	Since: base-2.1
Instance details Defined in GHC.Word Methods (==) :: Word8 -> Word8 -> Bool # (/=) :: Word8 -> Word8 -> Bool #
Ord Word8	Since: base-2.1
Instance details Defined in GHC.Word Methods compare :: Word8 -> Word8 -> Ordering # (<) :: Word8 -> Word8 -> Bool # (<=) :: Word8 -> Word8 -> Bool # (>) :: Word8 -> Word8 -> Bool # (>=) :: Word8 -> Word8 -> Bool # max :: Word8 -> Word8 -> Word8 # min :: Word8 -> Word8 -> Word8 #
Lift Word8
Instance details Defined in Language.Haskell.TH.Syntax Methods lift :: Quote m => Word8 -> m Exp # liftTyped :: forall (m :: Type -> Type). Quote m => Word8 -> Code m Word8 #

data Word16 #

16-bit unsigned integer type

Instances

Instances details

Bits Word16	Since: base-2.1
Instance details Defined in GHC.Word Methods (.&.) :: Word16 -> Word16 -> Word16 # (.\|.) :: Word16 -> Word16 -> Word16 # xor :: Word16 -> Word16 -> Word16 # complement :: Word16 -> Word16 # shift :: Word16 -> Int -> Word16 # rotate :: Word16 -> Int -> Word16 # zeroBits :: Word16 # bit :: Int -> Word16 # setBit :: Word16 -> Int -> Word16 # clearBit :: Word16 -> Int -> Word16 # complementBit :: Word16 -> Int -> Word16 # testBit :: Word16 -> Int -> Bool # bitSizeMaybe :: Word16 -> Maybe Int # bitSize :: Word16 -> Int # isSigned :: Word16 -> Bool # shiftL :: Word16 -> Int -> Word16 # unsafeShiftL :: Word16 -> Int -> Word16 # shiftR :: Word16 -> Int -> Word16 # unsafeShiftR :: Word16 -> Int -> Word16 # rotateL :: Word16 -> Int -> Word16 # rotateR :: Word16 -> Int -> Word16 # popCount :: Word16 -> Int #
FiniteBits Word16	Since: base-4.6.0.0
Instance details Defined in GHC.Word Methods finiteBitSize :: Word16 -> Int # countLeadingZeros :: Word16 -> Int # countTrailingZeros :: Word16 -> Int #
Bounded Word16	Since: base-2.1
Instance details Defined in GHC.Word Methods minBound :: Word16 # maxBound :: Word16 #
Enum Word16	Since: base-2.1
Instance details Defined in GHC.Word Methods succ :: Word16 -> Word16 # pred :: Word16 -> Word16 # toEnum :: Int -> Word16 # fromEnum :: Word16 -> Int # enumFrom :: Word16 -> [Word16] # enumFromThen :: Word16 -> Word16 -> [Word16] # enumFromTo :: Word16 -> Word16 -> [Word16] # enumFromThenTo :: Word16 -> Word16 -> Word16 -> [Word16] #
Ix Word16	Since: base-2.1
Instance details Defined in GHC.Word Methods range :: (Word16, Word16) -> [Word16] # index :: (Word16, Word16) -> Word16 -> Int # unsafeIndex :: (Word16, Word16) -> Word16 -> Int # inRange :: (Word16, Word16) -> Word16 -> Bool # rangeSize :: (Word16, Word16) -> Int # unsafeRangeSize :: (Word16, Word16) -> Int #
Num Word16	Since: base-2.1
Instance details Defined in GHC.Word Methods (+) :: Word16 -> Word16 -> Word16 # (-) :: Word16 -> Word16 -> Word16 # (*) :: Word16 -> Word16 -> Word16 # negate :: Word16 -> Word16 # abs :: Word16 -> Word16 # signum :: Word16 -> Word16 # fromInteger :: Integer -> Word16 #
Read Word16	Since: base-2.1
Instance details Defined in GHC.Read Methods readsPrec :: Int -> ReadS Word16 # readList :: ReadS [Word16] # readPrec :: ReadPrec Word16 # readListPrec :: ReadPrec [Word16] #
Integral Word16	Since: base-2.1
Instance details Defined in GHC.Word Methods quot :: Word16 -> Word16 -> Word16 # rem :: Word16 -> Word16 -> Word16 # div :: Word16 -> Word16 -> Word16 # mod :: Word16 -> Word16 -> Word16 # quotRem :: Word16 -> Word16 -> (Word16, Word16) # divMod :: Word16 -> Word16 -> (Word16, Word16) # toInteger :: Word16 -> Integer #
Real Word16	Since: base-2.1
Instance details Defined in GHC.Word Methods toRational :: Word16 -> Rational #
Show Word16	Since: base-2.1
Instance details Defined in GHC.Word Methods showsPrec :: Int -> Word16 -> ShowS # show :: Word16 -> String # showList :: [Word16] -> ShowS #
Default Word16
Instance details Defined in Data.Default.Class Methods def :: Word16 #
Eq Word16	Since: base-2.1
Instance details Defined in GHC.Word Methods (==) :: Word16 -> Word16 -> Bool # (/=) :: Word16 -> Word16 -> Bool #
Ord Word16	Since: base-2.1
Instance details Defined in GHC.Word Methods compare :: Word16 -> Word16 -> Ordering # (<) :: Word16 -> Word16 -> Bool # (<=) :: Word16 -> Word16 -> Bool # (>) :: Word16 -> Word16 -> Bool # (>=) :: Word16 -> Word16 -> Bool # max :: Word16 -> Word16 -> Word16 # min :: Word16 -> Word16 -> Word16 #
Lift Word16
Instance details Defined in Language.Haskell.TH.Syntax Methods lift :: Quote m => Word16 -> m Exp # liftTyped :: forall (m :: Type -> Type). Quote m => Word16 -> Code m Word16 #

data Word32 #

32-bit unsigned integer type

Instances

Instances details

Bits Word32	Since: base-2.1
Instance details Defined in GHC.Word Methods (.&.) :: Word32 -> Word32 -> Word32 # (.\|.) :: Word32 -> Word32 -> Word32 # xor :: Word32 -> Word32 -> Word32 # complement :: Word32 -> Word32 # shift :: Word32 -> Int -> Word32 # rotate :: Word32 -> Int -> Word32 # zeroBits :: Word32 # bit :: Int -> Word32 # setBit :: Word32 -> Int -> Word32 # clearBit :: Word32 -> Int -> Word32 # complementBit :: Word32 -> Int -> Word32 # testBit :: Word32 -> Int -> Bool # bitSizeMaybe :: Word32 -> Maybe Int # bitSize :: Word32 -> Int # isSigned :: Word32 -> Bool # shiftL :: Word32 -> Int -> Word32 # unsafeShiftL :: Word32 -> Int -> Word32 # shiftR :: Word32 -> Int -> Word32 # unsafeShiftR :: Word32 -> Int -> Word32 # rotateL :: Word32 -> Int -> Word32 # rotateR :: Word32 -> Int -> Word32 # popCount :: Word32 -> Int #
FiniteBits Word32	Since: base-4.6.0.0
Instance details Defined in GHC.Word Methods finiteBitSize :: Word32 -> Int # countLeadingZeros :: Word32 -> Int # countTrailingZeros :: Word32 -> Int #
Bounded Word32	Since: base-2.1
Instance details Defined in GHC.Word Methods minBound :: Word32 # maxBound :: Word32 #
Enum Word32	Since: base-2.1
Instance details Defined in GHC.Word Methods succ :: Word32 -> Word32 # pred :: Word32 -> Word32 # toEnum :: Int -> Word32 # fromEnum :: Word32 -> Int # enumFrom :: Word32 -> [Word32] # enumFromThen :: Word32 -> Word32 -> [Word32] # enumFromTo :: Word32 -> Word32 -> [Word32] # enumFromThenTo :: Word32 -> Word32 -> Word32 -> [Word32] #
Ix Word32	Since: base-2.1
Instance details Defined in GHC.Word Methods range :: (Word32, Word32) -> [Word32] # index :: (Word32, Word32) -> Word32 -> Int # unsafeIndex :: (Word32, Word32) -> Word32 -> Int # inRange :: (Word32, Word32) -> Word32 -> Bool # rangeSize :: (Word32, Word32) -> Int # unsafeRangeSize :: (Word32, Word32) -> Int #
Num Word32	Since: base-2.1
Instance details Defined in GHC.Word Methods (+) :: Word32 -> Word32 -> Word32 # (-) :: Word32 -> Word32 -> Word32 # (*) :: Word32 -> Word32 -> Word32 # negate :: Word32 -> Word32 # abs :: Word32 -> Word32 # signum :: Word32 -> Word32 # fromInteger :: Integer -> Word32 #
Read Word32	Since: base-2.1
Instance details Defined in GHC.Read Methods readsPrec :: Int -> ReadS Word32 # readList :: ReadS [Word32] # readPrec :: ReadPrec Word32 # readListPrec :: ReadPrec [Word32] #
Integral Word32	Since: base-2.1
Instance details Defined in GHC.Word Methods quot :: Word32 -> Word32 -> Word32 # rem :: Word32 -> Word32 -> Word32 # div :: Word32 -> Word32 -> Word32 # mod :: Word32 -> Word32 -> Word32 # quotRem :: Word32 -> Word32 -> (Word32, Word32) # divMod :: Word32 -> Word32 -> (Word32, Word32) # toInteger :: Word32 -> Integer #
Real Word32	Since: base-2.1
Instance details Defined in GHC.Word Methods toRational :: Word32 -> Rational #
Show Word32	Since: base-2.1
Instance details Defined in GHC.Word Methods showsPrec :: Int -> Word32 -> ShowS # show :: Word32 -> String # showList :: [Word32] -> ShowS #
Default Word32
Instance details Defined in Data.Default.Class Methods def :: Word32 #
Eq Word32	Since: base-2.1
Instance details Defined in GHC.Word Methods (==) :: Word32 -> Word32 -> Bool # (/=) :: Word32 -> Word32 -> Bool #
Ord Word32	Since: base-2.1
Instance details Defined in GHC.Word Methods compare :: Word32 -> Word32 -> Ordering # (<) :: Word32 -> Word32 -> Bool # (<=) :: Word32 -> Word32 -> Bool # (>) :: Word32 -> Word32 -> Bool # (>=) :: Word32 -> Word32 -> Bool # max :: Word32 -> Word32 -> Word32 # min :: Word32 -> Word32 -> Word32 #
Lift Word32
Instance details Defined in Language.Haskell.TH.Syntax Methods lift :: Quote m => Word32 -> m Exp # liftTyped :: forall (m :: Type -> Type). Quote m => Word32 -> Code m Word32 #

data Word64 #

64-bit unsigned integer type

Instances

Instances details

Bits Word64	Since: base-2.1
Instance details Defined in GHC.Word Methods (.&.) :: Word64 -> Word64 -> Word64 # (.\|.) :: Word64 -> Word64 -> Word64 # xor :: Word64 -> Word64 -> Word64 # complement :: Word64 -> Word64 # shift :: Word64 -> Int -> Word64 # rotate :: Word64 -> Int -> Word64 # zeroBits :: Word64 # bit :: Int -> Word64 # setBit :: Word64 -> Int -> Word64 # clearBit :: Word64 -> Int -> Word64 # complementBit :: Word64 -> Int -> Word64 # testBit :: Word64 -> Int -> Bool # bitSizeMaybe :: Word64 -> Maybe Int # bitSize :: Word64 -> Int # isSigned :: Word64 -> Bool # shiftL :: Word64 -> Int -> Word64 # unsafeShiftL :: Word64 -> Int -> Word64 # shiftR :: Word64 -> Int -> Word64 # unsafeShiftR :: Word64 -> Int -> Word64 # rotateL :: Word64 -> Int -> Word64 # rotateR :: Word64 -> Int -> Word64 # popCount :: Word64 -> Int #
FiniteBits Word64	Since: base-4.6.0.0
Instance details Defined in GHC.Word Methods finiteBitSize :: Word64 -> Int # countLeadingZeros :: Word64 -> Int # countTrailingZeros :: Word64 -> Int #
Bounded Word64	Since: base-2.1
Instance details Defined in GHC.Word Methods minBound :: Word64 # maxBound :: Word64 #
Enum Word64	Since: base-2.1
Instance details Defined in GHC.Word Methods succ :: Word64 -> Word64 # pred :: Word64 -> Word64 # toEnum :: Int -> Word64 # fromEnum :: Word64 -> Int # enumFrom :: Word64 -> [Word64] # enumFromThen :: Word64 -> Word64 -> [Word64] # enumFromTo :: Word64 -> Word64 -> [Word64] # enumFromThenTo :: Word64 -> Word64 -> Word64 -> [Word64] #
Ix Word64	Since: base-2.1
Instance details Defined in GHC.Word Methods range :: (Word64, Word64) -> [Word64] # index :: (Word64, Word64) -> Word64 -> Int # unsafeIndex :: (Word64, Word64) -> Word64 -> Int # inRange :: (Word64, Word64) -> Word64 -> Bool # rangeSize :: (Word64, Word64) -> Int # unsafeRangeSize :: (Word64, Word64) -> Int #
Num Word64	Since: base-2.1
Instance details Defined in GHC.Word Methods (+) :: Word64 -> Word64 -> Word64 # (-) :: Word64 -> Word64 -> Word64 # (*) :: Word64 -> Word64 -> Word64 # negate :: Word64 -> Word64 # abs :: Word64 -> Word64 # signum :: Word64 -> Word64 # fromInteger :: Integer -> Word64 #
Read Word64	Since: base-2.1
Instance details Defined in GHC.Read Methods readsPrec :: Int -> ReadS Word64 # readList :: ReadS [Word64] # readPrec :: ReadPrec Word64 # readListPrec :: ReadPrec [Word64] #
Integral Word64	Since: base-2.1
Instance details Defined in GHC.Word Methods quot :: Word64 -> Word64 -> Word64 # rem :: Word64 -> Word64 -> Word64 # div :: Word64 -> Word64 -> Word64 # mod :: Word64 -> Word64 -> Word64 # quotRem :: Word64 -> Word64 -> (Word64, Word64) # divMod :: Word64 -> Word64 -> (Word64, Word64) # toInteger :: Word64 -> Integer #
Real Word64	Since: base-2.1
Instance details Defined in GHC.Word Methods toRational :: Word64 -> Rational #
Show Word64	Since: base-2.1
Instance details Defined in GHC.Word Methods showsPrec :: Int -> Word64 -> ShowS # show :: Word64 -> String # showList :: [Word64] -> ShowS #
Default Word64
Instance details Defined in Data.Default.Class Methods def :: Word64 #
Eq Word64	Since: base-2.1
Instance details Defined in GHC.Word Methods (==) :: Word64 -> Word64 -> Bool # (/=) :: Word64 -> Word64 -> Bool #
Ord Word64	Since: base-2.1
Instance details Defined in GHC.Word Methods compare :: Word64 -> Word64 -> Ordering # (<) :: Word64 -> Word64 -> Bool # (<=) :: Word64 -> Word64 -> Bool # (>) :: Word64 -> Word64 -> Bool # (>=) :: Word64 -> Word64 -> Bool # max :: Word64 -> Word64 -> Word64 # min :: Word64 -> Word64 -> Word64 #
Lift Word64
Instance details Defined in Language.Haskell.TH.Syntax Methods lift :: Quote m => Word64 -> m Exp # liftTyped :: forall (m :: Type -> Type). Quote m => Word64 -> Code m Word64 #

seq :: forall {r :: RuntimeRep} a (b :: TYPE r). a -> b -> b infixr 0 #

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.

ord :: Char -> Int #

The fromEnum method restricted to the type Char.

minInt :: Int #

maxInt :: Int #

($!) :: forall (r :: RuntimeRep) a (b :: TYPE r). (a -> b) -> a -> b infixr 0 #

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

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.

Methods

minBound :: a #

maxBound :: a #

Instances

Instances details

Bounded Associativity	Since: base-4.9.0.0
Instance details Defined in GHC.Generics Methods minBound :: Associativity # maxBound :: Associativity #
Bounded DecidedStrictness	Since: base-4.9.0.0
Instance details Defined in GHC.Generics Methods minBound :: DecidedStrictness # maxBound :: DecidedStrictness #
Bounded SourceStrictness	Since: base-4.9.0.0
Instance details Defined in GHC.Generics Methods minBound :: SourceStrictness # maxBound :: SourceStrictness #
Bounded SourceUnpackedness	Since: base-4.9.0.0
Instance details Defined in GHC.Generics Methods minBound :: SourceUnpackedness # maxBound :: SourceUnpackedness #
Bounded Int16	Since: base-2.1
Instance details Defined in GHC.Int Methods minBound :: Int16 # maxBound :: Int16 #
Bounded Int32	Since: base-2.1
Instance details Defined in GHC.Int Methods minBound :: Int32 # maxBound :: Int32 #
Bounded Int64	Since: base-2.1
Instance details Defined in GHC.Int Methods minBound :: Int64 # maxBound :: Int64 #
Bounded Int8	Since: base-2.1
Instance details Defined in GHC.Int Methods minBound :: Int8 # maxBound :: Int8 #
Bounded Word16	Since: base-2.1
Instance details Defined in GHC.Word Methods minBound :: Word16 # maxBound :: Word16 #
Bounded Word32	Since: base-2.1
Instance details Defined in GHC.Word Methods minBound :: Word32 # maxBound :: Word32 #
Bounded Word64	Since: base-2.1
Instance details Defined in GHC.Word Methods minBound :: Word64 # maxBound :: Word64 #
Bounded Extension
Instance details Defined in GHC.LanguageExtensions.Type Methods minBound :: Extension # maxBound :: Extension #
Bounded Ordering	Since: base-2.1
Instance details Defined in GHC.Enum Methods minBound :: Ordering # maxBound :: Ordering #
Bounded Word8	Since: base-2.1
Instance details Defined in GHC.Word Methods minBound :: Word8 # maxBound :: Word8 #
Bounded ()	Since: base-2.1
Instance details Defined in GHC.Enum Methods minBound :: () # maxBound :: () #
Bounded Bool	Since: base-2.1
Instance details Defined in GHC.Enum Methods minBound :: Bool # maxBound :: Bool #
Bounded Char	Since: base-2.1
Instance details Defined in GHC.Enum Methods minBound :: Char # maxBound :: Char #
Bounded Int	Since: base-2.1
Instance details Defined in GHC.Enum Methods minBound :: Int # maxBound :: Int #
Bounded VecCount	Since: base-4.10.0.0
Instance details Defined in GHC.Enum Methods minBound :: VecCount # maxBound :: VecCount #
Bounded VecElem	Since: base-4.10.0.0
Instance details Defined in GHC.Enum Methods minBound :: VecElem # maxBound :: VecElem #
Bounded Word	Since: base-2.1
Instance details Defined in GHC.Enum Methods minBound :: Word # maxBound :: Word #
Bounded a => Bounded (Identity a)	Since: base-4.9.0.0
Instance details Defined in Data.Functor.Identity Methods minBound :: Identity a # maxBound :: Identity a #
Bounded a => Bounded (Down a)	Swaps `minBound` and `maxBound` of the underlying type. Since: base-4.14.0.0
Instance details Defined in Data.Ord Methods minBound :: Down a # maxBound :: Down a #
Bounded a => Bounded (First a)	Since: base-4.9.0.0
Instance details Defined in Data.Semigroup Methods minBound :: First a # maxBound :: First a #
Bounded a => Bounded (Last a)	Since: base-4.9.0.0
Instance details Defined in Data.Semigroup Methods minBound :: Last a # maxBound :: Last a #
Bounded a => Bounded (Max a)	Since: base-4.9.0.0
Instance details Defined in Data.Semigroup Methods minBound :: Max a # maxBound :: Max a #
Bounded a => Bounded (Min a)	Since: base-4.9.0.0
Instance details Defined in Data.Semigroup Methods minBound :: Min a # maxBound :: Min a #
Bounded m => Bounded (WrappedMonoid m)	Since: base-4.9.0.0
Instance details Defined in Data.Semigroup Methods minBound :: WrappedMonoid m # maxBound :: WrappedMonoid m #
Bounded (Proxy t)	Since: base-4.7.0.0
Instance details Defined in Data.Proxy Methods minBound :: Proxy t # maxBound :: Proxy t #
(Bounded a, Bounded b) => Bounded (a, b)	Since: base-2.1
Instance details Defined in GHC.Enum Methods minBound :: (a, b) # maxBound :: (a, b) #
Bounded a => Bounded (Const a b)	Since: base-4.9.0.0
Instance details Defined in Data.Functor.Const Methods minBound :: Const a b # maxBound :: Const a b #
(Applicative f, Bounded a) => Bounded (Ap f a)	Since: base-4.12.0.0
Instance details Defined in Data.Monoid Methods minBound :: Ap f a # maxBound :: Ap f a #
a ~ b => Bounded (a :~: b)	Since: base-4.7.0.0
Instance details Defined in Data.Type.Equality Methods minBound :: a :~: b # maxBound :: a :~: b #
(Bounded a, Bounded b, Bounded c) => Bounded (a, b, c)	Since: base-2.1
Instance details Defined in GHC.Enum Methods minBound :: (a, b, c) # maxBound :: (a, b, c) #
a ~~ b => Bounded (a :~~: b)	Since: base-4.10.0.0
Instance details Defined in Data.Type.Equality Methods minBound :: a :~~: b # maxBound :: a :~~: b #
(Bounded a, Bounded b, Bounded c, Bounded d) => Bounded (a, b, c, d)	Since: base-2.1
Instance details Defined in GHC.Enum Methods minBound :: (a, b, c, d) # maxBound :: (a, b, c, d) #
(Bounded a, Bounded b, Bounded c, Bounded d, Bounded e) => Bounded (a, b, c, d, e)	Since: base-2.1
Instance details Defined in GHC.Enum 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: base-2.1
Instance details Defined in GHC.Enum 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: base-2.1
Instance details Defined in GHC.Enum 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: base-2.1
Instance details Defined in GHC.Enum 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: base-2.1
Instance details Defined in GHC.Enum 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: base-2.1
Instance details Defined in GHC.Enum 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: base-2.1
Instance details Defined in GHC.Enum 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: base-2.1
Instance details Defined in GHC.Enum 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: base-2.1
Instance details Defined in GHC.Enum 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: base-2.1
Instance details Defined in GHC.Enum 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: base-2.1
Instance details Defined in GHC.Enum 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:

The calls succ maxBound and pred minBound should result in a runtime error.
fromEnum and toEnum should give a runtime error if the result value is not representable in the result type. For example, toEnum 7 :: Bool is an error.
enumFrom and enumFromThen should be defined with an implicit bound, thus:

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

Minimal complete definition

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..] with [n..] = enumFrom n, a possible implementation being enumFrom n = n : enumFrom (succ n). For example:

```
enumFrom 4 :: [Integer] = [4,5,6,7,...]
```

enumFrom 6 :: [Int] = [6,7,8,9,...,maxBound :: Int]

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

Used in Haskell's translation of [n,n'..] with [n,n'..] = enumFromThen n n', a possible implementation being enumFromThen n n' = n : n' : worker (f x) (f x n'), worker s v = v : worker s (s v), x = fromEnum n' - fromEnum n and f n y | n > 0 = f (n - 1) (succ y) | n < 0 = f (n + 1) (pred y) | otherwise = y For example:

enumFromThen 4 6 :: [Integer] = [4,6,8,10...]

enumFromThen 6 2 :: [Int] = [6,2,-2,-6,...,minBound :: Int]

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

Used in Haskell's translation of [n..m] with [n..m] = enumFromTo n m, a possible implementation being enumFromTo n m | n <= m = n : enumFromTo (succ n) m | otherwise = []. For example:

```
enumFromTo 6 10 :: [Int] = [6,7,8,9,10]
```
```
enumFromTo 42 1 :: [Integer] = []
```

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

Used in Haskell's translation of [n,n'..m] with [n,n'..m] = enumFromThenTo n n' m, a possible implementation being enumFromThenTo n n' m = worker (f x) (c x) n m, x = fromEnum n' - fromEnum n, c x = bool (>=) ((x 0) f n y | n > 0 = f (n - 1) (succ y) | n < 0 = f (n + 1) (pred y) | otherwise = y and worker s c v m | c v m = v : worker s c (s v) m | otherwise = [] For example:

enumFromThenTo 4 2 -6 :: [Integer] = [4,2,0,-2,-4,-6]

```
enumFromThenTo 6 8 2 :: [Int] = []
```

Instances

Instances details

Enum Associativity	Since: base-4.9.0.0
Instance details Defined in GHC.Generics Methods succ :: Associativity -> Associativity # pred :: Associativity -> Associativity # toEnum :: Int -> Associativity # fromEnum :: Associativity -> Int # enumFrom :: Associativity -> [Associativity] # enumFromThen :: Associativity -> Associativity -> [Associativity] # enumFromTo :: Associativity -> Associativity -> [Associativity] # enumFromThenTo :: Associativity -> Associativity -> Associativity -> [Associativity] #
Enum DecidedStrictness	Since: base-4.9.0.0
Instance details Defined in GHC.Generics Methods succ :: DecidedStrictness -> DecidedStrictness # pred :: DecidedStrictness -> DecidedStrictness # toEnum :: Int -> DecidedStrictness # fromEnum :: DecidedStrictness -> Int # enumFrom :: DecidedStrictness -> [DecidedStrictness] # enumFromThen :: DecidedStrictness -> DecidedStrictness -> [DecidedStrictness] # enumFromTo :: DecidedStrictness -> DecidedStrictness -> [DecidedStrictness] # enumFromThenTo :: DecidedStrictness -> DecidedStrictness -> DecidedStrictness -> [DecidedStrictness] #
Enum SourceStrictness	Since: base-4.9.0.0
Instance details Defined in GHC.Generics Methods succ :: SourceStrictness -> SourceStrictness # pred :: SourceStrictness -> SourceStrictness # toEnum :: Int -> SourceStrictness # fromEnum :: SourceStrictness -> Int # enumFrom :: SourceStrictness -> [SourceStrictness] # enumFromThen :: SourceStrictness -> SourceStrictness -> [SourceStrictness] # enumFromTo :: SourceStrictness -> SourceStrictness -> [SourceStrictness] # enumFromThenTo :: SourceStrictness -> SourceStrictness -> SourceStrictness -> [SourceStrictness] #
Enum SourceUnpackedness	Since: base-4.9.0.0
Instance details Defined in GHC.Generics Methods succ :: SourceUnpackedness -> SourceUnpackedness # pred :: SourceUnpackedness -> SourceUnpackedness # toEnum :: Int -> SourceUnpackedness # fromEnum :: SourceUnpackedness -> Int # enumFrom :: SourceUnpackedness -> [SourceUnpackedness] # enumFromThen :: SourceUnpackedness -> SourceUnpackedness -> [SourceUnpackedness] # enumFromTo :: SourceUnpackedness -> SourceUnpackedness -> [SourceUnpackedness] # enumFromThenTo :: SourceUnpackedness -> SourceUnpackedness -> SourceUnpackedness -> [SourceUnpackedness] #
Enum Int16	Since: base-2.1
Instance details Defined in GHC.Int Methods succ :: Int16 -> Int16 # pred :: Int16 -> Int16 # toEnum :: Int -> Int16 # fromEnum :: Int16 -> Int # enumFrom :: Int16 -> [Int16] # enumFromThen :: Int16 -> Int16 -> [Int16] # enumFromTo :: Int16 -> Int16 -> [Int16] # enumFromThenTo :: Int16 -> Int16 -> Int16 -> [Int16] #
Enum Int32	Since: base-2.1
Instance details Defined in GHC.Int Methods succ :: Int32 -> Int32 # pred :: Int32 -> Int32 # toEnum :: Int -> Int32 # fromEnum :: Int32 -> Int # enumFrom :: Int32 -> [Int32] # enumFromThen :: Int32 -> Int32 -> [Int32] # enumFromTo :: Int32 -> Int32 -> [Int32] # enumFromThenTo :: Int32 -> Int32 -> Int32 -> [Int32] #
Enum Int64	Since: base-2.1
Instance details Defined in GHC.Int Methods succ :: Int64 -> Int64 # pred :: Int64 -> Int64 # toEnum :: Int -> Int64 # fromEnum :: Int64 -> Int # enumFrom :: Int64 -> [Int64] # enumFromThen :: Int64 -> Int64 -> [Int64] # enumFromTo :: Int64 -> Int64 -> [Int64] # enumFromThenTo :: Int64 -> Int64 -> Int64 -> [Int64] #
Enum Int8	Since: base-2.1
Instance details Defined in GHC.Int 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 Word16	Since: base-2.1
Instance details Defined in GHC.Word Methods succ :: Word16 -> Word16 # pred :: Word16 -> Word16 # toEnum :: Int -> Word16 # fromEnum :: Word16 -> Int # enumFrom :: Word16 -> [Word16] # enumFromThen :: Word16 -> Word16 -> [Word16] # enumFromTo :: Word16 -> Word16 -> [Word16] # enumFromThenTo :: Word16 -> Word16 -> Word16 -> [Word16] #
Enum Word32	Since: base-2.1
Instance details Defined in GHC.Word Methods succ :: Word32 -> Word32 # pred :: Word32 -> Word32 # toEnum :: Int -> Word32 # fromEnum :: Word32 -> Int # enumFrom :: Word32 -> [Word32] # enumFromThen :: Word32 -> Word32 -> [Word32] # enumFromTo :: Word32 -> Word32 -> [Word32] # enumFromThenTo :: Word32 -> Word32 -> Word32 -> [Word32] #
Enum Word64	Since: base-2.1
Instance details Defined in GHC.Word Methods succ :: Word64 -> Word64 # pred :: Word64 -> Word64 # toEnum :: Int -> Word64 # fromEnum :: Word64 -> Int # enumFrom :: Word64 -> [Word64] # enumFromThen :: Word64 -> Word64 -> [Word64] # enumFromTo :: Word64 -> Word64 -> [Word64] # enumFromThenTo :: Word64 -> Word64 -> Word64 -> [Word64] #
Enum Extension
Instance details Defined in GHC.LanguageExtensions.Type Methods succ :: Extension -> Extension # pred :: Extension -> Extension # toEnum :: Int -> Extension # fromEnum :: Extension -> Int # enumFrom :: Extension -> [Extension] # enumFromThen :: Extension -> Extension -> [Extension] # enumFromTo :: Extension -> Extension -> [Extension] # enumFromThenTo :: Extension -> Extension -> Extension -> [Extension] #
Enum Ordering	Since: base-2.1
Instance details Defined in GHC.Enum Methods succ :: Ordering -> Ordering # pred :: Ordering -> Ordering # toEnum :: Int -> Ordering # fromEnum :: Ordering -> Int # enumFrom :: Ordering -> [Ordering] # enumFromThen :: Ordering -> Ordering -> [Ordering] # enumFromTo :: Ordering -> Ordering -> [Ordering] # enumFromThenTo :: Ordering -> Ordering -> Ordering -> [Ordering] #
Enum Word8	Since: base-2.1
Instance details Defined in GHC.Word Methods succ :: Word8 -> Word8 # pred :: Word8 -> Word8 # toEnum :: Int -> Word8 # fromEnum :: Word8 -> Int # enumFrom :: Word8 -> [Word8] # enumFromThen :: Word8 -> Word8 -> [Word8] # enumFromTo :: Word8 -> Word8 -> [Word8] # enumFromThenTo :: Word8 -> Word8 -> Word8 -> [Word8] #
Enum Integer	Since: base-2.1
Instance details Defined in GHC.Enum Methods succ :: Integer -> Integer # pred :: Integer -> Integer # toEnum :: Int -> Integer # fromEnum :: Integer -> Int # enumFrom :: Integer -> [Integer] # enumFromThen :: Integer -> Integer -> [Integer] # enumFromTo :: Integer -> Integer -> [Integer] # enumFromThenTo :: Integer -> Integer -> Integer -> [Integer] #
Enum Natural	Since: base-4.8.0.0
Instance details Defined in GHC.Enum Methods succ :: Natural -> Natural # pred :: Natural -> Natural # toEnum :: Int -> Natural # fromEnum :: Natural -> Int # enumFrom :: Natural -> [Natural] # enumFromThen :: Natural -> Natural -> [Natural] # enumFromTo :: Natural -> Natural -> [Natural] # enumFromThenTo :: Natural -> Natural -> Natural -> [Natural] #
Enum ()	Since: base-2.1
Instance details Defined in GHC.Enum Methods succ :: () -> () # pred :: () -> () # toEnum :: Int -> () # fromEnum :: () -> Int # enumFrom :: () -> [()] # enumFromThen :: () -> () -> [()] # enumFromTo :: () -> () -> [()] # enumFromThenTo :: () -> () -> () -> [()] #
Enum Bool	Since: base-2.1
Instance details Defined in GHC.Enum 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: base-2.1
Instance details Defined in GHC.Enum 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: base-2.1
Instance details Defined in GHC.Enum 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 VecCount	Since: base-4.10.0.0
Instance details Defined in GHC.Enum Methods succ :: VecCount -> VecCount # pred :: VecCount -> VecCount # toEnum :: Int -> VecCount # fromEnum :: VecCount -> Int # enumFrom :: VecCount -> [VecCount] # enumFromThen :: VecCount -> VecCount -> [VecCount] # enumFromTo :: VecCount -> VecCount -> [VecCount] # enumFromThenTo :: VecCount -> VecCount -> VecCount -> [VecCount] #
Enum VecElem	Since: base-4.10.0.0
Instance details Defined in GHC.Enum Methods succ :: VecElem -> VecElem # pred :: VecElem -> VecElem # toEnum :: Int -> VecElem # fromEnum :: VecElem -> Int # enumFrom :: VecElem -> [VecElem] # enumFromThen :: VecElem -> VecElem -> [VecElem] # enumFromTo :: VecElem -> VecElem -> [VecElem] # enumFromThenTo :: VecElem -> VecElem -> VecElem -> [VecElem] #
Enum Word	Since: base-2.1
Instance details Defined in GHC.Enum 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 a => Enum (Identity a)	Since: base-4.9.0.0
Instance details Defined in Data.Functor.Identity Methods succ :: Identity a -> Identity a # pred :: Identity a -> Identity a # toEnum :: Int -> Identity a # fromEnum :: Identity a -> Int # enumFrom :: Identity a -> [Identity a] # enumFromThen :: Identity a -> Identity a -> [Identity a] # enumFromTo :: Identity a -> Identity a -> [Identity a] # enumFromThenTo :: Identity a -> Identity a -> Identity a -> [Identity a] #
Enum a => Enum (First a)	Since: base-4.9.0.0
Instance details Defined in Data.Semigroup 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: base-4.9.0.0
Instance details Defined in Data.Semigroup 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 (Max a)	Since: base-4.9.0.0
Instance details Defined in Data.Semigroup 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 (Min a)	Since: base-4.9.0.0
Instance details Defined in Data.Semigroup 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 (WrappedMonoid a)	Since: base-4.9.0.0
Instance details Defined in Data.Semigroup Methods succ :: WrappedMonoid a -> WrappedMonoid a # pred :: WrappedMonoid a -> WrappedMonoid a # toEnum :: Int -> WrappedMonoid a # fromEnum :: WrappedMonoid a -> Int # enumFrom :: WrappedMonoid a -> [WrappedMonoid a] # enumFromThen :: WrappedMonoid a -> WrappedMonoid a -> [WrappedMonoid a] # enumFromTo :: WrappedMonoid a -> WrappedMonoid a -> [WrappedMonoid a] # enumFromThenTo :: WrappedMonoid a -> WrappedMonoid a -> WrappedMonoid a -> [WrappedMonoid a] #
Integral a => Enum (Ratio a)	Since: base-2.0.1
Instance details Defined in GHC.Real 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 (Fixed a)	Recall that, for numeric types, `succ` and `pred` typically add and subtract `1`, respectively. This is not true in the case of `Fixed`, whose successor and predecessor functions intuitively return the "next" and "previous" values in the enumeration. The results of these functions thus depend on the resolution of the `Fixed` value. For example, when enumerating values of resolution `10^-3` of `type Milli = Fixed E3`, succ (0.000 :: Milli) == 1.001 and likewise pred (0.000 :: Milli) == -0.001 In other words, `succ` and `pred` increment and decrement a fixed-precision value by the least amount such that the value's resolution is unchanged. For example, `10^-12` is the smallest (positive) amount that can be added to a value of `type Pico = Fixed E12` without changing its resolution, and so succ (0.000000000000 :: Pico) == 0.000000000001 and similarly pred (0.000000000000 :: Pico) == -0.000000000001 This is worth bearing in mind when defining `Fixed` arithmetic sequences. In particular, you may be forgiven for thinking the sequence [1..10] :: [Pico] evaluates to `[1, 2, 3, 4, 5, 6, 7, 8, 9, 10] :: [Pico]`. However, this is not true. On the contrary, similarly to the above implementations of `succ` and `pred`, `enumFromTo :: Pico -> Pico -> [Pico]` has a "step size" of `10^-12`. Hence, the list `[1..10] :: [Pico]` has the form [1.000000000000, 1.00000000001, 1.00000000002, ..., 10.000000000000] and contains `9 * 10^12 + 1` values. Since: base-2.1
Instance details Defined in Data.Fixed Methods succ :: Fixed a -> Fixed a # pred :: Fixed a -> Fixed a # toEnum :: Int -> Fixed a # fromEnum :: Fixed a -> Int # enumFrom :: Fixed a -> [Fixed a] # enumFromThen :: Fixed a -> Fixed a -> [Fixed a] # enumFromTo :: Fixed a -> Fixed a -> [Fixed a] # enumFromThenTo :: Fixed a -> Fixed a -> Fixed a -> [Fixed a] #
Enum (Proxy s)	Since: base-4.7.0.0
Instance details Defined in Data.Proxy 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)	Since: base-4.9.0.0
Instance details Defined in Data.Functor.Const 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 (Ap f a)	Since: base-4.12.0.0
Instance details Defined in Data.Monoid Methods succ :: Ap f a -> Ap f a # pred :: Ap f a -> Ap f a # toEnum :: Int -> Ap f a # fromEnum :: Ap f a -> Int # enumFrom :: Ap f a -> [Ap f a] # enumFromThen :: Ap f a -> Ap f a -> [Ap f a] # enumFromTo :: Ap f a -> Ap f a -> [Ap f a] # enumFromThenTo :: Ap f a -> Ap f a -> Ap f a -> [Ap f a] #
a ~ b => Enum (a :~: b)	Since: base-4.7.0.0
Instance details Defined in Data.Type.Equality 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] #
a ~~ b => Enum (a :~~: b)	Since: base-4.10.0.0
Instance details Defined in Data.Type.Equality 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] #

undefined :: forall (r :: RuntimeRep) (a :: TYPE r). HasCallStack => a #

A special case of error. It is expected that compilers will recognize this and insert error messages which are more appropriate to the context in which undefined appears.

error :: forall (r :: RuntimeRep) (a :: TYPE r). HasCallStack => [Char] -> a #

error stops execution and displays an error message.

data Double #

Double-precision floating point numbers. It is desirable that this type be at least equal in range and precision to the IEEE double-precision type.

Constructors

D# Double#

Instances

Instances details

Floating Double	Since: base-2.1
Instance details Defined in GHC.Float Methods pi :: Double # exp :: Double -> Double # log :: Double -> Double # sqrt :: Double -> Double # (**) :: Double -> Double -> Double # logBase :: Double -> Double -> Double # sin :: Double -> Double # cos :: Double -> Double # tan :: Double -> Double # asin :: Double -> Double # acos :: Double -> Double # atan :: Double -> Double # sinh :: Double -> Double # cosh :: Double -> Double # tanh :: Double -> Double # asinh :: Double -> Double # acosh :: Double -> Double # atanh :: Double -> Double # log1p :: Double -> Double # expm1 :: Double -> Double # log1pexp :: Double -> Double # log1mexp :: Double -> Double #
RealFloat Double	Since: base-2.1
Instance details Defined in GHC.Float Methods floatRadix :: Double -> Integer # floatDigits :: Double -> Int # floatRange :: Double -> (Int, Int) # decodeFloat :: Double -> (Integer, Int) # encodeFloat :: Integer -> Int -> Double # exponent :: Double -> Int # significand :: Double -> Double # scaleFloat :: Int -> Double -> Double # isNaN :: Double -> Bool # isInfinite :: Double -> Bool # isDenormalized :: Double -> Bool # isNegativeZero :: Double -> Bool # isIEEE :: Double -> Bool # atan2 :: Double -> Double -> Double #
Read Double	Since: base-2.1
Instance details Defined in GHC.Read Methods readsPrec :: Int -> ReadS Double # readList :: ReadS [Double] # readPrec :: ReadPrec Double # readListPrec :: ReadPrec [Double] #
Default Double
Instance details Defined in Data.Default.Class Methods def :: Double #
Eq Double	Note that due to the presence of `NaN`, `Double`'s `Eq` instance does not satisfy reflexivity. `>>>` `0/0 == (0/0 :: Double)`False Also note that `Double`'s `Eq` instance does not satisfy substitutivity: `>>>` `0 == (-0 :: Double)`True `>>>` `recip 0 == recip (-0 :: Double)`False
Instance details Defined in GHC.Classes Methods (==) :: Double -> Double -> Bool # (/=) :: Double -> Double -> Bool #
Ord Double	Note that due to the presence of `NaN`, `Double`'s `Ord` instance does not satisfy reflexivity. `>>>` `0/0 <= (0/0 :: Double)`False Also note that, due to the same, `Ord`'s operator interactions are not respected by `Double`'s instance: `>>>` `(0/0 :: Double) > 1`False `>>>` `compare (0/0 :: Double) 1`GT
Instance details Defined in GHC.Classes Methods compare :: Double -> Double -> Ordering # (<) :: Double -> Double -> Bool # (<=) :: Double -> Double -> Bool # (>) :: Double -> Double -> Bool # (>=) :: Double -> Double -> Bool # max :: Double -> Double -> Double # min :: Double -> Double -> Double #
Lift Double
Instance details Defined in Language.Haskell.TH.Syntax Methods lift :: Quote m => Double -> m Exp # liftTyped :: forall (m :: Type -> Type). Quote m => Double -> Code m Double #
Generic1 (URec Double :: k -> Type)
Instance details Defined in GHC.Generics Associated Types type Rep1 (URec Double) :: k -> Type # Methods from1 :: forall (a :: k0). URec Double a -> Rep1 (URec Double) a # to1 :: forall (a :: k0). Rep1 (URec Double) a -> URec Double a #
Foldable (UDouble :: Type -> Type)	Since: base-4.9.0.0
Instance details Defined in Data.Foldable Methods fold :: Monoid m => UDouble m -> m # foldMap :: Monoid m => (a -> m) -> UDouble a -> m # foldMap' :: Monoid m => (a -> m) -> UDouble a -> m # foldr :: (a -> b -> b) -> b -> UDouble a -> b # foldr' :: (a -> b -> b) -> b -> UDouble a -> b # foldl :: (b -> a -> b) -> b -> UDouble a -> b # foldl' :: (b -> a -> b) -> b -> UDouble a -> b # foldr1 :: (a -> a -> a) -> UDouble a -> a # foldl1 :: (a -> a -> a) -> UDouble a -> a # toList :: UDouble a -> [a] # null :: UDouble a -> Bool # length :: UDouble a -> Int # elem :: Eq a => a -> UDouble a -> Bool # maximum :: Ord a => UDouble a -> a # minimum :: Ord a => UDouble a -> a # sum :: Num a => UDouble a -> a # product :: Num a => UDouble a -> a #
Traversable (UDouble :: Type -> Type)	Since: base-4.9.0.0
Instance details Defined in Data.Traversable Methods traverse :: Applicative f => (a -> f b) -> UDouble a -> f (UDouble b) # sequenceA :: Applicative f => UDouble (f a) -> f (UDouble a) # mapM :: Monad m => (a -> m b) -> UDouble a -> m (UDouble b) # sequence :: Monad m => UDouble (m a) -> m (UDouble a) #
Functor (URec Double :: Type -> Type)	Since: base-4.9.0.0
Instance details Defined in GHC.Generics Methods fmap :: (a -> b) -> URec Double a -> URec Double b # (<$) :: a -> URec Double b -> URec Double a #
Generic (URec Double p)
Instance details Defined in GHC.Generics Associated Types type Rep (URec Double p) :: Type -> Type # Methods from :: URec Double p -> Rep (URec Double p) x # to :: Rep (URec Double p) x -> URec Double p #
Show (URec Double p)	Since: base-4.9.0.0
Instance details Defined in GHC.Generics Methods showsPrec :: Int -> URec Double p -> ShowS # show :: URec Double p -> String # showList :: [URec Double p] -> ShowS #
Eq (URec Double p)	Since: base-4.9.0.0
Instance details Defined in GHC.Generics Methods (==) :: URec Double p -> URec Double p -> Bool # (/=) :: URec Double p -> URec Double p -> Bool #
Ord (URec Double p)	Since: base-4.9.0.0
Instance details Defined in GHC.Generics Methods compare :: URec Double p -> URec Double p -> Ordering # (<) :: URec Double p -> URec Double p -> Bool # (<=) :: URec Double p -> URec Double p -> Bool # (>) :: URec Double p -> URec Double p -> Bool # (>=) :: URec Double p -> URec Double p -> Bool # max :: URec Double p -> URec Double p -> URec Double p # min :: URec Double p -> URec Double p -> URec Double p #
data URec Double (p :: k)	Used for marking occurrences of `Double#` Since: base-4.9.0.0
Instance details Defined in GHC.Generics data URec Double (p :: k) = UDouble { uDouble# :: Double# }
type Rep1 (URec Double :: k -> Type)	Since: base-4.9.0.0
Instance details Defined in GHC.Generics type Rep1 (URec Double :: k -> Type) = D1 ('MetaData "URec" "GHC.Generics" "base" 'False) (C1 ('MetaCons "UDouble" 'PrefixI 'True) (S1 ('MetaSel ('Just "uDouble#") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (UDouble :: k -> Type)))
type Rep (URec Double p)	Since: base-4.9.0.0
Instance details Defined in GHC.Generics type Rep (URec Double p) = D1 ('MetaData "URec" "GHC.Generics" "base" 'False) (C1 ('MetaCons "UDouble" 'PrefixI 'True) (S1 ('MetaSel ('Just "uDouble#") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (UDouble :: Type -> Type)))

data Float #

Single-precision floating point numbers. It is desirable that this type be at least equal in range and precision to the IEEE single-precision type.

Constructors

F# Float#

Instances

Instances details

Floating Float	Since: base-2.1
Instance details Defined in GHC.Float Methods pi :: Float # exp :: Float -> Float # log :: Float -> Float # sqrt :: Float -> Float # (**) :: Float -> Float -> Float # logBase :: Float -> Float -> Float # sin :: Float -> Float # cos :: Float -> Float # tan :: Float -> Float # asin :: Float -> Float # acos :: Float -> Float # atan :: Float -> Float # sinh :: Float -> Float # cosh :: Float -> Float # tanh :: Float -> Float # asinh :: Float -> Float # acosh :: Float -> Float # atanh :: Float -> Float # log1p :: Float -> Float # expm1 :: Float -> Float # log1pexp :: Float -> Float # log1mexp :: Float -> Float #
RealFloat Float	Since: base-2.1
Instance details Defined in GHC.Float Methods floatRadix :: Float -> Integer # floatDigits :: Float -> Int # floatRange :: Float -> (Int, Int) # decodeFloat :: Float -> (Integer, Int) # encodeFloat :: Integer -> Int -> Float # exponent :: Float -> Int # significand :: Float -> Float # scaleFloat :: Int -> Float -> Float # isNaN :: Float -> Bool # isInfinite :: Float -> Bool # isDenormalized :: Float -> Bool # isNegativeZero :: Float -> Bool # isIEEE :: Float -> Bool # atan2 :: Float -> Float -> Float #
Read Float	Since: base-2.1
Instance details Defined in GHC.Read Methods readsPrec :: Int -> ReadS Float # readList :: ReadS [Float] # readPrec :: ReadPrec Float # readListPrec :: ReadPrec [Float] #
Default Float
Instance details Defined in Data.Default.Class Methods def :: Float #
Eq Float	Note that due to the presence of `NaN`, `Float`'s `Eq` instance does not satisfy reflexivity. `>>>` `0/0 == (0/0 :: Float)`False Also note that `Float`'s `Eq` instance does not satisfy substitutivity: `>>>` `0 == (-0 :: Float)`True `>>>` `recip 0 == recip (-0 :: Float)`False
Instance details Defined in GHC.Classes Methods (==) :: Float -> Float -> Bool # (/=) :: Float -> Float -> Bool #
Ord Float	Note that due to the presence of `NaN`, `Float`'s `Ord` instance does not satisfy reflexivity. `>>>` `0/0 <= (0/0 :: Float)`False Also note that, due to the same, `Ord`'s operator interactions are not respected by `Float`'s instance: `>>>` `(0/0 :: Float) > 1`False `>>>` `compare (0/0 :: Float) 1`GT
Instance details Defined in GHC.Classes Methods compare :: Float -> Float -> Ordering # (<) :: Float -> Float -> Bool # (<=) :: Float -> Float -> Bool # (>) :: Float -> Float -> Bool # (>=) :: Float -> Float -> Bool # max :: Float -> Float -> Float # min :: Float -> Float -> Float #
Lift Float
Instance details Defined in Language.Haskell.TH.Syntax Methods lift :: Quote m => Float -> m Exp # liftTyped :: forall (m :: Type -> Type). Quote m => Float -> Code m Float #
Generic1 (URec Float :: k -> Type)
Instance details Defined in GHC.Generics Associated Types type Rep1 (URec Float) :: k -> Type # Methods from1 :: forall (a :: k0). URec Float a -> Rep1 (URec Float) a # to1 :: forall (a :: k0). Rep1 (URec Float) a -> URec Float a #
Foldable (UFloat :: Type -> Type)	Since: base-4.9.0.0
Instance details Defined in Data.Foldable Methods fold :: Monoid m => UFloat m -> m # foldMap :: Monoid m => (a -> m) -> UFloat a -> m # foldMap' :: Monoid m => (a -> m) -> UFloat a -> m # foldr :: (a -> b -> b) -> b -> UFloat a -> b # foldr' :: (a -> b -> b) -> b -> UFloat a -> b # foldl :: (b -> a -> b) -> b -> UFloat a -> b # foldl' :: (b -> a -> b) -> b -> UFloat a -> b # foldr1 :: (a -> a -> a) -> UFloat a -> a # foldl1 :: (a -> a -> a) -> UFloat a -> a # toList :: UFloat a -> [a] # null :: UFloat a -> Bool # length :: UFloat a -> Int # elem :: Eq a => a -> UFloat a -> Bool # maximum :: Ord a => UFloat a -> a # minimum :: Ord a => UFloat a -> a # sum :: Num a => UFloat a -> a # product :: Num a => UFloat a -> a #
Traversable (UFloat :: Type -> Type)	Since: base-4.9.0.0
Instance details Defined in Data.Traversable Methods traverse :: Applicative f => (a -> f b) -> UFloat a -> f (UFloat b) # sequenceA :: Applicative f => UFloat (f a) -> f (UFloat a) # mapM :: Monad m => (a -> m b) -> UFloat a -> m (UFloat b) # sequence :: Monad m => UFloat (m a) -> m (UFloat a) #
Functor (URec Float :: Type -> Type)	Since: base-4.9.0.0
Instance details Defined in GHC.Generics Methods fmap :: (a -> b) -> URec Float a -> URec Float b # (<$) :: a -> URec Float b -> URec Float a #
Generic (URec Float p)
Instance details Defined in GHC.Generics Associated Types type Rep (URec Float p) :: Type -> Type # Methods from :: URec Float p -> Rep (URec Float p) x # to :: Rep (URec Float p) x -> URec Float p #
Show (URec Float p)
Instance details Defined in GHC.Generics Methods showsPrec :: Int -> URec Float p -> ShowS # show :: URec Float p -> String # showList :: [URec Float p] -> ShowS #
Eq (URec Float p)
Instance details Defined in GHC.Generics Methods (==) :: URec Float p -> URec Float p -> Bool # (/=) :: URec Float p -> URec Float p -> Bool #
Ord (URec Float p)
Instance details Defined in GHC.Generics Methods compare :: URec Float p -> URec Float p -> Ordering # (<) :: URec Float p -> URec Float p -> Bool # (<=) :: URec Float p -> URec Float p -> Bool # (>) :: URec Float p -> URec Float p -> Bool # (>=) :: URec Float p -> URec Float p -> Bool # max :: URec Float p -> URec Float p -> URec Float p # min :: URec Float p -> URec Float p -> URec Float p #
data URec Float (p :: k)	Used for marking occurrences of `Float#` Since: base-4.9.0.0
Instance details Defined in GHC.Generics data URec Float (p :: k) = UFloat { uFloat# :: Float# }
type Rep1 (URec Float :: k -> Type)	Since: base-4.9.0.0
Instance details Defined in GHC.Generics type Rep1 (URec Float :: k -> Type) = D1 ('MetaData "URec" "GHC.Generics" "base" 'False) (C1 ('MetaCons "UFloat" 'PrefixI 'True) (S1 ('MetaSel ('Just "uFloat#") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (UFloat :: k -> Type)))
type Rep (URec Float p)
Instance details Defined in GHC.Generics type Rep (URec Float p) = D1 ('MetaData "URec" "GHC.Generics" "base" 'False) (C1 ('MetaCons "UFloat" 'PrefixI 'True) (S1 ('MetaSel ('Just "uFloat#") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (UFloat :: Type -> Type)))

class Generic a #

Representable types of kind *. This class is derivable in GHC with the DeriveGeneric flag on.

A Generic instance must satisfy the following laws:

from . to ≡ id
to . from ≡ id

Minimal complete definition

from, to

Instances

Instances details

Generic Void
Instance details Defined in Data.Void Associated Types type Rep Void :: Type -> Type # Methods from :: Void -> Rep Void x # to :: Rep Void x -> Void #
Generic Fingerprint
Instance details Defined in GHC.Generics Associated Types type Rep Fingerprint :: Type -> Type # Methods from :: Fingerprint -> Rep Fingerprint x # to :: Rep Fingerprint x -> Fingerprint #
Generic Associativity
Instance details Defined in GHC.Generics Associated Types type Rep Associativity :: Type -> Type # Methods from :: Associativity -> Rep Associativity x # to :: Rep Associativity x -> Associativity #
Generic DecidedStrictness
Instance details Defined in GHC.Generics Associated Types type Rep DecidedStrictness :: Type -> Type # Methods from :: DecidedStrictness -> Rep DecidedStrictness x # to :: Rep DecidedStrictness x -> DecidedStrictness #
Generic Fixity
Instance details Defined in GHC.Generics Associated Types type Rep Fixity :: Type -> Type # Methods from :: Fixity -> Rep Fixity x # to :: Rep Fixity x -> Fixity #
Generic SourceStrictness
Instance details Defined in GHC.Generics Associated Types type Rep SourceStrictness :: Type -> Type # Methods from :: SourceStrictness -> Rep SourceStrictness x # to :: Rep SourceStrictness x -> SourceStrictness #
Generic SourceUnpackedness
Instance details Defined in GHC.Generics Associated Types type Rep SourceUnpackedness :: Type -> Type # Methods from :: SourceUnpackedness -> Rep SourceUnpackedness x # to :: Rep SourceUnpackedness x -> SourceUnpackedness #
Generic SrcLoc
Instance details Defined in GHC.Generics Associated Types type Rep SrcLoc :: Type -> Type # Methods from :: SrcLoc -> Rep SrcLoc x # to :: Rep SrcLoc x -> SrcLoc #
Generic GeneralCategory
Instance details Defined in GHC.Generics Associated Types type Rep GeneralCategory :: Type -> Type # Methods from :: GeneralCategory -> Rep GeneralCategory x # to :: Rep GeneralCategory x -> GeneralCategory #
Generic ForeignSrcLang
Instance details Defined in GHC.ForeignSrcLang.Type Associated Types type Rep ForeignSrcLang :: Type -> Type # Methods from :: ForeignSrcLang -> Rep ForeignSrcLang x # to :: Rep ForeignSrcLang x -> ForeignSrcLang #
Generic Extension
Instance details Defined in GHC.LanguageExtensions.Type Associated Types type Rep Extension :: Type -> Type # Methods from :: Extension -> Rep Extension x # to :: Rep Extension x -> Extension #
Generic Ordering
Instance details Defined in GHC.Generics Associated Types type Rep Ordering :: Type -> Type # Methods from :: Ordering -> Rep Ordering x # to :: Rep Ordering x -> Ordering #
Generic AnnLookup
Instance details Defined in Language.Haskell.TH.Syntax Associated Types type Rep AnnLookup :: Type -> Type # Methods from :: AnnLookup -> Rep AnnLookup x # to :: Rep AnnLookup x -> AnnLookup #
Generic AnnTarget
Instance details Defined in Language.Haskell.TH.Syntax Associated Types type Rep AnnTarget :: Type -> Type # Methods from :: AnnTarget -> Rep AnnTarget x # to :: Rep AnnTarget x -> AnnTarget #
Generic Bang
Instance details Defined in Language.Haskell.TH.Syntax Associated Types type Rep Bang :: Type -> Type # Methods from :: Bang -> Rep Bang x # to :: Rep Bang x -> Bang #
Generic Body
Instance details Defined in Language.Haskell.TH.Syntax Associated Types type Rep Body :: Type -> Type # Methods from :: Body -> Rep Body x # to :: Rep Body x -> Body #
Generic Bytes
Instance details Defined in Language.Haskell.TH.Syntax Associated Types type Rep Bytes :: Type -> Type # Methods from :: Bytes -> Rep Bytes x # to :: Rep Bytes x -> Bytes #
Generic Callconv
Instance details Defined in Language.Haskell.TH.Syntax Associated Types type Rep Callconv :: Type -> Type # Methods from :: Callconv -> Rep Callconv x # to :: Rep Callconv x -> Callconv #
Generic Clause
Instance details Defined in Language.Haskell.TH.Syntax Associated Types type Rep Clause :: Type -> Type # Methods from :: Clause -> Rep Clause x # to :: Rep Clause x -> Clause #
Generic Con
Instance details Defined in Language.Haskell.TH.Syntax Associated Types type Rep Con :: Type -> Type # Methods from :: Con -> Rep Con x # to :: Rep Con x -> Con #
Generic Dec
Instance details Defined in Language.Haskell.TH.Syntax Associated Types type Rep Dec :: Type -> Type # Methods from :: Dec -> Rep Dec x # to :: Rep Dec x -> Dec #
Generic DecidedStrictness
Instance details Defined in Language.Haskell.TH.Syntax Associated Types type Rep DecidedStrictness :: Type -> Type # Methods from :: DecidedStrictness -> Rep DecidedStrictness x # to :: Rep DecidedStrictness x -> DecidedStrictness #
Generic DerivClause
Instance details Defined in Language.Haskell.TH.Syntax Associated Types type Rep DerivClause :: Type -> Type # Methods from :: DerivClause -> Rep DerivClause x # to :: Rep DerivClause x -> DerivClause #
Generic DerivStrategy
Instance details Defined in Language.Haskell.TH.Syntax Associated Types type Rep DerivStrategy :: Type -> Type # Methods from :: DerivStrategy -> Rep DerivStrategy x # to :: Rep DerivStrategy x -> DerivStrategy #
Generic Exp
Instance details Defined in Language.Haskell.TH.Syntax Associated Types type Rep Exp :: Type -> Type # Methods from :: Exp -> Rep Exp x # to :: Rep Exp x -> Exp #
Generic FamilyResultSig
Instance details Defined in Language.Haskell.TH.Syntax Associated Types type Rep FamilyResultSig :: Type -> Type # Methods from :: FamilyResultSig -> Rep FamilyResultSig x # to :: Rep FamilyResultSig x -> FamilyResultSig #
Generic Fixity
Instance details Defined in Language.Haskell.TH.Syntax Associated Types type Rep Fixity :: Type -> Type # Methods from :: Fixity -> Rep Fixity x # to :: Rep Fixity x -> Fixity #
Generic FixityDirection
Instance details Defined in Language.Haskell.TH.Syntax Associated Types type Rep FixityDirection :: Type -> Type # Methods from :: FixityDirection -> Rep FixityDirection x # to :: Rep FixityDirection x -> FixityDirection #
Generic Foreign
Instance details Defined in Language.Haskell.TH.Syntax Associated Types type Rep Foreign :: Type -> Type # Methods from :: Foreign -> Rep Foreign x # to :: Rep Foreign x -> Foreign #
Generic FunDep
Instance details Defined in Language.Haskell.TH.Syntax Associated Types type Rep FunDep :: Type -> Type # Methods from :: FunDep -> Rep FunDep x # to :: Rep FunDep x -> FunDep #
Generic Guard
Instance details Defined in Language.Haskell.TH.Syntax Associated Types type Rep Guard :: Type -> Type # Methods from :: Guard -> Rep Guard x # to :: Rep Guard x -> Guard #
Generic Info
Instance details Defined in Language.Haskell.TH.Syntax Associated Types type Rep Info :: Type -> Type # Methods from :: Info -> Rep Info x # to :: Rep Info x -> Info #
Generic InjectivityAnn
Instance details Defined in Language.Haskell.TH.Syntax Associated Types type Rep InjectivityAnn :: Type -> Type # Methods from :: InjectivityAnn -> Rep InjectivityAnn x # to :: Rep InjectivityAnn x -> InjectivityAnn #
Generic Inline
Instance details Defined in Language.Haskell.TH.Syntax Associated Types type Rep Inline :: Type -> Type # Methods from :: Inline -> Rep Inline x # to :: Rep Inline x -> Inline #
Generic Lit
Instance details Defined in Language.Haskell.TH.Syntax Associated Types type Rep Lit :: Type -> Type # Methods from :: Lit -> Rep Lit x # to :: Rep Lit x -> Lit #
Generic Loc
Instance details Defined in Language.Haskell.TH.Syntax Associated Types type Rep Loc :: Type -> Type # Methods from :: Loc -> Rep Loc x # to :: Rep Loc x -> Loc #
Generic Match
Instance details Defined in Language.Haskell.TH.Syntax Associated Types type Rep Match :: Type -> Type # Methods from :: Match -> Rep Match x # to :: Rep Match x -> Match #
Generic ModName
Instance details Defined in Language.Haskell.TH.Syntax Associated Types type Rep ModName :: Type -> Type # Methods from :: ModName -> Rep ModName x # to :: Rep ModName x -> ModName #
Generic Module
Instance details Defined in Language.Haskell.TH.Syntax Associated Types type Rep Module :: Type -> Type # Methods from :: Module -> Rep Module x # to :: Rep Module x -> Module #
Generic ModuleInfo
Instance details Defined in Language.Haskell.TH.Syntax Associated Types type Rep ModuleInfo :: Type -> Type # Methods from :: ModuleInfo -> Rep ModuleInfo x # to :: Rep ModuleInfo x -> ModuleInfo #
Generic Name
Instance details Defined in Language.Haskell.TH.Syntax Associated Types type Rep Name :: Type -> Type # Methods from :: Name -> Rep Name x # to :: Rep Name x -> Name #
Generic NameFlavour
Instance details Defined in Language.Haskell.TH.Syntax Associated Types type Rep NameFlavour :: Type -> Type # Methods from :: NameFlavour -> Rep NameFlavour x # to :: Rep NameFlavour x -> NameFlavour #
Generic NameSpace
Instance details Defined in Language.Haskell.TH.Syntax Associated Types type Rep NameSpace :: Type -> Type # Methods from :: NameSpace -> Rep NameSpace x # to :: Rep NameSpace x -> NameSpace #
Generic OccName
Instance details Defined in Language.Haskell.TH.Syntax Associated Types type Rep OccName :: Type -> Type # Methods from :: OccName -> Rep OccName x # to :: Rep OccName x -> OccName #
Generic Overlap
Instance details Defined in Language.Haskell.TH.Syntax Associated Types type Rep Overlap :: Type -> Type # Methods from :: Overlap -> Rep Overlap x # to :: Rep Overlap x -> Overlap #
Generic Pat
Instance details Defined in Language.Haskell.TH.Syntax Associated Types type Rep Pat :: Type -> Type # Methods from :: Pat -> Rep Pat x # to :: Rep Pat x -> Pat #
Generic PatSynArgs
Instance details Defined in Language.Haskell.TH.Syntax Associated Types type Rep PatSynArgs :: Type -> Type # Methods from :: PatSynArgs -> Rep PatSynArgs x # to :: Rep PatSynArgs x -> PatSynArgs #
Generic PatSynDir
Instance details Defined in Language.Haskell.TH.Syntax Associated Types type Rep PatSynDir :: Type -> Type # Methods from :: PatSynDir -> Rep PatSynDir x # to :: Rep PatSynDir x -> PatSynDir #
Generic Phases
Instance details Defined in Language.Haskell.TH.Syntax Associated Types type Rep Phases :: Type -> Type # Methods from :: Phases -> Rep Phases x # to :: Rep Phases x -> Phases #
Generic PkgName
Instance details Defined in Language.Haskell.TH.Syntax Associated Types type Rep PkgName :: Type -> Type # Methods from :: PkgName -> Rep PkgName x # to :: Rep PkgName x -> PkgName #
Generic Pragma
Instance details Defined in Language.Haskell.TH.Syntax Associated Types type Rep Pragma :: Type -> Type # Methods from :: Pragma -> Rep Pragma x # to :: Rep Pragma x -> Pragma #
Generic Range
Instance details Defined in Language.Haskell.TH.Syntax Associated Types type Rep Range :: Type -> Type # Methods from :: Range -> Rep Range x # to :: Rep Range x -> Range #
Generic Role
Instance details Defined in Language.Haskell.TH.Syntax Associated Types type Rep Role :: Type -> Type # Methods from :: Role -> Rep Role x # to :: Rep Role x -> Role #
Generic RuleBndr
Instance details Defined in Language.Haskell.TH.Syntax Associated Types type Rep RuleBndr :: Type -> Type # Methods from :: RuleBndr -> Rep RuleBndr x # to :: Rep RuleBndr x -> RuleBndr #
Generic RuleMatch
Instance details Defined in Language.Haskell.TH.Syntax Associated Types type Rep RuleMatch :: Type -> Type # Methods from :: RuleMatch -> Rep RuleMatch x # to :: Rep RuleMatch x -> RuleMatch #
Generic Safety
Instance details Defined in Language.Haskell.TH.Syntax Associated Types type Rep Safety :: Type -> Type # Methods from :: Safety -> Rep Safety x # to :: Rep Safety x -> Safety #
Generic SourceStrictness
Instance details Defined in Language.Haskell.TH.Syntax Associated Types type Rep SourceStrictness :: Type -> Type # Methods from :: SourceStrictness -> Rep SourceStrictness x # to :: Rep SourceStrictness x -> SourceStrictness #
Generic SourceUnpackedness
Instance details Defined in Language.Haskell.TH.Syntax Associated Types type Rep SourceUnpackedness :: Type -> Type # Methods from :: SourceUnpackedness -> Rep SourceUnpackedness x # to :: Rep SourceUnpackedness x -> SourceUnpackedness #
Generic Specificity
Instance details Defined in Language.Haskell.TH.Syntax Associated Types type Rep Specificity :: Type -> Type # Methods from :: Specificity -> Rep Specificity x # to :: Rep Specificity x -> Specificity #
Generic Stmt
Instance details Defined in Language.Haskell.TH.Syntax Associated Types type Rep Stmt :: Type -> Type # Methods from :: Stmt -> Rep Stmt x # to :: Rep Stmt x -> Stmt #
Generic TyLit
Instance details Defined in Language.Haskell.TH.Syntax Associated Types type Rep TyLit :: Type -> Type # Methods from :: TyLit -> Rep TyLit x # to :: Rep TyLit x -> TyLit #
Generic TySynEqn
Instance details Defined in Language.Haskell.TH.Syntax Associated Types type Rep TySynEqn :: Type -> Type # Methods from :: TySynEqn -> Rep TySynEqn x # to :: Rep TySynEqn x -> TySynEqn #
Generic Type
Instance details Defined in Language.Haskell.TH.Syntax Associated Types type Rep Type :: Type -> Type # Methods from :: Type -> Rep Type x # to :: Rep Type x -> Type #
Generic TypeFamilyHead
Instance details Defined in Language.Haskell.TH.Syntax Associated Types type Rep TypeFamilyHead :: Type -> Type # Methods from :: TypeFamilyHead -> Rep TypeFamilyHead x # to :: Rep TypeFamilyHead x -> TypeFamilyHead #
Generic ()
Instance details Defined in GHC.Generics Associated Types type Rep () :: Type -> Type # Methods from :: () -> Rep () x # to :: Rep () x -> () #
Generic Bool
Instance details Defined in GHC.Generics Associated Types type Rep Bool :: Type -> Type # Methods from :: Bool -> Rep Bool x # to :: Rep Bool x -> Bool #
Generic (ZipList a)
Instance details Defined in Control.Applicative Associated Types type Rep (ZipList a) :: Type -> Type # Methods from :: ZipList a -> Rep (ZipList a) x # to :: Rep (ZipList a) x -> ZipList a #
Generic (Identity a)
Instance details Defined in Data.Functor.Identity Associated Types type Rep (Identity a) :: Type -> Type # Methods from :: Identity a -> Rep (Identity a) x # to :: Rep (Identity a) x -> Identity a #
Generic (First a)
Instance details Defined in Data.Monoid Associated Types type Rep (First a) :: Type -> Type # Methods from :: First a -> Rep (First a) x # to :: Rep (First a) x -> First a #
Generic (Last a)
Instance details Defined in Data.Monoid Associated Types type Rep (Last a) :: Type -> Type # Methods from :: Last a -> Rep (Last a) x # to :: Rep (Last a) x -> Last a #
Generic (Down a)
Instance details Defined in GHC.Generics Associated Types type Rep (Down a) :: Type -> Type # Methods from :: Down a -> Rep (Down a) x # to :: Rep (Down a) x -> Down a #
Generic (First a)
Instance details Defined in Data.Semigroup Associated Types type Rep (First a) :: Type -> Type # Methods from :: First a -> Rep (First a) x # to :: Rep (First a) x -> First a #
Generic (Last a)
Instance details Defined in Data.Semigroup Associated Types type Rep (Last a) :: Type -> Type # Methods from :: Last a -> Rep (Last a) x # to :: Rep (Last a) x -> Last a #
Generic (Max a)
Instance details Defined in Data.Semigroup Associated Types type Rep (Max a) :: Type -> Type # Methods from :: Max a -> Rep (Max a) x # to :: Rep (Max a) x -> Max a #
Generic (Min a)
Instance details Defined in Data.Semigroup Associated Types type Rep (Min a) :: Type -> Type # Methods from :: Min a -> Rep (Min a) x # to :: Rep (Min a) x -> Min a #
Generic (Option a)
Instance details Defined in Data.Semigroup Associated Types type Rep (Option a) :: Type -> Type # Methods from :: Option a -> Rep (Option a) x # to :: Rep (Option a) x -> Option a #
Generic (WrappedMonoid m)
Instance details Defined in Data.Semigroup Associated Types type Rep (WrappedMonoid m) :: Type -> Type # Methods from :: WrappedMonoid m -> Rep (WrappedMonoid m) x # to :: Rep (WrappedMonoid m) x -> WrappedMonoid m #
Generic (NonEmpty a)
Instance details Defined in GHC.Generics Associated Types type Rep (NonEmpty a) :: Type -> Type # Methods from :: NonEmpty a -> Rep (NonEmpty a) x # to :: Rep (NonEmpty a) x -> NonEmpty a #
Generic (Par1 p)
Instance details Defined in GHC.Generics Associated Types type Rep (Par1 p) :: Type -> Type # Methods from :: Par1 p -> Rep (Par1 p) x # to :: Rep (Par1 p) x -> Par1 p #
Generic (Digit a)
Instance details Defined in Data.Sequence.Internal Associated Types type Rep (Digit a) :: Type -> Type # Methods from :: Digit a -> Rep (Digit a) x # to :: Rep (Digit a) x -> Digit a #
Generic (Elem a)
Instance details Defined in Data.Sequence.Internal Associated Types type Rep (Elem a) :: Type -> Type # Methods from :: Elem a -> Rep (Elem a) x # to :: Rep (Elem a) x -> Elem a #
Generic (FingerTree a)
Instance details Defined in Data.Sequence.Internal Associated Types type Rep (FingerTree a) :: Type -> Type # Methods from :: FingerTree a -> Rep (FingerTree a) x # to :: Rep (FingerTree a) x -> FingerTree a #
Generic (Node a)
Instance details Defined in Data.Sequence.Internal Associated Types type Rep (Node a) :: Type -> Type # Methods from :: Node a -> Rep (Node a) x # to :: Rep (Node a) x -> Node a #
Generic (ViewL a)
Instance details Defined in Data.Sequence.Internal Associated Types type Rep (ViewL a) :: Type -> Type # Methods from :: ViewL a -> Rep (ViewL a) x # to :: Rep (ViewL a) x -> ViewL a #
Generic (ViewR a)
Instance details Defined in Data.Sequence.Internal Associated Types type Rep (ViewR a) :: Type -> Type # Methods from :: ViewR a -> Rep (ViewR a) x # to :: Rep (ViewR a) x -> ViewR a #
Generic (TyVarBndr flag)
Instance details Defined in Language.Haskell.TH.Syntax Associated Types type Rep (TyVarBndr flag) :: Type -> Type # Methods from :: TyVarBndr flag -> Rep (TyVarBndr flag) x # to :: Rep (TyVarBndr flag) x -> TyVarBndr flag #
Generic (Maybe a)
Instance details Defined in GHC.Generics Associated Types type Rep (Maybe a) :: Type -> Type # Methods from :: Maybe a -> Rep (Maybe a) x # to :: Rep (Maybe a) x -> Maybe a #
Generic (a)
Instance details Defined in GHC.Generics Associated Types type Rep (a) :: Type -> Type # Methods from :: (a) -> Rep (a) x # to :: Rep (a) x -> (a) #
Generic [a]
Instance details Defined in GHC.Generics Associated Types type Rep [a] :: Type -> Type # Methods from :: [a] -> Rep [a] x # to :: Rep [a] x -> [a] #
Generic (WrappedMonad m a)
Instance details Defined in Control.Applicative Associated Types type Rep (WrappedMonad m a) :: Type -> Type # Methods from :: WrappedMonad m a -> Rep (WrappedMonad m a) x # to :: Rep (WrappedMonad m a) x -> WrappedMonad m a #
Generic (Either a b)
Instance details Defined in GHC.Generics Associated Types type Rep (Either a b) :: Type -> Type # Methods from :: Either a b -> Rep (Either a b) x # to :: Rep (Either a b) x -> Either a b #
Generic (Proxy t)
Instance details Defined in GHC.Generics Associated Types type Rep (Proxy t) :: Type -> Type # Methods from :: Proxy t -> Rep (Proxy t) x # to :: Rep (Proxy t) x -> Proxy t #
Generic (Arg a b)
Instance details Defined in Data.Semigroup Associated Types type Rep (Arg a b) :: Type -> Type # Methods from :: Arg a b -> Rep (Arg a b) x # to :: Rep (Arg a b) x -> Arg a b #
Generic (U1 p)
Instance details Defined in GHC.Generics Associated Types type Rep (U1 p) :: Type -> Type # Methods from :: U1 p -> Rep (U1 p) x # to :: Rep (U1 p) x -> U1 p #
Generic (V1 p)
Instance details Defined in GHC.Generics Associated Types type Rep (V1 p) :: Type -> Type # Methods from :: V1 p -> Rep (V1 p) x # to :: Rep (V1 p) x -> V1 p #
Generic (a, b)
Instance details Defined in GHC.Generics Associated Types type Rep (a, b) :: Type -> Type # Methods from :: (a, b) -> Rep (a, b) x # to :: Rep (a, b) x -> (a, b) #
Generic (WrappedArrow a b c)
Instance details Defined in Control.Applicative Associated Types type Rep (WrappedArrow a b c) :: Type -> Type # Methods from :: WrappedArrow a b c -> Rep (WrappedArrow a b c) x # to :: Rep (WrappedArrow a b c) x -> WrappedArrow a b c #
Generic (Kleisli m a b)
Instance details Defined in Control.Arrow Associated Types type Rep (Kleisli m a b) :: Type -> Type # Methods from :: Kleisli m a b -> Rep (Kleisli m a b) x # to :: Rep (Kleisli m a b) x -> Kleisli m a b #
Generic (Const a b)
Instance details Defined in Data.Functor.Const Associated Types type Rep (Const a b) :: Type -> Type # Methods from :: Const a b -> Rep (Const a b) x # to :: Rep (Const a b) x -> Const a b #
Generic (Ap f a)
Instance details Defined in Data.Monoid Associated Types type Rep (Ap f a) :: Type -> Type # Methods from :: Ap f a -> Rep (Ap f a) x # to :: Rep (Ap f a) x -> Ap f a #
Generic (Rec1 f p)
Instance details Defined in GHC.Generics Associated Types type Rep (Rec1 f p) :: Type -> Type # Methods from :: Rec1 f p -> Rep (Rec1 f p) x # to :: Rep (Rec1 f p) x -> Rec1 f p #
Generic (URec (Ptr ()) p)
Instance details Defined in GHC.Generics Associated Types type Rep (URec (Ptr ()) p) :: Type -> Type # Methods from :: URec (Ptr ()) p -> Rep (URec (Ptr ()) p) x # to :: Rep (URec (Ptr ()) p) x -> URec (Ptr ()) p #
Generic (URec Char p)
Instance details Defined in GHC.Generics Associated Types type Rep (URec Char p) :: Type -> Type # Methods from :: URec Char p -> Rep (URec Char p) x # to :: Rep (URec Char p) x -> URec Char p #
Generic (URec Double p)
Instance details Defined in GHC.Generics Associated Types type Rep (URec Double p) :: Type -> Type # Methods from :: URec Double p -> Rep (URec Double p) x # to :: Rep (URec Double p) x -> URec Double p #
Generic (URec Float p)
Instance details Defined in GHC.Generics Associated Types type Rep (URec Float p) :: Type -> Type # Methods from :: URec Float p -> Rep (URec Float p) x # to :: Rep (URec Float p) x -> URec Float p #
Generic (URec Int p)
Instance details Defined in GHC.Generics Associated Types type Rep (URec Int p) :: Type -> Type # Methods from :: URec Int p -> Rep (URec Int p) x # to :: Rep (URec Int p) x -> URec Int p #
Generic (URec Word p)
Instance details Defined in GHC.Generics Associated Types type Rep (URec Word p) :: Type -> Type # Methods from :: URec Word p -> Rep (URec Word p) x # to :: Rep (URec Word p) x -> URec Word p #
Generic (a, b, c)
Instance details Defined in GHC.Generics Associated Types type Rep (a, b, c) :: Type -> Type # Methods from :: (a, b, c) -> Rep (a, b, c) x # to :: Rep (a, b, c) x -> (a, b, c) #
Generic (Product f g a)
Instance details Defined in Data.Functor.Product Associated Types type Rep (Product f g a) :: Type -> Type # Methods from :: Product f g a -> Rep (Product f g a) x # to :: Rep (Product f g a) x -> Product f g a #
Generic (Sum f g a)
Instance details Defined in Data.Functor.Sum Associated Types type Rep (Sum f g a) :: Type -> Type # Methods from :: Sum f g a -> Rep (Sum f g a) x # to :: Rep (Sum f g a) x -> Sum f g a #
Generic ((f :*: g) p)
Instance details Defined in GHC.Generics Associated Types type Rep ((f :: g) p) :: Type -> Type # Methods from :: (f :: g) p -> Rep ((f :: g) p) x # to :: Rep ((f :: g) p) x -> (f :*: g) p #
Generic ((f :+: g) p)
Instance details Defined in GHC.Generics Associated Types type Rep ((f :+: g) p) :: Type -> Type # Methods from :: (f :+: g) p -> Rep ((f :+: g) p) x # to :: Rep ((f :+: g) p) x -> (f :+: g) p #
Generic (K1 i c p)
Instance details Defined in GHC.Generics Associated Types type Rep (K1 i c p) :: Type -> Type # Methods from :: K1 i c p -> Rep (K1 i c p) x # to :: Rep (K1 i c p) x -> K1 i c p #
Generic (a, b, c, d)
Instance details Defined in GHC.Generics Associated Types type Rep (a, b, c, d) :: Type -> Type # Methods from :: (a, b, c, d) -> Rep (a, b, c, d) x # to :: Rep (a, b, c, d) x -> (a, b, c, d) #
Generic (Compose f g a)
Instance details Defined in Data.Functor.Compose Associated Types type Rep (Compose f g a) :: Type -> Type # Methods from :: Compose f g a -> Rep (Compose f g a) x # to :: Rep (Compose f g a) x -> Compose f g a #
Generic ((f :.: g) p)
Instance details Defined in GHC.Generics Associated Types type Rep ((f :.: g) p) :: Type -> Type # Methods from :: (f :.: g) p -> Rep ((f :.: g) p) x # to :: Rep ((f :.: g) p) x -> (f :.: g) p #
Generic (M1 i c f p)
Instance details Defined in GHC.Generics Associated Types type Rep (M1 i c f p) :: Type -> Type # Methods from :: M1 i c f p -> Rep (M1 i c f p) x # to :: Rep (M1 i c f p) x -> M1 i c f p #
Generic (a, b, c, d, e)
Instance details Defined in GHC.Generics Associated Types type Rep (a, b, c, d, e) :: Type -> Type # Methods from :: (a, b, c, d, e) -> Rep (a, b, c, d, e) x # to :: Rep (a, b, c, d, e) x -> (a, b, c, d, e) #
Generic (a, b, c, d, e, f)
Instance details Defined in GHC.Generics Associated Types type Rep (a, b, c, d, e, f) :: Type -> Type # Methods from :: (a, b, c, d, e, f) -> Rep (a, b, c, d, e, f) x # to :: Rep (a, b, c, d, e, f) x -> (a, b, c, d, e, f) #
Generic (a, b, c, d, e, f, g)
Instance details Defined in GHC.Generics Associated Types type Rep (a, b, c, d, e, f, g) :: Type -> Type # Methods from :: (a, b, c, d, e, f, g) -> Rep (a, b, c, d, e, f, g) x # to :: Rep (a, b, c, d, e, f, g) x -> (a, b, c, d, e, f, g) #

class Num a where #

Basic numeric class.

The Haskell Report defines no laws for Num. However, (+) and (*) are customarily expected to define a ring and have the following properties:

Associativity of (+): (x + y) + z = x + (y + z)
Commutativity of (+): x + y = y + x
fromInteger 0 is the additive identity: x + fromInteger 0 = x
negate gives the additive inverse: x + negate x = fromInteger 0
Associativity of (*): (x * y) * z = x * (y * z)
fromInteger 1 is the multiplicative identity: x * fromInteger 1 = x and fromInteger 1 * x = x
Distributivity of (*) with respect to (+): a * (b + c) = (a * b) + (a * c) and (b + c) * a = (b * a) + (c * a)

Note that it isn't customarily expected that a type instance of both Num and Ord implement an ordered ring. Indeed, in base only Integer and Rational do.

Minimal complete definition

(+), (*), abs, signum, fromInteger, (negate | (-))

Methods

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

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

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

negate :: a -> a #

Unary negation.

abs :: a -> a #

Absolute value.

signum :: a -> a #

Sign of a number. The functions abs and signum should satisfy the law:

abs x * signum x == x

For real numbers, the signum is either -1 (negative), 0 (zero) or 1 (positive).

fromInteger :: Integer -> a #

Conversion from an Integer. An integer literal represents the application of the function fromInteger to the appropriate value of type Integer, so such literals have type (Num a) => a.

Instances

Instances details

Num Int16	Since: base-2.1
Instance details Defined in GHC.Int Methods (+) :: Int16 -> Int16 -> Int16 # (-) :: Int16 -> Int16 -> Int16 # (*) :: Int16 -> Int16 -> Int16 # negate :: Int16 -> Int16 # abs :: Int16 -> Int16 # signum :: Int16 -> Int16 # fromInteger :: Integer -> Int16 #
Num Int32	Since: base-2.1
Instance details Defined in GHC.Int Methods (+) :: Int32 -> Int32 -> Int32 # (-) :: Int32 -> Int32 -> Int32 # (*) :: Int32 -> Int32 -> Int32 # negate :: Int32 -> Int32 # abs :: Int32 -> Int32 # signum :: Int32 -> Int32 # fromInteger :: Integer -> Int32 #
Num Int64	Since: base-2.1
Instance details Defined in GHC.Int Methods (+) :: Int64 -> Int64 -> Int64 # (-) :: Int64 -> Int64 -> Int64 # (*) :: Int64 -> Int64 -> Int64 # negate :: Int64 -> Int64 # abs :: Int64 -> Int64 # signum :: Int64 -> Int64 # fromInteger :: Integer -> Int64 #
Num Int8	Since: base-2.1
Instance details Defined in GHC.Int Methods (+) :: Int8 -> Int8 -> Int8 # (-) :: Int8 -> Int8 -> Int8 # (*) :: Int8 -> Int8 -> Int8 # negate :: Int8 -> Int8 # abs :: Int8 -> Int8 # signum :: Int8 -> Int8 # fromInteger :: Integer -> Int8 #
Num Word16	Since: base-2.1
Instance details Defined in GHC.Word Methods (+) :: Word16 -> Word16 -> Word16 # (-) :: Word16 -> Word16 -> Word16 # (*) :: Word16 -> Word16 -> Word16 # negate :: Word16 -> Word16 # abs :: Word16 -> Word16 # signum :: Word16 -> Word16 # fromInteger :: Integer -> Word16 #
Num Word32	Since: base-2.1
Instance details Defined in GHC.Word Methods (+) :: Word32 -> Word32 -> Word32 # (-) :: Word32 -> Word32 -> Word32 # (*) :: Word32 -> Word32 -> Word32 # negate :: Word32 -> Word32 # abs :: Word32 -> Word32 # signum :: Word32 -> Word32 # fromInteger :: Integer -> Word32 #
Num Word64	Since: base-2.1
Instance details Defined in GHC.Word Methods (+) :: Word64 -> Word64 -> Word64 # (-) :: Word64 -> Word64 -> Word64 # (*) :: Word64 -> Word64 -> Word64 # negate :: Word64 -> Word64 # abs :: Word64 -> Word64 # signum :: Word64 -> Word64 # fromInteger :: Integer -> Word64 #
Num CodePoint
Instance details Defined in Data.Text.Encoding Methods (+) :: CodePoint -> CodePoint -> CodePoint # (-) :: CodePoint -> CodePoint -> CodePoint # (*) :: CodePoint -> CodePoint -> CodePoint # negate :: CodePoint -> CodePoint # abs :: CodePoint -> CodePoint # signum :: CodePoint -> CodePoint # fromInteger :: Integer -> CodePoint #
Num DecoderState
Instance details Defined in Data.Text.Encoding Methods (+) :: DecoderState -> DecoderState -> DecoderState # (-) :: DecoderState -> DecoderState -> DecoderState # (*) :: DecoderState -> DecoderState -> DecoderState # negate :: DecoderState -> DecoderState # abs :: DecoderState -> DecoderState # signum :: DecoderState -> DecoderState # fromInteger :: Integer -> DecoderState #
Num Word8	Since: base-2.1
Instance details Defined in GHC.Word Methods (+) :: Word8 -> Word8 -> Word8 # (-) :: Word8 -> Word8 -> Word8 # (*) :: Word8 -> Word8 -> Word8 # negate :: Word8 -> Word8 # abs :: Word8 -> Word8 # signum :: Word8 -> Word8 # fromInteger :: Integer -> Word8 #
Num Integer	Since: base-2.1
Instance details Defined in GHC.Num Methods (+) :: Integer -> Integer -> Integer # (-) :: Integer -> Integer -> Integer # (*) :: Integer -> Integer -> Integer # negate :: Integer -> Integer # abs :: Integer -> Integer # signum :: Integer -> Integer # fromInteger :: Integer -> Integer #
Num Natural	Note that `Natural`'s `Num` instance isn't a ring: no element but 0 has an additive inverse. It is a semiring though. Since: base-4.8.0.0
Instance details Defined in GHC.Num Methods (+) :: Natural -> Natural -> Natural # (-) :: Natural -> Natural -> Natural # (*) :: Natural -> Natural -> Natural # negate :: Natural -> Natural # abs :: Natural -> Natural # signum :: Natural -> Natural # fromInteger :: Integer -> Natural #
Num Int	Since: base-2.1
Instance details Defined in GHC.Num Methods (+) :: Int -> Int -> Int # (-) :: Int -> Int -> Int # (*) :: Int -> Int -> Int # negate :: Int -> Int # abs :: Int -> Int # signum :: Int -> Int # fromInteger :: Integer -> Int #
Num Word	Since: base-2.1
Instance details Defined in GHC.Num Methods (+) :: Word -> Word -> Word # (-) :: Word -> Word -> Word # (*) :: Word -> Word -> Word # negate :: Word -> Word # abs :: Word -> Word # signum :: Word -> Word # fromInteger :: Integer -> Word #
Num a => Num (Identity a)	Since: base-4.9.0.0
Instance details Defined in Data.Functor.Identity Methods (+) :: Identity a -> Identity a -> Identity a # (-) :: Identity a -> Identity a -> Identity a # (*) :: Identity a -> Identity a -> Identity a # negate :: Identity a -> Identity a # abs :: Identity a -> Identity a # signum :: Identity a -> Identity a # fromInteger :: Integer -> Identity a #
Num a => Num (Down a)	Since: base-4.11.0.0
Instance details Defined in Data.Ord Methods (+) :: Down a -> Down a -> Down a # (-) :: Down a -> Down a -> Down a # (*) :: Down a -> Down a -> Down a # negate :: Down a -> Down a # abs :: Down a -> Down a # signum :: Down a -> Down a # fromInteger :: Integer -> Down a #
Num a => Num (Max a)	Since: base-4.9.0.0
Instance details Defined in Data.Semigroup Methods (+) :: Max a -> Max a -> Max a # (-) :: Max a -> Max a -> Max a # (*) :: Max a -> Max a -> Max a # negate :: Max a -> Max a # abs :: Max a -> Max a # signum :: Max a -> Max a # fromInteger :: Integer -> Max a #
Num a => Num (Min a)	Since: base-4.9.0.0
Instance details Defined in Data.Semigroup Methods (+) :: Min a -> Min a -> Min a # (-) :: Min a -> Min a -> Min a # (*) :: Min a -> Min a -> Min a # negate :: Min a -> Min a # abs :: Min a -> Min a # signum :: Min a -> Min a # fromInteger :: Integer -> Min a #
Integral a => Num (Ratio a)	Since: base-2.0.1
Instance details Defined in GHC.Real Methods (+) :: Ratio a -> Ratio a -> Ratio a # (-) :: Ratio a -> Ratio a -> Ratio a # (*) :: Ratio a -> Ratio a -> Ratio a # negate :: Ratio a -> Ratio a # abs :: Ratio a -> Ratio a # signum :: Ratio a -> Ratio a # fromInteger :: Integer -> Ratio a #
HasResolution a => Num (Fixed a)	Since: base-2.1
Instance details Defined in Data.Fixed Methods (+) :: Fixed a -> Fixed a -> Fixed a # (-) :: Fixed a -> Fixed a -> Fixed a # (*) :: Fixed a -> Fixed a -> Fixed a # negate :: Fixed a -> Fixed a # abs :: Fixed a -> Fixed a # signum :: Fixed a -> Fixed a # fromInteger :: Integer -> Fixed a #
Num a => Num (Op a b)
Instance details Defined in Data.Functor.Contravariant Methods (+) :: Op a b -> Op a b -> Op a b # (-) :: Op a b -> Op a b -> Op a b # (*) :: Op a b -> Op a b -> Op a b # negate :: Op a b -> Op a b # abs :: Op a b -> Op a b # signum :: Op a b -> Op a b # fromInteger :: Integer -> Op a b #
Num a => Num (Const a b)	Since: base-4.9.0.0
Instance details Defined in Data.Functor.Const Methods (+) :: Const a b -> Const a b -> Const a b # (-) :: Const a b -> Const a b -> Const a b # (*) :: Const a b -> Const a b -> Const a b # negate :: Const a b -> Const a b # abs :: Const a b -> Const a b # signum :: Const a b -> Const a b # fromInteger :: Integer -> Const a b #
(Applicative f, Num a) => Num (Ap f a)	Note that even if the underlying `Num` and `Applicative` instances are lawful, for most `Applicative`s, this instance will not be lawful. If you use this instance with the list `Applicative`, the following customary laws will not hold: Commutativity: `>>>` `Ap [10,20] + Ap [1,2]`Ap {getAp = [11,12,21,22]} `>>>` `Ap [1,2] + Ap [10,20]`Ap {getAp = [11,21,12,22]} Additive inverse: `>>>` `Ap [] + negate (Ap [])`Ap {getAp = []} `>>>` `fromInteger 0 :: Ap [] Int`Ap {getAp = [0]} Distributivity: `>>>` *`Ap [1,2] (3 + 4)`Ap {getAp = [7,14]} `>>>` `(Ap [1,2] * 3) + (Ap [1,2] * 4)`*Ap {getAp = [7,11,10,14]} Since: base-4.12.0.0*
Instance details Defined in Data.Monoid Methods (+) :: Ap f a -> Ap f a -> Ap f a # (-) :: Ap f a -> Ap f a -> Ap f a # (*) :: Ap f a -> Ap f a -> Ap f a # negate :: Ap f a -> Ap f a # abs :: Ap f a -> Ap f a # signum :: Ap f a -> Ap f a # fromInteger :: Integer -> Ap f a #

data Integer #

Arbitrary precision integers. In contrast with fixed-size integral types such as Int, the Integer type represents the entire infinite range of integers.

Integers are stored in a kind of sign-magnitude form, hence do not expect two's complement form when using bit operations.

If the value is small (fit into an Int), IS constructor is used. Otherwise IP and IN constructors are used to store a BigNat representing respectively the positive or the negative value magnitude.

Invariant: IP and IN are used iff value doesn't fit in IS

Instances

Instances details

Bits Integer	Since: base-2.1
Instance details Defined in Data.Bits Methods (.&.) :: Integer -> Integer -> Integer # (.\|.) :: Integer -> Integer -> Integer # xor :: Integer -> Integer -> Integer # complement :: Integer -> Integer # shift :: Integer -> Int -> Integer # rotate :: Integer -> Int -> Integer # zeroBits :: Integer # bit :: Int -> Integer # setBit :: Integer -> Int -> Integer # clearBit :: Integer -> Int -> Integer # complementBit :: Integer -> Int -> Integer # testBit :: Integer -> Int -> Bool # bitSizeMaybe :: Integer -> Maybe Int # bitSize :: Integer -> Int # isSigned :: Integer -> Bool # shiftL :: Integer -> Int -> Integer # unsafeShiftL :: Integer -> Int -> Integer # shiftR :: Integer -> Int -> Integer # unsafeShiftR :: Integer -> Int -> Integer # rotateL :: Integer -> Int -> Integer # rotateR :: Integer -> Int -> Integer # popCount :: Integer -> Int #
Enum Integer	Since: base-2.1
Instance details Defined in GHC.Enum Methods succ :: Integer -> Integer # pred :: Integer -> Integer # toEnum :: Int -> Integer # fromEnum :: Integer -> Int # enumFrom :: Integer -> [Integer] # enumFromThen :: Integer -> Integer -> [Integer] # enumFromTo :: Integer -> Integer -> [Integer] # enumFromThenTo :: Integer -> Integer -> Integer -> [Integer] #
Num Integer	Since: base-2.1
Instance details Defined in GHC.Num Methods (+) :: Integer -> Integer -> Integer # (-) :: Integer -> Integer -> Integer # (*) :: Integer -> Integer -> Integer # negate :: Integer -> Integer # abs :: Integer -> Integer # signum :: Integer -> Integer # fromInteger :: Integer -> Integer #
Read Integer	Since: base-2.1
Instance details Defined in GHC.Read Methods readsPrec :: Int -> ReadS Integer # readList :: ReadS [Integer] # readPrec :: ReadPrec Integer # readListPrec :: ReadPrec [Integer] #
Integral Integer	Since: base-2.0.1
Instance details Defined in GHC.Real Methods quot :: Integer -> Integer -> Integer # rem :: Integer -> Integer -> Integer # div :: Integer -> Integer -> Integer # mod :: Integer -> Integer -> Integer # quotRem :: Integer -> Integer -> (Integer, Integer) # divMod :: Integer -> Integer -> (Integer, Integer) # toInteger :: Integer -> Integer #
Real Integer	Since: base-2.0.1
Instance details Defined in GHC.Real Methods toRational :: Integer -> Rational #
Show Integer	Since: base-2.1
Instance details Defined in GHC.Show Methods showsPrec :: Int -> Integer -> ShowS # show :: Integer -> String # showList :: [Integer] -> ShowS #
Default Integer
Instance details Defined in Data.Default.Class Methods def :: Integer #
Eq Integer
Instance details Defined in GHC.Num.Integer Methods (==) :: Integer -> Integer -> Bool # (/=) :: Integer -> Integer -> Bool #
Ord Integer
Instance details Defined in GHC.Num.Integer Methods compare :: Integer -> Integer -> Ordering # (<) :: Integer -> Integer -> Bool # (<=) :: Integer -> Integer -> Bool # (>) :: Integer -> Integer -> Bool # (>=) :: Integer -> Integer -> Bool # max :: Integer -> Integer -> Integer # min :: Integer -> Integer -> Integer #
Lift Integer
Instance details Defined in Language.Haskell.TH.Syntax Methods lift :: Quote m => Integer -> m Exp # liftTyped :: forall (m :: Type -> Type). Quote m => Integer -> Code m Integer #

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

the same as flip (-).

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

class IsLabel (x :: Symbol) a where #

Methods

fromLabel :: a #

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 Num a => Fractional a where #

Fractional numbers, supporting real division.

The Haskell Report defines no laws for Fractional. However, (+) and (*) are customarily expected to define a division ring and have the following properties:

recip gives the multiplicative inverse: x * recip x = recip x * x = fromInteger 1

Note that it isn't customarily expected that a type instance of Fractional implement a field. However, all instances in base do.

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

Instances details

Fractional a => Fractional (Identity a)	Since: base-4.9.0.0
Instance details Defined in Data.Functor.Identity Methods (/) :: Identity a -> Identity a -> Identity a # recip :: Identity a -> Identity a # fromRational :: Rational -> Identity a #
Fractional a => Fractional (Down a)	Since: base-4.14.0.0
Instance details Defined in Data.Ord Methods (/) :: Down a -> Down a -> Down a # recip :: Down a -> Down a # fromRational :: Rational -> Down a #
Integral a => Fractional (Ratio a)	Since: base-2.0.1
Instance details Defined in GHC.Real Methods (/) :: Ratio a -> Ratio a -> Ratio a # recip :: Ratio a -> Ratio a # fromRational :: Rational -> Ratio a #
HasResolution a => Fractional (Fixed a)	Since: base-2.1
Instance details Defined in Data.Fixed Methods (/) :: Fixed a -> Fixed a -> Fixed a # recip :: Fixed a -> Fixed a # fromRational :: Rational -> Fixed a #
Fractional a => Fractional (Op a b)
Instance details Defined in Data.Functor.Contravariant Methods (/) :: Op a b -> Op a b -> Op a b # recip :: Op a b -> Op a b # fromRational :: Rational -> Op a b #
Fractional a => Fractional (Const a b)	Since: base-4.9.0.0
Instance details Defined in Data.Functor.Const Methods (/) :: Const a b -> Const a b -> Const a b # recip :: Const a b -> Const a b # fromRational :: Rational -> Const a b #

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

Integral numbers, supporting integer division.

The Haskell Report defines no laws for Integral. However, Integral instances are customarily expected to define a Euclidean domain and have the following properties for the div/mod and quot/rem pairs, given suitable Euclidean functions f and g:

x = y * quot x y + rem x y with rem x y = fromInteger 0 or g (rem x y) < g y
x = y * div x y + mod x y with mod x y = fromInteger 0 or f (mod x y) < f y

An example of a suitable Euclidean function, for Integer's instance, is abs.

Minimal complete definition

quotRem, toInteger

Methods

toInteger :: a -> Integer #

conversion to Integer

Instances

Instances details

Integral Int16	Since: base-2.1
Instance details Defined in GHC.Int Methods quot :: Int16 -> Int16 -> Int16 # rem :: Int16 -> Int16 -> Int16 # div :: Int16 -> Int16 -> Int16 # mod :: Int16 -> Int16 -> Int16 # quotRem :: Int16 -> Int16 -> (Int16, Int16) # divMod :: Int16 -> Int16 -> (Int16, Int16) # toInteger :: Int16 -> Integer #
Integral Int32	Since: base-2.1
Instance details Defined in GHC.Int Methods quot :: Int32 -> Int32 -> Int32 # rem :: Int32 -> Int32 -> Int32 # div :: Int32 -> Int32 -> Int32 # mod :: Int32 -> Int32 -> Int32 # quotRem :: Int32 -> Int32 -> (Int32, Int32) # divMod :: Int32 -> Int32 -> (Int32, Int32) # toInteger :: Int32 -> Integer #
Integral Int64	Since: base-2.1
Instance details Defined in GHC.Int Methods quot :: Int64 -> Int64 -> Int64 # rem :: Int64 -> Int64 -> Int64 # div :: Int64 -> Int64 -> Int64 # mod :: Int64 -> Int64 -> Int64 # quotRem :: Int64 -> Int64 -> (Int64, Int64) # divMod :: Int64 -> Int64 -> (Int64, Int64) # toInteger :: Int64 -> Integer #
Integral Int8	Since: base-2.1
Instance details Defined in GHC.Int 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 Word16	Since: base-2.1
Instance details Defined in GHC.Word Methods quot :: Word16 -> Word16 -> Word16 # rem :: Word16 -> Word16 -> Word16 # div :: Word16 -> Word16 -> Word16 # mod :: Word16 -> Word16 -> Word16 # quotRem :: Word16 -> Word16 -> (Word16, Word16) # divMod :: Word16 -> Word16 -> (Word16, Word16) # toInteger :: Word16 -> Integer #
Integral Word32	Since: base-2.1
Instance details Defined in GHC.Word Methods quot :: Word32 -> Word32 -> Word32 # rem :: Word32 -> Word32 -> Word32 # div :: Word32 -> Word32 -> Word32 # mod :: Word32 -> Word32 -> Word32 # quotRem :: Word32 -> Word32 -> (Word32, Word32) # divMod :: Word32 -> Word32 -> (Word32, Word32) # toInteger :: Word32 -> Integer #
Integral Word64	Since: base-2.1
Instance details Defined in GHC.Word Methods quot :: Word64 -> Word64 -> Word64 # rem :: Word64 -> Word64 -> Word64 # div :: Word64 -> Word64 -> Word64 # mod :: Word64 -> Word64 -> Word64 # quotRem :: Word64 -> Word64 -> (Word64, Word64) # divMod :: Word64 -> Word64 -> (Word64, Word64) # toInteger :: Word64 -> Integer #
Integral Word8	Since: base-2.1
Instance details Defined in GHC.Word Methods quot :: Word8 -> Word8 -> Word8 # rem :: Word8 -> Word8 -> Word8 # div :: Word8 -> Word8 -> Word8 # mod :: Word8 -> Word8 -> Word8 # quotRem :: Word8 -> Word8 -> (Word8, Word8) # divMod :: Word8 -> Word8 -> (Word8, Word8) # toInteger :: Word8 -> Integer #
Integral Integer	Since: base-2.0.1
Instance details Defined in GHC.Real Methods quot :: Integer -> Integer -> Integer # rem :: Integer -> Integer -> Integer # div :: Integer -> Integer -> Integer # mod :: Integer -> Integer -> Integer # quotRem :: Integer -> Integer -> (Integer, Integer) # divMod :: Integer -> Integer -> (Integer, Integer) # toInteger :: Integer -> Integer #
Integral Natural	Since: base-4.8.0.0
Instance details Defined in GHC.Real Methods quot :: Natural -> Natural -> Natural # rem :: Natural -> Natural -> Natural # div :: Natural -> Natural -> Natural # mod :: Natural -> Natural -> Natural # quotRem :: Natural -> Natural -> (Natural, Natural) # divMod :: Natural -> Natural -> (Natural, Natural) # toInteger :: Natural -> Integer #
Integral Int	Since: base-2.0.1
Instance details Defined in GHC.Real 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 Word	Since: base-2.1
Instance details Defined in GHC.Real 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 a => Integral (Identity a)	Since: base-4.9.0.0
Instance details Defined in Data.Functor.Identity Methods quot :: Identity a -> Identity a -> Identity a # rem :: Identity a -> Identity a -> Identity a # div :: Identity a -> Identity a -> Identity a # mod :: Identity a -> Identity a -> Identity a # quotRem :: Identity a -> Identity a -> (Identity a, Identity a) # divMod :: Identity a -> Identity a -> (Identity a, Identity a) # toInteger :: Identity a -> Integer #
Integral a => Integral (Const a b)	Since: base-4.9.0.0
Instance details Defined in Data.Functor.Const 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 #

class (Num a, Ord a) => Real a where #

Methods

toRational :: a -> Rational #

the rational equivalent of its real argument with full precision

Instances

Instances details

Real Int16	Since: base-2.1
Instance details Defined in GHC.Int Methods toRational :: Int16 -> Rational #
Real Int32	Since: base-2.1
Instance details Defined in GHC.Int Methods toRational :: Int32 -> Rational #
Real Int64	Since: base-2.1
Instance details Defined in GHC.Int Methods toRational :: Int64 -> Rational #
Real Int8	Since: base-2.1
Instance details Defined in GHC.Int Methods toRational :: Int8 -> Rational #
Real Word16	Since: base-2.1
Instance details Defined in GHC.Word Methods toRational :: Word16 -> Rational #
Real Word32	Since: base-2.1
Instance details Defined in GHC.Word Methods toRational :: Word32 -> Rational #
Real Word64	Since: base-2.1
Instance details Defined in GHC.Word Methods toRational :: Word64 -> Rational #
Real Word8	Since: base-2.1
Instance details Defined in GHC.Word Methods toRational :: Word8 -> Rational #
Real Integer	Since: base-2.0.1
Instance details Defined in GHC.Real Methods toRational :: Integer -> Rational #
Real Natural	Since: base-4.8.0.0
Instance details Defined in GHC.Real Methods toRational :: Natural -> Rational #
Real Int	Since: base-2.0.1
Instance details Defined in GHC.Real Methods toRational :: Int -> Rational #
Real Word	Since: base-2.1
Instance details Defined in GHC.Real Methods toRational :: Word -> Rational #
Real a => Real (Identity a)	Since: base-4.9.0.0
Instance details Defined in Data.Functor.Identity Methods toRational :: Identity a -> Rational #
Real a => Real (Down a)	Since: base-4.14.0.0
Instance details Defined in Data.Ord Methods toRational :: Down a -> Rational #
Integral a => Real (Ratio a)	Since: base-2.0.1
Instance details Defined in GHC.Real Methods toRational :: Ratio a -> Rational #
HasResolution a => Real (Fixed a)	Since: base-2.1
Instance details Defined in Data.Fixed Methods toRational :: Fixed a -> Rational #
Real a => Real (Const a b)	Since: base-4.9.0.0
Instance details Defined in Data.Functor.Const Methods toRational :: Const a b -> Rational #

class (Real a, Fractional a) => RealFrac a where #

Extracting components of fractions.

Minimal complete definition

properFraction

Methods

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

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

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

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

truncate :: Integral b => a -> b #

truncate x returns the integer nearest x between zero and x

round :: Integral b => a -> b #

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

ceiling :: Integral b => a -> b #

ceiling x returns the least integer not less than x

floor :: Integral b => a -> b #

floor x returns the greatest integer not greater than x

Instances

Instances details

RealFrac a => RealFrac (Identity a)	Since: base-4.9.0.0
Instance details Defined in Data.Functor.Identity Methods properFraction :: Integral b => Identity a -> (b, Identity a) # truncate :: Integral b => Identity a -> b # round :: Integral b => Identity a -> b # ceiling :: Integral b => Identity a -> b # floor :: Integral b => Identity a -> b #
RealFrac a => RealFrac (Down a)	Since: base-4.14.0.0
Instance details Defined in Data.Ord Methods properFraction :: Integral b => Down a -> (b, Down a) # truncate :: Integral b => Down a -> b # round :: Integral b => Down a -> b # ceiling :: Integral b => Down a -> b # floor :: Integral b => Down a -> b #
Integral a => RealFrac (Ratio a)	Since: base-2.0.1
Instance details Defined in GHC.Real Methods properFraction :: Integral b => Ratio a -> (b, Ratio a) # truncate :: Integral b => Ratio a -> b # round :: Integral b => Ratio a -> b # ceiling :: Integral b => Ratio a -> b # floor :: Integral b => Ratio a -> b #
HasResolution a => RealFrac (Fixed a)	Since: base-2.1
Instance details Defined in Data.Fixed Methods properFraction :: Integral b => Fixed a -> (b, Fixed a) # truncate :: Integral b => Fixed a -> b # round :: Integral b => Fixed a -> b # ceiling :: Integral b => Fixed a -> b # floor :: Integral b => Fixed a -> b #
RealFrac a => RealFrac (Const a b)	Since: base-4.9.0.0
Instance details Defined in Data.Functor.Const Methods properFraction :: Integral b0 => Const a b -> (b0, Const a b) # truncate :: Integral b0 => Const a b -> b0 # round :: Integral b0 => Const a b -> b0 # ceiling :: Integral b0 => Const a b -> b0 # floor :: Integral b0 => Const a b -> b0 #

data Ratio a #

Rational numbers, with numerator and denominator of some Integral type.

Note that Ratio's instances inherit the deficiencies from the type parameter's. For example, Ratio Natural's Num instance has similar problems to Natural's.

Instances

Instances details

Integral a => Lift (Ratio a :: Type)
Instance details Defined in Language.Haskell.TH.Syntax Methods lift :: Quote m => Ratio a -> m Exp # liftTyped :: forall (m :: Type -> Type). Quote m => Ratio a -> Code m (Ratio a) #
Integral a => Enum (Ratio a)	Since: base-2.0.1
Instance details Defined in GHC.Real 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] #
Integral a => Num (Ratio a)	Since: base-2.0.1
Instance details Defined in GHC.Real Methods (+) :: Ratio a -> Ratio a -> Ratio a # (-) :: Ratio a -> Ratio a -> Ratio a # (*) :: Ratio a -> Ratio a -> Ratio a # negate :: Ratio a -> Ratio a # abs :: Ratio a -> Ratio a # signum :: Ratio a -> Ratio a # fromInteger :: Integer -> Ratio a #
(Integral a, Read a) => Read (Ratio a)	Since: base-2.1
Instance details Defined in GHC.Read Methods readsPrec :: Int -> ReadS (Ratio a) # readList :: ReadS [Ratio a] # readPrec :: ReadPrec (Ratio a) # readListPrec :: ReadPrec [Ratio a] #
Integral a => Fractional (Ratio a)	Since: base-2.0.1
Instance details Defined in GHC.Real Methods (/) :: Ratio a -> Ratio a -> Ratio a # recip :: Ratio a -> Ratio a # fromRational :: Rational -> Ratio a #
Integral a => Real (Ratio a)	Since: base-2.0.1
Instance details Defined in GHC.Real Methods toRational :: Ratio a -> Rational #
Integral a => RealFrac (Ratio a)	Since: base-2.0.1
Instance details Defined in GHC.Real Methods properFraction :: Integral b => Ratio a -> (b, Ratio a) # truncate :: Integral b => Ratio a -> b # round :: Integral b => Ratio a -> b # ceiling :: Integral b => Ratio a -> b # floor :: Integral b => Ratio a -> b #
Show a => Show (Ratio a)	Since: base-2.0.1
Instance details Defined in GHC.Real Methods showsPrec :: Int -> Ratio a -> ShowS # show :: Ratio a -> String # showList :: [Ratio a] -> ShowS #
Integral a => Default (Ratio a)
Instance details Defined in Data.Default.Class Methods def :: Ratio a #
Eq a => Eq (Ratio a)	Since: base-2.1
Instance details Defined in GHC.Real Methods (==) :: Ratio a -> Ratio a -> Bool # (/=) :: Ratio a -> Ratio a -> Bool #
Integral a => Ord (Ratio a)	Since: base-2.0.1
Instance details Defined in GHC.Real Methods compare :: Ratio a -> Ratio a -> Ordering # (<) :: Ratio a -> Ratio a -> Bool # (<=) :: Ratio a -> Ratio a -> Bool # (>) :: Ratio a -> Ratio a -> Bool # (>=) :: Ratio a -> Ratio a -> Bool # max :: Ratio a -> Ratio a -> Ratio a # min :: Ratio a -> Ratio a -> Ratio a #

type Rational = Ratio Integer #

Arbitrary-precision rational numbers, represented as a ratio of two Integer values. A rational number may be constructed using the % operator.

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

numerator :: Ratio a -> a #

Extract the numerator of the ratio in reduced form: the numerator and denominator have no common factor and the denominator is positive.

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

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

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

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

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

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

denominator :: Ratio a -> a #

Extract the denominator of the ratio in reduced form: the numerator and denominator have no common factor and the denominator is positive.

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

raise a number to an integral power

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

raise a number to a non-negative integral power

class Show a #

Conversion of values to readable Strings.

Derived instances of Show have the following properties, which are compatible with derived instances of Read:

The result of show is a syntactically correct Haskell expression containing only constants, given the fixity declarations in force at the point where the type is declared. It contains only the constructor names defined in the data type, parentheses, and spaces. When labelled constructor fields are used, braces, commas, field names, and equal signs are also used.
If the constructor is defined to be an infix operator, then showsPrec will produce infix applications of the constructor.
the representation will be enclosed in parentheses if the precedence of the top-level constructor in x is less than d (associativity is ignored). Thus, if d is 0 then the result is never surrounded in parentheses; if d is 11 it is always surrounded in parentheses, unless it is an atomic expression.
If the constructor is defined using record syntax, then show will produce the record-syntax form, with the fields given in the same order as the original declaration.

For example, given the declarations

infixr 5 :^:
data Tree a =  Leaf a  |  Tree a :^: Tree a

the derived instance of Show is equivalent to

instance (Show a) => Show (Tree a) where

       showsPrec d (Leaf m) = showParen (d > app_prec) $
            showString "Leaf " . showsPrec (app_prec+1) m
         where app_prec = 10

       showsPrec d (u :^: v) = showParen (d > up_prec) $
            showsPrec (up_prec+1) u .
            showString " :^: "      .
            showsPrec (up_prec+1) v
         where up_prec = 5

Note that right-associativity of :^: is ignored. For example,

show (Leaf 1 :^: Leaf 2 :^: Leaf 3) produces the string "Leaf 1 :^: (Leaf 2 :^: Leaf 3)".

Minimal complete definition

showsPrec | show

Instances

Instances details

Show SomeTypeRep	Since: base-4.10.0.0
Instance details Defined in Data.Typeable.Internal Methods showsPrec :: Int -> SomeTypeRep -> ShowS # show :: SomeTypeRep -> String # showList :: [SomeTypeRep] -> ShowS #
Show Void	Since: base-4.8.0.0
Instance details Defined in Data.Void Methods showsPrec :: Int -> Void -> ShowS # show :: Void -> String # showList :: [Void] -> ShowS #
Show ArithException	Since: base-4.0.0.0
Instance details Defined in GHC.Exception.Type Methods showsPrec :: Int -> ArithException -> ShowS # show :: ArithException -> String # showList :: [ArithException] -> ShowS #
Show SomeException	Since: base-3.0
Instance details Defined in GHC.Exception.Type Methods showsPrec :: Int -> SomeException -> ShowS # show :: SomeException -> String # showList :: [SomeException] -> ShowS #
Show Associativity	Since: base-4.6.0.0
Instance details Defined in GHC.Generics Methods showsPrec :: Int -> Associativity -> ShowS # show :: Associativity -> String # showList :: [Associativity] -> ShowS #
Show DecidedStrictness	Since: base-4.9.0.0
Instance details Defined in GHC.Generics Methods showsPrec :: Int -> DecidedStrictness -> ShowS # show :: DecidedStrictness -> String # showList :: [DecidedStrictness] -> ShowS #
Show Fixity	Since: base-4.6.0.0
Instance details Defined in GHC.Generics Methods showsPrec :: Int -> Fixity -> ShowS # show :: Fixity -> String # showList :: [Fixity] -> ShowS #
Show SourceStrictness	Since: base-4.9.0.0
Instance details Defined in GHC.Generics Methods showsPrec :: Int -> SourceStrictness -> ShowS # show :: SourceStrictness -> String # showList :: [SourceStrictness] -> ShowS #
Show SourceUnpackedness	Since: base-4.9.0.0
Instance details Defined in GHC.Generics Methods showsPrec :: Int -> SourceUnpackedness -> ShowS # show :: SourceUnpackedness -> String # showList :: [SourceUnpackedness] -> ShowS #
Show MaskingState	Since: base-4.3.0.0
Instance details Defined in GHC.IO Methods showsPrec :: Int -> MaskingState -> ShowS # show :: MaskingState -> String # showList :: [MaskingState] -> ShowS #
Show Int16	Since: base-2.1
Instance details Defined in GHC.Int Methods showsPrec :: Int -> Int16 -> ShowS # show :: Int16 -> String # showList :: [Int16] -> ShowS #
Show Int32	Since: base-2.1
Instance details Defined in GHC.Int Methods showsPrec :: Int -> Int32 -> ShowS # show :: Int32 -> String # showList :: [Int32] -> ShowS #
Show Int64	Since: base-2.1
Instance details Defined in GHC.Int Methods showsPrec :: Int -> Int64 -> ShowS # show :: Int64 -> String # showList :: [Int64] -> ShowS #
Show Int8	Since: base-2.1
Instance details Defined in GHC.Int Methods showsPrec :: Int -> Int8 -> ShowS # show :: Int8 -> String # showList :: [Int8] -> ShowS #
Show CallStack	Since: base-4.9.0.0
Instance details Defined in GHC.Show Methods showsPrec :: Int -> CallStack -> ShowS # show :: CallStack -> String # showList :: [CallStack] -> ShowS #
Show SrcLoc	Since: base-4.9.0.0
Instance details Defined in GHC.Show Methods showsPrec :: Int -> SrcLoc -> ShowS # show :: SrcLoc -> String # showList :: [SrcLoc] -> ShowS #
Show SomeSymbol	Since: base-4.7.0.0
Instance details Defined in GHC.TypeLits Methods showsPrec :: Int -> SomeSymbol -> ShowS # show :: SomeSymbol -> String # showList :: [SomeSymbol] -> ShowS #
Show SomeNat	Since: base-4.7.0.0
Instance details Defined in GHC.TypeNats Methods showsPrec :: Int -> SomeNat -> ShowS # show :: SomeNat -> String # showList :: [SomeNat] -> ShowS #
Show Word16	Since: base-2.1
Instance details Defined in GHC.Word Methods showsPrec :: Int -> Word16 -> ShowS # show :: Word16 -> String # showList :: [Word16] -> ShowS #
Show Word32	Since: base-2.1
Instance details Defined in GHC.Word Methods showsPrec :: Int -> Word32 -> ShowS # show :: Word32 -> String # showList :: [Word32] -> ShowS #
Show Word64	Since: base-2.1
Instance details Defined in GHC.Word Methods showsPrec :: Int -> Word64 -> ShowS # show :: Word64 -> String # showList :: [Word64] -> ShowS #
Show ByteString
Instance details Defined in Data.ByteString.Internal Methods showsPrec :: Int -> ByteString -> ShowS # show :: ByteString -> String # showList :: [ByteString] -> ShowS #
Show ByteString
Instance details Defined in Data.ByteString.Lazy.Internal Methods showsPrec :: Int -> ByteString -> ShowS # show :: ByteString -> String # showList :: [ByteString] -> ShowS #
Show ShortByteString
Instance details Defined in Data.ByteString.Short.Internal Methods showsPrec :: Int -> ShortByteString -> ShowS # show :: ShortByteString -> String # showList :: [ShortByteString] -> ShowS #
Show IntSet
Instance details Defined in Data.IntSet.Internal Methods showsPrec :: Int -> IntSet -> ShowS # show :: IntSet -> String # showList :: [IntSet] -> ShowS #
Show Relation
Instance details Defined in Data.IntSet.Internal Methods showsPrec :: Int -> Relation -> ShowS # show :: Relation -> String # showList :: [Relation] -> ShowS #
Show ForeignSrcLang
Instance details Defined in GHC.ForeignSrcLang.Type Methods showsPrec :: Int -> ForeignSrcLang -> ShowS # show :: ForeignSrcLang -> String # showList :: [ForeignSrcLang] -> ShowS #
Show Extension
Instance details Defined in GHC.LanguageExtensions.Type Methods showsPrec :: Int -> Extension -> ShowS # show :: Extension -> String # showList :: [Extension] -> ShowS #
Show KindRep
Instance details Defined in GHC.Show Methods showsPrec :: Int -> KindRep -> ShowS # show :: KindRep -> String # showList :: [KindRep] -> ShowS #
Show Module	Since: base-4.9.0.0
Instance details Defined in GHC.Show Methods showsPrec :: Int -> Module -> ShowS # show :: Module -> String # showList :: [Module] -> ShowS #
Show Ordering	Since: base-2.1
Instance details Defined in GHC.Show Methods showsPrec :: Int -> Ordering -> ShowS # show :: Ordering -> String # showList :: [Ordering] -> ShowS #
Show TrName	Since: base-4.9.0.0
Instance details Defined in GHC.Show Methods showsPrec :: Int -> TrName -> ShowS # show :: TrName -> String # showList :: [TrName] -> ShowS #
Show TyCon	Since: base-2.1
Instance details Defined in GHC.Show Methods showsPrec :: Int -> TyCon -> ShowS # show :: TyCon -> String # showList :: [TyCon] -> ShowS #
Show TypeLitSort	Since: base-4.11.0.0
Instance details Defined in GHC.Show Methods showsPrec :: Int -> TypeLitSort -> ShowS # show :: TypeLitSort -> String # showList :: [TypeLitSort] -> ShowS #
Show AnnLookup
Instance details Defined in Language.Haskell.TH.Syntax Methods showsPrec :: Int -> AnnLookup -> ShowS # show :: AnnLookup -> String # showList :: [AnnLookup] -> ShowS #
Show AnnTarget
Instance details Defined in Language.Haskell.TH.Syntax Methods showsPrec :: Int -> AnnTarget -> ShowS # show :: AnnTarget -> String # showList :: [AnnTarget] -> ShowS #
Show Bang
Instance details Defined in Language.Haskell.TH.Syntax Methods showsPrec :: Int -> Bang -> ShowS # show :: Bang -> String # showList :: [Bang] -> ShowS #
Show Body
Instance details Defined in Language.Haskell.TH.Syntax Methods showsPrec :: Int -> Body -> ShowS # show :: Body -> String # showList :: [Body] -> ShowS #
Show Bytes
Instance details Defined in Language.Haskell.TH.Syntax Methods showsPrec :: Int -> Bytes -> ShowS # show :: Bytes -> String # showList :: [Bytes] -> ShowS #
Show Callconv
Instance details Defined in Language.Haskell.TH.Syntax Methods showsPrec :: Int -> Callconv -> ShowS # show :: Callconv -> String # showList :: [Callconv] -> ShowS #
Show Clause
Instance details Defined in Language.Haskell.TH.Syntax Methods showsPrec :: Int -> Clause -> ShowS # show :: Clause -> String # showList :: [Clause] -> ShowS #
Show Con
Instance details Defined in Language.Haskell.TH.Syntax Methods showsPrec :: Int -> Con -> ShowS # show :: Con -> String # showList :: [Con] -> ShowS #
Show Dec
Instance details Defined in Language.Haskell.TH.Syntax Methods showsPrec :: Int -> Dec -> ShowS # show :: Dec -> String # showList :: [Dec] -> ShowS #
Show DecidedStrictness
Instance details Defined in Language.Haskell.TH.Syntax Methods showsPrec :: Int -> DecidedStrictness -> ShowS # show :: DecidedStrictness -> String # showList :: [DecidedStrictness] -> ShowS #
Show DerivClause
Instance details Defined in Language.Haskell.TH.Syntax Methods showsPrec :: Int -> DerivClause -> ShowS # show :: DerivClause -> String # showList :: [DerivClause] -> ShowS #
Show DerivStrategy
Instance details Defined in Language.Haskell.TH.Syntax Methods showsPrec :: Int -> DerivStrategy -> ShowS # show :: DerivStrategy -> String # showList :: [DerivStrategy] -> ShowS #
Show Exp
Instance details Defined in Language.Haskell.TH.Syntax Methods showsPrec :: Int -> Exp -> ShowS # show :: Exp -> String # showList :: [Exp] -> ShowS #
Show FamilyResultSig
Instance details Defined in Language.Haskell.TH.Syntax Methods showsPrec :: Int -> FamilyResultSig -> ShowS # show :: FamilyResultSig -> String # showList :: [FamilyResultSig] -> ShowS #
Show Fixity
Instance details Defined in Language.Haskell.TH.Syntax Methods showsPrec :: Int -> Fixity -> ShowS # show :: Fixity -> String # showList :: [Fixity] -> ShowS #
Show FixityDirection
Instance details Defined in Language.Haskell.TH.Syntax Methods showsPrec :: Int -> FixityDirection -> ShowS # show :: FixityDirection -> String # showList :: [FixityDirection] -> ShowS #
Show Foreign
Instance details Defined in Language.Haskell.TH.Syntax Methods showsPrec :: Int -> Foreign -> ShowS # show :: Foreign -> String # showList :: [Foreign] -> ShowS #
Show FunDep
Instance details Defined in Language.Haskell.TH.Syntax Methods showsPrec :: Int -> FunDep -> ShowS # show :: FunDep -> String # showList :: [FunDep] -> ShowS #
Show Guard
Instance details Defined in Language.Haskell.TH.Syntax Methods showsPrec :: Int -> Guard -> ShowS # show :: Guard -> String # showList :: [Guard] -> ShowS #
Show Info
Instance details Defined in Language.Haskell.TH.Syntax Methods showsPrec :: Int -> Info -> ShowS # show :: Info -> String # showList :: [Info] -> ShowS #
Show InjectivityAnn
Instance details Defined in Language.Haskell.TH.Syntax Methods showsPrec :: Int -> InjectivityAnn -> ShowS # show :: InjectivityAnn -> String # showList :: [InjectivityAnn] -> ShowS #
Show Inline
Instance details Defined in Language.Haskell.TH.Syntax Methods showsPrec :: Int -> Inline -> ShowS # show :: Inline -> String # showList :: [Inline] -> ShowS #
Show Lit
Instance details Defined in Language.Haskell.TH.Syntax Methods showsPrec :: Int -> Lit -> ShowS # show :: Lit -> String # showList :: [Lit] -> ShowS #
Show Loc
Instance details Defined in Language.Haskell.TH.Syntax Methods showsPrec :: Int -> Loc -> ShowS # show :: Loc -> String # showList :: [Loc] -> ShowS #
Show Match
Instance details Defined in Language.Haskell.TH.Syntax Methods showsPrec :: Int -> Match -> ShowS # show :: Match -> String # showList :: [Match] -> ShowS #
Show ModName
Instance details Defined in Language.Haskell.TH.Syntax Methods showsPrec :: Int -> ModName -> ShowS # show :: ModName -> String # showList :: [ModName] -> ShowS #
Show Module
Instance details Defined in Language.Haskell.TH.Syntax Methods showsPrec :: Int -> Module -> ShowS # show :: Module -> String # showList :: [Module] -> ShowS #
Show ModuleInfo
Instance details Defined in Language.Haskell.TH.Syntax Methods showsPrec :: Int -> ModuleInfo -> ShowS # show :: ModuleInfo -> String # showList :: [ModuleInfo] -> ShowS #
Show Name
Instance details Defined in Language.Haskell.TH.Syntax Methods showsPrec :: Int -> Name -> ShowS # show :: Name -> String # showList :: [Name] -> ShowS #
Show NameFlavour
Instance details Defined in Language.Haskell.TH.Syntax Methods showsPrec :: Int -> NameFlavour -> ShowS # show :: NameFlavour -> String # showList :: [NameFlavour] -> ShowS #
Show NameSpace
Instance details Defined in Language.Haskell.TH.Syntax Methods showsPrec :: Int -> NameSpace -> ShowS # show :: NameSpace -> String # showList :: [NameSpace] -> ShowS #
Show OccName
Instance details Defined in Language.Haskell.TH.Syntax Methods showsPrec :: Int -> OccName -> ShowS # show :: OccName -> String # showList :: [OccName] -> ShowS #
Show Overlap
Instance details Defined in Language.Haskell.TH.Syntax Methods showsPrec :: Int -> Overlap -> ShowS # show :: Overlap -> String # showList :: [Overlap] -> ShowS #
Show Pat
Instance details Defined in Language.Haskell.TH.Syntax Methods showsPrec :: Int -> Pat -> ShowS # show :: Pat -> String # showList :: [Pat] -> ShowS #
Show PatSynArgs
Instance details Defined in Language.Haskell.TH.Syntax Methods showsPrec :: Int -> PatSynArgs -> ShowS # show :: PatSynArgs -> String # showList :: [PatSynArgs] -> ShowS #
Show PatSynDir
Instance details Defined in Language.Haskell.TH.Syntax Methods showsPrec :: Int -> PatSynDir -> ShowS # show :: PatSynDir -> String # showList :: [PatSynDir] -> ShowS #
Show Phases
Instance details Defined in Language.Haskell.TH.Syntax Methods showsPrec :: Int -> Phases -> ShowS # show :: Phases -> String # showList :: [Phases] -> ShowS #
Show PkgName
Instance details Defined in Language.Haskell.TH.Syntax Methods showsPrec :: Int -> PkgName -> ShowS # show :: PkgName -> String # showList :: [PkgName] -> ShowS #
Show Pragma
Instance details Defined in Language.Haskell.TH.Syntax Methods showsPrec :: Int -> Pragma -> ShowS # show :: Pragma -> String # showList :: [Pragma] -> ShowS #
Show Range
Instance details Defined in Language.Haskell.TH.Syntax Methods showsPrec :: Int -> Range -> ShowS # show :: Range -> String # showList :: [Range] -> ShowS #
Show Role
Instance details Defined in Language.Haskell.TH.Syntax Methods showsPrec :: Int -> Role -> ShowS # show :: Role -> String # showList :: [Role] -> ShowS #
Show RuleBndr
Instance details Defined in Language.Haskell.TH.Syntax Methods showsPrec :: Int -> RuleBndr -> ShowS # show :: RuleBndr -> String # showList :: [RuleBndr] -> ShowS #
Show RuleMatch
Instance details Defined in Language.Haskell.TH.Syntax Methods showsPrec :: Int -> RuleMatch -> ShowS # show :: RuleMatch -> String # showList :: [RuleMatch] -> ShowS #
Show Safety
Instance details Defined in Language.Haskell.TH.Syntax Methods showsPrec :: Int -> Safety -> ShowS # show :: Safety -> String # showList :: [Safety] -> ShowS #
Show SourceStrictness
Instance details Defined in Language.Haskell.TH.Syntax Methods showsPrec :: Int -> SourceStrictness -> ShowS # show :: SourceStrictness -> String # showList :: [SourceStrictness] -> ShowS #
Show SourceUnpackedness
Instance details Defined in Language.Haskell.TH.Syntax Methods showsPrec :: Int -> SourceUnpackedness -> ShowS # show :: SourceUnpackedness -> String # showList :: [SourceUnpackedness] -> ShowS #
Show Specificity
Instance details Defined in Language.Haskell.TH.Syntax Methods showsPrec :: Int -> Specificity -> ShowS # show :: Specificity -> String # showList :: [Specificity] -> ShowS #
Show Stmt
Instance details Defined in Language.Haskell.TH.Syntax Methods showsPrec :: Int -> Stmt -> ShowS # show :: Stmt -> String # showList :: [Stmt] -> ShowS #
Show TyLit
Instance details Defined in Language.Haskell.TH.Syntax Methods showsPrec :: Int -> TyLit -> ShowS # show :: TyLit -> String # showList :: [TyLit] -> ShowS #
Show TySynEqn
Instance details Defined in Language.Haskell.TH.Syntax Methods showsPrec :: Int -> TySynEqn -> ShowS # show :: TySynEqn -> String # showList :: [TySynEqn] -> ShowS #
Show Type
Instance details Defined in Language.Haskell.TH.Syntax Methods showsPrec :: Int -> Type -> ShowS # show :: Type -> String # showList :: [Type] -> ShowS #
Show TypeFamilyHead
Instance details Defined in Language.Haskell.TH.Syntax Methods showsPrec :: Int -> TypeFamilyHead -> ShowS # show :: TypeFamilyHead -> String # showList :: [TypeFamilyHead] -> ShowS #
Show CodePoint
Instance details Defined in Data.Text.Encoding Methods showsPrec :: Int -> CodePoint -> ShowS # show :: CodePoint -> String # showList :: [CodePoint] -> ShowS #
Show DecoderState
Instance details Defined in Data.Text.Encoding Methods showsPrec :: Int -> DecoderState -> ShowS # show :: DecoderState -> String # showList :: [DecoderState] -> ShowS #
Show Decoding
Instance details Defined in Data.Text.Encoding Methods showsPrec :: Int -> Decoding -> ShowS # show :: Decoding -> String # showList :: [Decoding] -> ShowS #
Show UnicodeException
Instance details Defined in Data.Text.Encoding.Error Methods showsPrec :: Int -> UnicodeException -> ShowS # show :: UnicodeException -> String # showList :: [UnicodeException] -> ShowS #
Show Word8	Since: base-2.1
Instance details Defined in GHC.Word Methods showsPrec :: Int -> Word8 -> ShowS # show :: Word8 -> String # showList :: [Word8] -> ShowS #
Show Integer	Since: base-2.1
Instance details Defined in GHC.Show Methods showsPrec :: Int -> Integer -> ShowS # show :: Integer -> String # showList :: [Integer] -> ShowS #
Show Natural	Since: base-4.8.0.0
Instance details Defined in GHC.Show Methods showsPrec :: Int -> Natural -> ShowS # show :: Natural -> String # showList :: [Natural] -> ShowS #
Show ()	Since: base-2.1
Instance details Defined in GHC.Show Methods showsPrec :: Int -> () -> ShowS # show :: () -> String # showList :: [()] -> ShowS #
Show Bool	Since: base-2.1
Instance details Defined in GHC.Show Methods showsPrec :: Int -> Bool -> ShowS # show :: Bool -> String # showList :: [Bool] -> ShowS #
Show Char	Since: base-2.1
Instance details Defined in GHC.Show Methods showsPrec :: Int -> Char -> ShowS # show :: Char -> String # showList :: [Char] -> ShowS #
Show Int	Since: base-2.1
Instance details Defined in GHC.Show Methods showsPrec :: Int -> Int -> ShowS # show :: Int -> String # showList :: [Int] -> ShowS #
Show RuntimeRep	Since: base-4.11.0.0
Instance details Defined in GHC.Show Methods showsPrec :: Int -> RuntimeRep -> ShowS # show :: RuntimeRep -> String # showList :: [RuntimeRep] -> ShowS #
Show VecCount	Since: base-4.11.0.0
Instance details Defined in GHC.Show Methods showsPrec :: Int -> VecCount -> ShowS # show :: VecCount -> String # showList :: [VecCount] -> ShowS #
Show VecElem	Since: base-4.11.0.0
Instance details Defined in GHC.Show Methods showsPrec :: Int -> VecElem -> ShowS # show :: VecElem -> String # showList :: [VecElem] -> ShowS #
Show Word	Since: base-2.1
Instance details Defined in GHC.Show Methods showsPrec :: Int -> Word -> ShowS # show :: Word -> String # showList :: [Word] -> ShowS #
Show a => Show (ZipList a)	Since: base-4.7.0.0
Instance details Defined in Control.Applicative Methods showsPrec :: Int -> ZipList a -> ShowS # show :: ZipList a -> String # showList :: [ZipList a] -> ShowS #
Show a => Show (Identity a)	This instance would be equivalent to the derived instances of the `Identity` newtype if the `runIdentity` field were removed Since: base-4.8.0.0
Instance details Defined in Data.Functor.Identity Methods showsPrec :: Int -> Identity a -> ShowS # show :: Identity a -> String # showList :: [Identity a] -> ShowS #
Show a => Show (First a)	Since: base-2.1
Instance details Defined in Data.Monoid Methods showsPrec :: Int -> First a -> ShowS # show :: First a -> String # showList :: [First a] -> ShowS #
Show a => Show (Last a)	Since: base-2.1
Instance details Defined in Data.Monoid Methods showsPrec :: Int -> Last a -> ShowS # show :: Last a -> String # showList :: [Last a] -> ShowS #
Show a => Show (Down a)	This instance would be equivalent to the derived instances of the `Down` newtype if the `getDown` field were removed Since: base-4.7.0.0
Instance details Defined in Data.Ord Methods showsPrec :: Int -> Down a -> ShowS # show :: Down a -> String # showList :: [Down a] -> ShowS #
Show a => Show (First a)	Since: base-4.9.0.0
Instance details Defined in Data.Semigroup Methods showsPrec :: Int -> First a -> ShowS # show :: First a -> String # showList :: [First a] -> ShowS #
Show a => Show (Last a)	Since: base-4.9.0.0
Instance details Defined in Data.Semigroup Methods showsPrec :: Int -> Last a -> ShowS # show :: Last a -> String # showList :: [Last a] -> ShowS #
Show a => Show (Max a)	Since: base-4.9.0.0
Instance details Defined in Data.Semigroup Methods showsPrec :: Int -> Max a -> ShowS # show :: Max a -> String # showList :: [Max a] -> ShowS #
Show a => Show (Min a)	Since: base-4.9.0.0
Instance details Defined in Data.Semigroup Methods showsPrec :: Int -> Min a -> ShowS # show :: Min a -> String # showList :: [Min a] -> ShowS #
Show a => Show (Option a)	Since: base-4.9.0.0
Instance details Defined in Data.Semigroup Methods showsPrec :: Int -> Option a -> ShowS # show :: Option a -> String # showList :: [Option a] -> ShowS #
Show m => Show (WrappedMonoid m)	Since: base-4.9.0.0
Instance details Defined in Data.Semigroup Methods showsPrec :: Int -> WrappedMonoid m -> ShowS # show :: WrappedMonoid m -> String # showList :: [WrappedMonoid m] -> ShowS #
Show a => Show (NonEmpty a)	Since: base-4.11.0.0
Instance details Defined in GHC.Show Methods showsPrec :: Int -> NonEmpty a -> ShowS # show :: NonEmpty a -> String # showList :: [NonEmpty a] -> ShowS #
Show p => Show (Par1 p)	Since: base-4.7.0.0
Instance details Defined in GHC.Generics Methods showsPrec :: Int -> Par1 p -> ShowS # show :: Par1 p -> String # showList :: [Par1 p] -> ShowS #
Show a => Show (Ratio a)	Since: base-2.0.1
Instance details Defined in GHC.Real Methods showsPrec :: Int -> Ratio a -> ShowS # show :: Ratio a -> String # showList :: [Ratio a] -> ShowS #
Show a => Show (IntMap a)
Instance details Defined in Data.IntMap.Internal Methods showsPrec :: Int -> IntMap a -> ShowS # show :: IntMap a -> String # showList :: [IntMap a] -> ShowS #
Show a => Show (Seq a)
Instance details Defined in Data.Sequence.Internal Methods showsPrec :: Int -> Seq a -> ShowS # show :: Seq a -> String # showList :: [Seq a] -> ShowS #
Show a => Show (ViewL a)
Instance details Defined in Data.Sequence.Internal Methods showsPrec :: Int -> ViewL a -> ShowS # show :: ViewL a -> String # showList :: [ViewL a] -> ShowS #
Show a => Show (ViewR a)
Instance details Defined in Data.Sequence.Internal Methods showsPrec :: Int -> ViewR a -> ShowS # show :: ViewR a -> String # showList :: [ViewR a] -> ShowS #
Show a => Show (Set a)
Instance details Defined in Data.Set.Internal Methods showsPrec :: Int -> Set a -> ShowS # show :: Set a -> String # showList :: [Set a] -> ShowS #
Show a => Show (DList a)
Instance details Defined in Data.DList.Internal Methods showsPrec :: Int -> DList a -> ShowS # show :: DList a -> String # showList :: [DList a] -> ShowS #
Show flag => Show (TyVarBndr flag)
Instance details Defined in Language.Haskell.TH.Syntax Methods showsPrec :: Int -> TyVarBndr flag -> ShowS # show :: TyVarBndr flag -> String # showList :: [TyVarBndr flag] -> ShowS #
Show a => Show (Maybe a)	Since: base-2.1
Instance details Defined in GHC.Show Methods showsPrec :: Int -> Maybe a -> ShowS # show :: Maybe a -> String # showList :: [Maybe a] -> ShowS #
Show a => Show (a)	Since: base-4.15
Instance details Defined in GHC.Show Methods showsPrec :: Int -> (a) -> ShowS # show :: (a) -> String # showList :: [(a)] -> ShowS #
Show a => Show [a]	Since: base-2.1
Instance details Defined in GHC.Show Methods showsPrec :: Int -> [a] -> ShowS # show :: [a] -> String # showList :: [[a]] -> ShowS #
(Show a, Show b) => Show (Either a b)	Since: base-3.0
Instance details Defined in Data.Either Methods showsPrec :: Int -> Either a b -> ShowS # show :: Either a b -> String # showList :: [Either a b] -> ShowS #
HasResolution a => Show (Fixed a)	Since: base-2.1
Instance details Defined in Data.Fixed Methods showsPrec :: Int -> Fixed a -> ShowS # show :: Fixed a -> String # showList :: [Fixed a] -> ShowS #
Show (Proxy s)	Since: base-4.7.0.0
Instance details Defined in Data.Proxy Methods showsPrec :: Int -> Proxy s -> ShowS # show :: Proxy s -> String # showList :: [Proxy s] -> ShowS #
(Show a, Show b) => Show (Arg a b)	Since: base-4.9.0.0
Instance details Defined in Data.Semigroup Methods showsPrec :: Int -> Arg a b -> ShowS # show :: Arg a b -> String # showList :: [Arg a b] -> ShowS #
Show (TypeRep a)
Instance details Defined in Data.Typeable.Internal Methods showsPrec :: Int -> TypeRep a -> ShowS # show :: TypeRep a -> String # showList :: [TypeRep a] -> ShowS #
Show (U1 p)	Since: base-4.9.0.0
Instance details Defined in GHC.Generics Methods showsPrec :: Int -> U1 p -> ShowS # show :: U1 p -> String # showList :: [U1 p] -> ShowS #
Show (V1 p)	Since: base-4.9.0.0
Instance details Defined in GHC.Generics Methods showsPrec :: Int -> V1 p -> ShowS # show :: V1 p -> String # showList :: [V1 p] -> ShowS #
(Show k, Show a) => Show (Map k a)
Instance details Defined in Data.Map.Internal Methods showsPrec :: Int -> Map k a -> ShowS # show :: Map k a -> String # showList :: [Map k a] -> ShowS #
(Show a, Show b) => Show (a, b)	Since: base-2.1
Instance details Defined in GHC.Show Methods showsPrec :: Int -> (a, b) -> ShowS # show :: (a, b) -> String # showList :: [(a, b)] -> ShowS #
Show a => Show (Const a b)	This instance would be equivalent to the derived instances of the `Const` newtype if the `getConst` field were removed Since: base-4.8.0.0
Instance details Defined in Data.Functor.Const Methods showsPrec :: Int -> Const a b -> ShowS # show :: Const a b -> String # showList :: [Const a b] -> ShowS #
Show (f a) => Show (Ap f a)	Since: base-4.12.0.0
Instance details Defined in Data.Monoid Methods showsPrec :: Int -> Ap f a -> ShowS # show :: Ap f a -> String # showList :: [Ap f a] -> ShowS #
Show (a :~: b)	Since: base-4.7.0.0
Instance details Defined in Data.Type.Equality Methods showsPrec :: Int -> (a :~: b) -> ShowS # show :: (a :~: b) -> String # showList :: [a :~: b] -> ShowS #
Show (f p) => Show (Rec1 f p)	Since: base-4.7.0.0
Instance details Defined in GHC.Generics Methods showsPrec :: Int -> Rec1 f p -> ShowS # show :: Rec1 f p -> String # showList :: [Rec1 f p] -> ShowS #
Show (URec Char p)	Since: base-4.9.0.0
Instance details Defined in GHC.Generics Methods showsPrec :: Int -> URec Char p -> ShowS # show :: URec Char p -> String # showList :: [URec Char p] -> ShowS #
Show (URec Double p)	Since: base-4.9.0.0
Instance details Defined in GHC.Generics Methods showsPrec :: Int -> URec Double p -> ShowS # show :: URec Double p -> String # showList :: [URec Double p] -> ShowS #
Show (URec Float p)
Instance details Defined in GHC.Generics Methods showsPrec :: Int -> URec Float p -> ShowS # show :: URec Float p -> String # showList :: [URec Float p] -> ShowS #
Show (URec Int p)	Since: base-4.9.0.0
Instance details Defined in GHC.Generics Methods showsPrec :: Int -> URec Int p -> ShowS # show :: URec Int p -> String # showList :: [URec Int p] -> ShowS #
Show (URec Word p)	Since: base-4.9.0.0
Instance details Defined in GHC.Generics Methods showsPrec :: Int -> URec Word p -> ShowS # show :: URec Word p -> String # showList :: [URec Word p] -> ShowS #
(Show a, Show b, Show c) => Show (a, b, c)	Since: base-2.1
Instance details Defined in GHC.Show Methods showsPrec :: Int -> (a, b, c) -> ShowS # show :: (a, b, c) -> String # showList :: [(a, b, c)] -> ShowS #
(Show1 f, Show1 g, Show a) => Show (Product f g a)	Since: base-4.9.0.0
Instance details Defined in Data.Functor.Product Methods showsPrec :: Int -> Product f g a -> ShowS # show :: Product f g a -> String # showList :: [Product f g a] -> ShowS #
(Show1 f, Show1 g, Show a) => Show (Sum f g a)	Since: base-4.9.0.0
Instance details Defined in Data.Functor.Sum Methods showsPrec :: Int -> Sum f g a -> ShowS # show :: Sum f g a -> String # showList :: [Sum f g a] -> ShowS #
Show (a :~~: b)	Since: base-4.10.0.0
Instance details Defined in Data.Type.Equality Methods showsPrec :: Int -> (a :~~: b) -> ShowS # show :: (a :~~: b) -> String # showList :: [a :~~: b] -> ShowS #
(Show (f p), Show (g p)) => Show ((f :*: g) p)	Since: base-4.7.0.0
Instance details Defined in GHC.Generics Methods showsPrec :: Int -> (f :: g) p -> ShowS # show :: (f :: g) p -> String # showList :: [(f :*: g) p] -> ShowS #
(Show (f p), Show (g p)) => Show ((f :+: g) p)	Since: base-4.7.0.0
Instance details Defined in GHC.Generics Methods showsPrec :: Int -> (f :+: g) p -> ShowS # show :: (f :+: g) p -> String # showList :: [(f :+: g) p] -> ShowS #
Show c => Show (K1 i c p)	Since: base-4.7.0.0
Instance details Defined in GHC.Generics Methods showsPrec :: Int -> K1 i c p -> ShowS # show :: K1 i c p -> String # showList :: [K1 i c p] -> ShowS #
(Show a, Show b, Show c, Show d) => Show (a, b, c, d)	Since: base-2.1
Instance details Defined in GHC.Show Methods showsPrec :: Int -> (a, b, c, d) -> ShowS # show :: (a, b, c, d) -> String # showList :: [(a, b, c, d)] -> ShowS #
(Show1 f, Show1 g, Show a) => Show (Compose f g a)	Since: base-4.9.0.0
Instance details Defined in Data.Functor.Compose Methods showsPrec :: Int -> Compose f g a -> ShowS # show :: Compose f g a -> String # showList :: [Compose f g a] -> ShowS #
Show (f (g p)) => Show ((f :.: g) p)	Since: base-4.7.0.0
Instance details Defined in GHC.Generics Methods showsPrec :: Int -> (f :.: g) p -> ShowS # show :: (f :.: g) p -> String # showList :: [(f :.: g) p] -> ShowS #
Show (f p) => Show (M1 i c f p)	Since: base-4.7.0.0
Instance details Defined in GHC.Generics Methods showsPrec :: Int -> M1 i c f p -> ShowS # show :: M1 i c f p -> String # showList :: [M1 i c f p] -> ShowS #
(Show a, Show b, Show c, Show d, Show e) => Show (a, b, c, d, e)	Since: base-2.1
Instance details Defined in GHC.Show Methods showsPrec :: Int -> (a, b, c, d, e) -> ShowS # show :: (a, b, c, d, e) -> String # showList :: [(a, b, c, d, e)] -> ShowS #
(Show a, Show b, Show c, Show d, Show e, Show f) => Show (a, b, c, d, e, f)	Since: base-2.1
Instance details Defined in GHC.Show Methods showsPrec :: Int -> (a, b, c, d, e, f) -> ShowS # show :: (a, b, c, d, e, f) -> String # showList :: [(a, b, c, d, e, f)] -> ShowS #
(Show a, Show b, Show c, Show d, Show e, Show f, Show g) => Show (a, b, c, d, e, f, g)	Since: base-2.1
Instance details Defined in GHC.Show Methods showsPrec :: Int -> (a, b, c, d, e, f, g) -> ShowS # show :: (a, b, c, d, e, f, g) -> String # showList :: [(a, b, c, d, e, f, g)] -> ShowS #
(Show a, Show b, Show c, Show d, Show e, Show f, Show g, Show h) => Show (a, b, c, d, e, f, g, h)	Since: base-2.1
Instance details Defined in GHC.Show Methods showsPrec :: Int -> (a, b, c, d, e, f, g, h) -> ShowS # show :: (a, b, c, d, e, f, g, h) -> String # showList :: [(a, b, c, d, e, f, g, h)] -> ShowS #
(Show a, Show b, Show c, Show d, Show e, Show f, Show g, Show h, Show i) => Show (a, b, c, d, e, f, g, h, i)	Since: base-2.1
Instance details Defined in GHC.Show Methods showsPrec :: Int -> (a, b, c, d, e, f, g, h, i) -> ShowS # show :: (a, b, c, d, e, f, g, h, i) -> String # showList :: [(a, b, c, d, e, f, g, h, i)] -> ShowS #
(Show a, Show b, Show c, Show d, Show e, Show f, Show g, Show h, Show i, Show j) => Show (a, b, c, d, e, f, g, h, i, j)	Since: base-2.1
Instance details Defined in GHC.Show Methods showsPrec :: Int -> (a, b, c, d, e, f, g, h, i, j) -> ShowS # show :: (a, b, c, d, e, f, g, h, i, j) -> String # showList :: [(a, b, c, d, e, f, g, h, i, j)] -> ShowS #
(Show a, Show b, Show c, Show d, Show e, Show f, Show g, Show h, Show i, Show j, Show k) => Show (a, b, c, d, e, f, g, h, i, j, k)	Since: base-2.1
Instance details Defined in GHC.Show Methods showsPrec :: Int -> (a, b, c, d, e, f, g, h, i, j, k) -> ShowS # show :: (a, b, c, d, e, f, g, h, i, j, k) -> String # showList :: [(a, b, c, d, e, f, g, h, i, j, k)] -> ShowS #
(Show a, Show b, Show c, Show d, Show e, Show f, Show g, Show h, Show i, Show j, Show k, Show l) => Show (a, b, c, d, e, f, g, h, i, j, k, l)	Since: base-2.1
Instance details Defined in GHC.Show Methods showsPrec :: Int -> (a, b, c, d, e, f, g, h, i, j, k, l) -> ShowS # show :: (a, b, c, d, e, f, g, h, i, j, k, l) -> String # showList :: [(a, b, c, d, e, f, g, h, i, j, k, l)] -> ShowS #
(Show a, Show b, Show c, Show d, Show e, Show f, Show g, Show h, Show i, Show j, Show k, Show l, Show m) => Show (a, b, c, d, e, f, g, h, i, j, k, l, m)	Since: base-2.1
Instance details Defined in GHC.Show Methods showsPrec :: Int -> (a, b, c, d, e, f, g, h, i, j, k, l, m) -> ShowS # show :: (a, b, c, d, e, f, g, h, i, j, k, l, m) -> String # showList :: [(a, b, c, d, e, f, g, h, i, j, k, l, m)] -> ShowS #
(Show a, Show b, Show c, Show d, Show e, Show f, Show g, Show h, Show i, Show j, Show k, Show l, Show m, Show n) => Show (a, b, c, d, e, f, g, h, i, j, k, l, m, n)	Since: base-2.1
Instance details Defined in GHC.Show Methods showsPrec :: Int -> (a, b, c, d, e, f, g, h, i, j, k, l, m, n) -> ShowS # show :: (a, b, c, d, e, f, g, h, i, j, k, l, m, n) -> String # showList :: [(a, b, c, d, e, f, g, h, i, j, k, l, m, n)] -> ShowS #
(Show a, Show b, Show c, Show d, Show e, Show f, Show g, Show h, Show i, Show j, Show k, Show l, Show m, Show n, Show o) => Show (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o)	Since: base-2.1
Instance details Defined in GHC.Show Methods showsPrec :: Int -> (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o) -> ShowS # show :: (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o) -> String # showList :: [(a, b, c, d, e, f, g, h, i, j, k, l, m, n, o)] -> ShowS #

type HasCallStack = ?callStack :: CallStack #

Request a CallStack.

NOTE: The implicit parameter ?callStack :: CallStack is an implementation detail and should not be considered part of the CallStack API, we may decide to change the implementation in the future.

Since: base-4.9.0.0

class KnownNat (n :: Nat) #

This class gives the integer associated with a type-level natural. There are instances of the class for every concrete literal: 0, 1, 2, etc.

Since: base-4.7.0.0

Minimal complete definition

natSing

class KnownSymbol (n :: Symbol) #

This class gives the string associated with a type-level symbol. There are instances of the class for every concrete literal: "hello", etc.

Since: base-4.7.0.0

Minimal complete definition

symbolSing

data Nat #

(Kind) This is the kind of type-level natural numbers.

Instances

Instances details

KnownNat n => HasResolution (n :: Nat)	For example, `Fixed 1000` will give you a `Fixed` with a resolution of 1000.
Instance details Defined in Data.Fixed Methods resolution :: p n -> Integer #

data Symbol #

(Kind) This is the kind of type-level symbols. Declared here because class IP needs it

Instances

Instances details

SingKind Symbol	Since: base-4.9.0.0
Instance details Defined in GHC.Generics Associated Types type DemoteRep Symbol Methods fromSing :: forall (a :: Symbol). Sing a -> DemoteRep Symbol
KnownSymbol a => SingI (a :: Symbol)	Since: base-4.9.0.0
Instance details Defined in GHC.Generics Methods sing :: Sing a
type DemoteRep Symbol
Instance details Defined in GHC.Generics type DemoteRep Symbol = String
data Sing (s :: Symbol)
Instance details Defined in GHC.Generics data Sing (s :: Symbol) where SSym :: forall (s :: Symbol). KnownSymbol s => Sing s

type family (a :: Nat) + (b :: Nat) :: Nat where ... infixl 6 #

Addition of type-level naturals.

Since: base-4.7.0.0

type family (a :: Nat) * (b :: Nat) :: Nat where ... infixl 7 #

Multiplication of type-level naturals.

Since: base-4.7.0.0

type family (a :: Nat) ^ (b :: Nat) :: Nat where ... infixr 8 #

Exponentiation of type-level naturals.

Since: base-4.7.0.0

type family (a :: Nat) <=? (b :: Nat) :: Bool where ... infix 4 #

Comparison of type-level naturals, as a function. NOTE: The functionality for this function should be subsumed by CmpNat, so this might go away in the future. Please let us know, if you encounter discrepancies between the two.

type family (a :: Nat) - (b :: Nat) :: Nat where ... infixl 6 #

Subtraction of type-level naturals.

Since: base-4.7.0.0

type family CmpSymbol (a :: Symbol) (b :: Symbol) :: Ordering where ... #

Comparison of type-level symbols, as a function.

Since: base-4.7.0.0

type family CmpNat (a :: Nat) (b :: Nat) :: Ordering where ... #

Comparison of type-level naturals, as a function.

Since: base-4.7.0.0

type family Div (a :: Nat) (b :: Nat) :: Nat where ... infixl 7 #

Division (round down) of natural numbers. Div x 0 is undefined (i.e., it cannot be reduced).

Since: base-4.11.0.0

type family Mod (a :: Nat) (b :: Nat) :: Nat where ... infixl 7 #

Modulus of natural numbers. Mod x 0 is undefined (i.e., it cannot be reduced).

Since: base-4.11.0.0

type family Log2 (a :: Nat) :: Nat where ... #

Log base 2 (round down) of natural numbers. Log 0 is undefined (i.e., it cannot be reduced).

Since: base-4.11.0.0

type family TypeError (a :: ErrorMessage) :: b where ... #

The type-level equivalent of error.

The polymorphic kind of this type allows it to be used in several settings. For instance, it can be used as a constraint, e.g. to provide a better error message for a non-existent instance,

-- in a context
instance TypeError (Text "Cannot Show functions." :$$:
                    Text "Perhaps there is a missing argument?")
      => Show (a -> b) where
    showsPrec = error "unreachable"

It can also be placed on the right-hand side of a type-level function to provide an error for an invalid case,

type family ByteSize x where
   ByteSize Word16   = 2
   ByteSize Word8    = 1
   ByteSize a        = TypeError (Text "The type " :<>: ShowType a :<>:
                                  Text " is not exportable.")

Since: base-4.9.0.0

type family AppendSymbol (a :: Symbol) (b :: Symbol) :: Symbol where ... #

Concatenation of type-level symbols.

Since: base-4.10.0.0

data SomeSymbol #

This type represents unknown type-level symbols.

Constructors

KnownSymbol n => SomeSymbol (Proxy n)

Since: base-4.7.0.0

Instances

Instances details

Read SomeSymbol	Since: base-4.7.0.0
Instance details Defined in GHC.TypeLits Methods readsPrec :: Int -> ReadS SomeSymbol # readList :: ReadS [SomeSymbol] # readPrec :: ReadPrec SomeSymbol # readListPrec :: ReadPrec [SomeSymbol] #
Show SomeSymbol	Since: base-4.7.0.0
Instance details Defined in GHC.TypeLits Methods showsPrec :: Int -> SomeSymbol -> ShowS # show :: SomeSymbol -> String # showList :: [SomeSymbol] -> ShowS #
Eq SomeSymbol	Since: base-4.7.0.0
Instance details Defined in GHC.TypeLits Methods (==) :: SomeSymbol -> SomeSymbol -> Bool # (/=) :: SomeSymbol -> SomeSymbol -> Bool #
Ord SomeSymbol	Since: base-4.7.0.0
Instance details Defined in GHC.TypeLits Methods compare :: SomeSymbol -> SomeSymbol -> Ordering # (<) :: SomeSymbol -> SomeSymbol -> Bool # (<=) :: SomeSymbol -> SomeSymbol -> Bool # (>) :: SomeSymbol -> SomeSymbol -> Bool # (>=) :: SomeSymbol -> SomeSymbol -> Bool # max :: SomeSymbol -> SomeSymbol -> SomeSymbol # min :: SomeSymbol -> SomeSymbol -> SomeSymbol #

pattern ShowType :: t -> ErrorMessage #

Pretty print the type. ShowType :: k -> ErrorMessage

pattern (:<>:) :: ErrorMessage -> ErrorMessage -> ErrorMessage infixl 6 #

Put two pieces of error message next to each other.

pattern (:$$:) :: ErrorMessage -> ErrorMessage -> ErrorMessage infixl 5 #

Stack two pieces of error message on top of each other.

symbolVal' :: forall (n :: Symbol). KnownSymbol n => Proxy# n -> String #

Since: base-4.8.0.0

symbolVal :: forall (n :: Symbol) proxy. KnownSymbol n => proxy n -> String #

Since: base-4.7.0.0

someSymbolVal :: String -> SomeSymbol #

Convert a string into an unknown type-level symbol.

Since: base-4.7.0.0

someNatVal :: Integer -> Maybe SomeNat #

Convert an integer into an unknown type-level natural.

Since: base-4.7.0.0

sameSymbol :: forall (a :: Symbol) (b :: Symbol) proxy1 proxy2. (KnownSymbol a, KnownSymbol b) => proxy1 a -> proxy2 b -> Maybe (a :~: b) #

We either get evidence that this function was instantiated with the same type-level symbols, or Nothing.

Since: base-4.7.0.0

natVal' :: forall (n :: Nat). KnownNat n => Proxy# n -> Integer #

Since: base-4.8.0.0

natVal :: forall (n :: Nat) proxy. KnownNat n => proxy n -> Integer #

Since: base-4.7.0.0

data SomeNat #

This type represents unknown type-level natural numbers.

Since: base-4.10.0.0

Constructors

KnownNat n => SomeNat (Proxy n)

Instances

Instances details

Read SomeNat	Since: base-4.7.0.0
Instance details Defined in GHC.TypeNats Methods readsPrec :: Int -> ReadS SomeNat # readList :: ReadS [SomeNat] # readPrec :: ReadPrec SomeNat # readListPrec :: ReadPrec [SomeNat] #
Show SomeNat	Since: base-4.7.0.0
Instance details Defined in GHC.TypeNats Methods showsPrec :: Int -> SomeNat -> ShowS # show :: SomeNat -> String # showList :: [SomeNat] -> ShowS #
Eq SomeNat	Since: base-4.7.0.0
Instance details Defined in GHC.TypeNats Methods (==) :: SomeNat -> SomeNat -> Bool # (/=) :: SomeNat -> SomeNat -> Bool #
Ord SomeNat	Since: base-4.7.0.0
Instance details Defined in GHC.TypeNats Methods compare :: SomeNat -> SomeNat -> Ordering # (<) :: SomeNat -> SomeNat -> Bool # (<=) :: SomeNat -> SomeNat -> Bool # (>) :: SomeNat -> SomeNat -> Bool # (>=) :: SomeNat -> SomeNat -> Bool # max :: SomeNat -> SomeNat -> SomeNat # min :: SomeNat -> SomeNat -> SomeNat #

type (<=) (x :: Nat) (y :: Nat) = (x <=? y) ~ 'True infix 4 #

Comparison of type-level naturals, as a constraint.

Since: base-4.7.0.0

sameNat :: forall (a :: Nat) (b :: Nat) proxy1 proxy2. (KnownNat a, KnownNat b) => proxy1 a -> proxy2 b -> Maybe (a :~: b) #

We either get evidence that this function was instantiated with the same type-level numbers, or Nothing.

Since: base-4.7.0.0

module Incipit.Fixed

module Incipit.Integral

data Natural #

Natural number

Invariant: numbers <= 0xffffffffffffffff use the NS constructor

Instances

Instances details

Bits Natural	Since: base-4.8.0
Instance details Defined in Data.Bits Methods (.&.) :: Natural -> Natural -> Natural # (.\|.) :: Natural -> Natural -> Natural # xor :: Natural -> Natural -> Natural # complement :: Natural -> Natural # shift :: Natural -> Int -> Natural # rotate :: Natural -> Int -> Natural # zeroBits :: Natural # bit :: Int -> Natural # setBit :: Natural -> Int -> Natural # clearBit :: Natural -> Int -> Natural # complementBit :: Natural -> Int -> Natural # testBit :: Natural -> Int -> Bool # bitSizeMaybe :: Natural -> Maybe Int # bitSize :: Natural -> Int # isSigned :: Natural -> Bool # shiftL :: Natural -> Int -> Natural # unsafeShiftL :: Natural -> Int -> Natural # shiftR :: Natural -> Int -> Natural # unsafeShiftR :: Natural -> Int -> Natural # rotateL :: Natural -> Int -> Natural # rotateR :: Natural -> Int -> Natural # popCount :: Natural -> Int #
Enum Natural	Since: base-4.8.0.0
Instance details Defined in GHC.Enum Methods succ :: Natural -> Natural # pred :: Natural -> Natural # toEnum :: Int -> Natural # fromEnum :: Natural -> Int # enumFrom :: Natural -> [Natural] # enumFromThen :: Natural -> Natural -> [Natural] # enumFromTo :: Natural -> Natural -> [Natural] # enumFromThenTo :: Natural -> Natural -> Natural -> [Natural] #
Num Natural	Note that `Natural`'s `Num` instance isn't a ring: no element but 0 has an additive inverse. It is a semiring though. Since: base-4.8.0.0
Instance details Defined in GHC.Num Methods (+) :: Natural -> Natural -> Natural # (-) :: Natural -> Natural -> Natural # (*) :: Natural -> Natural -> Natural # negate :: Natural -> Natural # abs :: Natural -> Natural # signum :: Natural -> Natural # fromInteger :: Integer -> Natural #
Read Natural	Since: base-4.8.0.0
Instance details Defined in GHC.Read Methods readsPrec :: Int -> ReadS Natural # readList :: ReadS [Natural] # readPrec :: ReadPrec Natural # readListPrec :: ReadPrec [Natural] #
Integral Natural	Since: base-4.8.0.0
Instance details Defined in GHC.Real Methods quot :: Natural -> Natural -> Natural # rem :: Natural -> Natural -> Natural # div :: Natural -> Natural -> Natural # mod :: Natural -> Natural -> Natural # quotRem :: Natural -> Natural -> (Natural, Natural) # divMod :: Natural -> Natural -> (Natural, Natural) # toInteger :: Natural -> Integer #
Real Natural	Since: base-4.8.0.0
Instance details Defined in GHC.Real Methods toRational :: Natural -> Rational #
Show Natural	Since: base-4.8.0.0
Instance details Defined in GHC.Show Methods showsPrec :: Int -> Natural -> ShowS # show :: Natural -> String # showList :: [Natural] -> ShowS #
Eq Natural
Instance details Defined in GHC.Num.Natural Methods (==) :: Natural -> Natural -> Bool # (/=) :: Natural -> Natural -> Bool #
Ord Natural
Instance details Defined in GHC.Num.Natural Methods compare :: Natural -> Natural -> Ordering # (<) :: Natural -> Natural -> Bool # (<=) :: Natural -> Natural -> Bool # (>) :: Natural -> Natural -> Bool # (>=) :: Natural -> Natural -> Bool # max :: Natural -> Natural -> Natural # min :: Natural -> Natural -> Natural #
Lift Natural
Instance details Defined in Language.Haskell.TH.Syntax Methods lift :: Quote m => Natural -> m Exp # liftTyped :: forall (m :: Type -> Type). Quote m => Natural -> Code m Natural #

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

data IO a #

A value of type IO a is a computation which, when performed, does some I/O before returning a value of type a.

There is really only one way to "perform" an I/O action: bind it to Main.main in your program. When your program is run, the I/O will be performed. It isn't possible to perform I/O from an arbitrary function, unless that function is itself in the IO monad and called at some point, directly or indirectly, from Main.main.

IO is a monad, so IO actions can be combined using either the do-notation or the >> and >>= operations from the Monad class.

Instances

Instances details

MonadFail IO	Since: base-4.9.0.0
Instance details Defined in Control.Monad.Fail Methods fail :: String -> IO a #
MonadIO IO	Since: base-4.9.0.0
Instance details Defined in Control.Monad.IO.Class Methods liftIO :: IO a -> IO a #
Alternative IO	Since: base-4.9.0.0
Instance details Defined in GHC.Base Methods empty :: IO a # (<\|>) :: IO a -> IO a -> IO a # some :: IO a -> IO [a] # many :: IO a -> IO [a] #
Applicative IO	Since: base-2.1
Instance details Defined in GHC.Base Methods pure :: a -> IO a # (<>) :: IO (a -> b) -> IO a -> IO b # liftA2 :: (a -> b -> c) -> IO a -> IO b -> IO c # (>) :: IO a -> IO b -> IO b # (<*) :: IO a -> IO b -> IO a #
Functor IO	Since: base-2.1
Instance details Defined in GHC.Base Methods fmap :: (a -> b) -> IO a -> IO b # (<$) :: a -> IO b -> IO a #
Monad IO	Since: base-2.1
Instance details Defined in GHC.Base Methods (>>=) :: IO a -> (a -> IO b) -> IO b # (>>) :: IO a -> IO b -> IO b # return :: a -> IO a #
MonadPlus IO	Since: base-4.9.0.0
Instance details Defined in GHC.Base Methods mzero :: IO a # mplus :: IO a -> IO a -> IO a #
Quasi IO
Instance details Defined in Language.Haskell.TH.Syntax Methods qNewName :: String -> IO Name # qReport :: Bool -> String -> IO () # qRecover :: IO a -> IO a -> IO a # qLookupName :: Bool -> String -> IO (Maybe Name) # qReify :: Name -> IO Info # qReifyFixity :: Name -> IO (Maybe Fixity) # qReifyType :: Name -> IO Type # qReifyInstances :: Name -> [Type] -> IO [Dec] # qReifyRoles :: Name -> IO [Role] # qReifyAnnotations :: Data a => AnnLookup -> IO [a] # qReifyModule :: Module -> IO ModuleInfo # qReifyConStrictness :: Name -> IO [DecidedStrictness] # qLocation :: IO Loc # qRunIO :: IO a -> IO a # qAddDependentFile :: FilePath -> IO () # qAddTempFile :: String -> IO FilePath # qAddTopDecls :: [Dec] -> IO () # qAddForeignFilePath :: ForeignSrcLang -> String -> IO () # qAddModFinalizer :: Q () -> IO () # qAddCorePlugin :: String -> IO () # qGetQ :: Typeable a => IO (Maybe a) # qPutQ :: Typeable a => a -> IO () # qIsExtEnabled :: Extension -> IO Bool # qExtsEnabled :: IO [Extension] #
Quote IO
Instance details Defined in Language.Haskell.TH.Syntax Methods newName :: String -> IO Name #
Monoid a => Monoid (IO a)	Since: base-4.9.0.0
Instance details Defined in GHC.Base Methods mempty :: IO a # mappend :: IO a -> IO a -> IO a # mconcat :: [IO a] -> IO a #
Semigroup a => Semigroup (IO a)	Since: base-4.10.0.0
Instance details Defined in GHC.Base Methods (<>) :: IO a -> IO a -> IO a # sconcat :: NonEmpty (IO a) -> IO a # stimes :: Integral b => b -> IO a -> IO a #
Default a => Default (IO a)
Instance details Defined in Data.Default.Class Methods def :: IO a #

putStrLn :: String -> IO () #

The same as putStr, but adds a newline character.

putStr :: String -> IO () #

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

type FilePath = String #

File and directory names are values of type String, whose precise meaning is operating system dependent. Files can be opened, yielding a handle which can then be used to operate on the contents of that file.