Acme.Functors.Classes

Documentation

class Functor f => Applicative f where

A functor with application, providing operations to

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

A minimal complete definition must include implementations of these functions satisfying the following laws:

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 = pure (const id) <*> u <*> v

• u <* v = pure const <*> u <*> v

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

• fmap f x = pure f <*> x

If f is also a Monad, it should satisfy

• pure = return

• (<*>) = ap

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

Minimal complete definition

pure, (<*>)

Methods

pure :: a -> f a

Lift a value.

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

Sequential application.

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

Sequence actions, discarding the value of the first argument.

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

Sequence actions, discarding the value of the second argument.

Instances

Applicative []

Methods

pure :: a -> [a]

(<*>) :: [a -> b] -> [a] -> [b]

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

(<*) :: [a] -> [b] -> [a]

Applicative Maybe

Methods

pure :: a -> Maybe a

(<*>) :: Maybe (a -> b) -> Maybe a -> Maybe b

(*>) :: Maybe a -> Maybe b -> Maybe b

(<*) :: Maybe a -> Maybe b -> Maybe a

Applicative IO

Methods

pure :: a -> IO a

(<*>) :: IO (a -> b) -> IO a -> IO b

(*>) :: IO a -> IO b -> IO b

(<*) :: IO a -> IO b -> IO a

Applicative U1

Methods

pure :: a -> U1 a

(<*>) :: U1 (a -> b) -> U1 a -> U1 b

(*>) :: U1 a -> U1 b -> U1 b

(<*) :: U1 a -> U1 b -> U1 a

Applicative Par1

Methods

pure :: a -> Par1 a

(<*>) :: Par1 (a -> b) -> Par1 a -> Par1 b

(*>) :: Par1 a -> Par1 b -> Par1 b

(<*) :: Par1 a -> Par1 b -> Par1 a

Applicative Min

Methods

pure :: a -> Min a

(<*>) :: Min (a -> b) -> Min a -> Min b

(*>) :: Min a -> Min b -> Min b

(<*) :: Min a -> Min b -> Min a

Applicative Max

Methods

pure :: a -> Max a

(<*>) :: Max (a -> b) -> Max a -> Max b

(*>) :: Max a -> Max b -> Max b

(<*) :: Max a -> Max b -> Max a

Applicative First

Methods

pure :: a -> First a

(<*>) :: First (a -> b) -> First a -> First b

(*>) :: First a -> First b -> First b

(<*) :: First a -> First b -> First a

Applicative Last

Methods

pure :: a -> Last a

(<*>) :: Last (a -> b) -> Last a -> Last b

(*>) :: Last a -> Last b -> Last b

(<*) :: Last a -> Last b -> Last a

Applicative Option

Methods

pure :: a -> Option a

(<*>) :: Option (a -> b) -> Option a -> Option b

(*>) :: Option a -> Option b -> Option b

(<*) :: Option a -> Option b -> Option a

Applicative NonEmpty

Methods

pure :: a -> NonEmpty a

(<*>) :: NonEmpty (a -> b) -> NonEmpty a -> NonEmpty b

(*>) :: NonEmpty a -> NonEmpty b -> NonEmpty b

(<*) :: NonEmpty a -> NonEmpty b -> NonEmpty a

Applicative ZipList

Methods

pure :: a -> ZipList a

(<*>) :: ZipList (a -> b) -> ZipList a -> ZipList b

(*>) :: ZipList a -> ZipList b -> ZipList b

(<*) :: ZipList a -> ZipList b -> ZipList a

Applicative Dual

Methods

pure :: a -> Dual a

(<*>) :: Dual (a -> b) -> Dual a -> Dual b

(*>) :: Dual a -> Dual b -> Dual b

(<*) :: Dual a -> Dual b -> Dual a

Applicative Sum

Methods

pure :: a -> Sum a

(<*>) :: Sum (a -> b) -> Sum a -> Sum b

(*>) :: Sum a -> Sum b -> Sum b

(<*) :: Sum a -> Sum b -> Sum a

Applicative Product

Methods

pure :: a -> Product a

(<*>) :: Product (a -> b) -> Product a -> Product b

(*>) :: Product a -> Product b -> Product b

(<*) :: Product a -> Product b -> Product a

Applicative First

Methods

pure :: a -> First a

(<*>) :: First (a -> b) -> First a -> First b

(*>) :: First a -> First b -> First b

(<*) :: First a -> First b -> First a

Applicative Last

Methods

pure :: a -> Last a

(<*>) :: Last (a -> b) -> Last a -> Last b

(*>) :: Last a -> Last b -> Last b

(<*) :: Last a -> Last b -> Last a

Applicative OneOrMore

pure a = OneOrMore a ActuallyNone

OneOrMore f fs <*> OneOrMore x xs = OneOrMore (f x) (fs <*> xs)

Methods

pure :: a -> OneOrMore a

(<*>) :: OneOrMore (a -> b) -> OneOrMore a -> OneOrMore b

(*>) :: OneOrMore a -> OneOrMore b -> OneOrMore b

(<*) :: OneOrMore a -> OneOrMore b -> OneOrMore a

Applicative AnyNumberOf

You can use this to apply any number of functions to any number of arguments.

pure a = OneAndMaybeMore a ActuallyNone

OneAndMaybeMore f fs <*> OneAndMaybeMore x xs =
    OneAndMaybeMore (f x) (fs <*> xs)
_ <*> _ = ActuallyNone

Example:

    ( (+ 1) ~~ (* 2) ~~ (+ 5) ~~       ActuallyNone )
<*> (    1  ~~    6  ~~    4  ~~ 37 ~~ ActuallyNone )
 =  (    7  ~~   12  ~~    9  ~~       ActuallyNone )

This example demonstrates how when there are more arguments than functions, any excess arguments (in this case, the 37) are ignored.

Methods

pure :: a -> AnyNumberOf a

(<*>) :: AnyNumberOf (a -> b) -> AnyNumberOf a -> AnyNumberOf b

(*>) :: AnyNumberOf a -> AnyNumberOf b -> AnyNumberOf b

(<*) :: AnyNumberOf a -> AnyNumberOf b -> AnyNumberOf a

Applicative Two

If you have two functions f and g and two values a and a', then you can apply them with (<*>) to get two results f a and g a'.

pure a = Two a a

Two f g <*> Two a a' = Two (f a) (g a')

Methods

pure :: a -> Two a

(<*>) :: Two (a -> b) -> Two a -> Two b

(*>) :: Two a -> Two b -> Two b

(<*) :: Two a -> Two b -> Two a

Applicative OrNot

If you have a function f that might not actually be there, and a value a that might not actually be there, lifted application (<*>) gives you f a only if both of them are actually there.

pure = ActuallyYes

ActuallyYes f <*> ActuallyYes a = ActuallyYes (f a)
_             <*> _             = Nope

Methods

pure :: a -> OrNot a

(<*>) :: OrNot (a -> b) -> OrNot a -> OrNot b

(*>) :: OrNot a -> OrNot b -> OrNot b

(<*) :: OrNot a -> OrNot b -> OrNot a

Applicative LiftedButWhy

pure = LiftedButWhy

LiftedButWhy f <*> LiftedButWhy a = LiftedButWhy (f a)

Methods

pure :: a -> LiftedButWhy a

(<*>) :: LiftedButWhy (a -> b) -> LiftedButWhy a -> LiftedButWhy b

(*>) :: LiftedButWhy a -> LiftedButWhy b -> LiftedButWhy b

(<*) :: LiftedButWhy a -> LiftedButWhy b -> LiftedButWhy a

Applicative ((->) a)

Methods

pure :: a -> a -> a

(<*>) :: (a -> a -> b) -> (a -> a) -> a -> b

(*>) :: (a -> a) -> (a -> b) -> a -> b

(<*) :: (a -> a) -> (a -> b) -> a -> a

Applicative (Either e)

Methods

pure :: a -> Either e a

(<*>) :: Either e (a -> b) -> Either e a -> Either e b

(*>) :: Either e a -> Either e b -> Either e b

(<*) :: Either e a -> Either e b -> Either e a

Applicative f => Applicative (Rec1 f)

Methods

pure :: a -> Rec1 f a

(<*>) :: Rec1 f (a -> b) -> Rec1 f a -> Rec1 f b

(*>) :: Rec1 f a -> Rec1 f b -> Rec1 f b

(<*) :: Rec1 f a -> Rec1 f b -> Rec1 f a

Monoid a => Applicative ((,) a)

Methods

pure :: a -> (a, a)

(<*>) :: (a, a -> b) -> (a, a) -> (a, b)

(*>) :: (a, a) -> (a, b) -> (a, b)

(<*) :: (a, a) -> (a, b) -> (a, a)

Monad m => Applicative (WrappedMonad m)

Methods

pure :: a -> WrappedMonad m a

(<*>) :: WrappedMonad m (a -> b) -> WrappedMonad m a -> WrappedMonad m b

(*>) :: WrappedMonad m a -> WrappedMonad m b -> WrappedMonad m b

(<*) :: WrappedMonad m a -> WrappedMonad m b -> WrappedMonad m a

Applicative (DeterminedBy parameter)

pure a = Determination (\_ -> a)

Determination f <*> Determination a = Determination (\x -> f x (a x))

Methods

pure :: a -> DeterminedBy parameter a

(<*>) :: DeterminedBy parameter (a -> b) -> DeterminedBy parameter a -> DeterminedBy parameter b

(*>) :: DeterminedBy parameter a -> DeterminedBy parameter b -> DeterminedBy parameter b

(<*) :: DeterminedBy parameter a -> DeterminedBy parameter b -> DeterminedBy parameter a

Applicative (OrInsteadFirst otherThing)

pure = NotInsteadFirst

NotInsteadFirst f  <*> NotInsteadFirst a  = NotInsteadFirst (f a)
InsteadFirst other <*> _                  = InsteadFirst other
_                  <*> InsteadFirst other = InsteadFirst other

Methods

pure :: a -> OrInsteadFirst otherThing a

(<*>) :: OrInsteadFirst otherThing (a -> b) -> OrInsteadFirst otherThing a -> OrInsteadFirst otherThing b

(*>) :: OrInsteadFirst otherThing a -> OrInsteadFirst otherThing b -> OrInsteadFirst otherThing b

(<*) :: OrInsteadFirst otherThing a -> OrInsteadFirst otherThing b -> OrInsteadFirst otherThing a

Semigroup otherThing => Applicative (OrInstead otherThing)

The possibility of having an otherThing obstructs this functor's ability to be applicative, much like the extra thing in Also extraThing does. In this case, since we do not need an empty value for the otherThing, it needs only a semigroup to be in compliance.

pure = NotInstead

NotInstead f   <*> NotInstead a   = NotInstead (f a)
Instead other1 <*> Instead other2 = Instead (other1 <> other2)
Instead other  <*> _              = Instead other
_              <*> Instead other  = Instead other

Methods

pure :: a -> OrInstead otherThing a

(<*>) :: OrInstead otherThing (a -> b) -> OrInstead otherThing a -> OrInstead otherThing b

(*>) :: OrInstead otherThing a -> OrInstead otherThing b -> OrInstead otherThing b

(<*) :: OrInstead otherThing a -> OrInstead otherThing b -> OrInstead otherThing a

Monoid extraThing => Applicative (Also extraThing)

Dragging the extraThing along can be a bit of a burden. It prevents Also extraThing from being an applicative functor — unless the extraThing can pull its weight by bringing a monoid to the table.

pure = (`Also` mempty)

(f `Also` extra1) <*> (a `Also` extra2) = f a
                                          `Also` (extra1 <> extra2)

Methods

pure :: a -> Also extraThing a

(<*>) :: Also extraThing (a -> b) -> Also extraThing a -> Also extraThing b

(*>) :: Also extraThing a -> Also extraThing b -> Also extraThing b

(<*) :: Also extraThing a -> Also extraThing b -> Also extraThing a

(Applicative f, Applicative g) => Applicative ((:*:) f g)

Methods

pure :: a -> (f :*: g) a

(<*>) :: (f :*: g) (a -> b) -> (f :*: g) a -> (f :*: g) b

(*>) :: (f :*: g) a -> (f :*: g) b -> (f :*: g) b

(<*) :: (f :*: g) a -> (f :*: g) b -> (f :*: g) a

(Applicative f, Applicative g) => Applicative ((:.:) f g)

Methods

pure :: a -> (f :.: g) a

(<*>) :: (f :.: g) (a -> b) -> (f :.: g) a -> (f :.: g) b

(*>) :: (f :.: g) a -> (f :.: g) b -> (f :.: g) b

(<*) :: (f :.: g) a -> (f :.: g) b -> (f :.: g) a

Arrow a => Applicative (WrappedArrow a b)

Methods

pure :: a -> WrappedArrow a b a

(<*>) :: WrappedArrow a b (a -> b) -> WrappedArrow a b a -> WrappedArrow a b b

(*>) :: WrappedArrow a b a -> WrappedArrow a b b -> WrappedArrow a b b

(<*) :: WrappedArrow a b a -> WrappedArrow a b b -> WrappedArrow a b a

Monoid m => Applicative (Const * m)

Methods

pure :: a -> Const * m a

(<*>) :: Const * m (a -> b) -> Const * m a -> Const * m b

(*>) :: Const * m a -> Const * m b -> Const * m b

(<*) :: Const * m a -> Const * m b -> Const * m a

Applicative f => Applicative (Alt * f)

Methods

pure :: a -> Alt * f a

(<*>) :: Alt * f (a -> b) -> Alt * f a -> Alt * f b

(*>) :: Alt * f a -> Alt * f b -> Alt * f b

(<*) :: Alt * f a -> Alt * f b -> Alt * f a

Applicative f => Applicative (M1 i c f)

Methods

pure :: a -> M1 i c f a

(<*>) :: M1 i c f (a -> b) -> M1 i c f a -> M1 i c f b

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

class Applicative m => Monad m where

The Monad class defines the basic operations over a monad, a concept from a branch of mathematics known as category theory. From the perspective of a Haskell programmer, however, it is best to think of a monad as an abstract datatype of actions. Haskell's do expressions provide a convenient syntax for writing monadic expressions.

Instances of Monad should satisfy the following laws:

• return a >>= k  =  k a

• m >>= return  =  m

• m >>= (\x -> k x >>= h)  =  (m >>= k) >>= h

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

• pure = return

• (<*>) = ap

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.

(>>) :: m a -> m b -> m b infixl 1

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

return :: a -> m a

Inject a value into the monadic type.

fail :: String -> m a

Fail with a message. This operation is not part of the mathematical definition of a monad, but is invoked on pattern-match failure in a do expression.

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

Instances

Monad []

Methods

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

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

return :: a -> [a]

fail :: String -> [a]

Monad Maybe

Methods

(>>=) :: Maybe a -> (a -> Maybe b) -> Maybe b

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

return :: a -> Maybe a

fail :: String -> Maybe a

Monad IO

Methods

(>>=) :: IO a -> (a -> IO b) -> IO b

(>>) :: IO a -> IO b -> IO b

return :: a -> IO a

fail :: String -> IO a

Monad U1

Methods

(>>=) :: U1 a -> (a -> U1 b) -> U1 b

(>>) :: U1 a -> U1 b -> U1 b

return :: a -> U1 a

fail :: String -> U1 a

Monad Par1

Methods

(>>=) :: Par1 a -> (a -> Par1 b) -> Par1 b

(>>) :: Par1 a -> Par1 b -> Par1 b

return :: a -> Par1 a

fail :: String -> Par1 a

Monad Min

Methods

(>>=) :: Min a -> (a -> Min b) -> Min b

(>>) :: Min a -> Min b -> Min b

return :: a -> Min a

fail :: String -> Min a

Monad Max

Methods

(>>=) :: Max a -> (a -> Max b) -> Max b

(>>) :: Max a -> Max b -> Max b

return :: a -> Max a

fail :: String -> Max a

Monad First

Methods

(>>=) :: First a -> (a -> First b) -> First b

(>>) :: First a -> First b -> First b

return :: a -> First a

fail :: String -> First a

Monad Last

Methods

(>>=) :: Last a -> (a -> Last b) -> Last b

(>>) :: Last a -> Last b -> Last b

return :: a -> Last a

fail :: String -> Last a

Monad Option

Methods

(>>=) :: Option a -> (a -> Option b) -> Option b

(>>) :: Option a -> Option b -> Option b

return :: a -> Option a

fail :: String -> Option a

Monad NonEmpty

Methods

(>>=) :: NonEmpty a -> (a -> NonEmpty b) -> NonEmpty b

(>>) :: NonEmpty a -> NonEmpty b -> NonEmpty b

return :: a -> NonEmpty a

fail :: String -> NonEmpty a

Monad Dual

Methods

(>>=) :: Dual a -> (a -> Dual b) -> Dual b

(>>) :: Dual a -> Dual b -> Dual b

return :: a -> Dual a

fail :: String -> Dual a

Monad Sum

Methods

(>>=) :: Sum a -> (a -> Sum b) -> Sum b

(>>) :: Sum a -> Sum b -> Sum b

return :: a -> Sum a

fail :: String -> Sum a

Monad Product

Methods

(>>=) :: Product a -> (a -> Product b) -> Product b

(>>) :: Product a -> Product b -> Product b

return :: a -> Product a

fail :: String -> Product a

Monad First

Methods

(>>=) :: First a -> (a -> First b) -> First b

(>>) :: First a -> First b -> First b

return :: a -> First a

fail :: String -> First a

Monad Last

Methods

(>>=) :: Last a -> (a -> Last b) -> Last b

(>>) :: Last a -> Last b -> Last b

return :: a -> Last a

fail :: String -> Last a

Monad OrNot

Methods

(>>=) :: OrNot a -> (a -> OrNot b) -> OrNot b

(>>) :: OrNot a -> OrNot b -> OrNot b

return :: a -> OrNot a

fail :: String -> OrNot a

Monad LiftedButWhy

LiftedButWhy a >>= f = f a

Methods

(>>=) :: LiftedButWhy a -> (a -> LiftedButWhy b) -> LiftedButWhy b

(>>) :: LiftedButWhy a -> LiftedButWhy b -> LiftedButWhy b

return :: a -> LiftedButWhy a

fail :: String -> LiftedButWhy a

Monad ((->) r)

Methods

(>>=) :: (r -> a) -> (a -> r -> b) -> r -> b

(>>) :: (r -> a) -> (r -> b) -> r -> b

return :: a -> r -> a

fail :: String -> r -> a

Monad (Either e)

Methods

(>>=) :: Either e a -> (a -> Either e b) -> Either e b

(>>) :: Either e a -> Either e b -> Either e b

return :: a -> Either e a

fail :: String -> Either e a

Monad f => Monad (Rec1 f)

Methods

(>>=) :: Rec1 f a -> (a -> Rec1 f b) -> Rec1 f b

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

return :: a -> Rec1 f a

fail :: String -> Rec1 f a

Monoid a => Monad ((,) a)

Methods

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

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

return :: a -> (a, a)

fail :: String -> (a, a)

Monad m => Monad (WrappedMonad m)

Methods

(>>=) :: WrappedMonad m a -> (a -> WrappedMonad m b) -> WrappedMonad m b

(>>) :: WrappedMonad m a -> WrappedMonad m b -> WrappedMonad m b

return :: a -> WrappedMonad m a

fail :: String -> WrappedMonad m a

Monad (Proxy *)

Methods

(>>=) :: Proxy * a -> (a -> Proxy * b) -> Proxy * b

(>>) :: Proxy * a -> Proxy * b -> Proxy * b

return :: a -> Proxy * a

fail :: String -> Proxy * a

Monad (DeterminedBy parameter)

Determination fa >>= ff =
    Determination (\x -> let Determination f = ff (fa x) in f x)

Methods

(>>=) :: DeterminedBy parameter a -> (a -> DeterminedBy parameter b) -> DeterminedBy parameter b

(>>) :: DeterminedBy parameter a -> DeterminedBy parameter b -> DeterminedBy parameter b

return :: a -> DeterminedBy parameter a

fail :: String -> DeterminedBy parameter a

Monad (OrInsteadFirst otherThing)

InsteadFirst other >>= _ = InsteadFirst other
NotInsteadFirst a  >>= f = f a

Methods

(>>=) :: OrInsteadFirst otherThing a -> (a -> OrInsteadFirst otherThing b) -> OrInsteadFirst otherThing b

(>>) :: OrInsteadFirst otherThing a -> OrInsteadFirst otherThing b -> OrInsteadFirst otherThing b

return :: a -> OrInsteadFirst otherThing a

fail :: String -> OrInsteadFirst otherThing a

(Monad f, Monad g) => Monad ((:*:) f g)

Methods

(>>=) :: (f :*: g) a -> (a -> (f :*: g) b) -> (f :*: g) b

(>>) :: (f :*: g) a -> (f :*: g) b -> (f :*: g) b

return :: a -> (f :*: g) a

fail :: String -> (f :*: g) a

Monad f => Monad (Alt * f)

Methods

(>>=) :: Alt * f a -> (a -> Alt * f b) -> Alt * f b

(>>) :: Alt * f a -> Alt * f b -> Alt * f b

return :: a -> Alt * f a

fail :: String -> Alt * f a

Monad f => Monad (M1 i c f)

Methods

(>>=) :: M1 i c f a -> (a -> M1 i c f b) -> M1 i c f b

(>>) :: M1 i c f a -> M1 i c f b -> M1 i c f b

return :: a -> M1 i c f a

fail :: String -> M1 i c f a

class Eq a where

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

Minimal complete definition: either == or /=.

Minimal complete definition

(==) | (/=)

Methods

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

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

Instances

Eq Bool

Methods

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

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

Eq Char

Methods

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

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

Eq Double

Methods

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

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

Eq Float

Methods

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

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

Eq Int

Methods

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

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

Eq Integer

Methods

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

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

Eq Ordering

Methods

(==) :: Ordering -> Ordering -> Bool

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

Eq Word

Methods

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

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

Eq ()

Methods

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

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

Eq TyCon

Methods

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

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

Eq BigNat

Methods

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

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

Eq SpecConstrAnnotation

Methods

(==) :: SpecConstrAnnotation -> SpecConstrAnnotation -> Bool

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

Eq Void

Methods

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

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

Eq Version

Methods

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

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

Eq AsyncException

Methods

(==) :: AsyncException -> AsyncException -> Bool

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

Eq ArrayException

Methods

(==) :: ArrayException -> ArrayException -> Bool

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

Eq ExitCode

Methods

(==) :: ExitCode -> ExitCode -> Bool

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

Eq IOErrorType

Methods

(==) :: IOErrorType -> IOErrorType -> Bool

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

Eq All

Methods

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

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

Eq Any

Methods

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

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

Eq Fixity

Methods

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

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

Eq Associativity

Methods

(==) :: Associativity -> Associativity -> Bool

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

Eq SourceUnpackedness

Methods

(==) :: SourceUnpackedness -> SourceUnpackedness -> Bool

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

Eq SourceStrictness

Methods

(==) :: SourceStrictness -> SourceStrictness -> Bool

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

Eq DecidedStrictness

Methods

(==) :: DecidedStrictness -> DecidedStrictness -> Bool

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

Eq MaskingState

Methods

(==) :: MaskingState -> MaskingState -> Bool

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

Eq IOException

Methods

(==) :: IOException -> IOException -> Bool

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

Eq ErrorCall

Methods

(==) :: ErrorCall -> ErrorCall -> Bool

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

Eq ArithException

Methods

(==) :: ArithException -> ArithException -> Bool

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

Eq SomeNat

Methods

(==) :: SomeNat -> SomeNat -> Bool

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

Eq SomeSymbol

Methods

(==) :: SomeSymbol -> SomeSymbol -> Bool

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

Eq SrcLoc

Methods

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

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

Eq a => Eq [a]

Methods

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

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

Eq a => Eq (Maybe a)

Methods

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

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

Eq a => Eq (Ratio a)

Methods

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

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

Eq (Ptr a)

Methods

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

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

Eq (FunPtr a)

Methods

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

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

Eq (V1 p)

Methods

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

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

Eq (U1 p)

Methods

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

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

Eq p => Eq (Par1 p)

Methods

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

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

Eq a => Eq (Min a)

Methods

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

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

Eq a => Eq (Max a)

Methods

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

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

Eq a => Eq (First a)

Methods

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

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

Eq a => Eq (Last a)

Methods

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

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

Eq m => Eq (WrappedMonoid m)

Methods

(==) :: WrappedMonoid m -> WrappedMonoid m -> Bool

(/=) :: WrappedMonoid m -> WrappedMonoid m -> Bool

Eq a => Eq (Option a)

Methods

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

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

Eq a => Eq (NonEmpty a)

Methods

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

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

Eq a => Eq (ZipList a)

Methods

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

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

Eq a => Eq (Dual a)

Methods

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

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

Eq a => Eq (Sum a)

Methods

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

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

Eq a => Eq (Product a)

Methods

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

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

Eq a => Eq (First a)

Methods

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

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

Eq a => Eq (Last a)

Methods

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

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

Eq a => Eq (OneOrMore a)

Methods

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

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

Eq a => Eq (AnyNumberOf a)

Methods

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

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

Eq a => Eq (Two a)

Methods

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

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

Eq a => Eq (OrNot a)

Methods

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

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

Eq a => Eq (LiftedButWhy a)

Methods

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

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

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

Methods

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

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

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

Methods

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

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

Eq (URec Char p)

Methods

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

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

Eq (URec Double p)

Methods

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

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

Eq (URec Float p)

Methods

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

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

Eq (URec Int p)

Methods

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

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

Eq (URec Word p)

Methods

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

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

Eq (URec (Ptr ()) p)

Methods

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

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

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

Methods

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

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

Eq a => Eq (Arg a b)

Methods

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

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

Eq (Proxy k s)

Methods

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

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

(Eq otherThing, Eq a) => Eq (OrInsteadFirst otherThing a)

Methods

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

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

(Eq otherThing, Eq a) => Eq (OrInstead otherThing a)

Methods

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

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

(Eq extraThing, Eq a) => Eq (Also extraThing a)

Methods

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

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

Eq c => Eq (K1 i c p)

Methods

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

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

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

Methods

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

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

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

Methods

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

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

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

Methods

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

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

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

Methods

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

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

Eq a => Eq (Const k a b)

Methods

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

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

Eq (f a) => Eq (Alt k f a)

Methods

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

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

Eq ((:~:) k a b)

Methods

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

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

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

Methods

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

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

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

Methods

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

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

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

Methods

(==) :: (a, b, c, d, e) -> (a, b, c, d, e) -> Bool

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

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

Methods

(==) :: (a, b, c, d, e, f) -> (a, b, c, d, e, f) -> Bool

(/=) :: (a, b, c, d, e, f) -> (a, b, c, d, e, f) -> Bool

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

Methods

(==) :: (a, b, c, d, e, f, g) -> (a, b, c, d, e, f, g) -> Bool

(/=) :: (a, b, c, d, e, f, g) -> (a, b, c, d, e, f, g) -> Bool

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

Methods

(==) :: (a, b, c, d, e, f, g, h) -> (a, b, c, d, e, f, g, h) -> Bool

(/=) :: (a, b, c, d, e, f, g, h) -> (a, b, c, d, e, f, g, h) -> Bool

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

Methods

(==) :: (a, b, c, d, e, f, g, h, i) -> (a, b, c, d, e, f, g, h, i) -> Bool

(/=) :: (a, b, c, d, e, f, g, h, i) -> (a, b, c, d, e, f, g, h, i) -> Bool

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

Methods

(==) :: (a, b, c, d, e, f, g, h, i, j) -> (a, b, c, d, e, f, g, h, i, j) -> Bool

(/=) :: (a, b, c, d, e, f, g, h, i, j) -> (a, b, c, d, e, f, g, h, i, j) -> Bool

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

Methods

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

(/=) :: (a, b, c, d, e, f, g, h, i, j, k) -> (a, b, c, d, e, f, g, h, i, j, k) -> Bool

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

Methods

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

(/=) :: (a, b, c, d, e, f, g, h, i, j, k, l) -> (a, b, c, d, e, f, g, h, i, j, k, l) -> Bool

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

Methods

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

(/=) :: (a, b, c, d, e, f, g, h, i, j, k, l, m) -> (a, b, c, d, e, f, g, h, i, j, k, l, m) -> Bool

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

Methods

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

(/=) :: (a, b, c, d, e, f, g, h, i, j, k, l, m, n) -> (a, b, c, d, e, f, g, h, i, j, k, l, m, n) -> Bool

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

Methods

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

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

class Functor f where

The Functor class is used for types that can be mapped over. Instances of Functor should satisfy the following laws:

fmap id  ==  id
fmap (f . g)  ==  fmap f . fmap g

The instances of Functor for lists, Maybe and IO satisfy these laws.

Minimal complete definition

fmap

Methods

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

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

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

Instances

Functor []

Methods

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

(<$) :: a -> [b] -> [a]

Functor Maybe

Methods

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

(<$) :: a -> Maybe b -> Maybe a

Functor IO

Methods

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

(<$) :: a -> IO b -> IO a

Functor V1

Methods

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

(<$) :: a -> V1 b -> V1 a

Functor U1

Methods

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

(<$) :: a -> U1 b -> U1 a

Functor Par1

Methods

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

(<$) :: a -> Par1 b -> Par1 a

Functor Min

Methods

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

(<$) :: a -> Min b -> Min a

Functor Max

Methods

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

(<$) :: a -> Max b -> Max a

Functor First

Methods

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

(<$) :: a -> First b -> First a

Functor Last

Methods

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

(<$) :: a -> Last b -> Last a

Functor Option

Methods

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

(<$) :: a -> Option b -> Option a

Functor NonEmpty

Methods

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

(<$) :: a -> NonEmpty b -> NonEmpty a

Functor ZipList

Methods

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

(<$) :: a -> ZipList b -> ZipList a

Functor Handler

Methods

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

(<$) :: a -> Handler b -> Handler a

Functor Dual

Methods

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

(<$) :: a -> Dual b -> Dual a

Functor Sum

Methods

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

(<$) :: a -> Sum b -> Sum a

Functor Product

Methods

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

(<$) :: a -> Product b -> Product a

Functor First

Methods

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

(<$) :: a -> First b -> First a

Functor Last

Methods

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

(<$) :: a -> Last b -> Last a

Functor OneOrMore

Methods

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

(<$) :: a -> OneOrMore b -> OneOrMore a

Functor AnyNumberOf

Methods

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

(<$) :: a -> AnyNumberOf b -> AnyNumberOf a

Functor Two

Methods

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

(<$) :: a -> Two b -> Two a

Functor OrNot

Methods

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

(<$) :: a -> OrNot b -> OrNot a

Functor LiftedButWhy

Methods

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

(<$) :: a -> LiftedButWhy b -> LiftedButWhy a

Functor ((->) r)

Methods

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

(<$) :: a -> (r -> b) -> r -> a

Functor (Either a)

Methods

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

(<$) :: a -> Either a b -> Either a a

Functor f => Functor (Rec1 f)

Methods

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

(<$) :: a -> Rec1 f b -> Rec1 f a

Functor (URec Char)

Methods

fmap :: (a -> b) -> URec Char a -> URec Char b

(<$) :: a -> URec Char b -> URec Char a

Functor (URec Double)

Methods

fmap :: (a -> b) -> URec Double a -> URec Double b

(<$) :: a -> URec Double b -> URec Double a

Functor (URec Float)

Methods

fmap :: (a -> b) -> URec Float a -> URec Float b

(<$) :: a -> URec Float b -> URec Float a

Functor (URec Int)

Methods

fmap :: (a -> b) -> URec Int a -> URec Int b

(<$) :: a -> URec Int b -> URec Int a

Functor (URec Word)

Methods

fmap :: (a -> b) -> URec Word a -> URec Word b

(<$) :: a -> URec Word b -> URec Word a

Functor (URec (Ptr ()))

Methods

fmap :: (a -> b) -> URec (Ptr ()) a -> URec (Ptr ()) b

(<$) :: a -> URec (Ptr ()) b -> URec (Ptr ()) a

Functor ((,) a)

Methods

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

(<$) :: a -> (a, b) -> (a, a)

Functor (Arg a)

Methods

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

(<$) :: a -> Arg a b -> Arg a a

Monad m => Functor (WrappedMonad m)

Methods

fmap :: (a -> b) -> WrappedMonad m a -> WrappedMonad m b

(<$) :: a -> WrappedMonad m b -> WrappedMonad m a

Functor (Proxy *)

Methods

fmap :: (a -> b) -> Proxy * a -> Proxy * b

(<$) :: a -> Proxy * b -> Proxy * a

Functor (DeterminedBy parameter)

Methods

fmap :: (a -> b) -> DeterminedBy parameter a -> DeterminedBy parameter b

(<$) :: a -> DeterminedBy parameter b -> DeterminedBy parameter a

Functor (OrInsteadFirst otherThing)

Methods

fmap :: (a -> b) -> OrInsteadFirst otherThing a -> OrInsteadFirst otherThing b

(<$) :: a -> OrInsteadFirst otherThing b -> OrInsteadFirst otherThing a

Functor (OrInstead otherThing)

Methods

fmap :: (a -> b) -> OrInstead otherThing a -> OrInstead otherThing b

(<$) :: a -> OrInstead otherThing b -> OrInstead otherThing a

Functor (Also extraThing)

Methods

fmap :: (a -> b) -> Also extraThing a -> Also extraThing b

(<$) :: a -> Also extraThing b -> Also extraThing a

Functor (K1 i c)

Methods

fmap :: (a -> b) -> K1 i c a -> K1 i c b

(<$) :: a -> K1 i c b -> K1 i c a

(Functor g, Functor f) => Functor ((:+:) f g)

Methods

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

(<$) :: a -> (f :+: g) b -> (f :+: g) a

(Functor g, Functor f) => Functor ((:*:) f g)

Methods

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

(<$) :: a -> (f :*: g) b -> (f :*: g) a

(Functor g, Functor f) => Functor ((:.:) f g)

Methods

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

(<$) :: a -> (f :.: g) b -> (f :.: g) a

Arrow a => Functor (WrappedArrow a b)

Methods

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

(<$) :: a -> WrappedArrow a b b -> WrappedArrow a b a

Functor (Const * m)

Methods

fmap :: (a -> b) -> Const * m a -> Const * m b

(<$) :: a -> Const * m b -> Const * m a

Functor f => Functor (Alt * f)

Methods

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

(<$) :: a -> Alt * f b -> Alt * f a

Functor f => Functor (M1 i c f)

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

class Semigroup a => Monoid a where

Minimal complete definition

mempty

Methods

mempty :: a

Instances

Monoid a => Monoid (OneOrMore a)

mempty = OneOrMore mempty ActuallyNone

Methods

mempty :: OneOrMore a

Monoid a => Monoid (AnyNumberOf a)

mempty = mempty ~~ mempty

Methods

mempty :: AnyNumberOf a

Monoid a => Monoid (Two a)

mempty = Two mempty mempty

Methods

mempty :: Two a

Monoid a => Monoid (OrNot a)

mempty = ActuallyYes mempty

Methods

mempty :: OrNot a

Monoid a => Monoid (LiftedButWhy a)

mempty = LiftedButWhy mempty

Methods

mempty :: LiftedButWhy a

Monoid a => Monoid (DeterminedBy parameter a)

mempty = Determination (\_ -> mempty)

Methods

mempty :: DeterminedBy parameter a

(Semigroup otherThing, Monoid a) => Monoid (OrInsteadFirst otherThing a)

mempty = NotInsteadFirst mempty

Methods

mempty :: OrInsteadFirst otherThing a

(Semigroup otherThing, Monoid a) => Monoid (OrInstead otherThing a)

Methods

mempty :: OrInstead otherThing a

(Monoid extraThing, Monoid a) => Monoid (Also extraThing a)

mempty = Also mempty mempty

Methods

mempty :: Also extraThing a

class Semigroup a where

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

Since: 4.9.0.0

Methods

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

An associative operation.

(a <> b) <> c = a <> (b <> c)

If a is also a Monoid we further require

(<>) = mappend

sconcat :: NonEmpty a -> a

Reduce a non-empty list with <>

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

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 O(1) by picking stimes = stimesIdempotent or stimes = stimesIdempotentMonoid respectively.

Instances

Semigroup Ordering

Methods

(<>) :: Ordering -> Ordering -> Ordering

sconcat :: NonEmpty Ordering -> Ordering

stimes :: Integral b => b -> Ordering -> Ordering

Semigroup ()

Methods

(<>) :: () -> () -> ()

sconcat :: NonEmpty () -> ()

stimes :: Integral b => b -> () -> ()

Semigroup Void

Methods

(<>) :: Void -> Void -> Void

sconcat :: NonEmpty Void -> Void

stimes :: Integral b => b -> Void -> Void

Semigroup All

Methods

(<>) :: All -> All -> All

sconcat :: NonEmpty All -> All

stimes :: Integral b => b -> All -> All

Semigroup Any

Methods

(<>) :: Any -> Any -> Any

sconcat :: NonEmpty Any -> Any

stimes :: Integral b => b -> Any -> Any

Semigroup [a]

Methods

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

sconcat :: NonEmpty [a] -> [a]

stimes :: Integral b => b -> [a] -> [a]

Semigroup a => Semigroup (Maybe a)

Methods

(<>) :: Maybe a -> Maybe a -> Maybe a

sconcat :: NonEmpty (Maybe a) -> Maybe a

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

Ord a => Semigroup (Min a)

Methods

(<>) :: Min a -> Min a -> Min a

sconcat :: NonEmpty (Min a) -> Min a

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

Ord a => Semigroup (Max a)

Methods

(<>) :: Max a -> Max a -> Max a

sconcat :: NonEmpty (Max a) -> Max a

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

Semigroup (First a)

Methods

(<>) :: First a -> First a -> First a

sconcat :: NonEmpty (First a) -> First a

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

Semigroup (Last a)

Methods

(<>) :: Last a -> Last a -> Last a

sconcat :: NonEmpty (Last a) -> Last a

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

Monoid m => Semigroup (WrappedMonoid m)

Methods

(<>) :: WrappedMonoid m -> WrappedMonoid m -> WrappedMonoid m

sconcat :: NonEmpty (WrappedMonoid m) -> WrappedMonoid m

stimes :: Integral b => b -> WrappedMonoid m -> WrappedMonoid m

Semigroup a => Semigroup (Option a)

Methods

(<>) :: Option a -> Option a -> Option a

sconcat :: NonEmpty (Option a) -> Option a

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

Semigroup (NonEmpty a)

Methods

(<>) :: NonEmpty a -> NonEmpty a -> NonEmpty a

sconcat :: NonEmpty (NonEmpty a) -> NonEmpty a

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

Semigroup a => Semigroup (Dual a)

Methods

(<>) :: Dual a -> Dual a -> Dual a

sconcat :: NonEmpty (Dual a) -> Dual a

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

Semigroup (Endo a)

Methods

(<>) :: Endo a -> Endo a -> Endo a

sconcat :: NonEmpty (Endo a) -> Endo a

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

Num a => Semigroup (Sum a)

Methods

(<>) :: Sum a -> Sum a -> Sum a

sconcat :: NonEmpty (Sum a) -> Sum a

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

Num a => Semigroup (Product a)

Methods

(<>) :: Product a -> Product a -> Product a

sconcat :: NonEmpty (Product a) -> Product a

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

Semigroup (First a)

Methods

(<>) :: First a -> First a -> First a

sconcat :: NonEmpty (First a) -> First a

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

Semigroup (Last a)

Methods

(<>) :: Last a -> Last a -> Last a

sconcat :: NonEmpty (Last a) -> Last a

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

Semigroup a => Semigroup (OneOrMore a)

OneOrMore a more <> OneOrMore a' more' =
    OneOrMore a (more <> OneAndMaybeMore a' more')

Methods

(<>) :: OneOrMore a -> OneOrMore a -> OneOrMore a

sconcat :: NonEmpty (OneOrMore a) -> OneOrMore a

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

Semigroup a => Semigroup (AnyNumberOf a)

The operation of combining some number of a with some other number of a is sometimes referred to as zipping.

OneAndMaybeMore x xs <> OneAndMaybeMore y ys =
    OneAndMaybeMore (x <> y) (xs <> ys)
_ <> _ = ActuallyNone

Methods

(<>) :: AnyNumberOf a -> AnyNumberOf a -> AnyNumberOf a

sconcat :: NonEmpty (AnyNumberOf a) -> AnyNumberOf a

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

Semigroup a => Semigroup (Two a)

Two x y <> Two x' y' = Two (x <> x') (y <> y')

Methods

(<>) :: Two a -> Two a -> Two a

sconcat :: NonEmpty (Two a) -> Two a

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

Semigroup a => Semigroup (OrNot a)

If you have value a that may not actually be there, and another value a' that might not actually be there, the lifted semigroup operation (<>) gives you a <> a' only if both of them are actually there.

ActuallyYes a <> ActuallyYes a' = ActuallyYes (a <> a')
_             <> _              = Nope

Methods

(<>) :: OrNot a -> OrNot a -> OrNot a

sconcat :: NonEmpty (OrNot a) -> OrNot a

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

Semigroup a => Semigroup (LiftedButWhy a)

LiftedButWhy x <> LiftedButWhy y = LiftedButWhy (x <> y)

Methods

(<>) :: LiftedButWhy a -> LiftedButWhy a -> LiftedButWhy a

sconcat :: NonEmpty (LiftedButWhy a) -> LiftedButWhy a

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

Semigroup b => Semigroup (a -> b)

Methods

(<>) :: (a -> b) -> (a -> b) -> a -> b

sconcat :: NonEmpty (a -> b) -> a -> b

stimes :: Integral b => b -> (a -> b) -> a -> b

Semigroup (Either a b)

Methods

(<>) :: Either a b -> Either a b -> Either a b

sconcat :: NonEmpty (Either a b) -> Either a b

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

(Semigroup a, Semigroup b) => Semigroup (a, b)

Methods

(<>) :: (a, b) -> (a, b) -> (a, b)

sconcat :: NonEmpty (a, b) -> (a, b)

stimes :: Integral b => b -> (a, b) -> (a, b)

Semigroup (Proxy k s)

Methods

(<>) :: Proxy k s -> Proxy k s -> Proxy k s

sconcat :: NonEmpty (Proxy k s) -> Proxy k s

stimes :: Integral b => b -> Proxy k s -> Proxy k s

Semigroup a => Semigroup (DeterminedBy parameter a)

Determination f <> Determination g = Determination (\x -> f x <> g x)

Methods

(<>) :: DeterminedBy parameter a -> DeterminedBy parameter a -> DeterminedBy parameter a

sconcat :: NonEmpty (DeterminedBy parameter a) -> DeterminedBy parameter a

stimes :: Integral b => b -> DeterminedBy parameter a -> DeterminedBy parameter a

(Semigroup otherThing, Semigroup a) => Semigroup (OrInsteadFirst otherThing a)

NotInsteadFirst a  <> NotInsteadFirst a' = NotInsteadFirst (a <> a')
InsteadFirst other <> _                  = InsteadFirst other
_                  <> InsteadFirst other = InsteadFirst other

Methods

(<>) :: OrInsteadFirst otherThing a -> OrInsteadFirst otherThing a -> OrInsteadFirst otherThing a

sconcat :: NonEmpty (OrInsteadFirst otherThing a) -> OrInsteadFirst otherThing a

stimes :: Integral b => b -> OrInsteadFirst otherThing a -> OrInsteadFirst otherThing a

(Semigroup otherThing, Semigroup a) => Semigroup (OrInstead otherThing a)

NotInstead a   <> NotInstead a'  = NotInstead (a <> a')
Instead other1 <> Instead other2 = Instead (other1 <> other2)
Instead other  <> _              = Instead other
_              <> Instead other  = Instead other

Methods

(<>) :: OrInstead otherThing a -> OrInstead otherThing a -> OrInstead otherThing a

sconcat :: NonEmpty (OrInstead otherThing a) -> OrInstead otherThing a

stimes :: Integral b => b -> OrInstead otherThing a -> OrInstead otherThing a

(Semigroup extraThing, Semigroup a) => Semigroup (Also extraThing a)

(a `Also` extra1) <> (a' `Also` extra2) = (a <> a')
                                          `Also` (extra1 <> extra2)

Methods

(<>) :: Also extraThing a -> Also extraThing a -> Also extraThing a

sconcat :: NonEmpty (Also extraThing a) -> Also extraThing a

stimes :: Integral b => b -> Also extraThing a -> Also extraThing a

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

Methods

(<>) :: (a, b, c) -> (a, b, c) -> (a, b, c)

sconcat :: NonEmpty (a, b, c) -> (a, b, c)

stimes :: Integral b => b -> (a, b, c) -> (a, b, c)

Semigroup a => Semigroup (Const k a b)

Methods

(<>) :: Const k a b -> Const k a b -> Const k a b

sconcat :: NonEmpty (Const k a b) -> Const k a b

stimes :: Integral b => b -> Const k a b -> Const k a b

Alternative f => Semigroup (Alt * f a)

Methods

(<>) :: Alt * f a -> Alt * f a -> Alt * f a

sconcat :: NonEmpty (Alt * f a) -> Alt * f a

stimes :: Integral b => b -> Alt * f a -> Alt * f a

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

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

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

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

class Show a where

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

Methods

showsPrec :: Int -> a -> ShowS

Convert a value to a readable String.

showsPrec should satisfy the law

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

Derived instances of Read and Show satisfy the following:

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

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

show :: a -> String

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

showList :: [a] -> ShowS

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

Instances

Show Bool

Methods

showsPrec :: Int -> Bool -> ShowS

show :: Bool -> String

showList :: [Bool] -> ShowS

Show Char

Methods

showsPrec :: Int -> Char -> ShowS

show :: Char -> String

showList :: [Char] -> ShowS

Show Int

Methods

showsPrec :: Int -> Int -> ShowS

show :: Int -> String

showList :: [Int] -> ShowS

Show Integer

Methods

showsPrec :: Int -> Integer -> ShowS

show :: Integer -> String

showList :: [Integer] -> ShowS

Show Ordering

Methods

showsPrec :: Int -> Ordering -> ShowS

show :: Ordering -> String

showList :: [Ordering] -> ShowS

Show Word

Methods

showsPrec :: Int -> Word -> ShowS

show :: Word -> String

showList :: [Word] -> ShowS

Show CallStack

Methods

showsPrec :: Int -> CallStack -> ShowS

show :: CallStack -> String

showList :: [CallStack] -> ShowS

Show ()

Methods

showsPrec :: Int -> () -> ShowS

show :: () -> String

showList :: [()] -> ShowS

Show TyCon

Methods

showsPrec :: Int -> TyCon -> ShowS

show :: TyCon -> String

showList :: [TyCon] -> ShowS

Show Module

Methods

showsPrec :: Int -> Module -> ShowS

show :: Module -> String

showList :: [Module] -> ShowS

Show TrName

Methods

showsPrec :: Int -> TrName -> ShowS

show :: TrName -> String

showList :: [TrName] -> ShowS

Show Void

Methods

showsPrec :: Int -> Void -> ShowS

show :: Void -> String

showList :: [Void] -> ShowS

Show Version

Methods

showsPrec :: Int -> Version -> ShowS

show :: Version -> String

showList :: [Version] -> ShowS

Show PatternMatchFail

Methods

showsPrec :: Int -> PatternMatchFail -> ShowS

show :: PatternMatchFail -> String

showList :: [PatternMatchFail] -> ShowS

Show RecSelError

Methods

showsPrec :: Int -> RecSelError -> ShowS

show :: RecSelError -> String

showList :: [RecSelError] -> ShowS

Show RecConError

Methods

showsPrec :: Int -> RecConError -> ShowS

show :: RecConError -> String

showList :: [RecConError] -> ShowS

Show RecUpdError

Methods

showsPrec :: Int -> RecUpdError -> ShowS

show :: RecUpdError -> String

showList :: [RecUpdError] -> ShowS

Show NoMethodError

Methods

showsPrec :: Int -> NoMethodError -> ShowS

show :: NoMethodError -> String

showList :: [NoMethodError] -> ShowS

Show TypeError

Methods

showsPrec :: Int -> TypeError -> ShowS

show :: TypeError -> String

showList :: [TypeError] -> ShowS

Show NonTermination

Methods

showsPrec :: Int -> NonTermination -> ShowS

show :: NonTermination -> String

showList :: [NonTermination] -> ShowS

Show NestedAtomically

Methods

showsPrec :: Int -> NestedAtomically -> ShowS

show :: NestedAtomically -> String

showList :: [NestedAtomically] -> ShowS

Show BlockedIndefinitelyOnMVar

Methods

showsPrec :: Int -> BlockedIndefinitelyOnMVar -> ShowS

show :: BlockedIndefinitelyOnMVar -> String

showList :: [BlockedIndefinitelyOnMVar] -> ShowS

Show BlockedIndefinitelyOnSTM

Methods

showsPrec :: Int -> BlockedIndefinitelyOnSTM -> ShowS

show :: BlockedIndefinitelyOnSTM -> String

showList :: [BlockedIndefinitelyOnSTM] -> ShowS

Show Deadlock

Methods

showsPrec :: Int -> Deadlock -> ShowS

show :: Deadlock -> String

showList :: [Deadlock] -> ShowS

Show AllocationLimitExceeded

Methods

showsPrec :: Int -> AllocationLimitExceeded -> ShowS

show :: AllocationLimitExceeded -> String

showList :: [AllocationLimitExceeded] -> ShowS

Show AssertionFailed

Methods

showsPrec :: Int -> AssertionFailed -> ShowS

show :: AssertionFailed -> String

showList :: [AssertionFailed] -> ShowS

Show SomeAsyncException

Methods

showsPrec :: Int -> SomeAsyncException -> ShowS

show :: SomeAsyncException -> String

showList :: [SomeAsyncException] -> ShowS

Show AsyncException

Methods

showsPrec :: Int -> AsyncException -> ShowS

show :: AsyncException -> String

showList :: [AsyncException] -> ShowS

Show ArrayException

Methods

showsPrec :: Int -> ArrayException -> ShowS

show :: ArrayException -> String

showList :: [ArrayException] -> ShowS

Show ExitCode

Methods

showsPrec :: Int -> ExitCode -> ShowS

show :: ExitCode -> String

showList :: [ExitCode] -> ShowS

Show IOErrorType

Methods

showsPrec :: Int -> IOErrorType -> ShowS

show :: IOErrorType -> String

showList :: [IOErrorType] -> ShowS

Show All

Methods

showsPrec :: Int -> All -> ShowS

show :: All -> String

showList :: [All] -> ShowS

Show Any

Methods

showsPrec :: Int -> Any -> ShowS

show :: Any -> String

showList :: [Any] -> ShowS

Show Fixity

Methods

showsPrec :: Int -> Fixity -> ShowS

show :: Fixity -> String

showList :: [Fixity] -> ShowS

Show Associativity

Methods

showsPrec :: Int -> Associativity -> ShowS

show :: Associativity -> String

showList :: [Associativity] -> ShowS

Show SourceUnpackedness

Methods

showsPrec :: Int -> SourceUnpackedness -> ShowS

show :: SourceUnpackedness -> String

showList :: [SourceUnpackedness] -> ShowS

Show SourceStrictness

Methods

showsPrec :: Int -> SourceStrictness -> ShowS

show :: SourceStrictness -> String

showList :: [SourceStrictness] -> ShowS

Show DecidedStrictness

Methods

showsPrec :: Int -> DecidedStrictness -> ShowS

show :: DecidedStrictness -> String

showList :: [DecidedStrictness] -> ShowS

Show MaskingState

Methods

showsPrec :: Int -> MaskingState -> ShowS

show :: MaskingState -> String

showList :: [MaskingState] -> ShowS

Show IOException

Methods

showsPrec :: Int -> IOException -> ShowS

show :: IOException -> String

showList :: [IOException] -> ShowS

Show ErrorCall

Methods

showsPrec :: Int -> ErrorCall -> ShowS

show :: ErrorCall -> String

showList :: [ErrorCall] -> ShowS

Show ArithException

Methods

showsPrec :: Int -> ArithException -> ShowS

show :: ArithException -> String

showList :: [ArithException] -> ShowS

Show SomeNat

Methods

showsPrec :: Int -> SomeNat -> ShowS

show :: SomeNat -> String

showList :: [SomeNat] -> ShowS

Show SomeSymbol

Methods

showsPrec :: Int -> SomeSymbol -> ShowS

show :: SomeSymbol -> String

showList :: [SomeSymbol] -> ShowS

Show SomeException

Methods

showsPrec :: Int -> SomeException -> ShowS

show :: SomeException -> String

showList :: [SomeException] -> ShowS

Show SrcLoc

Methods

showsPrec :: Int -> SrcLoc -> ShowS

show :: SrcLoc -> String

showList :: [SrcLoc] -> ShowS

Show a => Show [a]

Methods

showsPrec :: Int -> [a] -> ShowS

show :: [a] -> String

showList :: [[a]] -> ShowS

Show a => Show (Maybe a)

Methods

showsPrec :: Int -> Maybe a -> ShowS

show :: Maybe a -> String

showList :: [Maybe a] -> ShowS

Show a => Show (Ratio a)

Methods

showsPrec :: Int -> Ratio a -> ShowS

show :: Ratio a -> String

showList :: [Ratio a] -> ShowS

Show (Ptr a)

Methods

showsPrec :: Int -> Ptr a -> ShowS

show :: Ptr a -> String

showList :: [Ptr a] -> ShowS

Show (FunPtr a)

Methods

showsPrec :: Int -> FunPtr a -> ShowS

show :: FunPtr a -> String

showList :: [FunPtr a] -> ShowS

Show (V1 p)

Methods

showsPrec :: Int -> V1 p -> ShowS

show :: V1 p -> String

showList :: [V1 p] -> ShowS

Show (U1 p)

Methods

showsPrec :: Int -> U1 p -> ShowS

show :: U1 p -> String

showList :: [U1 p] -> ShowS

Show p => Show (Par1 p)

Methods

showsPrec :: Int -> Par1 p -> ShowS

show :: Par1 p -> String

showList :: [Par1 p] -> ShowS

Show a => Show (Min a)

Methods

showsPrec :: Int -> Min a -> ShowS

show :: Min a -> String

showList :: [Min a] -> ShowS

Show a => Show (Max a)

Methods

showsPrec :: Int -> Max a -> ShowS

show :: Max a -> String

showList :: [Max a] -> ShowS

Show a => Show (First a)

Methods

showsPrec :: Int -> First a -> ShowS

show :: First a -> String

showList :: [First a] -> ShowS

Show a => Show (Last a)

Methods

showsPrec :: Int -> Last a -> ShowS

show :: Last a -> String

showList :: [Last a] -> ShowS

Show m => Show (WrappedMonoid m)

Methods

showsPrec :: Int -> WrappedMonoid m -> ShowS

show :: WrappedMonoid m -> String

showList :: [WrappedMonoid m] -> ShowS

Show a => Show (Option a)

Methods

showsPrec :: Int -> Option a -> ShowS

show :: Option a -> String

showList :: [Option a] -> ShowS

Show a => Show (NonEmpty a)

Methods

showsPrec :: Int -> NonEmpty a -> ShowS

show :: NonEmpty a -> String

showList :: [NonEmpty a] -> ShowS

Show a => Show (ZipList a)

Methods

showsPrec :: Int -> ZipList a -> ShowS

show :: ZipList a -> String

showList :: [ZipList a] -> ShowS

Show a => Show (Dual a)

Methods

showsPrec :: Int -> Dual a -> ShowS

show :: Dual a -> String

showList :: [Dual a] -> ShowS

Show a => Show (Sum a)

Methods

showsPrec :: Int -> Sum a -> ShowS

show :: Sum a -> String

showList :: [Sum a] -> ShowS

Show a => Show (Product a)

Methods

showsPrec :: Int -> Product a -> ShowS

show :: Product a -> String

showList :: [Product a] -> ShowS

Show a => Show (First a)

Methods

showsPrec :: Int -> First a -> ShowS

show :: First a -> String

showList :: [First a] -> ShowS

Show a => Show (Last a)

Methods

showsPrec :: Int -> Last a -> ShowS

show :: Last a -> String

showList :: [Last a] -> ShowS

Show a => Show (OneOrMore a)

Methods

showsPrec :: Int -> OneOrMore a -> ShowS

show :: OneOrMore a -> String

showList :: [OneOrMore a] -> ShowS

Show a => Show (AnyNumberOf a)

Methods

showsPrec :: Int -> AnyNumberOf a -> ShowS

show :: AnyNumberOf a -> String

showList :: [AnyNumberOf a] -> ShowS

Show a => Show (Two a)

Methods

showsPrec :: Int -> Two a -> ShowS

show :: Two a -> String

showList :: [Two a] -> ShowS

Show a => Show (OrNot a)

Methods

showsPrec :: Int -> OrNot a -> ShowS

show :: OrNot a -> String

showList :: [OrNot a] -> ShowS

Show a => Show (LiftedButWhy a)

Methods

showsPrec :: Int -> LiftedButWhy a -> ShowS

show :: LiftedButWhy a -> String

showList :: [LiftedButWhy a] -> ShowS

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

Methods

showsPrec :: Int -> Either a b -> ShowS

show :: Either a b -> String

showList :: [Either a b] -> ShowS

Show (f p) => Show (Rec1 f p)

Methods

showsPrec :: Int -> Rec1 f p -> ShowS

show :: Rec1 f p -> String

showList :: [Rec1 f p] -> ShowS

Show (URec Char p)

Methods

showsPrec :: Int -> URec Char p -> ShowS

show :: URec Char p -> String

showList :: [URec Char p] -> ShowS

Show (URec Double p)

Methods

showsPrec :: Int -> URec Double p -> ShowS

show :: URec Double p -> String

showList :: [URec Double p] -> ShowS

Show (URec Float p)

Methods

showsPrec :: Int -> URec Float p -> ShowS

show :: URec Float p -> String

showList :: [URec Float p] -> ShowS

Show (URec Int p)

Methods

showsPrec :: Int -> URec Int p -> ShowS

show :: URec Int p -> String

showList :: [URec Int p] -> ShowS

Show (URec Word p)

Methods

showsPrec :: Int -> URec Word p -> ShowS

show :: URec Word p -> String

showList :: [URec Word p] -> ShowS

(Show a, Show b) => Show (a, b)

Methods

showsPrec :: Int -> (a, b) -> ShowS

show :: (a, b) -> String

showList :: [(a, b)] -> ShowS

(Show b, Show a) => Show (Arg a b)

Methods

showsPrec :: Int -> Arg a b -> ShowS

show :: Arg a b -> String

showList :: [Arg a b] -> ShowS

Show (Proxy k s)

Methods

showsPrec :: Int -> Proxy k s -> ShowS

show :: Proxy k s -> String

showList :: [Proxy k s] -> ShowS

(Show otherThing, Show a) => Show (OrInsteadFirst otherThing a)

Methods

showsPrec :: Int -> OrInsteadFirst otherThing a -> ShowS

show :: OrInsteadFirst otherThing a -> String

showList :: [OrInsteadFirst otherThing a] -> ShowS

(Show otherThing, Show a) => Show (OrInstead otherThing a)

Methods

showsPrec :: Int -> OrInstead otherThing a -> ShowS

show :: OrInstead otherThing a -> String

showList :: [OrInstead otherThing a] -> ShowS

(Show extraThing, Show a) => Show (Also extraThing a)

Methods

showsPrec :: Int -> Also extraThing a -> ShowS

show :: Also extraThing a -> String

showList :: [Also extraThing a] -> ShowS

Show c => Show (K1 i c p)

Methods

showsPrec :: Int -> K1 i c p -> ShowS

show :: K1 i c p -> String

showList :: [K1 i c p] -> ShowS

(Show (g p), Show (f p)) => Show ((:+:) f g p)

Methods

showsPrec :: Int -> (f :+: g) p -> ShowS

show :: (f :+: g) p -> String

showList :: [(f :+: g) p] -> ShowS

(Show (g p), Show (f p)) => Show ((:*:) f g p)

Methods

showsPrec :: Int -> (f :*: g) p -> ShowS

show :: (f :*: g) p -> String

showList :: [(f :*: g) p] -> ShowS

Show (f (g p)) => Show ((:.:) f g p)

Methods

showsPrec :: Int -> (f :.: g) p -> ShowS

show :: (f :.: g) p -> String

showList :: [(f :.: g) p] -> ShowS

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

Methods

showsPrec :: Int -> (a, b, c) -> ShowS

show :: (a, b, c) -> String

showList :: [(a, b, c)] -> ShowS

Show a => Show (Const k a b)

This instance would be equivalent to the derived instances of the Const newtype if the runConst field were removed

Methods

showsPrec :: Int -> Const k a b -> ShowS

show :: Const k a b -> String

showList :: [Const k a b] -> ShowS

Show (f a) => Show (Alt k f a)

Methods

showsPrec :: Int -> Alt k f a -> ShowS

show :: Alt k f a -> String

showList :: [Alt k f a] -> ShowS

Show ((:~:) k a b)

Methods

showsPrec :: Int -> (k :~: a) b -> ShowS

show :: (k :~: a) b -> String

showList :: [(k :~: a) b] -> ShowS

Show (f p) => Show (M1 i c f p)

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 (a, b, c, d)

Methods

showsPrec :: Int -> (a, b, c, d) -> ShowS

show :: (a, b, c, d) -> String

showList :: [(a, b, c, d)] -> ShowS

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

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)

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)

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)

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)

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)

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)

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)

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)

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)

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)

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