Safe Haskell	Safe
Language	Haskell98

Data.Tuple.Homogenous

Description

Provides wrappers for homogenous tuples defined as

newtype TupleN a = TupleN (a,...,a)

together with helper methods

tupleN :: a -> ... -> a -> TupleN a

and instances for

Functor applies a given function to all elements of a tuple.
Applicative zips two tuples, applying i-th function of the first to i-th element of the second.
Monad where i-th element of x >>= f is the result of applying f to the i-th element of x and taking its i-th result. In other words, join :: Tupple N (TuppleN a) -> TuppleN a returns the diagonal of the NxN matrix.
Foldable and Traversable folds/traverses over the N elements.

Synopsis

Documentation

newtype Tuple0 a #

Constructors

Tuple0
Fields untuple0 :: ()

Instances

Monad Tuple0 #
Methods (>>=) :: Tuple0 a -> (a -> Tuple0 b) -> Tuple0 b # (>>) :: Tuple0 a -> Tuple0 b -> Tuple0 b # return :: a -> Tuple0 a # fail :: String -> Tuple0 a #
Functor Tuple0 #
Methods fmap :: (a -> b) -> Tuple0 a -> Tuple0 b # (<$) :: a -> Tuple0 b -> Tuple0 a #
Applicative Tuple0 #
Methods pure :: a -> Tuple0 a # (<>) :: Tuple0 (a -> b) -> Tuple0 a -> Tuple0 b # (>) :: Tuple0 a -> Tuple0 b -> Tuple0 b # (<*) :: Tuple0 a -> Tuple0 b -> Tuple0 a #
Foldable Tuple0 #
Methods fold :: Monoid m => Tuple0 m -> m # foldMap :: Monoid m => (a -> m) -> Tuple0 a -> m # foldr :: (a -> b -> b) -> b -> Tuple0 a -> b # foldr' :: (a -> b -> b) -> b -> Tuple0 a -> b # foldl :: (b -> a -> b) -> b -> Tuple0 a -> b # foldl' :: (b -> a -> b) -> b -> Tuple0 a -> b # foldr1 :: (a -> a -> a) -> Tuple0 a -> a # foldl1 :: (a -> a -> a) -> Tuple0 a -> a # toList :: Tuple0 a -> [a] # null :: Tuple0 a -> Bool # length :: Tuple0 a -> Int # elem :: Eq a => a -> Tuple0 a -> Bool # maximum :: Ord a => Tuple0 a -> a # minimum :: Ord a => Tuple0 a -> a # sum :: Num a => Tuple0 a -> a # product :: Num a => Tuple0 a -> a #
Traversable Tuple0 #
Methods traverse :: Applicative f => (a -> f b) -> Tuple0 a -> f (Tuple0 b) # sequenceA :: Applicative f => Tuple0 (f a) -> f (Tuple0 a) # mapM :: Monad m => (a -> m b) -> Tuple0 a -> m (Tuple0 b) # sequence :: Monad m => Tuple0 (m a) -> m (Tuple0 a) #
Bounded (Tuple0 a) #
Methods minBound :: Tuple0 a # maxBound :: Tuple0 a #
Eq (Tuple0 a) #
Methods (==) :: Tuple0 a -> Tuple0 a -> Bool # (/=) :: Tuple0 a -> Tuple0 a -> Bool #
Ord (Tuple0 a) #
Methods compare :: Tuple0 a -> Tuple0 a -> Ordering # (<) :: Tuple0 a -> Tuple0 a -> Bool # (<=) :: Tuple0 a -> Tuple0 a -> Bool # (>) :: Tuple0 a -> Tuple0 a -> Bool # (>=) :: Tuple0 a -> Tuple0 a -> Bool # max :: Tuple0 a -> Tuple0 a -> Tuple0 a # min :: Tuple0 a -> Tuple0 a -> Tuple0 a #
Read (Tuple0 a) #
Methods readsPrec :: Int -> ReadS (Tuple0 a) # readList :: ReadS [Tuple0 a] # readPrec :: ReadPrec (Tuple0 a) # readListPrec :: ReadPrec [Tuple0 a] #
Show (Tuple0 a) #
Methods showsPrec :: Int -> Tuple0 a -> ShowS # show :: Tuple0 a -> String # showList :: [Tuple0 a] -> ShowS #

tuple0 :: Tuple0 a #

newtype Tuple1 a #

This newtype intentionally omits the untuple1 accessor as there is no 1-tuple in Haskell.

Constructors

Tuple1 a

Instances

Monad Tuple1 #
Methods (>>=) :: Tuple1 a -> (a -> Tuple1 b) -> Tuple1 b # (>>) :: Tuple1 a -> Tuple1 b -> Tuple1 b # return :: a -> Tuple1 a # fail :: String -> Tuple1 a #
Functor Tuple1 #
Methods fmap :: (a -> b) -> Tuple1 a -> Tuple1 b # (<$) :: a -> Tuple1 b -> Tuple1 a #
Applicative Tuple1 #
Methods pure :: a -> Tuple1 a # (<>) :: Tuple1 (a -> b) -> Tuple1 a -> Tuple1 b # (>) :: Tuple1 a -> Tuple1 b -> Tuple1 b # (<*) :: Tuple1 a -> Tuple1 b -> Tuple1 a #
Foldable Tuple1 #
Methods fold :: Monoid m => Tuple1 m -> m # foldMap :: Monoid m => (a -> m) -> Tuple1 a -> m # foldr :: (a -> b -> b) -> b -> Tuple1 a -> b # foldr' :: (a -> b -> b) -> b -> Tuple1 a -> b # foldl :: (b -> a -> b) -> b -> Tuple1 a -> b # foldl' :: (b -> a -> b) -> b -> Tuple1 a -> b # foldr1 :: (a -> a -> a) -> Tuple1 a -> a # foldl1 :: (a -> a -> a) -> Tuple1 a -> a # toList :: Tuple1 a -> [a] # null :: Tuple1 a -> Bool # length :: Tuple1 a -> Int # elem :: Eq a => a -> Tuple1 a -> Bool # maximum :: Ord a => Tuple1 a -> a # minimum :: Ord a => Tuple1 a -> a # sum :: Num a => Tuple1 a -> a # product :: Num a => Tuple1 a -> a #
Traversable Tuple1 #
Methods traverse :: Applicative f => (a -> f b) -> Tuple1 a -> f (Tuple1 b) # sequenceA :: Applicative f => Tuple1 (f a) -> f (Tuple1 a) # mapM :: Monad m => (a -> m b) -> Tuple1 a -> m (Tuple1 b) # sequence :: Monad m => Tuple1 (m a) -> m (Tuple1 a) #
Bounded a => Bounded (Tuple1 a) #
Methods minBound :: Tuple1 a # maxBound :: Tuple1 a #
Eq a => Eq (Tuple1 a) #
Methods (==) :: Tuple1 a -> Tuple1 a -> Bool # (/=) :: Tuple1 a -> Tuple1 a -> Bool #
Ord a => Ord (Tuple1 a) #
Methods compare :: Tuple1 a -> Tuple1 a -> Ordering # (<) :: Tuple1 a -> Tuple1 a -> Bool # (<=) :: Tuple1 a -> Tuple1 a -> Bool # (>) :: Tuple1 a -> Tuple1 a -> Bool # (>=) :: Tuple1 a -> Tuple1 a -> Bool # max :: Tuple1 a -> Tuple1 a -> Tuple1 a # min :: Tuple1 a -> Tuple1 a -> Tuple1 a #
Read a => Read (Tuple1 a) #
Methods readsPrec :: Int -> ReadS (Tuple1 a) # readList :: ReadS [Tuple1 a] # readPrec :: ReadPrec (Tuple1 a) # readListPrec :: ReadPrec [Tuple1 a] #
Show a => Show (Tuple1 a) #
Methods showsPrec :: Int -> Tuple1 a -> ShowS # show :: Tuple1 a -> String # showList :: [Tuple1 a] -> ShowS #

tuple1 :: a -> Tuple1 a #

newtype Tuple2 a #

Constructors

Tuple2
Fields untuple2 :: (a, a)

Instances

Monad Tuple2 #
Methods (>>=) :: Tuple2 a -> (a -> Tuple2 b) -> Tuple2 b # (>>) :: Tuple2 a -> Tuple2 b -> Tuple2 b # return :: a -> Tuple2 a # fail :: String -> Tuple2 a #
Functor Tuple2 #
Methods fmap :: (a -> b) -> Tuple2 a -> Tuple2 b # (<$) :: a -> Tuple2 b -> Tuple2 a #
Applicative Tuple2 #
Methods pure :: a -> Tuple2 a # (<>) :: Tuple2 (a -> b) -> Tuple2 a -> Tuple2 b # (>) :: Tuple2 a -> Tuple2 b -> Tuple2 b # (<*) :: Tuple2 a -> Tuple2 b -> Tuple2 a #
Foldable Tuple2 #
Methods fold :: Monoid m => Tuple2 m -> m # foldMap :: Monoid m => (a -> m) -> Tuple2 a -> m # foldr :: (a -> b -> b) -> b -> Tuple2 a -> b # foldr' :: (a -> b -> b) -> b -> Tuple2 a -> b # foldl :: (b -> a -> b) -> b -> Tuple2 a -> b # foldl' :: (b -> a -> b) -> b -> Tuple2 a -> b # foldr1 :: (a -> a -> a) -> Tuple2 a -> a # foldl1 :: (a -> a -> a) -> Tuple2 a -> a # toList :: Tuple2 a -> [a] # null :: Tuple2 a -> Bool # length :: Tuple2 a -> Int # elem :: Eq a => a -> Tuple2 a -> Bool # maximum :: Ord a => Tuple2 a -> a # minimum :: Ord a => Tuple2 a -> a # sum :: Num a => Tuple2 a -> a # product :: Num a => Tuple2 a -> a #
Traversable Tuple2 #
Methods traverse :: Applicative f => (a -> f b) -> Tuple2 a -> f (Tuple2 b) # sequenceA :: Applicative f => Tuple2 (f a) -> f (Tuple2 a) # mapM :: Monad m => (a -> m b) -> Tuple2 a -> m (Tuple2 b) # sequence :: Monad m => Tuple2 (m a) -> m (Tuple2 a) #
Bounded a => Bounded (Tuple2 a) #
Methods minBound :: Tuple2 a # maxBound :: Tuple2 a #
Eq a => Eq (Tuple2 a) #
Methods (==) :: Tuple2 a -> Tuple2 a -> Bool # (/=) :: Tuple2 a -> Tuple2 a -> Bool #
Ord a => Ord (Tuple2 a) #
Methods compare :: Tuple2 a -> Tuple2 a -> Ordering # (<) :: Tuple2 a -> Tuple2 a -> Bool # (<=) :: Tuple2 a -> Tuple2 a -> Bool # (>) :: Tuple2 a -> Tuple2 a -> Bool # (>=) :: Tuple2 a -> Tuple2 a -> Bool # max :: Tuple2 a -> Tuple2 a -> Tuple2 a # min :: Tuple2 a -> Tuple2 a -> Tuple2 a #
Read a => Read (Tuple2 a) #
Methods readsPrec :: Int -> ReadS (Tuple2 a) # readList :: ReadS [Tuple2 a] # readPrec :: ReadPrec (Tuple2 a) # readListPrec :: ReadPrec [Tuple2 a] #
Show a => Show (Tuple2 a) #
Methods showsPrec :: Int -> Tuple2 a -> ShowS # show :: Tuple2 a -> String # showList :: [Tuple2 a] -> ShowS #

tuple2 :: a -> a -> Tuple2 a #

newtype Tuple3 a #

Constructors

Tuple3
Fields untuple3 :: (a, a, a)

Instances

Monad Tuple3 #
Methods (>>=) :: Tuple3 a -> (a -> Tuple3 b) -> Tuple3 b # (>>) :: Tuple3 a -> Tuple3 b -> Tuple3 b # return :: a -> Tuple3 a # fail :: String -> Tuple3 a #
Functor Tuple3 #
Methods fmap :: (a -> b) -> Tuple3 a -> Tuple3 b # (<$) :: a -> Tuple3 b -> Tuple3 a #
Applicative Tuple3 #
Methods pure :: a -> Tuple3 a # (<>) :: Tuple3 (a -> b) -> Tuple3 a -> Tuple3 b # (>) :: Tuple3 a -> Tuple3 b -> Tuple3 b # (<*) :: Tuple3 a -> Tuple3 b -> Tuple3 a #
Foldable Tuple3 #
Methods fold :: Monoid m => Tuple3 m -> m # foldMap :: Monoid m => (a -> m) -> Tuple3 a -> m # foldr :: (a -> b -> b) -> b -> Tuple3 a -> b # foldr' :: (a -> b -> b) -> b -> Tuple3 a -> b # foldl :: (b -> a -> b) -> b -> Tuple3 a -> b # foldl' :: (b -> a -> b) -> b -> Tuple3 a -> b # foldr1 :: (a -> a -> a) -> Tuple3 a -> a # foldl1 :: (a -> a -> a) -> Tuple3 a -> a # toList :: Tuple3 a -> [a] # null :: Tuple3 a -> Bool # length :: Tuple3 a -> Int # elem :: Eq a => a -> Tuple3 a -> Bool # maximum :: Ord a => Tuple3 a -> a # minimum :: Ord a => Tuple3 a -> a # sum :: Num a => Tuple3 a -> a # product :: Num a => Tuple3 a -> a #
Traversable Tuple3 #
Methods traverse :: Applicative f => (a -> f b) -> Tuple3 a -> f (Tuple3 b) # sequenceA :: Applicative f => Tuple3 (f a) -> f (Tuple3 a) # mapM :: Monad m => (a -> m b) -> Tuple3 a -> m (Tuple3 b) # sequence :: Monad m => Tuple3 (m a) -> m (Tuple3 a) #
Bounded a => Bounded (Tuple3 a) #
Methods minBound :: Tuple3 a # maxBound :: Tuple3 a #
Eq a => Eq (Tuple3 a) #
Methods (==) :: Tuple3 a -> Tuple3 a -> Bool # (/=) :: Tuple3 a -> Tuple3 a -> Bool #
Ord a => Ord (Tuple3 a) #
Methods compare :: Tuple3 a -> Tuple3 a -> Ordering # (<) :: Tuple3 a -> Tuple3 a -> Bool # (<=) :: Tuple3 a -> Tuple3 a -> Bool # (>) :: Tuple3 a -> Tuple3 a -> Bool # (>=) :: Tuple3 a -> Tuple3 a -> Bool # max :: Tuple3 a -> Tuple3 a -> Tuple3 a # min :: Tuple3 a -> Tuple3 a -> Tuple3 a #
Read a => Read (Tuple3 a) #
Methods readsPrec :: Int -> ReadS (Tuple3 a) # readList :: ReadS [Tuple3 a] # readPrec :: ReadPrec (Tuple3 a) # readListPrec :: ReadPrec [Tuple3 a] #
Show a => Show (Tuple3 a) #
Methods showsPrec :: Int -> Tuple3 a -> ShowS # show :: Tuple3 a -> String # showList :: [Tuple3 a] -> ShowS #

tuple3 :: a -> a -> a -> Tuple3 a #

newtype Tuple4 a #

Constructors

Tuple4
Fields untuple4 :: (a, a, a, a)

Instances

Monad Tuple4 #
Methods (>>=) :: Tuple4 a -> (a -> Tuple4 b) -> Tuple4 b # (>>) :: Tuple4 a -> Tuple4 b -> Tuple4 b # return :: a -> Tuple4 a # fail :: String -> Tuple4 a #
Functor Tuple4 #
Methods fmap :: (a -> b) -> Tuple4 a -> Tuple4 b # (<$) :: a -> Tuple4 b -> Tuple4 a #
Applicative Tuple4 #
Methods pure :: a -> Tuple4 a # (<>) :: Tuple4 (a -> b) -> Tuple4 a -> Tuple4 b # (>) :: Tuple4 a -> Tuple4 b -> Tuple4 b # (<*) :: Tuple4 a -> Tuple4 b -> Tuple4 a #
Foldable Tuple4 #
Methods fold :: Monoid m => Tuple4 m -> m # foldMap :: Monoid m => (a -> m) -> Tuple4 a -> m # foldr :: (a -> b -> b) -> b -> Tuple4 a -> b # foldr' :: (a -> b -> b) -> b -> Tuple4 a -> b # foldl :: (b -> a -> b) -> b -> Tuple4 a -> b # foldl' :: (b -> a -> b) -> b -> Tuple4 a -> b # foldr1 :: (a -> a -> a) -> Tuple4 a -> a # foldl1 :: (a -> a -> a) -> Tuple4 a -> a # toList :: Tuple4 a -> [a] # null :: Tuple4 a -> Bool # length :: Tuple4 a -> Int # elem :: Eq a => a -> Tuple4 a -> Bool # maximum :: Ord a => Tuple4 a -> a # minimum :: Ord a => Tuple4 a -> a # sum :: Num a => Tuple4 a -> a # product :: Num a => Tuple4 a -> a #
Traversable Tuple4 #
Methods traverse :: Applicative f => (a -> f b) -> Tuple4 a -> f (Tuple4 b) # sequenceA :: Applicative f => Tuple4 (f a) -> f (Tuple4 a) # mapM :: Monad m => (a -> m b) -> Tuple4 a -> m (Tuple4 b) # sequence :: Monad m => Tuple4 (m a) -> m (Tuple4 a) #
Bounded a => Bounded (Tuple4 a) #
Methods minBound :: Tuple4 a # maxBound :: Tuple4 a #
Eq a => Eq (Tuple4 a) #
Methods (==) :: Tuple4 a -> Tuple4 a -> Bool # (/=) :: Tuple4 a -> Tuple4 a -> Bool #
Ord a => Ord (Tuple4 a) #
Methods compare :: Tuple4 a -> Tuple4 a -> Ordering # (<) :: Tuple4 a -> Tuple4 a -> Bool # (<=) :: Tuple4 a -> Tuple4 a -> Bool # (>) :: Tuple4 a -> Tuple4 a -> Bool # (>=) :: Tuple4 a -> Tuple4 a -> Bool # max :: Tuple4 a -> Tuple4 a -> Tuple4 a # min :: Tuple4 a -> Tuple4 a -> Tuple4 a #
Read a => Read (Tuple4 a) #
Methods readsPrec :: Int -> ReadS (Tuple4 a) # readList :: ReadS [Tuple4 a] # readPrec :: ReadPrec (Tuple4 a) # readListPrec :: ReadPrec [Tuple4 a] #
Show a => Show (Tuple4 a) #
Methods showsPrec :: Int -> Tuple4 a -> ShowS # show :: Tuple4 a -> String # showList :: [Tuple4 a] -> ShowS #

tuple4 :: a -> a -> a -> a -> Tuple4 a #

newtype Tuple5 a #

Constructors

Tuple5
Fields untuple5 :: (a, a, a, a, a)

Instances

Monad Tuple5 #
Methods (>>=) :: Tuple5 a -> (a -> Tuple5 b) -> Tuple5 b # (>>) :: Tuple5 a -> Tuple5 b -> Tuple5 b # return :: a -> Tuple5 a # fail :: String -> Tuple5 a #
Functor Tuple5 #
Methods fmap :: (a -> b) -> Tuple5 a -> Tuple5 b # (<$) :: a -> Tuple5 b -> Tuple5 a #
Applicative Tuple5 #
Methods pure :: a -> Tuple5 a # (<>) :: Tuple5 (a -> b) -> Tuple5 a -> Tuple5 b # (>) :: Tuple5 a -> Tuple5 b -> Tuple5 b # (<*) :: Tuple5 a -> Tuple5 b -> Tuple5 a #
Foldable Tuple5 #
Methods fold :: Monoid m => Tuple5 m -> m # foldMap :: Monoid m => (a -> m) -> Tuple5 a -> m # foldr :: (a -> b -> b) -> b -> Tuple5 a -> b # foldr' :: (a -> b -> b) -> b -> Tuple5 a -> b # foldl :: (b -> a -> b) -> b -> Tuple5 a -> b # foldl' :: (b -> a -> b) -> b -> Tuple5 a -> b # foldr1 :: (a -> a -> a) -> Tuple5 a -> a # foldl1 :: (a -> a -> a) -> Tuple5 a -> a # toList :: Tuple5 a -> [a] # null :: Tuple5 a -> Bool # length :: Tuple5 a -> Int # elem :: Eq a => a -> Tuple5 a -> Bool # maximum :: Ord a => Tuple5 a -> a # minimum :: Ord a => Tuple5 a -> a # sum :: Num a => Tuple5 a -> a # product :: Num a => Tuple5 a -> a #
Traversable Tuple5 #
Methods traverse :: Applicative f => (a -> f b) -> Tuple5 a -> f (Tuple5 b) # sequenceA :: Applicative f => Tuple5 (f a) -> f (Tuple5 a) # mapM :: Monad m => (a -> m b) -> Tuple5 a -> m (Tuple5 b) # sequence :: Monad m => Tuple5 (m a) -> m (Tuple5 a) #
Bounded a => Bounded (Tuple5 a) #
Methods minBound :: Tuple5 a # maxBound :: Tuple5 a #
Eq a => Eq (Tuple5 a) #
Methods (==) :: Tuple5 a -> Tuple5 a -> Bool # (/=) :: Tuple5 a -> Tuple5 a -> Bool #
Ord a => Ord (Tuple5 a) #
Methods compare :: Tuple5 a -> Tuple5 a -> Ordering # (<) :: Tuple5 a -> Tuple5 a -> Bool # (<=) :: Tuple5 a -> Tuple5 a -> Bool # (>) :: Tuple5 a -> Tuple5 a -> Bool # (>=) :: Tuple5 a -> Tuple5 a -> Bool # max :: Tuple5 a -> Tuple5 a -> Tuple5 a # min :: Tuple5 a -> Tuple5 a -> Tuple5 a #
Read a => Read (Tuple5 a) #
Methods readsPrec :: Int -> ReadS (Tuple5 a) # readList :: ReadS [Tuple5 a] # readPrec :: ReadPrec (Tuple5 a) # readListPrec :: ReadPrec [Tuple5 a] #
Show a => Show (Tuple5 a) #
Methods showsPrec :: Int -> Tuple5 a -> ShowS # show :: Tuple5 a -> String # showList :: [Tuple5 a] -> ShowS #

tuple5 :: a -> a -> a -> a -> a -> Tuple5 a #

newtype Tuple6 a #

Constructors

Tuple6
Fields untuple6 :: (a, a, a, a, a, a)

Instances

Monad Tuple6 #
Methods (>>=) :: Tuple6 a -> (a -> Tuple6 b) -> Tuple6 b # (>>) :: Tuple6 a -> Tuple6 b -> Tuple6 b # return :: a -> Tuple6 a # fail :: String -> Tuple6 a #
Functor Tuple6 #
Methods fmap :: (a -> b) -> Tuple6 a -> Tuple6 b # (<$) :: a -> Tuple6 b -> Tuple6 a #
Applicative Tuple6 #
Methods pure :: a -> Tuple6 a # (<>) :: Tuple6 (a -> b) -> Tuple6 a -> Tuple6 b # (>) :: Tuple6 a -> Tuple6 b -> Tuple6 b # (<*) :: Tuple6 a -> Tuple6 b -> Tuple6 a #
Foldable Tuple6 #
Methods fold :: Monoid m => Tuple6 m -> m # foldMap :: Monoid m => (a -> m) -> Tuple6 a -> m # foldr :: (a -> b -> b) -> b -> Tuple6 a -> b # foldr' :: (a -> b -> b) -> b -> Tuple6 a -> b # foldl :: (b -> a -> b) -> b -> Tuple6 a -> b # foldl' :: (b -> a -> b) -> b -> Tuple6 a -> b # foldr1 :: (a -> a -> a) -> Tuple6 a -> a # foldl1 :: (a -> a -> a) -> Tuple6 a -> a # toList :: Tuple6 a -> [a] # null :: Tuple6 a -> Bool # length :: Tuple6 a -> Int # elem :: Eq a => a -> Tuple6 a -> Bool # maximum :: Ord a => Tuple6 a -> a # minimum :: Ord a => Tuple6 a -> a # sum :: Num a => Tuple6 a -> a # product :: Num a => Tuple6 a -> a #
Traversable Tuple6 #
Methods traverse :: Applicative f => (a -> f b) -> Tuple6 a -> f (Tuple6 b) # sequenceA :: Applicative f => Tuple6 (f a) -> f (Tuple6 a) # mapM :: Monad m => (a -> m b) -> Tuple6 a -> m (Tuple6 b) # sequence :: Monad m => Tuple6 (m a) -> m (Tuple6 a) #
Bounded a => Bounded (Tuple6 a) #
Methods minBound :: Tuple6 a # maxBound :: Tuple6 a #
Eq a => Eq (Tuple6 a) #
Methods (==) :: Tuple6 a -> Tuple6 a -> Bool # (/=) :: Tuple6 a -> Tuple6 a -> Bool #
Ord a => Ord (Tuple6 a) #
Methods compare :: Tuple6 a -> Tuple6 a -> Ordering # (<) :: Tuple6 a -> Tuple6 a -> Bool # (<=) :: Tuple6 a -> Tuple6 a -> Bool # (>) :: Tuple6 a -> Tuple6 a -> Bool # (>=) :: Tuple6 a -> Tuple6 a -> Bool # max :: Tuple6 a -> Tuple6 a -> Tuple6 a # min :: Tuple6 a -> Tuple6 a -> Tuple6 a #
Read a => Read (Tuple6 a) #
Methods readsPrec :: Int -> ReadS (Tuple6 a) # readList :: ReadS [Tuple6 a] # readPrec :: ReadPrec (Tuple6 a) # readListPrec :: ReadPrec [Tuple6 a] #
Show a => Show (Tuple6 a) #
Methods showsPrec :: Int -> Tuple6 a -> ShowS # show :: Tuple6 a -> String # showList :: [Tuple6 a] -> ShowS #

tuple6 :: a -> a -> a -> a -> a -> a -> Tuple6 a #

newtype Tuple7 a #

Constructors

Tuple7
Fields untuple7 :: (a, a, a, a, a, a, a)

Instances

Monad Tuple7 #
Methods (>>=) :: Tuple7 a -> (a -> Tuple7 b) -> Tuple7 b # (>>) :: Tuple7 a -> Tuple7 b -> Tuple7 b # return :: a -> Tuple7 a # fail :: String -> Tuple7 a #
Functor Tuple7 #
Methods fmap :: (a -> b) -> Tuple7 a -> Tuple7 b # (<$) :: a -> Tuple7 b -> Tuple7 a #
Applicative Tuple7 #
Methods pure :: a -> Tuple7 a # (<>) :: Tuple7 (a -> b) -> Tuple7 a -> Tuple7 b # (>) :: Tuple7 a -> Tuple7 b -> Tuple7 b # (<*) :: Tuple7 a -> Tuple7 b -> Tuple7 a #
Foldable Tuple7 #
Methods fold :: Monoid m => Tuple7 m -> m # foldMap :: Monoid m => (a -> m) -> Tuple7 a -> m # foldr :: (a -> b -> b) -> b -> Tuple7 a -> b # foldr' :: (a -> b -> b) -> b -> Tuple7 a -> b # foldl :: (b -> a -> b) -> b -> Tuple7 a -> b # foldl' :: (b -> a -> b) -> b -> Tuple7 a -> b # foldr1 :: (a -> a -> a) -> Tuple7 a -> a # foldl1 :: (a -> a -> a) -> Tuple7 a -> a # toList :: Tuple7 a -> [a] # null :: Tuple7 a -> Bool # length :: Tuple7 a -> Int # elem :: Eq a => a -> Tuple7 a -> Bool # maximum :: Ord a => Tuple7 a -> a # minimum :: Ord a => Tuple7 a -> a # sum :: Num a => Tuple7 a -> a # product :: Num a => Tuple7 a -> a #
Traversable Tuple7 #
Methods traverse :: Applicative f => (a -> f b) -> Tuple7 a -> f (Tuple7 b) # sequenceA :: Applicative f => Tuple7 (f a) -> f (Tuple7 a) # mapM :: Monad m => (a -> m b) -> Tuple7 a -> m (Tuple7 b) # sequence :: Monad m => Tuple7 (m a) -> m (Tuple7 a) #
Bounded a => Bounded (Tuple7 a) #
Methods minBound :: Tuple7 a # maxBound :: Tuple7 a #
Eq a => Eq (Tuple7 a) #
Methods (==) :: Tuple7 a -> Tuple7 a -> Bool # (/=) :: Tuple7 a -> Tuple7 a -> Bool #
Ord a => Ord (Tuple7 a) #
Methods compare :: Tuple7 a -> Tuple7 a -> Ordering # (<) :: Tuple7 a -> Tuple7 a -> Bool # (<=) :: Tuple7 a -> Tuple7 a -> Bool # (>) :: Tuple7 a -> Tuple7 a -> Bool # (>=) :: Tuple7 a -> Tuple7 a -> Bool # max :: Tuple7 a -> Tuple7 a -> Tuple7 a # min :: Tuple7 a -> Tuple7 a -> Tuple7 a #
Read a => Read (Tuple7 a) #
Methods readsPrec :: Int -> ReadS (Tuple7 a) # readList :: ReadS [Tuple7 a] # readPrec :: ReadPrec (Tuple7 a) # readListPrec :: ReadPrec [Tuple7 a] #
Show a => Show (Tuple7 a) #
Methods showsPrec :: Int -> Tuple7 a -> ShowS # show :: Tuple7 a -> String # showList :: [Tuple7 a] -> ShowS #

tuple7 :: a -> a -> a -> a -> a -> a -> a -> Tuple7 a #

newtype Tuple8 a #

Constructors

Tuple8
Fields untuple8 :: (a, a, a, a, a, a, a, a)

Instances

Monad Tuple8 #
Methods (>>=) :: Tuple8 a -> (a -> Tuple8 b) -> Tuple8 b # (>>) :: Tuple8 a -> Tuple8 b -> Tuple8 b # return :: a -> Tuple8 a # fail :: String -> Tuple8 a #
Functor Tuple8 #
Methods fmap :: (a -> b) -> Tuple8 a -> Tuple8 b # (<$) :: a -> Tuple8 b -> Tuple8 a #
Applicative Tuple8 #
Methods pure :: a -> Tuple8 a # (<>) :: Tuple8 (a -> b) -> Tuple8 a -> Tuple8 b # (>) :: Tuple8 a -> Tuple8 b -> Tuple8 b # (<*) :: Tuple8 a -> Tuple8 b -> Tuple8 a #
Foldable Tuple8 #
Methods fold :: Monoid m => Tuple8 m -> m # foldMap :: Monoid m => (a -> m) -> Tuple8 a -> m # foldr :: (a -> b -> b) -> b -> Tuple8 a -> b # foldr' :: (a -> b -> b) -> b -> Tuple8 a -> b # foldl :: (b -> a -> b) -> b -> Tuple8 a -> b # foldl' :: (b -> a -> b) -> b -> Tuple8 a -> b # foldr1 :: (a -> a -> a) -> Tuple8 a -> a # foldl1 :: (a -> a -> a) -> Tuple8 a -> a # toList :: Tuple8 a -> [a] # null :: Tuple8 a -> Bool # length :: Tuple8 a -> Int # elem :: Eq a => a -> Tuple8 a -> Bool # maximum :: Ord a => Tuple8 a -> a # minimum :: Ord a => Tuple8 a -> a # sum :: Num a => Tuple8 a -> a # product :: Num a => Tuple8 a -> a #
Traversable Tuple8 #
Methods traverse :: Applicative f => (a -> f b) -> Tuple8 a -> f (Tuple8 b) # sequenceA :: Applicative f => Tuple8 (f a) -> f (Tuple8 a) # mapM :: Monad m => (a -> m b) -> Tuple8 a -> m (Tuple8 b) # sequence :: Monad m => Tuple8 (m a) -> m (Tuple8 a) #
Bounded a => Bounded (Tuple8 a) #
Methods minBound :: Tuple8 a # maxBound :: Tuple8 a #
Eq a => Eq (Tuple8 a) #
Methods (==) :: Tuple8 a -> Tuple8 a -> Bool # (/=) :: Tuple8 a -> Tuple8 a -> Bool #
Ord a => Ord (Tuple8 a) #
Methods compare :: Tuple8 a -> Tuple8 a -> Ordering # (<) :: Tuple8 a -> Tuple8 a -> Bool # (<=) :: Tuple8 a -> Tuple8 a -> Bool # (>) :: Tuple8 a -> Tuple8 a -> Bool # (>=) :: Tuple8 a -> Tuple8 a -> Bool # max :: Tuple8 a -> Tuple8 a -> Tuple8 a # min :: Tuple8 a -> Tuple8 a -> Tuple8 a #
Read a => Read (Tuple8 a) #
Methods readsPrec :: Int -> ReadS (Tuple8 a) # readList :: ReadS [Tuple8 a] # readPrec :: ReadPrec (Tuple8 a) # readListPrec :: ReadPrec [Tuple8 a] #
Show a => Show (Tuple8 a) #
Methods showsPrec :: Int -> Tuple8 a -> ShowS # show :: Tuple8 a -> String # showList :: [Tuple8 a] -> ShowS #

tuple8 :: a -> a -> a -> a -> a -> a -> a -> a -> Tuple8 a #

newtype Tuple9 a #

Constructors

Tuple9
Fields untuple9 :: (a, a, a, a, a, a, a, a, a)

Instances

Monad Tuple9 #
Methods (>>=) :: Tuple9 a -> (a -> Tuple9 b) -> Tuple9 b # (>>) :: Tuple9 a -> Tuple9 b -> Tuple9 b # return :: a -> Tuple9 a # fail :: String -> Tuple9 a #
Functor Tuple9 #
Methods fmap :: (a -> b) -> Tuple9 a -> Tuple9 b # (<$) :: a -> Tuple9 b -> Tuple9 a #
Applicative Tuple9 #
Methods pure :: a -> Tuple9 a # (<>) :: Tuple9 (a -> b) -> Tuple9 a -> Tuple9 b # (>) :: Tuple9 a -> Tuple9 b -> Tuple9 b # (<*) :: Tuple9 a -> Tuple9 b -> Tuple9 a #
Foldable Tuple9 #
Methods fold :: Monoid m => Tuple9 m -> m # foldMap :: Monoid m => (a -> m) -> Tuple9 a -> m # foldr :: (a -> b -> b) -> b -> Tuple9 a -> b # foldr' :: (a -> b -> b) -> b -> Tuple9 a -> b # foldl :: (b -> a -> b) -> b -> Tuple9 a -> b # foldl' :: (b -> a -> b) -> b -> Tuple9 a -> b # foldr1 :: (a -> a -> a) -> Tuple9 a -> a # foldl1 :: (a -> a -> a) -> Tuple9 a -> a # toList :: Tuple9 a -> [a] # null :: Tuple9 a -> Bool # length :: Tuple9 a -> Int # elem :: Eq a => a -> Tuple9 a -> Bool # maximum :: Ord a => Tuple9 a -> a # minimum :: Ord a => Tuple9 a -> a # sum :: Num a => Tuple9 a -> a # product :: Num a => Tuple9 a -> a #
Traversable Tuple9 #
Methods traverse :: Applicative f => (a -> f b) -> Tuple9 a -> f (Tuple9 b) # sequenceA :: Applicative f => Tuple9 (f a) -> f (Tuple9 a) # mapM :: Monad m => (a -> m b) -> Tuple9 a -> m (Tuple9 b) # sequence :: Monad m => Tuple9 (m a) -> m (Tuple9 a) #
Bounded a => Bounded (Tuple9 a) #
Methods minBound :: Tuple9 a # maxBound :: Tuple9 a #
Eq a => Eq (Tuple9 a) #
Methods (==) :: Tuple9 a -> Tuple9 a -> Bool # (/=) :: Tuple9 a -> Tuple9 a -> Bool #
Ord a => Ord (Tuple9 a) #
Methods compare :: Tuple9 a -> Tuple9 a -> Ordering # (<) :: Tuple9 a -> Tuple9 a -> Bool # (<=) :: Tuple9 a -> Tuple9 a -> Bool # (>) :: Tuple9 a -> Tuple9 a -> Bool # (>=) :: Tuple9 a -> Tuple9 a -> Bool # max :: Tuple9 a -> Tuple9 a -> Tuple9 a # min :: Tuple9 a -> Tuple9 a -> Tuple9 a #
Read a => Read (Tuple9 a) #
Methods readsPrec :: Int -> ReadS (Tuple9 a) # readList :: ReadS [Tuple9 a] # readPrec :: ReadPrec (Tuple9 a) # readListPrec :: ReadPrec [Tuple9 a] #
Show a => Show (Tuple9 a) #
Methods showsPrec :: Int -> Tuple9 a -> ShowS # show :: Tuple9 a -> String # showList :: [Tuple9 a] -> ShowS #

tuple9 :: a -> a -> a -> a -> a -> a -> a -> a -> a -> Tuple9 a #

newtype Tuple10 a #

Constructors

Tuple10
Fields untuple10 :: (a, a, a, a, a, a, a, a, a, a)

Instances

Monad Tuple10 #
Methods (>>=) :: Tuple10 a -> (a -> Tuple10 b) -> Tuple10 b # (>>) :: Tuple10 a -> Tuple10 b -> Tuple10 b # return :: a -> Tuple10 a # fail :: String -> Tuple10 a #
Functor Tuple10 #
Methods fmap :: (a -> b) -> Tuple10 a -> Tuple10 b # (<$) :: a -> Tuple10 b -> Tuple10 a #
Applicative Tuple10 #
Methods pure :: a -> Tuple10 a # (<>) :: Tuple10 (a -> b) -> Tuple10 a -> Tuple10 b # (>) :: Tuple10 a -> Tuple10 b -> Tuple10 b # (<*) :: Tuple10 a -> Tuple10 b -> Tuple10 a #
Foldable Tuple10 #
Methods fold :: Monoid m => Tuple10 m -> m # foldMap :: Monoid m => (a -> m) -> Tuple10 a -> m # foldr :: (a -> b -> b) -> b -> Tuple10 a -> b # foldr' :: (a -> b -> b) -> b -> Tuple10 a -> b # foldl :: (b -> a -> b) -> b -> Tuple10 a -> b # foldl' :: (b -> a -> b) -> b -> Tuple10 a -> b # foldr1 :: (a -> a -> a) -> Tuple10 a -> a # foldl1 :: (a -> a -> a) -> Tuple10 a -> a # toList :: Tuple10 a -> [a] # null :: Tuple10 a -> Bool # length :: Tuple10 a -> Int # elem :: Eq a => a -> Tuple10 a -> Bool # maximum :: Ord a => Tuple10 a -> a # minimum :: Ord a => Tuple10 a -> a # sum :: Num a => Tuple10 a -> a # product :: Num a => Tuple10 a -> a #
Traversable Tuple10 #
Methods traverse :: Applicative f => (a -> f b) -> Tuple10 a -> f (Tuple10 b) # sequenceA :: Applicative f => Tuple10 (f a) -> f (Tuple10 a) # mapM :: Monad m => (a -> m b) -> Tuple10 a -> m (Tuple10 b) # sequence :: Monad m => Tuple10 (m a) -> m (Tuple10 a) #
Bounded a => Bounded (Tuple10 a) #
Methods minBound :: Tuple10 a # maxBound :: Tuple10 a #
Eq a => Eq (Tuple10 a) #
Methods (==) :: Tuple10 a -> Tuple10 a -> Bool # (/=) :: Tuple10 a -> Tuple10 a -> Bool #
Ord a => Ord (Tuple10 a) #
Methods compare :: Tuple10 a -> Tuple10 a -> Ordering # (<) :: Tuple10 a -> Tuple10 a -> Bool # (<=) :: Tuple10 a -> Tuple10 a -> Bool # (>) :: Tuple10 a -> Tuple10 a -> Bool # (>=) :: Tuple10 a -> Tuple10 a -> Bool # max :: Tuple10 a -> Tuple10 a -> Tuple10 a # min :: Tuple10 a -> Tuple10 a -> Tuple10 a #
Read a => Read (Tuple10 a) #
Methods readsPrec :: Int -> ReadS (Tuple10 a) # readList :: ReadS [Tuple10 a] # readPrec :: ReadPrec (Tuple10 a) # readListPrec :: ReadPrec [Tuple10 a] #
Show a => Show (Tuple10 a) #
Methods showsPrec :: Int -> Tuple10 a -> ShowS # show :: Tuple10 a -> String # showList :: [Tuple10 a] -> ShowS #

tuple10 :: a -> a -> a -> a -> a -> a -> a -> a -> a -> a -> Tuple10 a #

newtype Tuple11 a #

Constructors

Tuple11
Fields untuple11 :: (a, a, a, a, a, a, a, a, a, a, a)

Instances

Monad Tuple11 #
Methods (>>=) :: Tuple11 a -> (a -> Tuple11 b) -> Tuple11 b # (>>) :: Tuple11 a -> Tuple11 b -> Tuple11 b # return :: a -> Tuple11 a # fail :: String -> Tuple11 a #
Functor Tuple11 #
Methods fmap :: (a -> b) -> Tuple11 a -> Tuple11 b # (<$) :: a -> Tuple11 b -> Tuple11 a #
Applicative Tuple11 #
Methods pure :: a -> Tuple11 a # (<>) :: Tuple11 (a -> b) -> Tuple11 a -> Tuple11 b # (>) :: Tuple11 a -> Tuple11 b -> Tuple11 b # (<*) :: Tuple11 a -> Tuple11 b -> Tuple11 a #
Foldable Tuple11 #
Methods fold :: Monoid m => Tuple11 m -> m # foldMap :: Monoid m => (a -> m) -> Tuple11 a -> m # foldr :: (a -> b -> b) -> b -> Tuple11 a -> b # foldr' :: (a -> b -> b) -> b -> Tuple11 a -> b # foldl :: (b -> a -> b) -> b -> Tuple11 a -> b # foldl' :: (b -> a -> b) -> b -> Tuple11 a -> b # foldr1 :: (a -> a -> a) -> Tuple11 a -> a # foldl1 :: (a -> a -> a) -> Tuple11 a -> a # toList :: Tuple11 a -> [a] # null :: Tuple11 a -> Bool # length :: Tuple11 a -> Int # elem :: Eq a => a -> Tuple11 a -> Bool # maximum :: Ord a => Tuple11 a -> a # minimum :: Ord a => Tuple11 a -> a # sum :: Num a => Tuple11 a -> a # product :: Num a => Tuple11 a -> a #
Traversable Tuple11 #
Methods traverse :: Applicative f => (a -> f b) -> Tuple11 a -> f (Tuple11 b) # sequenceA :: Applicative f => Tuple11 (f a) -> f (Tuple11 a) # mapM :: Monad m => (a -> m b) -> Tuple11 a -> m (Tuple11 b) # sequence :: Monad m => Tuple11 (m a) -> m (Tuple11 a) #
Bounded a => Bounded (Tuple11 a) #
Methods minBound :: Tuple11 a # maxBound :: Tuple11 a #
Eq a => Eq (Tuple11 a) #
Methods (==) :: Tuple11 a -> Tuple11 a -> Bool # (/=) :: Tuple11 a -> Tuple11 a -> Bool #
Ord a => Ord (Tuple11 a) #
Methods compare :: Tuple11 a -> Tuple11 a -> Ordering # (<) :: Tuple11 a -> Tuple11 a -> Bool # (<=) :: Tuple11 a -> Tuple11 a -> Bool # (>) :: Tuple11 a -> Tuple11 a -> Bool # (>=) :: Tuple11 a -> Tuple11 a -> Bool # max :: Tuple11 a -> Tuple11 a -> Tuple11 a # min :: Tuple11 a -> Tuple11 a -> Tuple11 a #
Read a => Read (Tuple11 a) #
Methods readsPrec :: Int -> ReadS (Tuple11 a) # readList :: ReadS [Tuple11 a] # readPrec :: ReadPrec (Tuple11 a) # readListPrec :: ReadPrec [Tuple11 a] #
Show a => Show (Tuple11 a) #
Methods showsPrec :: Int -> Tuple11 a -> ShowS # show :: Tuple11 a -> String # showList :: [Tuple11 a] -> ShowS #

tuple11 :: a -> a -> a -> a -> a -> a -> a -> a -> a -> a -> a -> Tuple11 a #

newtype Tuple12 a #

Constructors

Tuple12
Fields untuple12 :: (a, a, a, a, a, a, a, a, a, a, a, a)

Instances

Monad Tuple12 #
Methods (>>=) :: Tuple12 a -> (a -> Tuple12 b) -> Tuple12 b # (>>) :: Tuple12 a -> Tuple12 b -> Tuple12 b # return :: a -> Tuple12 a # fail :: String -> Tuple12 a #
Functor Tuple12 #
Methods fmap :: (a -> b) -> Tuple12 a -> Tuple12 b # (<$) :: a -> Tuple12 b -> Tuple12 a #
Applicative Tuple12 #
Methods pure :: a -> Tuple12 a # (<>) :: Tuple12 (a -> b) -> Tuple12 a -> Tuple12 b # (>) :: Tuple12 a -> Tuple12 b -> Tuple12 b # (<*) :: Tuple12 a -> Tuple12 b -> Tuple12 a #
Foldable Tuple12 #
Methods fold :: Monoid m => Tuple12 m -> m # foldMap :: Monoid m => (a -> m) -> Tuple12 a -> m # foldr :: (a -> b -> b) -> b -> Tuple12 a -> b # foldr' :: (a -> b -> b) -> b -> Tuple12 a -> b # foldl :: (b -> a -> b) -> b -> Tuple12 a -> b # foldl' :: (b -> a -> b) -> b -> Tuple12 a -> b # foldr1 :: (a -> a -> a) -> Tuple12 a -> a # foldl1 :: (a -> a -> a) -> Tuple12 a -> a # toList :: Tuple12 a -> [a] # null :: Tuple12 a -> Bool # length :: Tuple12 a -> Int # elem :: Eq a => a -> Tuple12 a -> Bool # maximum :: Ord a => Tuple12 a -> a # minimum :: Ord a => Tuple12 a -> a # sum :: Num a => Tuple12 a -> a # product :: Num a => Tuple12 a -> a #
Traversable Tuple12 #
Methods traverse :: Applicative f => (a -> f b) -> Tuple12 a -> f (Tuple12 b) # sequenceA :: Applicative f => Tuple12 (f a) -> f (Tuple12 a) # mapM :: Monad m => (a -> m b) -> Tuple12 a -> m (Tuple12 b) # sequence :: Monad m => Tuple12 (m a) -> m (Tuple12 a) #
Bounded a => Bounded (Tuple12 a) #
Methods minBound :: Tuple12 a # maxBound :: Tuple12 a #
Eq a => Eq (Tuple12 a) #
Methods (==) :: Tuple12 a -> Tuple12 a -> Bool # (/=) :: Tuple12 a -> Tuple12 a -> Bool #
Ord a => Ord (Tuple12 a) #
Methods compare :: Tuple12 a -> Tuple12 a -> Ordering # (<) :: Tuple12 a -> Tuple12 a -> Bool # (<=) :: Tuple12 a -> Tuple12 a -> Bool # (>) :: Tuple12 a -> Tuple12 a -> Bool # (>=) :: Tuple12 a -> Tuple12 a -> Bool # max :: Tuple12 a -> Tuple12 a -> Tuple12 a # min :: Tuple12 a -> Tuple12 a -> Tuple12 a #
Read a => Read (Tuple12 a) #
Methods readsPrec :: Int -> ReadS (Tuple12 a) # readList :: ReadS [Tuple12 a] # readPrec :: ReadPrec (Tuple12 a) # readListPrec :: ReadPrec [Tuple12 a] #
Show a => Show (Tuple12 a) #
Methods showsPrec :: Int -> Tuple12 a -> ShowS # show :: Tuple12 a -> String # showList :: [Tuple12 a] -> ShowS #

tuple12 :: a -> a -> a -> a -> a -> a -> a -> a -> a -> a -> a -> a -> Tuple12 a #

newtype Tuple13 a #

Constructors

Tuple13
Fields untuple13 :: (a, a, a, a, a, a, a, a, a, a, a, a, a)

Instances

Monad Tuple13 #
Methods (>>=) :: Tuple13 a -> (a -> Tuple13 b) -> Tuple13 b # (>>) :: Tuple13 a -> Tuple13 b -> Tuple13 b # return :: a -> Tuple13 a # fail :: String -> Tuple13 a #
Functor Tuple13 #
Methods fmap :: (a -> b) -> Tuple13 a -> Tuple13 b # (<$) :: a -> Tuple13 b -> Tuple13 a #
Applicative Tuple13 #
Methods pure :: a -> Tuple13 a # (<>) :: Tuple13 (a -> b) -> Tuple13 a -> Tuple13 b # (>) :: Tuple13 a -> Tuple13 b -> Tuple13 b # (<*) :: Tuple13 a -> Tuple13 b -> Tuple13 a #
Foldable Tuple13 #
Methods fold :: Monoid m => Tuple13 m -> m # foldMap :: Monoid m => (a -> m) -> Tuple13 a -> m # foldr :: (a -> b -> b) -> b -> Tuple13 a -> b # foldr' :: (a -> b -> b) -> b -> Tuple13 a -> b # foldl :: (b -> a -> b) -> b -> Tuple13 a -> b # foldl' :: (b -> a -> b) -> b -> Tuple13 a -> b # foldr1 :: (a -> a -> a) -> Tuple13 a -> a # foldl1 :: (a -> a -> a) -> Tuple13 a -> a # toList :: Tuple13 a -> [a] # null :: Tuple13 a -> Bool # length :: Tuple13 a -> Int # elem :: Eq a => a -> Tuple13 a -> Bool # maximum :: Ord a => Tuple13 a -> a # minimum :: Ord a => Tuple13 a -> a # sum :: Num a => Tuple13 a -> a # product :: Num a => Tuple13 a -> a #
Traversable Tuple13 #
Methods traverse :: Applicative f => (a -> f b) -> Tuple13 a -> f (Tuple13 b) # sequenceA :: Applicative f => Tuple13 (f a) -> f (Tuple13 a) # mapM :: Monad m => (a -> m b) -> Tuple13 a -> m (Tuple13 b) # sequence :: Monad m => Tuple13 (m a) -> m (Tuple13 a) #
Bounded a => Bounded (Tuple13 a) #
Methods minBound :: Tuple13 a # maxBound :: Tuple13 a #
Eq a => Eq (Tuple13 a) #
Methods (==) :: Tuple13 a -> Tuple13 a -> Bool # (/=) :: Tuple13 a -> Tuple13 a -> Bool #
Ord a => Ord (Tuple13 a) #
Methods compare :: Tuple13 a -> Tuple13 a -> Ordering # (<) :: Tuple13 a -> Tuple13 a -> Bool # (<=) :: Tuple13 a -> Tuple13 a -> Bool # (>) :: Tuple13 a -> Tuple13 a -> Bool # (>=) :: Tuple13 a -> Tuple13 a -> Bool # max :: Tuple13 a -> Tuple13 a -> Tuple13 a # min :: Tuple13 a -> Tuple13 a -> Tuple13 a #
Read a => Read (Tuple13 a) #
Methods readsPrec :: Int -> ReadS (Tuple13 a) # readList :: ReadS [Tuple13 a] # readPrec :: ReadPrec (Tuple13 a) # readListPrec :: ReadPrec [Tuple13 a] #
Show a => Show (Tuple13 a) #
Methods showsPrec :: Int -> Tuple13 a -> ShowS # show :: Tuple13 a -> String # showList :: [Tuple13 a] -> ShowS #

tuple13 :: a -> a -> a -> a -> a -> a -> a -> a -> a -> a -> a -> a -> a -> Tuple13 a #

newtype Tuple14 a #

Constructors

Tuple14
Fields untuple14 :: (a, a, a, a, a, a, a, a, a, a, a, a, a, a)

Instances

Monad Tuple14 #
Methods (>>=) :: Tuple14 a -> (a -> Tuple14 b) -> Tuple14 b # (>>) :: Tuple14 a -> Tuple14 b -> Tuple14 b # return :: a -> Tuple14 a # fail :: String -> Tuple14 a #
Functor Tuple14 #
Methods fmap :: (a -> b) -> Tuple14 a -> Tuple14 b # (<$) :: a -> Tuple14 b -> Tuple14 a #
Applicative Tuple14 #
Methods pure :: a -> Tuple14 a # (<>) :: Tuple14 (a -> b) -> Tuple14 a -> Tuple14 b # (>) :: Tuple14 a -> Tuple14 b -> Tuple14 b # (<*) :: Tuple14 a -> Tuple14 b -> Tuple14 a #
Foldable Tuple14 #
Methods fold :: Monoid m => Tuple14 m -> m # foldMap :: Monoid m => (a -> m) -> Tuple14 a -> m # foldr :: (a -> b -> b) -> b -> Tuple14 a -> b # foldr' :: (a -> b -> b) -> b -> Tuple14 a -> b # foldl :: (b -> a -> b) -> b -> Tuple14 a -> b # foldl' :: (b -> a -> b) -> b -> Tuple14 a -> b # foldr1 :: (a -> a -> a) -> Tuple14 a -> a # foldl1 :: (a -> a -> a) -> Tuple14 a -> a # toList :: Tuple14 a -> [a] # null :: Tuple14 a -> Bool # length :: Tuple14 a -> Int # elem :: Eq a => a -> Tuple14 a -> Bool # maximum :: Ord a => Tuple14 a -> a # minimum :: Ord a => Tuple14 a -> a # sum :: Num a => Tuple14 a -> a # product :: Num a => Tuple14 a -> a #
Traversable Tuple14 #
Methods traverse :: Applicative f => (a -> f b) -> Tuple14 a -> f (Tuple14 b) # sequenceA :: Applicative f => Tuple14 (f a) -> f (Tuple14 a) # mapM :: Monad m => (a -> m b) -> Tuple14 a -> m (Tuple14 b) # sequence :: Monad m => Tuple14 (m a) -> m (Tuple14 a) #
Bounded a => Bounded (Tuple14 a) #
Methods minBound :: Tuple14 a # maxBound :: Tuple14 a #
Eq a => Eq (Tuple14 a) #
Methods (==) :: Tuple14 a -> Tuple14 a -> Bool # (/=) :: Tuple14 a -> Tuple14 a -> Bool #
Ord a => Ord (Tuple14 a) #
Methods compare :: Tuple14 a -> Tuple14 a -> Ordering # (<) :: Tuple14 a -> Tuple14 a -> Bool # (<=) :: Tuple14 a -> Tuple14 a -> Bool # (>) :: Tuple14 a -> Tuple14 a -> Bool # (>=) :: Tuple14 a -> Tuple14 a -> Bool # max :: Tuple14 a -> Tuple14 a -> Tuple14 a # min :: Tuple14 a -> Tuple14 a -> Tuple14 a #
Read a => Read (Tuple14 a) #
Methods readsPrec :: Int -> ReadS (Tuple14 a) # readList :: ReadS [Tuple14 a] # readPrec :: ReadPrec (Tuple14 a) # readListPrec :: ReadPrec [Tuple14 a] #
Show a => Show (Tuple14 a) #
Methods showsPrec :: Int -> Tuple14 a -> ShowS # show :: Tuple14 a -> String # showList :: [Tuple14 a] -> ShowS #

tuple14 :: a -> a -> a -> a -> a -> a -> a -> a -> a -> a -> a -> a -> a -> a -> Tuple14 a #

newtype Tuple15 a #

Constructors

Tuple15
Fields untuple15 :: (a, a, a, a, a, a, a, a, a, a, a, a, a, a, a)

Instances

Monad Tuple15 #
Methods (>>=) :: Tuple15 a -> (a -> Tuple15 b) -> Tuple15 b # (>>) :: Tuple15 a -> Tuple15 b -> Tuple15 b # return :: a -> Tuple15 a # fail :: String -> Tuple15 a #
Functor Tuple15 #
Methods fmap :: (a -> b) -> Tuple15 a -> Tuple15 b # (<$) :: a -> Tuple15 b -> Tuple15 a #
Applicative Tuple15 #
Methods pure :: a -> Tuple15 a # (<>) :: Tuple15 (a -> b) -> Tuple15 a -> Tuple15 b # (>) :: Tuple15 a -> Tuple15 b -> Tuple15 b # (<*) :: Tuple15 a -> Tuple15 b -> Tuple15 a #
Foldable Tuple15 #
Methods fold :: Monoid m => Tuple15 m -> m # foldMap :: Monoid m => (a -> m) -> Tuple15 a -> m # foldr :: (a -> b -> b) -> b -> Tuple15 a -> b # foldr' :: (a -> b -> b) -> b -> Tuple15 a -> b # foldl :: (b -> a -> b) -> b -> Tuple15 a -> b # foldl' :: (b -> a -> b) -> b -> Tuple15 a -> b # foldr1 :: (a -> a -> a) -> Tuple15 a -> a # foldl1 :: (a -> a -> a) -> Tuple15 a -> a # toList :: Tuple15 a -> [a] # null :: Tuple15 a -> Bool # length :: Tuple15 a -> Int # elem :: Eq a => a -> Tuple15 a -> Bool # maximum :: Ord a => Tuple15 a -> a # minimum :: Ord a => Tuple15 a -> a # sum :: Num a => Tuple15 a -> a # product :: Num a => Tuple15 a -> a #
Traversable Tuple15 #
Methods traverse :: Applicative f => (a -> f b) -> Tuple15 a -> f (Tuple15 b) # sequenceA :: Applicative f => Tuple15 (f a) -> f (Tuple15 a) # mapM :: Monad m => (a -> m b) -> Tuple15 a -> m (Tuple15 b) # sequence :: Monad m => Tuple15 (m a) -> m (Tuple15 a) #
Bounded a => Bounded (Tuple15 a) #
Methods minBound :: Tuple15 a # maxBound :: Tuple15 a #
Eq a => Eq (Tuple15 a) #
Methods (==) :: Tuple15 a -> Tuple15 a -> Bool # (/=) :: Tuple15 a -> Tuple15 a -> Bool #
Ord a => Ord (Tuple15 a) #
Methods compare :: Tuple15 a -> Tuple15 a -> Ordering # (<) :: Tuple15 a -> Tuple15 a -> Bool # (<=) :: Tuple15 a -> Tuple15 a -> Bool # (>) :: Tuple15 a -> Tuple15 a -> Bool # (>=) :: Tuple15 a -> Tuple15 a -> Bool # max :: Tuple15 a -> Tuple15 a -> Tuple15 a # min :: Tuple15 a -> Tuple15 a -> Tuple15 a #
Read a => Read (Tuple15 a) #
Methods readsPrec :: Int -> ReadS (Tuple15 a) # readList :: ReadS [Tuple15 a] # readPrec :: ReadPrec (Tuple15 a) # readListPrec :: ReadPrec [Tuple15 a] #
Show a => Show (Tuple15 a) #
Methods showsPrec :: Int -> Tuple15 a -> ShowS # show :: Tuple15 a -> String # showList :: [Tuple15 a] -> ShowS #

tuple15 :: a -> a -> a -> a -> a -> a -> a -> a -> a -> a -> a -> a -> a -> a -> a -> Tuple15 a #