acme-functors-0.1.0.0: The best applicative functors.

Acme.Functors.Classes

Synopsis

# 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 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  Methodspure :: a -> [a] #(<*>) :: [a -> b] -> [a] -> [b] #(*>) :: [a] -> [b] -> [b] #(<*) :: [a] -> [b] -> [a] # Methodspure :: a -> Maybe a #(<*>) :: Maybe (a -> b) -> Maybe a -> Maybe b #(*>) :: Maybe a -> Maybe b -> Maybe b #(<*) :: Maybe a -> Maybe b -> Maybe a # Methodspure :: a -> IO a #(<*>) :: IO (a -> b) -> IO a -> IO b #(*>) :: IO a -> IO b -> IO b #(<*) :: IO a -> IO b -> IO a # Methodspure :: a -> U1 a #(<*>) :: U1 (a -> b) -> U1 a -> U1 b #(*>) :: U1 a -> U1 b -> U1 b #(<*) :: U1 a -> U1 b -> U1 a # Methodspure :: a -> Par1 a #(<*>) :: Par1 (a -> b) -> Par1 a -> Par1 b #(*>) :: Par1 a -> Par1 b -> Par1 b #(<*) :: Par1 a -> Par1 b -> Par1 a # Methodspure :: a -> Min a #(<*>) :: Min (a -> b) -> Min a -> Min b #(*>) :: Min a -> Min b -> Min b #(<*) :: Min a -> Min b -> Min a # Methodspure :: a -> Max a #(<*>) :: Max (a -> b) -> Max a -> Max b #(*>) :: Max a -> Max b -> Max b #(<*) :: Max a -> Max b -> Max a # Methodspure :: a -> First a #(<*>) :: First (a -> b) -> First a -> First b #(*>) :: First a -> First b -> First b #(<*) :: First a -> First b -> First a # Methodspure :: a -> Last a #(<*>) :: Last (a -> b) -> Last a -> Last b #(*>) :: Last a -> Last b -> Last b #(<*) :: Last a -> Last b -> Last a # Methodspure :: a -> Option a #(<*>) :: Option (a -> b) -> Option a -> Option b #(*>) :: Option a -> Option b -> Option b #(<*) :: Option a -> Option b -> Option a # Methodspure :: a -> NonEmpty a #(<*>) :: NonEmpty (a -> b) -> NonEmpty a -> NonEmpty b #(*>) :: NonEmpty a -> NonEmpty b -> NonEmpty b #(<*) :: NonEmpty a -> NonEmpty b -> NonEmpty a # Methodspure :: a -> ZipList a #(<*>) :: ZipList (a -> b) -> ZipList a -> ZipList b #(*>) :: ZipList a -> ZipList b -> ZipList b #(<*) :: ZipList a -> ZipList b -> ZipList a # Methodspure :: a -> Dual a #(<*>) :: Dual (a -> b) -> Dual a -> Dual b #(*>) :: Dual a -> Dual b -> Dual b #(<*) :: Dual a -> Dual b -> Dual a # Methodspure :: a -> Sum a #(<*>) :: Sum (a -> b) -> Sum a -> Sum b #(*>) :: Sum a -> Sum b -> Sum b #(<*) :: Sum a -> Sum b -> Sum a # Methodspure :: a -> Product a #(<*>) :: Product (a -> b) -> Product a -> Product b #(*>) :: Product a -> Product b -> Product b #(<*) :: Product a -> Product b -> Product a # Methodspure :: a -> First a #(<*>) :: First (a -> b) -> First a -> First b #(*>) :: First a -> First b -> First b #(<*) :: First a -> First b -> First a # Methodspure :: a -> Last a #(<*>) :: Last (a -> b) -> Last a -> Last b #(*>) :: Last a -> Last b -> Last b #(<*) :: Last a -> Last b -> Last a # # pure a = OneOrMore a ActuallyNone OneOrMore f fs <*> OneOrMore x xs = OneOrMore (f x) (fs <*> xs) Methodspure :: a -> OneOrMore a #(<*>) :: OneOrMore (a -> b) -> OneOrMore a -> OneOrMore b #(*>) :: OneOrMore a -> OneOrMore b -> OneOrMore b #(<*) :: OneOrMore a -> OneOrMore b -> OneOrMore a # # 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) _ <*> _ = ActuallyNoneExample: ( (+ 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. Methodspure :: a -> AnyNumberOf a #(<*>) :: AnyNumberOf (a -> b) -> AnyNumberOf a -> AnyNumberOf b #(*>) :: AnyNumberOf a -> AnyNumberOf b -> AnyNumberOf b #(<*) :: AnyNumberOf a -> AnyNumberOf b -> AnyNumberOf a # # 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') Methodspure :: a -> Two a #(<*>) :: Two (a -> b) -> Two a -> Two b #(*>) :: Two a -> Two b -> Two b #(<*) :: Two a -> Two b -> Two a # # 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 Methodspure :: a -> OrNot a #(<*>) :: OrNot (a -> b) -> OrNot a -> OrNot b #(*>) :: OrNot a -> OrNot b -> OrNot b #(<*) :: OrNot a -> OrNot b -> OrNot a # # pure = LiftedButWhy LiftedButWhy f <*> LiftedButWhy a = LiftedButWhy (f a) Methodspure :: a -> LiftedButWhy a #(<*>) :: LiftedButWhy (a -> b) -> LiftedButWhy a -> LiftedButWhy b #(*>) :: LiftedButWhy a -> LiftedButWhy b -> LiftedButWhy b #(<*) :: LiftedButWhy a -> LiftedButWhy b -> LiftedButWhy a # Applicative ((->) a) Methodspure :: a -> a -> a #(<*>) :: (a -> a -> b) -> (a -> a) -> a -> b #(*>) :: (a -> a) -> (a -> b) -> a -> b #(<*) :: (a -> a) -> (a -> b) -> a -> a # Methodspure :: 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) Methodspure :: 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) Methodspure :: 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) Methodspure :: 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)) Methodspure :: 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 Methodspure :: 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 Methodspure :: 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) Methodspure :: 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) Methodspure :: 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) Methodspure :: 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) Methodspure :: 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) Methodspure :: 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) Methodspure :: 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) Methodspure :: 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] # Methods(>>=) :: Maybe a -> (a -> Maybe b) -> Maybe b #(>>) :: Maybe a -> Maybe b -> Maybe b #return :: a -> Maybe a #fail :: String -> Maybe a # Methods(>>=) :: IO a -> (a -> IO b) -> IO b #(>>) :: IO a -> IO b -> IO b #return :: a -> IO a #fail :: String -> IO a # Methods(>>=) :: U1 a -> (a -> U1 b) -> U1 b #(>>) :: U1 a -> U1 b -> U1 b #return :: a -> U1 a #fail :: String -> U1 a # Methods(>>=) :: Par1 a -> (a -> Par1 b) -> Par1 b #(>>) :: Par1 a -> Par1 b -> Par1 b #return :: a -> Par1 a #fail :: String -> Par1 a # Methods(>>=) :: Min a -> (a -> Min b) -> Min b #(>>) :: Min a -> Min b -> Min b #return :: a -> Min a #fail :: String -> Min a # Methods(>>=) :: Max a -> (a -> Max b) -> Max b #(>>) :: Max a -> Max b -> Max b #return :: a -> Max a #fail :: String -> Max a # Methods(>>=) :: First a -> (a -> First b) -> First b #(>>) :: First a -> First b -> First b #return :: a -> First a #fail :: String -> First a # Methods(>>=) :: Last a -> (a -> Last b) -> Last b #(>>) :: Last a -> Last b -> Last b #return :: a -> Last a #fail :: String -> Last a # Methods(>>=) :: Option a -> (a -> Option b) -> Option b #(>>) :: Option a -> Option b -> Option b #return :: a -> Option a #fail :: String -> Option a # Methods(>>=) :: NonEmpty a -> (a -> NonEmpty b) -> NonEmpty b #(>>) :: NonEmpty a -> NonEmpty b -> NonEmpty b #return :: a -> NonEmpty a #fail :: String -> NonEmpty a # Methods(>>=) :: Dual a -> (a -> Dual b) -> Dual b #(>>) :: Dual a -> Dual b -> Dual b #return :: a -> Dual a #fail :: String -> Dual a # Methods(>>=) :: Sum a -> (a -> Sum b) -> Sum b #(>>) :: Sum a -> Sum b -> Sum b #return :: a -> Sum a #fail :: String -> Sum a # Methods(>>=) :: Product a -> (a -> Product b) -> Product b #(>>) :: Product a -> Product b -> Product b #return :: a -> Product a #fail :: String -> Product a # Methods(>>=) :: First a -> (a -> First b) -> First b #(>>) :: First a -> First b -> First b #return :: a -> First a #fail :: String -> First a # Methods(>>=) :: Last a -> (a -> Last b) -> Last b #(>>) :: Last a -> Last b -> Last b #return :: a -> Last a #fail :: String -> Last a # # Methods(>>=) :: OrNot a -> (a -> OrNot b) -> OrNot b #(>>) :: OrNot a -> OrNot b -> OrNot b #return :: a -> OrNot a #fail :: String -> OrNot a # # LiftedButWhy a >>= f = f a Methods(>>=) :: LiftedButWhy a -> (a -> LiftedButWhy b) -> LiftedButWhy b #(>>) :: LiftedButWhy a -> LiftedButWhy b -> LiftedButWhy b #return :: a -> 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 # 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  Methods(==) :: Bool -> Bool -> Bool #(/=) :: Bool -> Bool -> Bool # Methods(==) :: Char -> Char -> Bool #(/=) :: Char -> Char -> Bool # Methods(==) :: Double -> Double -> Bool #(/=) :: Double -> Double -> Bool # Methods(==) :: Float -> Float -> Bool #(/=) :: Float -> Float -> Bool # Methods(==) :: Int -> Int -> Bool #(/=) :: Int -> Int -> Bool # Methods(==) :: Integer -> Integer -> Bool #(/=) :: Integer -> Integer -> Bool # Methods Methods(==) :: Word -> Word -> Bool #(/=) :: Word -> Word -> Bool # Eq () Methods(==) :: () -> () -> Bool #(/=) :: () -> () -> Bool # Methods(==) :: TyCon -> TyCon -> Bool #(/=) :: TyCon -> TyCon -> Bool # Methods(==) :: BigNat -> BigNat -> Bool #(/=) :: BigNat -> BigNat -> Bool # Methods Methods(==) :: Void -> Void -> Bool #(/=) :: Void -> Void -> Bool # Methods(==) :: Version -> Version -> Bool #(/=) :: Version -> Version -> Bool # Methods Methods Methods Methods Methods(==) :: All -> All -> Bool #(/=) :: All -> All -> Bool # Methods(==) :: Any -> Any -> Bool #(/=) :: Any -> Any -> Bool # Methods(==) :: Fixity -> Fixity -> Bool #(/=) :: Fixity -> Fixity -> Bool # Methods Methods Methods Methods Methods Methods Methods Methods Methods(==) :: SomeNat -> SomeNat -> Bool #(/=) :: SomeNat -> SomeNat -> Bool # Methods 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 [] Methodsfmap :: (a -> b) -> [a] -> [b] #(<$) :: a -> [b] -> [a] # Methodsfmap :: (a -> b) -> Maybe a -> Maybe b #(<$) :: a -> Maybe b -> Maybe a # Methodsfmap :: (a -> b) -> IO a -> IO b #(<$) :: a -> IO b -> IO a # Methodsfmap :: (a -> b) -> V1 a -> V1 b #(<$) :: a -> V1 b -> V1 a # Methodsfmap :: (a -> b) -> U1 a -> U1 b #(<$) :: a -> U1 b -> U1 a # Methodsfmap :: (a -> b) -> Par1 a -> Par1 b #(<$) :: a -> Par1 b -> Par1 a # Methodsfmap :: (a -> b) -> Min a -> Min b #(<$) :: a -> Min b -> Min a # Methodsfmap :: (a -> b) -> Max a -> Max b #(<$) :: a -> Max b -> Max a # Methodsfmap :: (a -> b) -> First a -> First b #(<$) :: a -> First b -> First a # Methodsfmap :: (a -> b) -> Last a -> Last b #(<$) :: a -> Last b -> Last a # Methodsfmap :: (a -> b) -> Option a -> Option b #(<$) :: a -> Option b -> Option a # Methodsfmap :: (a -> b) -> NonEmpty a -> NonEmpty b #(<$) :: a -> NonEmpty b -> NonEmpty a # Methodsfmap :: (a -> b) -> ZipList a -> ZipList b #(<$) :: a -> ZipList b -> ZipList a # Methodsfmap :: (a -> b) -> Handler a -> Handler b #(<$) :: a -> Handler b -> Handler a # Methodsfmap :: (a -> b) -> Dual a -> Dual b #(<$) :: a -> Dual b -> Dual a # Methodsfmap :: (a -> b) -> Sum a -> Sum b #(<$) :: a -> Sum b -> Sum a # Methodsfmap :: (a -> b) -> Product a -> Product b #(<$) :: a -> Product b -> Product a # Methodsfmap :: (a -> b) -> First a -> First b #(<$) :: a -> First b -> First a # Methodsfmap :: (a -> b) -> Last a -> Last b #(<$) :: a -> Last b -> Last a # # Methodsfmap :: (a -> b) -> OneOrMore a -> OneOrMore b #(<$) :: a -> OneOrMore b -> OneOrMore a # # Methodsfmap :: (a -> b) -> AnyNumberOf a -> AnyNumberOf b #(<$) :: a -> AnyNumberOf b -> AnyNumberOf a # # Methodsfmap :: (a -> b) -> Two a -> Two b #(<$) :: a -> Two b -> Two a # # Methodsfmap :: (a -> b) -> OrNot a -> OrNot b #(<$) :: a -> OrNot b -> OrNot a # # Methodsfmap :: (a -> b) -> LiftedButWhy a -> LiftedButWhy b #(<$) :: a -> LiftedButWhy b -> LiftedButWhy a # Functor ((->) r) Methodsfmap :: (a -> b) -> (r -> a) -> r -> b #(<$) :: a -> (r -> b) -> r -> a # Methodsfmap :: (a -> b) -> Either a a -> Either a b #(<$) :: a -> Either a b -> Either a a # Functor f => Functor (Rec1 f) Methodsfmap :: (a -> b) -> Rec1 f a -> Rec1 f b #(<$) :: a -> Rec1 f b -> Rec1 f a # Methodsfmap :: (a -> b) -> URec Char a -> URec Char b #(<$) :: a -> URec Char b -> URec Char a # Methodsfmap :: (a -> b) -> URec Double a -> URec Double b #(<$) :: a -> URec Double b -> URec Double a # Methodsfmap :: (a -> b) -> URec Float a -> URec Float b #(<$) :: a -> URec Float b -> URec Float a # Methodsfmap :: (a -> b) -> URec Int a -> URec Int b #(<$) :: a -> URec Int b -> URec Int a # Methodsfmap :: (a -> b) -> URec Word a -> URec Word b #(<$) :: a -> URec Word b -> URec Word a # Functor (URec (Ptr ())) Methodsfmap :: (a -> b) -> URec (Ptr ()) a -> URec (Ptr ()) b #(<$) :: a -> URec (Ptr ()) b -> URec (Ptr ()) a # Functor ((,) a) Methodsfmap :: (a -> b) -> (a, a) -> (a, b) #(<$) :: a -> (a, b) -> (a, a) # Functor (Arg a) Methodsfmap :: (a -> b) -> Arg a a -> Arg a b #(<$) :: a -> Arg a b -> Arg a a # Monad m => Functor (WrappedMonad m) Methodsfmap :: (a -> b) -> WrappedMonad m a -> WrappedMonad m b #(<$) :: a -> WrappedMonad m b -> WrappedMonad m a # Methodsfmap :: (a -> b) -> Proxy * a -> Proxy * b #(<$) :: a -> Proxy * b -> Proxy * a # Functor (DeterminedBy parameter) # Methodsfmap :: (a -> b) -> DeterminedBy parameter a -> DeterminedBy parameter b #(<$) :: a -> DeterminedBy parameter b -> DeterminedBy parameter a # Functor (OrInsteadFirst otherThing) # Methodsfmap :: (a -> b) -> OrInsteadFirst otherThing a -> OrInsteadFirst otherThing b #(<$) :: a -> OrInsteadFirst otherThing b -> OrInsteadFirst otherThing a # Functor (OrInstead otherThing) # Methodsfmap :: (a -> b) -> OrInstead otherThing a -> OrInstead otherThing b #(<$) :: a -> OrInstead otherThing b -> OrInstead otherThing a # Functor (Also extraThing) # Methodsfmap :: (a -> b) -> Also extraThing a -> Also extraThing b #(<$) :: a -> Also extraThing b -> Also extraThing a # Functor (K1 i c) Methodsfmap :: (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) Methodsfmap :: (a -> b) -> (f :+: g) a -> (f :+: g) b #(<$) :: a -> (f :+: g) b -> (f :+: g) a # (Functor g, Functor f) => Functor ((:*:) f g) Methodsfmap :: (a -> b) -> (f :*: g) a -> (f :*: g) b #(<$) :: a -> (f :*: g) b -> (f :*: g) a # (Functor g, Functor f) => Functor ((:.:) f g) Methodsfmap :: (a -> b) -> (f :.: g) a -> (f :.: g) b #(<$) :: a -> (f :.: g) b -> (f :.: g) a # Arrow a => Functor (WrappedArrow a b) Methodsfmap :: (a -> b) -> WrappedArrow a b a -> WrappedArrow a b b #(<$) :: a -> WrappedArrow a b b -> WrappedArrow a b a # Methodsfmap :: (a -> b) -> Const * m a -> Const * m b #(<$) :: a -> Const * m b -> Const * m a # Functor f => Functor (Alt * f) Methodsfmap :: (a -> b) -> Alt * f a -> Alt * f b #(<$) :: a -> Alt * f b -> Alt * f a # Functor f => Functor (M1 i c f) Methodsfmap :: (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 Source # Minimal complete definition mempty Methods mempty :: a Source # Instances  Monoid a => Monoid (OneOrMore a) Source # mempty = OneOrMore mempty ActuallyNone Methods Monoid a => Monoid (AnyNumberOf a) Source # mempty = mempty ~~ mempty Methods Monoid a => Monoid (Two a) Source # mempty = Two mempty mempty Methods Monoid a => Monoid (OrNot a) Source # mempty = ActuallyYes mempty Methods Monoid a => Monoid (LiftedButWhy a) Source # mempty = LiftedButWhy mempty Methods Monoid a => Monoid (DeterminedBy parameter a) Source # mempty = Determination (\_ -> mempty) Methodsmempty :: DeterminedBy parameter a Source # (Semigroup otherThing, Monoid a) => Monoid (OrInsteadFirst otherThing a) Source # mempty = NotInsteadFirst mempty Methodsmempty :: OrInsteadFirst otherThing a Source # (Semigroup otherThing, Monoid a) => Monoid (OrInstead otherThing a) Source # Methodsmempty :: OrInstead otherThing a Source # (Monoid extraThing, Monoid a) => Monoid (Also extraThing a) Source # mempty = Also mempty mempty Methodsmempty :: Also extraThing a Source # 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  Methodsstimes :: Integral b => b -> Ordering -> Ordering # Methods(<>) :: () -> () -> () #sconcat :: NonEmpty () -> () #stimes :: Integral b => b -> () -> () # Methods(<>) :: Void -> Void -> Void #stimes :: Integral b => b -> Void -> Void # Methods(<>) :: All -> All -> All #stimes :: Integral b => b -> All -> All # Methods(<>) :: Any -> 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 # Methods(<>) :: First a -> First a -> First a #sconcat :: NonEmpty (First a) -> First a #stimes :: Integral b => b -> First a -> First 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 #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 # 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 # 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 # Methods(<>) :: First a -> First a -> First a #sconcat :: NonEmpty (First a) -> First a #stimes :: Integral b => b -> First a -> First 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 # # 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 #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 # # LiftedButWhy x <> LiftedButWhy y = LiftedButWhy (x <> y) Methods(<>) :: LiftedButWhy a -> 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

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

 MethodsshowsPrec :: Int -> Bool -> ShowS #show :: Bool -> String #showList :: [Bool] -> ShowS # MethodsshowsPrec :: Int -> Char -> ShowS #show :: Char -> String #showList :: [Char] -> ShowS # MethodsshowsPrec :: Int -> Int -> ShowS #show :: Int -> String #showList :: [Int] -> ShowS # MethodsshowList :: [Integer] -> ShowS # MethodsshowList :: [Ordering] -> ShowS # MethodsshowsPrec :: Int -> Word -> ShowS #show :: Word -> String #showList :: [Word] -> ShowS # MethodsshowList :: [CallStack] -> ShowS # Show () MethodsshowsPrec :: Int -> () -> ShowS #show :: () -> String #showList :: [()] -> ShowS # MethodsshowsPrec :: Int -> TyCon -> ShowS #show :: TyCon -> String #showList :: [TyCon] -> ShowS # MethodsshowsPrec :: Int -> Module -> ShowS #showList :: [Module] -> ShowS # MethodsshowsPrec :: Int -> TrName -> ShowS #showList :: [TrName] -> ShowS # MethodsshowsPrec :: Int -> Void -> ShowS #show :: Void -> String #showList :: [Void] -> ShowS # MethodsshowList :: [Version] -> ShowS # MethodsshowList :: [PatternMatchFail] -> ShowS # MethodsshowList :: [RecSelError] -> ShowS # MethodsshowList :: [RecConError] -> ShowS # MethodsshowList :: [RecUpdError] -> ShowS # MethodsshowList :: [NoMethodError] -> ShowS # MethodsshowList :: [TypeError] -> ShowS # MethodsshowList :: [NonTermination] -> ShowS # MethodsshowList :: [NestedAtomically] -> ShowS # Methods Methods MethodsshowList :: [Deadlock] -> ShowS # Methods MethodsshowList :: [AssertionFailed] -> ShowS # MethodsshowList :: [SomeAsyncException] -> ShowS # MethodsshowList :: [AsyncException] -> ShowS # MethodsshowList :: [ArrayException] -> ShowS # MethodsshowList :: [ExitCode] -> ShowS # MethodsshowList :: [IOErrorType] -> ShowS # MethodsshowsPrec :: Int -> All -> ShowS #show :: All -> String #showList :: [All] -> ShowS # MethodsshowsPrec :: Int -> Any -> ShowS #show :: Any -> String #showList :: [Any] -> ShowS # MethodsshowsPrec :: Int -> Fixity -> ShowS #showList :: [Fixity] -> ShowS # MethodsshowList :: [Associativity] -> ShowS # MethodsshowList :: [SourceUnpackedness] -> ShowS # MethodsshowList :: [SourceStrictness] -> ShowS # MethodsshowList :: [DecidedStrictness] -> ShowS # MethodsshowList :: [MaskingState] -> ShowS # MethodsshowList :: [IOException] -> ShowS # MethodsshowList :: [ErrorCall] -> ShowS # MethodsshowList :: [ArithException] -> ShowS # MethodsshowList :: [SomeNat] -> ShowS # MethodsshowList :: [SomeSymbol] -> ShowS # MethodsshowList :: [SomeException] -> ShowS # MethodsshowsPrec :: Int -> SrcLoc -> ShowS #showList :: [SrcLoc] -> ShowS # Show a => Show [a] MethodsshowsPrec :: Int -> [a] -> ShowS #show :: [a] -> String #showList :: [[a]] -> ShowS # Show a => Show (Maybe a) MethodsshowsPrec :: Int -> Maybe a -> ShowS #show :: Maybe a -> String #showList :: [Maybe a] -> ShowS # Show a => Show (Ratio a) MethodsshowsPrec :: Int -> Ratio a -> ShowS #show :: Ratio a -> String #showList :: [Ratio a] -> ShowS # Show (Ptr a) MethodsshowsPrec :: Int -> Ptr a -> ShowS #show :: Ptr a -> String #showList :: [Ptr a] -> ShowS # Show (FunPtr a) MethodsshowsPrec :: Int -> FunPtr a -> ShowS #show :: FunPtr a -> String #showList :: [FunPtr a] -> ShowS # Show (V1 p) MethodsshowsPrec :: Int -> V1 p -> ShowS #show :: V1 p -> String #showList :: [V1 p] -> ShowS # Show (U1 p) MethodsshowsPrec :: Int -> U1 p -> ShowS #show :: U1 p -> String #showList :: [U1 p] -> ShowS # Show p => Show (Par1 p) MethodsshowsPrec :: Int -> Par1 p -> ShowS #show :: Par1 p -> String #showList :: [Par1 p] -> ShowS # Show a => Show (Min a) MethodsshowsPrec :: Int -> Min a -> ShowS #show :: Min a -> String #showList :: [Min a] -> ShowS # Show a => Show (Max a) MethodsshowsPrec :: Int -> Max a -> ShowS #show :: Max a -> String #showList :: [Max a] -> ShowS # Show a => Show (First a) MethodsshowsPrec :: Int -> First a -> ShowS #show :: First a -> String #showList :: [First a] -> ShowS # Show a => Show (Last a) MethodsshowsPrec :: Int -> Last a -> ShowS #show :: Last a -> String #showList :: [Last a] -> ShowS # Show m => Show (WrappedMonoid m) MethodsshowsPrec :: Int -> WrappedMonoid m -> ShowS #show :: WrappedMonoid m -> String #showList :: [WrappedMonoid m] -> ShowS # Show a => Show (Option a) MethodsshowsPrec :: Int -> Option a -> ShowS #show :: Option a -> String #showList :: [Option a] -> ShowS # Show a => Show (NonEmpty a) MethodsshowsPrec :: Int -> NonEmpty a -> ShowS #show :: NonEmpty a -> String #showList :: [NonEmpty a] -> ShowS # Show a => Show (ZipList a) MethodsshowsPrec :: Int -> ZipList a -> ShowS #show :: ZipList a -> String #showList :: [ZipList a] -> ShowS # Show a => Show (Dual a) MethodsshowsPrec :: Int -> Dual a -> ShowS #show :: Dual a -> String #showList :: [Dual a] -> ShowS # Show a => Show (Sum a) MethodsshowsPrec :: Int -> Sum a -> ShowS #show :: Sum a -> String #showList :: [Sum a] -> ShowS # Show a => Show (Product a) MethodsshowsPrec :: Int -> Product a -> ShowS #show :: Product a -> String #showList :: [Product a] -> ShowS # Show a => Show (First a) MethodsshowsPrec :: Int -> First a -> ShowS #show :: First a -> String #showList :: [First a] -> ShowS # Show a => Show (Last a) MethodsshowsPrec :: Int -> Last a -> ShowS #show :: Last a -> String #showList :: [Last a] -> ShowS # Show a => Show (OneOrMore a) # MethodsshowsPrec :: Int -> OneOrMore a -> ShowS #show :: OneOrMore a -> String #showList :: [OneOrMore a] -> ShowS # Show a => Show (AnyNumberOf a) # MethodsshowsPrec :: Int -> AnyNumberOf a -> ShowS #show :: AnyNumberOf a -> String #showList :: [AnyNumberOf a] -> ShowS # Show a => Show (Two a) # MethodsshowsPrec :: Int -> Two a -> ShowS #show :: Two a -> String #showList :: [Two a] -> ShowS # Show a => Show (OrNot a) # MethodsshowsPrec :: Int -> OrNot a -> ShowS #show :: OrNot a -> String #showList :: [OrNot a] -> ShowS # Show a => Show (LiftedButWhy a) # MethodsshowsPrec :: Int -> LiftedButWhy a -> ShowS #show :: LiftedButWhy a -> String #showList :: [LiftedButWhy a] -> ShowS # (Show b, Show a) => Show (Either a b) MethodsshowsPrec :: Int -> Either a b -> ShowS #show :: Either a b -> String #showList :: [Either a b] -> ShowS # Show (f p) => Show (Rec1 f p) MethodsshowsPrec :: Int -> Rec1 f p -> ShowS #show :: Rec1 f p -> String #showList :: [Rec1 f p] -> ShowS # Show (URec Char p) MethodsshowsPrec :: Int -> URec Char p -> ShowS #show :: URec Char p -> String #showList :: [URec Char p] -> ShowS # MethodsshowsPrec :: Int -> URec Double p -> ShowS #show :: URec Double p -> String #showList :: [URec Double p] -> ShowS # MethodsshowsPrec :: Int -> URec Float p -> ShowS #show :: URec Float p -> String #showList :: [URec Float p] -> ShowS # Show (URec Int p) MethodsshowsPrec :: Int -> URec Int p -> ShowS #show :: URec Int p -> String #showList :: [URec Int p] -> ShowS # Show (URec Word p) MethodsshowsPrec :: Int -> URec Word p -> ShowS #show :: URec Word p -> String #showList :: [URec Word p] -> ShowS # (Show a, Show b) => Show (a, b) MethodsshowsPrec :: Int -> (a, b) -> ShowS #show :: (a, b) -> String #showList :: [(a, b)] -> ShowS # (Show b, Show a) => Show (Arg a b) MethodsshowsPrec :: Int -> Arg a b -> ShowS #show :: Arg a b -> String #showList :: [Arg a b] -> ShowS # Show (Proxy k s) MethodsshowsPrec :: Int -> Proxy k s -> ShowS #show :: Proxy k s -> String #showList :: [Proxy k s] -> ShowS # (Show otherThing, Show a) => Show (OrInsteadFirst otherThing a) # MethodsshowsPrec :: Int -> OrInsteadFirst otherThing a -> ShowS #show :: OrInsteadFirst otherThing a -> String #showList :: [OrInsteadFirst otherThing a] -> ShowS # (Show otherThing, Show a) => Show (OrInstead otherThing a) # MethodsshowsPrec :: Int -> OrInstead otherThing a -> ShowS #show :: OrInstead otherThing a -> String #showList :: [OrInstead otherThing a] -> ShowS # (Show extraThing, Show a) => Show (Also extraThing a) # MethodsshowsPrec :: Int -> Also extraThing a -> ShowS #show :: Also extraThing a -> String #showList :: [Also extraThing a] -> ShowS # Show c => Show (K1 i c p) MethodsshowsPrec :: 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) MethodsshowsPrec :: 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) MethodsshowsPrec :: Int -> (f :*: g) p -> ShowS #show :: (f :*: g) p -> String #showList :: [(f :*: g) p] -> ShowS # Show (f (g p)) => Show ((:.:) f g p) MethodsshowsPrec :: 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) MethodsshowsPrec :: 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 MethodsshowsPrec :: 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) MethodsshowsPrec :: Int -> Alt k f a -> ShowS #show :: Alt k f a -> String #showList :: [Alt k f a] -> ShowS # Show ((:~:) k a b) MethodsshowsPrec :: Int -> (k :~: a) b -> ShowS #show :: (k :~: a) b -> String #showList :: [(k :~: a) b] -> ShowS # Show (f p) => Show (M1 i c f p) MethodsshowsPrec :: 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) MethodsshowsPrec :: 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) MethodsshowsPrec :: 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) MethodsshowsPrec :: 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) MethodsshowsPrec :: 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) MethodsshowsPrec :: 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) MethodsshowsPrec :: 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) MethodsshowsPrec :: 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) MethodsshowsPrec :: 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) MethodsshowsPrec :: 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) MethodsshowsPrec :: 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) MethodsshowsPrec :: 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) MethodsshowsPrec :: 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 #