Safe Haskell	Safe
Language	Haskell98

Data.Tup.Tup.Lazy

Contents

data type declarations
"tupping"
instances

Description

Lazy homogeneous tuples

Synopsis

data type declarations

data Tup0 a Source #

Constructors

Tup0

Instances

Functor Tup0 Source #
Methods fmap :: (a -> b) -> Tup0 a -> Tup0 b # (<$) :: a -> Tup0 b -> Tup0 a #
Applicative Tup0 Source #
Methods pure :: a -> Tup0 a # (<>) :: Tup0 (a -> b) -> Tup0 a -> Tup0 b # (>) :: Tup0 a -> Tup0 b -> Tup0 b # (<*) :: Tup0 a -> Tup0 b -> Tup0 a #
Foldable Tup0 Source #
Methods fold :: Monoid m => Tup0 m -> m # foldMap :: Monoid m => (a -> m) -> Tup0 a -> m # foldr :: (a -> b -> b) -> b -> Tup0 a -> b # foldr' :: (a -> b -> b) -> b -> Tup0 a -> b # foldl :: (b -> a -> b) -> b -> Tup0 a -> b # foldl' :: (b -> a -> b) -> b -> Tup0 a -> b # foldr1 :: (a -> a -> a) -> Tup0 a -> a # foldl1 :: (a -> a -> a) -> Tup0 a -> a # toList :: Tup0 a -> [a] # null :: Tup0 a -> Bool # length :: Tup0 a -> Int # elem :: Eq a => a -> Tup0 a -> Bool # maximum :: Ord a => Tup0 a -> a # minimum :: Ord a => Tup0 a -> a # sum :: Num a => Tup0 a -> a # product :: Num a => Tup0 a -> a #
Traversable Tup0 Source #
Methods traverse :: Applicative f => (a -> f b) -> Tup0 a -> f (Tup0 b) # sequenceA :: Applicative f => Tup0 (f a) -> f (Tup0 a) # mapM :: Monad m => (a -> m b) -> Tup0 a -> m (Tup0 b) # sequence :: Monad m => Tup0 (m a) -> m (Tup0 a) #
Tup Tup0 Source #
Methods tupSize :: Tup0 a -> Int Source # tupToList :: Tup0 a -> [a] Source # tupFromList :: [a] -> Tup0 a Source # tupProxy :: Tup0 a -> Proxy * a Source # tupUndef :: Tup0 a -> a Source # constantTup :: a -> Tup0 a Source # undefinedTup :: Tup0 a Source #
TupConcat Tup9 Tup0 Tup9 Source #
Methods tupConcat :: Tup9 a -> Tup0 a -> Tup9 a Source #
TupConcat Tup8 Tup0 Tup8 Source #
Methods tupConcat :: Tup8 a -> Tup0 a -> Tup8 a Source #
TupConcat Tup7 Tup0 Tup7 Source #
Methods tupConcat :: Tup7 a -> Tup0 a -> Tup7 a Source #
TupConcat Tup6 Tup0 Tup6 Source #
Methods tupConcat :: Tup6 a -> Tup0 a -> Tup6 a Source #
TupConcat Tup5 Tup0 Tup5 Source #
Methods tupConcat :: Tup5 a -> Tup0 a -> Tup5 a Source #
TupConcat Tup4 Tup0 Tup4 Source #
Methods tupConcat :: Tup4 a -> Tup0 a -> Tup4 a Source #
TupConcat Tup3 Tup0 Tup3 Source #
Methods tupConcat :: Tup3 a -> Tup0 a -> Tup3 a Source #
TupConcat Tup2 Tup0 Tup2 Source #
Methods tupConcat :: Tup2 a -> Tup0 a -> Tup2 a Source #
TupConcat Tup1 Tup0 Tup1 Source #
Methods tupConcat :: Tup1 a -> Tup0 a -> Tup1 a Source #
TupConcat Tup0 Tup9 Tup9 Source #
Methods tupConcat :: Tup0 a -> Tup9 a -> Tup9 a Source #
TupConcat Tup0 Tup8 Tup8 Source #
Methods tupConcat :: Tup0 a -> Tup8 a -> Tup8 a Source #
TupConcat Tup0 Tup7 Tup7 Source #
Methods tupConcat :: Tup0 a -> Tup7 a -> Tup7 a Source #
TupConcat Tup0 Tup6 Tup6 Source #
Methods tupConcat :: Tup0 a -> Tup6 a -> Tup6 a Source #
TupConcat Tup0 Tup5 Tup5 Source #
Methods tupConcat :: Tup0 a -> Tup5 a -> Tup5 a Source #
TupConcat Tup0 Tup4 Tup4 Source #
Methods tupConcat :: Tup0 a -> Tup4 a -> Tup4 a Source #
TupConcat Tup0 Tup3 Tup3 Source #
Methods tupConcat :: Tup0 a -> Tup3 a -> Tup3 a Source #
TupConcat Tup0 Tup2 Tup2 Source #
Methods tupConcat :: Tup0 a -> Tup2 a -> Tup2 a Source #
TupConcat Tup0 Tup1 Tup1 Source #
Methods tupConcat :: Tup0 a -> Tup1 a -> Tup1 a Source #
TupConcat Tup0 Tup0 Tup0 Source #
Methods tupConcat :: Tup0 a -> Tup0 a -> Tup0 a Source #
Bounded (Tup0 a) Source #
Methods minBound :: Tup0 a # maxBound :: Tup0 a #
Eq (Tup0 a) Source #
Methods (==) :: Tup0 a -> Tup0 a -> Bool # (/=) :: Tup0 a -> Tup0 a -> Bool #
Fractional a => Fractional (Tup0 a) Source #
Methods (/) :: Tup0 a -> Tup0 a -> Tup0 a # recip :: Tup0 a -> Tup0 a # fromRational :: Rational -> Tup0 a #
Num a => Num (Tup0 a) Source #
Methods (+) :: Tup0 a -> Tup0 a -> Tup0 a # (-) :: Tup0 a -> Tup0 a -> Tup0 a # (*) :: Tup0 a -> Tup0 a -> Tup0 a # negate :: Tup0 a -> Tup0 a # abs :: Tup0 a -> Tup0 a # signum :: Tup0 a -> Tup0 a # fromInteger :: Integer -> Tup0 a #
Ord (Tup0 a) Source #
Methods compare :: Tup0 a -> Tup0 a -> Ordering # (<) :: Tup0 a -> Tup0 a -> Bool # (<=) :: Tup0 a -> Tup0 a -> Bool # (>) :: Tup0 a -> Tup0 a -> Bool # (>=) :: Tup0 a -> Tup0 a -> Bool # max :: Tup0 a -> Tup0 a -> Tup0 a # min :: Tup0 a -> Tup0 a -> Tup0 a #
Read (Tup0 a) Source #
Methods readsPrec :: Int -> ReadS (Tup0 a) # readList :: ReadS [Tup0 a] # readPrec :: ReadPrec (Tup0 a) # readListPrec :: ReadPrec [Tup0 a] #
Show (Tup0 a) Source #
Methods showsPrec :: Int -> Tup0 a -> ShowS # show :: Tup0 a -> String # showList :: [Tup0 a] -> ShowS #
Monoid a => Monoid (Tup0 a) Source #
Methods mempty :: Tup0 a # mappend :: Tup0 a -> Tup0 a -> Tup0 a # mconcat :: [Tup0 a] -> Tup0 a #
Storable a => Storable (Tup0 a) Source #
Methods sizeOf :: Tup0 a -> Int # alignment :: Tup0 a -> Int # peekElemOff :: Ptr (Tup0 a) -> Int -> IO (Tup0 a) # pokeElemOff :: Ptr (Tup0 a) -> Int -> Tup0 a -> IO () # peekByteOff :: Ptr b -> Int -> IO (Tup0 a) # pokeByteOff :: Ptr b -> Int -> Tup0 a -> IO () # peek :: Ptr (Tup0 a) -> IO (Tup0 a) # poke :: Ptr (Tup0 a) -> Tup0 a -> IO () #

data Tup1 a Source #

Constructors

Tup1 a

Instances

Functor Tup1 Source #
Methods fmap :: (a -> b) -> Tup1 a -> Tup1 b # (<$) :: a -> Tup1 b -> Tup1 a #
Applicative Tup1 Source #
Methods pure :: a -> Tup1 a # (<>) :: Tup1 (a -> b) -> Tup1 a -> Tup1 b # (>) :: Tup1 a -> Tup1 b -> Tup1 b # (<*) :: Tup1 a -> Tup1 b -> Tup1 a #
Foldable Tup1 Source #
Methods fold :: Monoid m => Tup1 m -> m # foldMap :: Monoid m => (a -> m) -> Tup1 a -> m # foldr :: (a -> b -> b) -> b -> Tup1 a -> b # foldr' :: (a -> b -> b) -> b -> Tup1 a -> b # foldl :: (b -> a -> b) -> b -> Tup1 a -> b # foldl' :: (b -> a -> b) -> b -> Tup1 a -> b # foldr1 :: (a -> a -> a) -> Tup1 a -> a # foldl1 :: (a -> a -> a) -> Tup1 a -> a # toList :: Tup1 a -> [a] # null :: Tup1 a -> Bool # length :: Tup1 a -> Int # elem :: Eq a => a -> Tup1 a -> Bool # maximum :: Ord a => Tup1 a -> a # minimum :: Ord a => Tup1 a -> a # sum :: Num a => Tup1 a -> a # product :: Num a => Tup1 a -> a #
Traversable Tup1 Source #
Methods traverse :: Applicative f => (a -> f b) -> Tup1 a -> f (Tup1 b) # sequenceA :: Applicative f => Tup1 (f a) -> f (Tup1 a) # mapM :: Monad m => (a -> m b) -> Tup1 a -> m (Tup1 b) # sequence :: Monad m => Tup1 (m a) -> m (Tup1 a) #
Tup Tup1 Source #
Methods tupSize :: Tup1 a -> Int Source # tupToList :: Tup1 a -> [a] Source # tupFromList :: [a] -> Tup1 a Source # tupProxy :: Tup1 a -> Proxy * a Source # tupUndef :: Tup1 a -> a Source # constantTup :: a -> Tup1 a Source # undefinedTup :: Tup1 a Source #
TupConcat Tup8 Tup1 Tup9 Source #
Methods tupConcat :: Tup8 a -> Tup1 a -> Tup9 a Source #
TupConcat Tup7 Tup1 Tup8 Source #
Methods tupConcat :: Tup7 a -> Tup1 a -> Tup8 a Source #
TupConcat Tup6 Tup1 Tup7 Source #
Methods tupConcat :: Tup6 a -> Tup1 a -> Tup7 a Source #
TupConcat Tup5 Tup1 Tup6 Source #
Methods tupConcat :: Tup5 a -> Tup1 a -> Tup6 a Source #
TupConcat Tup4 Tup1 Tup5 Source #
Methods tupConcat :: Tup4 a -> Tup1 a -> Tup5 a Source #
TupConcat Tup3 Tup1 Tup4 Source #
Methods tupConcat :: Tup3 a -> Tup1 a -> Tup4 a Source #
TupConcat Tup2 Tup1 Tup3 Source #
Methods tupConcat :: Tup2 a -> Tup1 a -> Tup3 a Source #
TupConcat Tup1 Tup8 Tup9 Source #
Methods tupConcat :: Tup1 a -> Tup8 a -> Tup9 a Source #
TupConcat Tup1 Tup7 Tup8 Source #
Methods tupConcat :: Tup1 a -> Tup7 a -> Tup8 a Source #
TupConcat Tup1 Tup6 Tup7 Source #
Methods tupConcat :: Tup1 a -> Tup6 a -> Tup7 a Source #
TupConcat Tup1 Tup5 Tup6 Source #
Methods tupConcat :: Tup1 a -> Tup5 a -> Tup6 a Source #
TupConcat Tup1 Tup4 Tup5 Source #
Methods tupConcat :: Tup1 a -> Tup4 a -> Tup5 a Source #
TupConcat Tup1 Tup3 Tup4 Source #
Methods tupConcat :: Tup1 a -> Tup3 a -> Tup4 a Source #
TupConcat Tup1 Tup2 Tup3 Source #
Methods tupConcat :: Tup1 a -> Tup2 a -> Tup3 a Source #
TupConcat Tup1 Tup1 Tup2 Source #
Methods tupConcat :: Tup1 a -> Tup1 a -> Tup2 a Source #
TupConcat Tup1 Tup0 Tup1 Source #
Methods tupConcat :: Tup1 a -> Tup0 a -> Tup1 a Source #
TupConcat Tup0 Tup1 Tup1 Source #
Methods tupConcat :: Tup0 a -> Tup1 a -> Tup1 a Source #
Bounded a => Bounded (Tup1 a) Source #
Methods minBound :: Tup1 a # maxBound :: Tup1 a #
Eq a => Eq (Tup1 a) Source #
Methods (==) :: Tup1 a -> Tup1 a -> Bool # (/=) :: Tup1 a -> Tup1 a -> Bool #
Fractional a => Fractional (Tup1 a) Source #
Methods (/) :: Tup1 a -> Tup1 a -> Tup1 a # recip :: Tup1 a -> Tup1 a # fromRational :: Rational -> Tup1 a #
Num a => Num (Tup1 a) Source #
Methods (+) :: Tup1 a -> Tup1 a -> Tup1 a # (-) :: Tup1 a -> Tup1 a -> Tup1 a # (*) :: Tup1 a -> Tup1 a -> Tup1 a # negate :: Tup1 a -> Tup1 a # abs :: Tup1 a -> Tup1 a # signum :: Tup1 a -> Tup1 a # fromInteger :: Integer -> Tup1 a #
Ord a => Ord (Tup1 a) Source #
Methods compare :: Tup1 a -> Tup1 a -> Ordering # (<) :: Tup1 a -> Tup1 a -> Bool # (<=) :: Tup1 a -> Tup1 a -> Bool # (>) :: Tup1 a -> Tup1 a -> Bool # (>=) :: Tup1 a -> Tup1 a -> Bool # max :: Tup1 a -> Tup1 a -> Tup1 a # min :: Tup1 a -> Tup1 a -> Tup1 a #
Read a => Read (Tup1 a) Source #
Methods readsPrec :: Int -> ReadS (Tup1 a) # readList :: ReadS [Tup1 a] # readPrec :: ReadPrec (Tup1 a) # readListPrec :: ReadPrec [Tup1 a] #
Show a => Show (Tup1 a) Source #
Methods showsPrec :: Int -> Tup1 a -> ShowS # show :: Tup1 a -> String # showList :: [Tup1 a] -> ShowS #
Monoid a => Monoid (Tup1 a) Source #
Methods mempty :: Tup1 a # mappend :: Tup1 a -> Tup1 a -> Tup1 a # mconcat :: [Tup1 a] -> Tup1 a #
Storable a => Storable (Tup1 a) Source #
Methods sizeOf :: Tup1 a -> Int # alignment :: Tup1 a -> Int # peekElemOff :: Ptr (Tup1 a) -> Int -> IO (Tup1 a) # pokeElemOff :: Ptr (Tup1 a) -> Int -> Tup1 a -> IO () # peekByteOff :: Ptr b -> Int -> IO (Tup1 a) # pokeByteOff :: Ptr b -> Int -> Tup1 a -> IO () # peek :: Ptr (Tup1 a) -> IO (Tup1 a) # poke :: Ptr (Tup1 a) -> Tup1 a -> IO () #

data Tup2 a Source #

Constructors

Tup2 a a

Instances

Functor Tup2 Source #
Methods fmap :: (a -> b) -> Tup2 a -> Tup2 b # (<$) :: a -> Tup2 b -> Tup2 a #
Applicative Tup2 Source #
Methods pure :: a -> Tup2 a # (<>) :: Tup2 (a -> b) -> Tup2 a -> Tup2 b # (>) :: Tup2 a -> Tup2 b -> Tup2 b # (<*) :: Tup2 a -> Tup2 b -> Tup2 a #
Foldable Tup2 Source #
Methods fold :: Monoid m => Tup2 m -> m # foldMap :: Monoid m => (a -> m) -> Tup2 a -> m # foldr :: (a -> b -> b) -> b -> Tup2 a -> b # foldr' :: (a -> b -> b) -> b -> Tup2 a -> b # foldl :: (b -> a -> b) -> b -> Tup2 a -> b # foldl' :: (b -> a -> b) -> b -> Tup2 a -> b # foldr1 :: (a -> a -> a) -> Tup2 a -> a # foldl1 :: (a -> a -> a) -> Tup2 a -> a # toList :: Tup2 a -> [a] # null :: Tup2 a -> Bool # length :: Tup2 a -> Int # elem :: Eq a => a -> Tup2 a -> Bool # maximum :: Ord a => Tup2 a -> a # minimum :: Ord a => Tup2 a -> a # sum :: Num a => Tup2 a -> a # product :: Num a => Tup2 a -> a #
Traversable Tup2 Source #
Methods traverse :: Applicative f => (a -> f b) -> Tup2 a -> f (Tup2 b) # sequenceA :: Applicative f => Tup2 (f a) -> f (Tup2 a) # mapM :: Monad m => (a -> m b) -> Tup2 a -> m (Tup2 b) # sequence :: Monad m => Tup2 (m a) -> m (Tup2 a) #
Tup Tup2 Source #
Methods tupSize :: Tup2 a -> Int Source # tupToList :: Tup2 a -> [a] Source # tupFromList :: [a] -> Tup2 a Source # tupProxy :: Tup2 a -> Proxy * a Source # tupUndef :: Tup2 a -> a Source # constantTup :: a -> Tup2 a Source # undefinedTup :: Tup2 a Source #
TupConcat Tup7 Tup2 Tup9 Source #
Methods tupConcat :: Tup7 a -> Tup2 a -> Tup9 a Source #
TupConcat Tup6 Tup2 Tup8 Source #
Methods tupConcat :: Tup6 a -> Tup2 a -> Tup8 a Source #
TupConcat Tup5 Tup2 Tup7 Source #
Methods tupConcat :: Tup5 a -> Tup2 a -> Tup7 a Source #
TupConcat Tup4 Tup2 Tup6 Source #
Methods tupConcat :: Tup4 a -> Tup2 a -> Tup6 a Source #
TupConcat Tup3 Tup2 Tup5 Source #
Methods tupConcat :: Tup3 a -> Tup2 a -> Tup5 a Source #
TupConcat Tup2 Tup7 Tup9 Source #
Methods tupConcat :: Tup2 a -> Tup7 a -> Tup9 a Source #
TupConcat Tup2 Tup6 Tup8 Source #
Methods tupConcat :: Tup2 a -> Tup6 a -> Tup8 a Source #
TupConcat Tup2 Tup5 Tup7 Source #
Methods tupConcat :: Tup2 a -> Tup5 a -> Tup7 a Source #
TupConcat Tup2 Tup4 Tup6 Source #
Methods tupConcat :: Tup2 a -> Tup4 a -> Tup6 a Source #
TupConcat Tup2 Tup3 Tup5 Source #
Methods tupConcat :: Tup2 a -> Tup3 a -> Tup5 a Source #
TupConcat Tup2 Tup2 Tup4 Source #
Methods tupConcat :: Tup2 a -> Tup2 a -> Tup4 a Source #
TupConcat Tup2 Tup1 Tup3 Source #
Methods tupConcat :: Tup2 a -> Tup1 a -> Tup3 a Source #
TupConcat Tup2 Tup0 Tup2 Source #
Methods tupConcat :: Tup2 a -> Tup0 a -> Tup2 a Source #
TupConcat Tup1 Tup2 Tup3 Source #
Methods tupConcat :: Tup1 a -> Tup2 a -> Tup3 a Source #
TupConcat Tup1 Tup1 Tup2 Source #
Methods tupConcat :: Tup1 a -> Tup1 a -> Tup2 a Source #
TupConcat Tup0 Tup2 Tup2 Source #
Methods tupConcat :: Tup0 a -> Tup2 a -> Tup2 a Source #
Bounded a => Bounded (Tup2 a) Source #
Methods minBound :: Tup2 a # maxBound :: Tup2 a #
Eq a => Eq (Tup2 a) Source #
Methods (==) :: Tup2 a -> Tup2 a -> Bool # (/=) :: Tup2 a -> Tup2 a -> Bool #
Fractional a => Fractional (Tup2 a) Source #
Methods (/) :: Tup2 a -> Tup2 a -> Tup2 a # recip :: Tup2 a -> Tup2 a # fromRational :: Rational -> Tup2 a #
Num a => Num (Tup2 a) Source #
Methods (+) :: Tup2 a -> Tup2 a -> Tup2 a # (-) :: Tup2 a -> Tup2 a -> Tup2 a # (*) :: Tup2 a -> Tup2 a -> Tup2 a # negate :: Tup2 a -> Tup2 a # abs :: Tup2 a -> Tup2 a # signum :: Tup2 a -> Tup2 a # fromInteger :: Integer -> Tup2 a #
Ord a => Ord (Tup2 a) Source #
Methods compare :: Tup2 a -> Tup2 a -> Ordering # (<) :: Tup2 a -> Tup2 a -> Bool # (<=) :: Tup2 a -> Tup2 a -> Bool # (>) :: Tup2 a -> Tup2 a -> Bool # (>=) :: Tup2 a -> Tup2 a -> Bool # max :: Tup2 a -> Tup2 a -> Tup2 a # min :: Tup2 a -> Tup2 a -> Tup2 a #
Read a => Read (Tup2 a) Source #
Methods readsPrec :: Int -> ReadS (Tup2 a) # readList :: ReadS [Tup2 a] # readPrec :: ReadPrec (Tup2 a) # readListPrec :: ReadPrec [Tup2 a] #
Show a => Show (Tup2 a) Source #
Methods showsPrec :: Int -> Tup2 a -> ShowS # show :: Tup2 a -> String # showList :: [Tup2 a] -> ShowS #
Monoid a => Monoid (Tup2 a) Source #
Methods mempty :: Tup2 a # mappend :: Tup2 a -> Tup2 a -> Tup2 a # mconcat :: [Tup2 a] -> Tup2 a #
Storable a => Storable (Tup2 a) Source #
Methods sizeOf :: Tup2 a -> Int # alignment :: Tup2 a -> Int # peekElemOff :: Ptr (Tup2 a) -> Int -> IO (Tup2 a) # pokeElemOff :: Ptr (Tup2 a) -> Int -> Tup2 a -> IO () # peekByteOff :: Ptr b -> Int -> IO (Tup2 a) # pokeByteOff :: Ptr b -> Int -> Tup2 a -> IO () # peek :: Ptr (Tup2 a) -> IO (Tup2 a) # poke :: Ptr (Tup2 a) -> Tup2 a -> IO () #

data Tup3 a Source #

Constructors

Tup3 a a a

Instances

Functor Tup3 Source #
Methods fmap :: (a -> b) -> Tup3 a -> Tup3 b # (<$) :: a -> Tup3 b -> Tup3 a #
Applicative Tup3 Source #
Methods pure :: a -> Tup3 a # (<>) :: Tup3 (a -> b) -> Tup3 a -> Tup3 b # (>) :: Tup3 a -> Tup3 b -> Tup3 b # (<*) :: Tup3 a -> Tup3 b -> Tup3 a #
Foldable Tup3 Source #
Methods fold :: Monoid m => Tup3 m -> m # foldMap :: Monoid m => (a -> m) -> Tup3 a -> m # foldr :: (a -> b -> b) -> b -> Tup3 a -> b # foldr' :: (a -> b -> b) -> b -> Tup3 a -> b # foldl :: (b -> a -> b) -> b -> Tup3 a -> b # foldl' :: (b -> a -> b) -> b -> Tup3 a -> b # foldr1 :: (a -> a -> a) -> Tup3 a -> a # foldl1 :: (a -> a -> a) -> Tup3 a -> a # toList :: Tup3 a -> [a] # null :: Tup3 a -> Bool # length :: Tup3 a -> Int # elem :: Eq a => a -> Tup3 a -> Bool # maximum :: Ord a => Tup3 a -> a # minimum :: Ord a => Tup3 a -> a # sum :: Num a => Tup3 a -> a # product :: Num a => Tup3 a -> a #
Traversable Tup3 Source #
Methods traverse :: Applicative f => (a -> f b) -> Tup3 a -> f (Tup3 b) # sequenceA :: Applicative f => Tup3 (f a) -> f (Tup3 a) # mapM :: Monad m => (a -> m b) -> Tup3 a -> m (Tup3 b) # sequence :: Monad m => Tup3 (m a) -> m (Tup3 a) #
Tup Tup3 Source #
Methods tupSize :: Tup3 a -> Int Source # tupToList :: Tup3 a -> [a] Source # tupFromList :: [a] -> Tup3 a Source # tupProxy :: Tup3 a -> Proxy * a Source # tupUndef :: Tup3 a -> a Source # constantTup :: a -> Tup3 a Source # undefinedTup :: Tup3 a Source #
TupConcat Tup6 Tup3 Tup9 Source #
Methods tupConcat :: Tup6 a -> Tup3 a -> Tup9 a Source #
TupConcat Tup5 Tup3 Tup8 Source #
Methods tupConcat :: Tup5 a -> Tup3 a -> Tup8 a Source #
TupConcat Tup4 Tup3 Tup7 Source #
Methods tupConcat :: Tup4 a -> Tup3 a -> Tup7 a Source #
TupConcat Tup3 Tup6 Tup9 Source #
Methods tupConcat :: Tup3 a -> Tup6 a -> Tup9 a Source #
TupConcat Tup3 Tup5 Tup8 Source #
Methods tupConcat :: Tup3 a -> Tup5 a -> Tup8 a Source #
TupConcat Tup3 Tup4 Tup7 Source #
Methods tupConcat :: Tup3 a -> Tup4 a -> Tup7 a Source #
TupConcat Tup3 Tup3 Tup6 Source #
Methods tupConcat :: Tup3 a -> Tup3 a -> Tup6 a Source #
TupConcat Tup3 Tup2 Tup5 Source #
Methods tupConcat :: Tup3 a -> Tup2 a -> Tup5 a Source #
TupConcat Tup3 Tup1 Tup4 Source #
Methods tupConcat :: Tup3 a -> Tup1 a -> Tup4 a Source #
TupConcat Tup3 Tup0 Tup3 Source #
Methods tupConcat :: Tup3 a -> Tup0 a -> Tup3 a Source #
TupConcat Tup2 Tup3 Tup5 Source #
Methods tupConcat :: Tup2 a -> Tup3 a -> Tup5 a Source #
TupConcat Tup2 Tup1 Tup3 Source #
Methods tupConcat :: Tup2 a -> Tup1 a -> Tup3 a Source #
TupConcat Tup1 Tup3 Tup4 Source #
Methods tupConcat :: Tup1 a -> Tup3 a -> Tup4 a Source #
TupConcat Tup1 Tup2 Tup3 Source #
Methods tupConcat :: Tup1 a -> Tup2 a -> Tup3 a Source #
TupConcat Tup0 Tup3 Tup3 Source #
Methods tupConcat :: Tup0 a -> Tup3 a -> Tup3 a Source #
Bounded a => Bounded (Tup3 a) Source #
Methods minBound :: Tup3 a # maxBound :: Tup3 a #
Eq a => Eq (Tup3 a) Source #
Methods (==) :: Tup3 a -> Tup3 a -> Bool # (/=) :: Tup3 a -> Tup3 a -> Bool #
Fractional a => Fractional (Tup3 a) Source #
Methods (/) :: Tup3 a -> Tup3 a -> Tup3 a # recip :: Tup3 a -> Tup3 a # fromRational :: Rational -> Tup3 a #
Num a => Num (Tup3 a) Source #
Methods (+) :: Tup3 a -> Tup3 a -> Tup3 a # (-) :: Tup3 a -> Tup3 a -> Tup3 a # (*) :: Tup3 a -> Tup3 a -> Tup3 a # negate :: Tup3 a -> Tup3 a # abs :: Tup3 a -> Tup3 a # signum :: Tup3 a -> Tup3 a # fromInteger :: Integer -> Tup3 a #
Ord a => Ord (Tup3 a) Source #
Methods compare :: Tup3 a -> Tup3 a -> Ordering # (<) :: Tup3 a -> Tup3 a -> Bool # (<=) :: Tup3 a -> Tup3 a -> Bool # (>) :: Tup3 a -> Tup3 a -> Bool # (>=) :: Tup3 a -> Tup3 a -> Bool # max :: Tup3 a -> Tup3 a -> Tup3 a # min :: Tup3 a -> Tup3 a -> Tup3 a #
Read a => Read (Tup3 a) Source #
Methods readsPrec :: Int -> ReadS (Tup3 a) # readList :: ReadS [Tup3 a] # readPrec :: ReadPrec (Tup3 a) # readListPrec :: ReadPrec [Tup3 a] #
Show a => Show (Tup3 a) Source #
Methods showsPrec :: Int -> Tup3 a -> ShowS # show :: Tup3 a -> String # showList :: [Tup3 a] -> ShowS #
Monoid a => Monoid (Tup3 a) Source #
Methods mempty :: Tup3 a # mappend :: Tup3 a -> Tup3 a -> Tup3 a # mconcat :: [Tup3 a] -> Tup3 a #
Storable a => Storable (Tup3 a) Source #
Methods sizeOf :: Tup3 a -> Int # alignment :: Tup3 a -> Int # peekElemOff :: Ptr (Tup3 a) -> Int -> IO (Tup3 a) # pokeElemOff :: Ptr (Tup3 a) -> Int -> Tup3 a -> IO () # peekByteOff :: Ptr b -> Int -> IO (Tup3 a) # pokeByteOff :: Ptr b -> Int -> Tup3 a -> IO () # peek :: Ptr (Tup3 a) -> IO (Tup3 a) # poke :: Ptr (Tup3 a) -> Tup3 a -> IO () #

data Tup4 a Source #

Constructors

Tup4 a a a a

Instances

Functor Tup4 Source #
Methods fmap :: (a -> b) -> Tup4 a -> Tup4 b # (<$) :: a -> Tup4 b -> Tup4 a #
Applicative Tup4 Source #
Methods pure :: a -> Tup4 a # (<>) :: Tup4 (a -> b) -> Tup4 a -> Tup4 b # (>) :: Tup4 a -> Tup4 b -> Tup4 b # (<*) :: Tup4 a -> Tup4 b -> Tup4 a #
Foldable Tup4 Source #
Methods fold :: Monoid m => Tup4 m -> m # foldMap :: Monoid m => (a -> m) -> Tup4 a -> m # foldr :: (a -> b -> b) -> b -> Tup4 a -> b # foldr' :: (a -> b -> b) -> b -> Tup4 a -> b # foldl :: (b -> a -> b) -> b -> Tup4 a -> b # foldl' :: (b -> a -> b) -> b -> Tup4 a -> b # foldr1 :: (a -> a -> a) -> Tup4 a -> a # foldl1 :: (a -> a -> a) -> Tup4 a -> a # toList :: Tup4 a -> [a] # null :: Tup4 a -> Bool # length :: Tup4 a -> Int # elem :: Eq a => a -> Tup4 a -> Bool # maximum :: Ord a => Tup4 a -> a # minimum :: Ord a => Tup4 a -> a # sum :: Num a => Tup4 a -> a # product :: Num a => Tup4 a -> a #
Traversable Tup4 Source #
Methods traverse :: Applicative f => (a -> f b) -> Tup4 a -> f (Tup4 b) # sequenceA :: Applicative f => Tup4 (f a) -> f (Tup4 a) # mapM :: Monad m => (a -> m b) -> Tup4 a -> m (Tup4 b) # sequence :: Monad m => Tup4 (m a) -> m (Tup4 a) #
Tup Tup4 Source #
Methods tupSize :: Tup4 a -> Int Source # tupToList :: Tup4 a -> [a] Source # tupFromList :: [a] -> Tup4 a Source # tupProxy :: Tup4 a -> Proxy * a Source # tupUndef :: Tup4 a -> a Source # constantTup :: a -> Tup4 a Source # undefinedTup :: Tup4 a Source #
TupConcat Tup5 Tup4 Tup9 Source #
Methods tupConcat :: Tup5 a -> Tup4 a -> Tup9 a Source #
TupConcat Tup4 Tup5 Tup9 Source #
Methods tupConcat :: Tup4 a -> Tup5 a -> Tup9 a Source #
TupConcat Tup4 Tup4 Tup8 Source #
Methods tupConcat :: Tup4 a -> Tup4 a -> Tup8 a Source #
TupConcat Tup4 Tup3 Tup7 Source #
Methods tupConcat :: Tup4 a -> Tup3 a -> Tup7 a Source #
TupConcat Tup4 Tup2 Tup6 Source #
Methods tupConcat :: Tup4 a -> Tup2 a -> Tup6 a Source #
TupConcat Tup4 Tup1 Tup5 Source #
Methods tupConcat :: Tup4 a -> Tup1 a -> Tup5 a Source #
TupConcat Tup4 Tup0 Tup4 Source #
Methods tupConcat :: Tup4 a -> Tup0 a -> Tup4 a Source #
TupConcat Tup3 Tup4 Tup7 Source #
Methods tupConcat :: Tup3 a -> Tup4 a -> Tup7 a Source #
TupConcat Tup3 Tup1 Tup4 Source #
Methods tupConcat :: Tup3 a -> Tup1 a -> Tup4 a Source #
TupConcat Tup2 Tup4 Tup6 Source #
Methods tupConcat :: Tup2 a -> Tup4 a -> Tup6 a Source #
TupConcat Tup2 Tup2 Tup4 Source #
Methods tupConcat :: Tup2 a -> Tup2 a -> Tup4 a Source #
TupConcat Tup1 Tup4 Tup5 Source #
Methods tupConcat :: Tup1 a -> Tup4 a -> Tup5 a Source #
TupConcat Tup1 Tup3 Tup4 Source #
Methods tupConcat :: Tup1 a -> Tup3 a -> Tup4 a Source #
TupConcat Tup0 Tup4 Tup4 Source #
Methods tupConcat :: Tup0 a -> Tup4 a -> Tup4 a Source #
Bounded a => Bounded (Tup4 a) Source #
Methods minBound :: Tup4 a # maxBound :: Tup4 a #
Eq a => Eq (Tup4 a) Source #
Methods (==) :: Tup4 a -> Tup4 a -> Bool # (/=) :: Tup4 a -> Tup4 a -> Bool #
Fractional a => Fractional (Tup4 a) Source #
Methods (/) :: Tup4 a -> Tup4 a -> Tup4 a # recip :: Tup4 a -> Tup4 a # fromRational :: Rational -> Tup4 a #
Num a => Num (Tup4 a) Source #
Methods (+) :: Tup4 a -> Tup4 a -> Tup4 a # (-) :: Tup4 a -> Tup4 a -> Tup4 a # (*) :: Tup4 a -> Tup4 a -> Tup4 a # negate :: Tup4 a -> Tup4 a # abs :: Tup4 a -> Tup4 a # signum :: Tup4 a -> Tup4 a # fromInteger :: Integer -> Tup4 a #
Ord a => Ord (Tup4 a) Source #
Methods compare :: Tup4 a -> Tup4 a -> Ordering # (<) :: Tup4 a -> Tup4 a -> Bool # (<=) :: Tup4 a -> Tup4 a -> Bool # (>) :: Tup4 a -> Tup4 a -> Bool # (>=) :: Tup4 a -> Tup4 a -> Bool # max :: Tup4 a -> Tup4 a -> Tup4 a # min :: Tup4 a -> Tup4 a -> Tup4 a #
Read a => Read (Tup4 a) Source #
Methods readsPrec :: Int -> ReadS (Tup4 a) # readList :: ReadS [Tup4 a] # readPrec :: ReadPrec (Tup4 a) # readListPrec :: ReadPrec [Tup4 a] #
Show a => Show (Tup4 a) Source #
Methods showsPrec :: Int -> Tup4 a -> ShowS # show :: Tup4 a -> String # showList :: [Tup4 a] -> ShowS #
Monoid a => Monoid (Tup4 a) Source #
Methods mempty :: Tup4 a # mappend :: Tup4 a -> Tup4 a -> Tup4 a # mconcat :: [Tup4 a] -> Tup4 a #
Storable a => Storable (Tup4 a) Source #
Methods sizeOf :: Tup4 a -> Int # alignment :: Tup4 a -> Int # peekElemOff :: Ptr (Tup4 a) -> Int -> IO (Tup4 a) # pokeElemOff :: Ptr (Tup4 a) -> Int -> Tup4 a -> IO () # peekByteOff :: Ptr b -> Int -> IO (Tup4 a) # pokeByteOff :: Ptr b -> Int -> Tup4 a -> IO () # peek :: Ptr (Tup4 a) -> IO (Tup4 a) # poke :: Ptr (Tup4 a) -> Tup4 a -> IO () #

data Tup5 a Source #

Constructors

Tup5 a a a a a

Instances

Functor Tup5 Source #
Methods fmap :: (a -> b) -> Tup5 a -> Tup5 b # (<$) :: a -> Tup5 b -> Tup5 a #
Applicative Tup5 Source #
Methods pure :: a -> Tup5 a # (<>) :: Tup5 (a -> b) -> Tup5 a -> Tup5 b # (>) :: Tup5 a -> Tup5 b -> Tup5 b # (<*) :: Tup5 a -> Tup5 b -> Tup5 a #
Foldable Tup5 Source #
Methods fold :: Monoid m => Tup5 m -> m # foldMap :: Monoid m => (a -> m) -> Tup5 a -> m # foldr :: (a -> b -> b) -> b -> Tup5 a -> b # foldr' :: (a -> b -> b) -> b -> Tup5 a -> b # foldl :: (b -> a -> b) -> b -> Tup5 a -> b # foldl' :: (b -> a -> b) -> b -> Tup5 a -> b # foldr1 :: (a -> a -> a) -> Tup5 a -> a # foldl1 :: (a -> a -> a) -> Tup5 a -> a # toList :: Tup5 a -> [a] # null :: Tup5 a -> Bool # length :: Tup5 a -> Int # elem :: Eq a => a -> Tup5 a -> Bool # maximum :: Ord a => Tup5 a -> a # minimum :: Ord a => Tup5 a -> a # sum :: Num a => Tup5 a -> a # product :: Num a => Tup5 a -> a #
Traversable Tup5 Source #
Methods traverse :: Applicative f => (a -> f b) -> Tup5 a -> f (Tup5 b) # sequenceA :: Applicative f => Tup5 (f a) -> f (Tup5 a) # mapM :: Monad m => (a -> m b) -> Tup5 a -> m (Tup5 b) # sequence :: Monad m => Tup5 (m a) -> m (Tup5 a) #
Tup Tup5 Source #
Methods tupSize :: Tup5 a -> Int Source # tupToList :: Tup5 a -> [a] Source # tupFromList :: [a] -> Tup5 a Source # tupProxy :: Tup5 a -> Proxy * a Source # tupUndef :: Tup5 a -> a Source # constantTup :: a -> Tup5 a Source # undefinedTup :: Tup5 a Source #
TupConcat Tup5 Tup4 Tup9 Source #
Methods tupConcat :: Tup5 a -> Tup4 a -> Tup9 a Source #
TupConcat Tup5 Tup3 Tup8 Source #
Methods tupConcat :: Tup5 a -> Tup3 a -> Tup8 a Source #
TupConcat Tup5 Tup2 Tup7 Source #
Methods tupConcat :: Tup5 a -> Tup2 a -> Tup7 a Source #
TupConcat Tup5 Tup1 Tup6 Source #
Methods tupConcat :: Tup5 a -> Tup1 a -> Tup6 a Source #
TupConcat Tup5 Tup0 Tup5 Source #
Methods tupConcat :: Tup5 a -> Tup0 a -> Tup5 a Source #
TupConcat Tup4 Tup5 Tup9 Source #
Methods tupConcat :: Tup4 a -> Tup5 a -> Tup9 a Source #
TupConcat Tup4 Tup1 Tup5 Source #
Methods tupConcat :: Tup4 a -> Tup1 a -> Tup5 a Source #
TupConcat Tup3 Tup5 Tup8 Source #
Methods tupConcat :: Tup3 a -> Tup5 a -> Tup8 a Source #
TupConcat Tup3 Tup2 Tup5 Source #
Methods tupConcat :: Tup3 a -> Tup2 a -> Tup5 a Source #
TupConcat Tup2 Tup5 Tup7 Source #
Methods tupConcat :: Tup2 a -> Tup5 a -> Tup7 a Source #
TupConcat Tup2 Tup3 Tup5 Source #
Methods tupConcat :: Tup2 a -> Tup3 a -> Tup5 a Source #
TupConcat Tup1 Tup5 Tup6 Source #
Methods tupConcat :: Tup1 a -> Tup5 a -> Tup6 a Source #
TupConcat Tup1 Tup4 Tup5 Source #
Methods tupConcat :: Tup1 a -> Tup4 a -> Tup5 a Source #
TupConcat Tup0 Tup5 Tup5 Source #
Methods tupConcat :: Tup0 a -> Tup5 a -> Tup5 a Source #
Bounded a => Bounded (Tup5 a) Source #
Methods minBound :: Tup5 a # maxBound :: Tup5 a #
Eq a => Eq (Tup5 a) Source #
Methods (==) :: Tup5 a -> Tup5 a -> Bool # (/=) :: Tup5 a -> Tup5 a -> Bool #
Fractional a => Fractional (Tup5 a) Source #
Methods (/) :: Tup5 a -> Tup5 a -> Tup5 a # recip :: Tup5 a -> Tup5 a # fromRational :: Rational -> Tup5 a #
Num a => Num (Tup5 a) Source #
Methods (+) :: Tup5 a -> Tup5 a -> Tup5 a # (-) :: Tup5 a -> Tup5 a -> Tup5 a # (*) :: Tup5 a -> Tup5 a -> Tup5 a # negate :: Tup5 a -> Tup5 a # abs :: Tup5 a -> Tup5 a # signum :: Tup5 a -> Tup5 a # fromInteger :: Integer -> Tup5 a #
Ord a => Ord (Tup5 a) Source #
Methods compare :: Tup5 a -> Tup5 a -> Ordering # (<) :: Tup5 a -> Tup5 a -> Bool # (<=) :: Tup5 a -> Tup5 a -> Bool # (>) :: Tup5 a -> Tup5 a -> Bool # (>=) :: Tup5 a -> Tup5 a -> Bool # max :: Tup5 a -> Tup5 a -> Tup5 a # min :: Tup5 a -> Tup5 a -> Tup5 a #
Read a => Read (Tup5 a) Source #
Methods readsPrec :: Int -> ReadS (Tup5 a) # readList :: ReadS [Tup5 a] # readPrec :: ReadPrec (Tup5 a) # readListPrec :: ReadPrec [Tup5 a] #
Show a => Show (Tup5 a) Source #
Methods showsPrec :: Int -> Tup5 a -> ShowS # show :: Tup5 a -> String # showList :: [Tup5 a] -> ShowS #
Monoid a => Monoid (Tup5 a) Source #
Methods mempty :: Tup5 a # mappend :: Tup5 a -> Tup5 a -> Tup5 a # mconcat :: [Tup5 a] -> Tup5 a #
Storable a => Storable (Tup5 a) Source #
Methods sizeOf :: Tup5 a -> Int # alignment :: Tup5 a -> Int # peekElemOff :: Ptr (Tup5 a) -> Int -> IO (Tup5 a) # pokeElemOff :: Ptr (Tup5 a) -> Int -> Tup5 a -> IO () # peekByteOff :: Ptr b -> Int -> IO (Tup5 a) # pokeByteOff :: Ptr b -> Int -> Tup5 a -> IO () # peek :: Ptr (Tup5 a) -> IO (Tup5 a) # poke :: Ptr (Tup5 a) -> Tup5 a -> IO () #

data Tup6 a Source #

Constructors

Tup6 a a a a a a

Instances

Functor Tup6 Source #
Methods fmap :: (a -> b) -> Tup6 a -> Tup6 b # (<$) :: a -> Tup6 b -> Tup6 a #
Applicative Tup6 Source #
Methods pure :: a -> Tup6 a # (<>) :: Tup6 (a -> b) -> Tup6 a -> Tup6 b # (>) :: Tup6 a -> Tup6 b -> Tup6 b # (<*) :: Tup6 a -> Tup6 b -> Tup6 a #
Foldable Tup6 Source #
Methods fold :: Monoid m => Tup6 m -> m # foldMap :: Monoid m => (a -> m) -> Tup6 a -> m # foldr :: (a -> b -> b) -> b -> Tup6 a -> b # foldr' :: (a -> b -> b) -> b -> Tup6 a -> b # foldl :: (b -> a -> b) -> b -> Tup6 a -> b # foldl' :: (b -> a -> b) -> b -> Tup6 a -> b # foldr1 :: (a -> a -> a) -> Tup6 a -> a # foldl1 :: (a -> a -> a) -> Tup6 a -> a # toList :: Tup6 a -> [a] # null :: Tup6 a -> Bool # length :: Tup6 a -> Int # elem :: Eq a => a -> Tup6 a -> Bool # maximum :: Ord a => Tup6 a -> a # minimum :: Ord a => Tup6 a -> a # sum :: Num a => Tup6 a -> a # product :: Num a => Tup6 a -> a #
Traversable Tup6 Source #
Methods traverse :: Applicative f => (a -> f b) -> Tup6 a -> f (Tup6 b) # sequenceA :: Applicative f => Tup6 (f a) -> f (Tup6 a) # mapM :: Monad m => (a -> m b) -> Tup6 a -> m (Tup6 b) # sequence :: Monad m => Tup6 (m a) -> m (Tup6 a) #
Tup Tup6 Source #
Methods tupSize :: Tup6 a -> Int Source # tupToList :: Tup6 a -> [a] Source # tupFromList :: [a] -> Tup6 a Source # tupProxy :: Tup6 a -> Proxy * a Source # tupUndef :: Tup6 a -> a Source # constantTup :: a -> Tup6 a Source # undefinedTup :: Tup6 a Source #
TupConcat Tup6 Tup3 Tup9 Source #
Methods tupConcat :: Tup6 a -> Tup3 a -> Tup9 a Source #
TupConcat Tup6 Tup2 Tup8 Source #
Methods tupConcat :: Tup6 a -> Tup2 a -> Tup8 a Source #
TupConcat Tup6 Tup1 Tup7 Source #
Methods tupConcat :: Tup6 a -> Tup1 a -> Tup7 a Source #
TupConcat Tup6 Tup0 Tup6 Source #
Methods tupConcat :: Tup6 a -> Tup0 a -> Tup6 a Source #
TupConcat Tup5 Tup1 Tup6 Source #
Methods tupConcat :: Tup5 a -> Tup1 a -> Tup6 a Source #
TupConcat Tup4 Tup2 Tup6 Source #
Methods tupConcat :: Tup4 a -> Tup2 a -> Tup6 a Source #
TupConcat Tup3 Tup6 Tup9 Source #
Methods tupConcat :: Tup3 a -> Tup6 a -> Tup9 a Source #
TupConcat Tup3 Tup3 Tup6 Source #
Methods tupConcat :: Tup3 a -> Tup3 a -> Tup6 a Source #
TupConcat Tup2 Tup6 Tup8 Source #
Methods tupConcat :: Tup2 a -> Tup6 a -> Tup8 a Source #
TupConcat Tup2 Tup4 Tup6 Source #
Methods tupConcat :: Tup2 a -> Tup4 a -> Tup6 a Source #
TupConcat Tup1 Tup6 Tup7 Source #
Methods tupConcat :: Tup1 a -> Tup6 a -> Tup7 a Source #
TupConcat Tup1 Tup5 Tup6 Source #
Methods tupConcat :: Tup1 a -> Tup5 a -> Tup6 a Source #
TupConcat Tup0 Tup6 Tup6 Source #
Methods tupConcat :: Tup0 a -> Tup6 a -> Tup6 a Source #
Bounded a => Bounded (Tup6 a) Source #
Methods minBound :: Tup6 a # maxBound :: Tup6 a #
Eq a => Eq (Tup6 a) Source #
Methods (==) :: Tup6 a -> Tup6 a -> Bool # (/=) :: Tup6 a -> Tup6 a -> Bool #
Fractional a => Fractional (Tup6 a) Source #
Methods (/) :: Tup6 a -> Tup6 a -> Tup6 a # recip :: Tup6 a -> Tup6 a # fromRational :: Rational -> Tup6 a #
Num a => Num (Tup6 a) Source #
Methods (+) :: Tup6 a -> Tup6 a -> Tup6 a # (-) :: Tup6 a -> Tup6 a -> Tup6 a # (*) :: Tup6 a -> Tup6 a -> Tup6 a # negate :: Tup6 a -> Tup6 a # abs :: Tup6 a -> Tup6 a # signum :: Tup6 a -> Tup6 a # fromInteger :: Integer -> Tup6 a #
Ord a => Ord (Tup6 a) Source #
Methods compare :: Tup6 a -> Tup6 a -> Ordering # (<) :: Tup6 a -> Tup6 a -> Bool # (<=) :: Tup6 a -> Tup6 a -> Bool # (>) :: Tup6 a -> Tup6 a -> Bool # (>=) :: Tup6 a -> Tup6 a -> Bool # max :: Tup6 a -> Tup6 a -> Tup6 a # min :: Tup6 a -> Tup6 a -> Tup6 a #
Read a => Read (Tup6 a) Source #
Methods readsPrec :: Int -> ReadS (Tup6 a) # readList :: ReadS [Tup6 a] # readPrec :: ReadPrec (Tup6 a) # readListPrec :: ReadPrec [Tup6 a] #
Show a => Show (Tup6 a) Source #
Methods showsPrec :: Int -> Tup6 a -> ShowS # show :: Tup6 a -> String # showList :: [Tup6 a] -> ShowS #
Monoid a => Monoid (Tup6 a) Source #
Methods mempty :: Tup6 a # mappend :: Tup6 a -> Tup6 a -> Tup6 a # mconcat :: [Tup6 a] -> Tup6 a #
Storable a => Storable (Tup6 a) Source #
Methods sizeOf :: Tup6 a -> Int # alignment :: Tup6 a -> Int # peekElemOff :: Ptr (Tup6 a) -> Int -> IO (Tup6 a) # pokeElemOff :: Ptr (Tup6 a) -> Int -> Tup6 a -> IO () # peekByteOff :: Ptr b -> Int -> IO (Tup6 a) # pokeByteOff :: Ptr b -> Int -> Tup6 a -> IO () # peek :: Ptr (Tup6 a) -> IO (Tup6 a) # poke :: Ptr (Tup6 a) -> Tup6 a -> IO () #

data Tup7 a Source #

Constructors

Tup7 a a a a a a a

Instances

Functor Tup7 Source #
Methods fmap :: (a -> b) -> Tup7 a -> Tup7 b # (<$) :: a -> Tup7 b -> Tup7 a #
Applicative Tup7 Source #
Methods pure :: a -> Tup7 a # (<>) :: Tup7 (a -> b) -> Tup7 a -> Tup7 b # (>) :: Tup7 a -> Tup7 b -> Tup7 b # (<*) :: Tup7 a -> Tup7 b -> Tup7 a #
Foldable Tup7 Source #
Methods fold :: Monoid m => Tup7 m -> m # foldMap :: Monoid m => (a -> m) -> Tup7 a -> m # foldr :: (a -> b -> b) -> b -> Tup7 a -> b # foldr' :: (a -> b -> b) -> b -> Tup7 a -> b # foldl :: (b -> a -> b) -> b -> Tup7 a -> b # foldl' :: (b -> a -> b) -> b -> Tup7 a -> b # foldr1 :: (a -> a -> a) -> Tup7 a -> a # foldl1 :: (a -> a -> a) -> Tup7 a -> a # toList :: Tup7 a -> [a] # null :: Tup7 a -> Bool # length :: Tup7 a -> Int # elem :: Eq a => a -> Tup7 a -> Bool # maximum :: Ord a => Tup7 a -> a # minimum :: Ord a => Tup7 a -> a # sum :: Num a => Tup7 a -> a # product :: Num a => Tup7 a -> a #
Traversable Tup7 Source #
Methods traverse :: Applicative f => (a -> f b) -> Tup7 a -> f (Tup7 b) # sequenceA :: Applicative f => Tup7 (f a) -> f (Tup7 a) # mapM :: Monad m => (a -> m b) -> Tup7 a -> m (Tup7 b) # sequence :: Monad m => Tup7 (m a) -> m (Tup7 a) #
Tup Tup7 Source #
Methods tupSize :: Tup7 a -> Int Source # tupToList :: Tup7 a -> [a] Source # tupFromList :: [a] -> Tup7 a Source # tupProxy :: Tup7 a -> Proxy * a Source # tupUndef :: Tup7 a -> a Source # constantTup :: a -> Tup7 a Source # undefinedTup :: Tup7 a Source #
TupConcat Tup7 Tup2 Tup9 Source #
Methods tupConcat :: Tup7 a -> Tup2 a -> Tup9 a Source #
TupConcat Tup7 Tup1 Tup8 Source #
Methods tupConcat :: Tup7 a -> Tup1 a -> Tup8 a Source #
TupConcat Tup7 Tup0 Tup7 Source #
Methods tupConcat :: Tup7 a -> Tup0 a -> Tup7 a Source #
TupConcat Tup6 Tup1 Tup7 Source #
Methods tupConcat :: Tup6 a -> Tup1 a -> Tup7 a Source #
TupConcat Tup5 Tup2 Tup7 Source #
Methods tupConcat :: Tup5 a -> Tup2 a -> Tup7 a Source #
TupConcat Tup4 Tup3 Tup7 Source #
Methods tupConcat :: Tup4 a -> Tup3 a -> Tup7 a Source #
TupConcat Tup3 Tup4 Tup7 Source #
Methods tupConcat :: Tup3 a -> Tup4 a -> Tup7 a Source #
TupConcat Tup2 Tup7 Tup9 Source #
Methods tupConcat :: Tup2 a -> Tup7 a -> Tup9 a Source #
TupConcat Tup2 Tup5 Tup7 Source #
Methods tupConcat :: Tup2 a -> Tup5 a -> Tup7 a Source #
TupConcat Tup1 Tup7 Tup8 Source #
Methods tupConcat :: Tup1 a -> Tup7 a -> Tup8 a Source #
TupConcat Tup1 Tup6 Tup7 Source #
Methods tupConcat :: Tup1 a -> Tup6 a -> Tup7 a Source #
TupConcat Tup0 Tup7 Tup7 Source #
Methods tupConcat :: Tup0 a -> Tup7 a -> Tup7 a Source #
Bounded a => Bounded (Tup7 a) Source #
Methods minBound :: Tup7 a # maxBound :: Tup7 a #
Eq a => Eq (Tup7 a) Source #
Methods (==) :: Tup7 a -> Tup7 a -> Bool # (/=) :: Tup7 a -> Tup7 a -> Bool #
Fractional a => Fractional (Tup7 a) Source #
Methods (/) :: Tup7 a -> Tup7 a -> Tup7 a # recip :: Tup7 a -> Tup7 a # fromRational :: Rational -> Tup7 a #
Num a => Num (Tup7 a) Source #
Methods (+) :: Tup7 a -> Tup7 a -> Tup7 a # (-) :: Tup7 a -> Tup7 a -> Tup7 a # (*) :: Tup7 a -> Tup7 a -> Tup7 a # negate :: Tup7 a -> Tup7 a # abs :: Tup7 a -> Tup7 a # signum :: Tup7 a -> Tup7 a # fromInteger :: Integer -> Tup7 a #
Ord a => Ord (Tup7 a) Source #
Methods compare :: Tup7 a -> Tup7 a -> Ordering # (<) :: Tup7 a -> Tup7 a -> Bool # (<=) :: Tup7 a -> Tup7 a -> Bool # (>) :: Tup7 a -> Tup7 a -> Bool # (>=) :: Tup7 a -> Tup7 a -> Bool # max :: Tup7 a -> Tup7 a -> Tup7 a # min :: Tup7 a -> Tup7 a -> Tup7 a #
Read a => Read (Tup7 a) Source #
Methods readsPrec :: Int -> ReadS (Tup7 a) # readList :: ReadS [Tup7 a] # readPrec :: ReadPrec (Tup7 a) # readListPrec :: ReadPrec [Tup7 a] #
Show a => Show (Tup7 a) Source #
Methods showsPrec :: Int -> Tup7 a -> ShowS # show :: Tup7 a -> String # showList :: [Tup7 a] -> ShowS #
Monoid a => Monoid (Tup7 a) Source #
Methods mempty :: Tup7 a # mappend :: Tup7 a -> Tup7 a -> Tup7 a # mconcat :: [Tup7 a] -> Tup7 a #
Storable a => Storable (Tup7 a) Source #
Methods sizeOf :: Tup7 a -> Int # alignment :: Tup7 a -> Int # peekElemOff :: Ptr (Tup7 a) -> Int -> IO (Tup7 a) # pokeElemOff :: Ptr (Tup7 a) -> Int -> Tup7 a -> IO () # peekByteOff :: Ptr b -> Int -> IO (Tup7 a) # pokeByteOff :: Ptr b -> Int -> Tup7 a -> IO () # peek :: Ptr (Tup7 a) -> IO (Tup7 a) # poke :: Ptr (Tup7 a) -> Tup7 a -> IO () #

data Tup8 a Source #

Constructors

Tup8 a a a a a a a a

Instances

Functor Tup8 Source #
Methods fmap :: (a -> b) -> Tup8 a -> Tup8 b # (<$) :: a -> Tup8 b -> Tup8 a #
Applicative Tup8 Source #
Methods pure :: a -> Tup8 a # (<>) :: Tup8 (a -> b) -> Tup8 a -> Tup8 b # (>) :: Tup8 a -> Tup8 b -> Tup8 b # (<*) :: Tup8 a -> Tup8 b -> Tup8 a #
Foldable Tup8 Source #
Methods fold :: Monoid m => Tup8 m -> m # foldMap :: Monoid m => (a -> m) -> Tup8 a -> m # foldr :: (a -> b -> b) -> b -> Tup8 a -> b # foldr' :: (a -> b -> b) -> b -> Tup8 a -> b # foldl :: (b -> a -> b) -> b -> Tup8 a -> b # foldl' :: (b -> a -> b) -> b -> Tup8 a -> b # foldr1 :: (a -> a -> a) -> Tup8 a -> a # foldl1 :: (a -> a -> a) -> Tup8 a -> a # toList :: Tup8 a -> [a] # null :: Tup8 a -> Bool # length :: Tup8 a -> Int # elem :: Eq a => a -> Tup8 a -> Bool # maximum :: Ord a => Tup8 a -> a # minimum :: Ord a => Tup8 a -> a # sum :: Num a => Tup8 a -> a # product :: Num a => Tup8 a -> a #
Traversable Tup8 Source #
Methods traverse :: Applicative f => (a -> f b) -> Tup8 a -> f (Tup8 b) # sequenceA :: Applicative f => Tup8 (f a) -> f (Tup8 a) # mapM :: Monad m => (a -> m b) -> Tup8 a -> m (Tup8 b) # sequence :: Monad m => Tup8 (m a) -> m (Tup8 a) #
Tup Tup8 Source #
Methods tupSize :: Tup8 a -> Int Source # tupToList :: Tup8 a -> [a] Source # tupFromList :: [a] -> Tup8 a Source # tupProxy :: Tup8 a -> Proxy * a Source # tupUndef :: Tup8 a -> a Source # constantTup :: a -> Tup8 a Source # undefinedTup :: Tup8 a Source #
TupConcat Tup8 Tup1 Tup9 Source #
Methods tupConcat :: Tup8 a -> Tup1 a -> Tup9 a Source #
TupConcat Tup8 Tup0 Tup8 Source #
Methods tupConcat :: Tup8 a -> Tup0 a -> Tup8 a Source #
TupConcat Tup7 Tup1 Tup8 Source #
Methods tupConcat :: Tup7 a -> Tup1 a -> Tup8 a Source #
TupConcat Tup6 Tup2 Tup8 Source #
Methods tupConcat :: Tup6 a -> Tup2 a -> Tup8 a Source #
TupConcat Tup5 Tup3 Tup8 Source #
Methods tupConcat :: Tup5 a -> Tup3 a -> Tup8 a Source #
TupConcat Tup4 Tup4 Tup8 Source #
Methods tupConcat :: Tup4 a -> Tup4 a -> Tup8 a Source #
TupConcat Tup3 Tup5 Tup8 Source #
Methods tupConcat :: Tup3 a -> Tup5 a -> Tup8 a Source #
TupConcat Tup2 Tup6 Tup8 Source #
Methods tupConcat :: Tup2 a -> Tup6 a -> Tup8 a Source #
TupConcat Tup1 Tup8 Tup9 Source #
Methods tupConcat :: Tup1 a -> Tup8 a -> Tup9 a Source #
TupConcat Tup1 Tup7 Tup8 Source #
Methods tupConcat :: Tup1 a -> Tup7 a -> Tup8 a Source #
TupConcat Tup0 Tup8 Tup8 Source #
Methods tupConcat :: Tup0 a -> Tup8 a -> Tup8 a Source #
Bounded a => Bounded (Tup8 a) Source #
Methods minBound :: Tup8 a # maxBound :: Tup8 a #
Eq a => Eq (Tup8 a) Source #
Methods (==) :: Tup8 a -> Tup8 a -> Bool # (/=) :: Tup8 a -> Tup8 a -> Bool #
Fractional a => Fractional (Tup8 a) Source #
Methods (/) :: Tup8 a -> Tup8 a -> Tup8 a # recip :: Tup8 a -> Tup8 a # fromRational :: Rational -> Tup8 a #
Num a => Num (Tup8 a) Source #
Methods (+) :: Tup8 a -> Tup8 a -> Tup8 a # (-) :: Tup8 a -> Tup8 a -> Tup8 a # (*) :: Tup8 a -> Tup8 a -> Tup8 a # negate :: Tup8 a -> Tup8 a # abs :: Tup8 a -> Tup8 a # signum :: Tup8 a -> Tup8 a # fromInteger :: Integer -> Tup8 a #
Ord a => Ord (Tup8 a) Source #
Methods compare :: Tup8 a -> Tup8 a -> Ordering # (<) :: Tup8 a -> Tup8 a -> Bool # (<=) :: Tup8 a -> Tup8 a -> Bool # (>) :: Tup8 a -> Tup8 a -> Bool # (>=) :: Tup8 a -> Tup8 a -> Bool # max :: Tup8 a -> Tup8 a -> Tup8 a # min :: Tup8 a -> Tup8 a -> Tup8 a #
Read a => Read (Tup8 a) Source #
Methods readsPrec :: Int -> ReadS (Tup8 a) # readList :: ReadS [Tup8 a] # readPrec :: ReadPrec (Tup8 a) # readListPrec :: ReadPrec [Tup8 a] #
Show a => Show (Tup8 a) Source #
Methods showsPrec :: Int -> Tup8 a -> ShowS # show :: Tup8 a -> String # showList :: [Tup8 a] -> ShowS #
Monoid a => Monoid (Tup8 a) Source #
Methods mempty :: Tup8 a # mappend :: Tup8 a -> Tup8 a -> Tup8 a # mconcat :: [Tup8 a] -> Tup8 a #
Storable a => Storable (Tup8 a) Source #
Methods sizeOf :: Tup8 a -> Int # alignment :: Tup8 a -> Int # peekElemOff :: Ptr (Tup8 a) -> Int -> IO (Tup8 a) # pokeElemOff :: Ptr (Tup8 a) -> Int -> Tup8 a -> IO () # peekByteOff :: Ptr b -> Int -> IO (Tup8 a) # pokeByteOff :: Ptr b -> Int -> Tup8 a -> IO () # peek :: Ptr (Tup8 a) -> IO (Tup8 a) # poke :: Ptr (Tup8 a) -> Tup8 a -> IO () #

data Tup9 a Source #

Constructors

Tup9 a a a a a a a a a

Instances

Functor Tup9 Source #
Methods fmap :: (a -> b) -> Tup9 a -> Tup9 b # (<$) :: a -> Tup9 b -> Tup9 a #
Applicative Tup9 Source #
Methods pure :: a -> Tup9 a # (<>) :: Tup9 (a -> b) -> Tup9 a -> Tup9 b # (>) :: Tup9 a -> Tup9 b -> Tup9 b # (<*) :: Tup9 a -> Tup9 b -> Tup9 a #
Foldable Tup9 Source #
Methods fold :: Monoid m => Tup9 m -> m # foldMap :: Monoid m => (a -> m) -> Tup9 a -> m # foldr :: (a -> b -> b) -> b -> Tup9 a -> b # foldr' :: (a -> b -> b) -> b -> Tup9 a -> b # foldl :: (b -> a -> b) -> b -> Tup9 a -> b # foldl' :: (b -> a -> b) -> b -> Tup9 a -> b # foldr1 :: (a -> a -> a) -> Tup9 a -> a # foldl1 :: (a -> a -> a) -> Tup9 a -> a # toList :: Tup9 a -> [a] # null :: Tup9 a -> Bool # length :: Tup9 a -> Int # elem :: Eq a => a -> Tup9 a -> Bool # maximum :: Ord a => Tup9 a -> a # minimum :: Ord a => Tup9 a -> a # sum :: Num a => Tup9 a -> a # product :: Num a => Tup9 a -> a #
Traversable Tup9 Source #
Methods traverse :: Applicative f => (a -> f b) -> Tup9 a -> f (Tup9 b) # sequenceA :: Applicative f => Tup9 (f a) -> f (Tup9 a) # mapM :: Monad m => (a -> m b) -> Tup9 a -> m (Tup9 b) # sequence :: Monad m => Tup9 (m a) -> m (Tup9 a) #
Tup Tup9 Source #
Methods tupSize :: Tup9 a -> Int Source # tupToList :: Tup9 a -> [a] Source # tupFromList :: [a] -> Tup9 a Source # tupProxy :: Tup9 a -> Proxy * a Source # tupUndef :: Tup9 a -> a Source # constantTup :: a -> Tup9 a Source # undefinedTup :: Tup9 a Source #
TupConcat Tup9 Tup0 Tup9 Source #
Methods tupConcat :: Tup9 a -> Tup0 a -> Tup9 a Source #
TupConcat Tup8 Tup1 Tup9 Source #
Methods tupConcat :: Tup8 a -> Tup1 a -> Tup9 a Source #
TupConcat Tup7 Tup2 Tup9 Source #
Methods tupConcat :: Tup7 a -> Tup2 a -> Tup9 a Source #
TupConcat Tup6 Tup3 Tup9 Source #
Methods tupConcat :: Tup6 a -> Tup3 a -> Tup9 a Source #
TupConcat Tup5 Tup4 Tup9 Source #
Methods tupConcat :: Tup5 a -> Tup4 a -> Tup9 a Source #
TupConcat Tup4 Tup5 Tup9 Source #
Methods tupConcat :: Tup4 a -> Tup5 a -> Tup9 a Source #
TupConcat Tup3 Tup6 Tup9 Source #
Methods tupConcat :: Tup3 a -> Tup6 a -> Tup9 a Source #
TupConcat Tup2 Tup7 Tup9 Source #
Methods tupConcat :: Tup2 a -> Tup7 a -> Tup9 a Source #
TupConcat Tup1 Tup8 Tup9 Source #
Methods tupConcat :: Tup1 a -> Tup8 a -> Tup9 a Source #
TupConcat Tup0 Tup9 Tup9 Source #
Methods tupConcat :: Tup0 a -> Tup9 a -> Tup9 a Source #
Bounded a => Bounded (Tup9 a) Source #
Methods minBound :: Tup9 a # maxBound :: Tup9 a #
Eq a => Eq (Tup9 a) Source #
Methods (==) :: Tup9 a -> Tup9 a -> Bool # (/=) :: Tup9 a -> Tup9 a -> Bool #
Fractional a => Fractional (Tup9 a) Source #
Methods (/) :: Tup9 a -> Tup9 a -> Tup9 a # recip :: Tup9 a -> Tup9 a # fromRational :: Rational -> Tup9 a #
Num a => Num (Tup9 a) Source #
Methods (+) :: Tup9 a -> Tup9 a -> Tup9 a # (-) :: Tup9 a -> Tup9 a -> Tup9 a # (*) :: Tup9 a -> Tup9 a -> Tup9 a # negate :: Tup9 a -> Tup9 a # abs :: Tup9 a -> Tup9 a # signum :: Tup9 a -> Tup9 a # fromInteger :: Integer -> Tup9 a #
Ord a => Ord (Tup9 a) Source #
Methods compare :: Tup9 a -> Tup9 a -> Ordering # (<) :: Tup9 a -> Tup9 a -> Bool # (<=) :: Tup9 a -> Tup9 a -> Bool # (>) :: Tup9 a -> Tup9 a -> Bool # (>=) :: Tup9 a -> Tup9 a -> Bool # max :: Tup9 a -> Tup9 a -> Tup9 a # min :: Tup9 a -> Tup9 a -> Tup9 a #
Read a => Read (Tup9 a) Source #
Methods readsPrec :: Int -> ReadS (Tup9 a) # readList :: ReadS [Tup9 a] # readPrec :: ReadPrec (Tup9 a) # readListPrec :: ReadPrec [Tup9 a] #
Show a => Show (Tup9 a) Source #
Methods showsPrec :: Int -> Tup9 a -> ShowS # show :: Tup9 a -> String # showList :: [Tup9 a] -> ShowS #
Monoid a => Monoid (Tup9 a) Source #
Methods mempty :: Tup9 a # mappend :: Tup9 a -> Tup9 a -> Tup9 a # mconcat :: [Tup9 a] -> Tup9 a #
Storable a => Storable (Tup9 a) Source #
Methods sizeOf :: Tup9 a -> Int # alignment :: Tup9 a -> Int # peekElemOff :: Ptr (Tup9 a) -> Int -> IO (Tup9 a) # pokeElemOff :: Ptr (Tup9 a) -> Int -> Tup9 a -> IO () # peekByteOff :: Ptr b -> Int -> IO (Tup9 a) # pokeByteOff :: Ptr b -> Int -> Tup9 a -> IO () # peek :: Ptr (Tup9 a) -> IO (Tup9 a) # poke :: Ptr (Tup9 a) -> Tup9 a -> IO () #

"tupping"

tupTup :: Applicative f => f a -> f a -> f (Tup2 a) Source #

tupTup3 :: Applicative f => f a -> f a -> f a -> f (Tup3 a) Source #

tupTup4 :: Applicative f => f a -> f a -> f a -> f a -> f (Tup4 a) Source #

tupTup5 :: Applicative f => f a -> f a -> f a -> f a -> f a -> f (Tup5 a) Source #

data type declarations

"tupping"

instances