Numeric.Tuple

This module defines a set of tuple data types to substitute normal Haskell tuples. The reason is that Monoid instances of normal tuples are lazy, which makes folds with arithmetic operations leak memory. Semigroup and Monoid instances of tuples in this module are strict in all their arguments.

Using tuple types defined here together with Numeric.Semigroup.foldMap', one can combine multiple monoidal fold structures in a single pass over a foldable container:

> foldMap' (T3 <$> Max <*> Sum <*> Min) $ take 100000000 ([1..] :: [Int])

The example above runs in constant space, which would not happen with normal GHC tuples due to strictness properties of their mappend implementations (tuple arguments are not enforced).

Documentation

data T0

Constructors

T0

Instances

Bounded T0

Methods

minBound :: T0

maxBound :: T0

Eq T0

Methods

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

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

Data T0

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> T0 -> c T0

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c T0

toConstr :: T0 -> Constr

dataTypeOf :: T0 -> DataType

dataCast1 :: Typeable (* -> *) t => (forall d. Data d => c (t d)) -> Maybe (c T0)

dataCast2 :: Typeable (* -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c T0)

gmapT :: (forall b. Data b => b -> b) -> T0 -> T0

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> T0 -> r

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> T0 -> r

gmapQ :: (forall d. Data d => d -> u) -> T0 -> [u]

gmapQi :: Int -> (forall d. Data d => d -> u) -> T0 -> u

gmapM :: Monad m => (forall d. Data d => d -> m d) -> T0 -> m T0

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> T0 -> m T0

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> T0 -> m T0

Ord T0

Methods

compare :: T0 -> T0 -> Ordering

(<) :: T0 -> T0 -> Bool

(<=) :: T0 -> T0 -> Bool

(>) :: T0 -> T0 -> Bool

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

max :: T0 -> T0 -> T0

min :: T0 -> T0 -> T0

Read T0

Methods

readsPrec :: Int -> ReadS T0

readList :: ReadS [T0]

readPrec :: ReadPrec T0

readListPrec :: ReadPrec [T0]

Show T0

Methods

showsPrec :: Int -> T0 -> ShowS

show :: T0 -> String

showList :: [T0] -> ShowS

Generic T0

Associated Types

type Rep T0 :: * -> *

Methods

from :: T0 -> Rep T0 x

to :: Rep T0 x -> T0

Semigroup T0

Methods

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

sconcat :: NonEmpty T0 -> T0

stimes :: Integral b => b -> T0 -> T0

Monoid T0

Methods

mempty :: T0

mappend :: T0 -> T0 -> T0

mconcat :: [T0] -> T0

AsTuple () T0

Methods

toTuple :: () -> T0

fromTuple :: T0 -> ()

type Rep T0

type Rep T0 = D1 (MetaData "T0" "Numeric.Tuple" "easytensor-0.4.0.0-Fjq1YCsNiDYFELhVj4IBRg" False) (C1 (MetaCons "T0" PrefixI False) U1)

newtype T1 a

Constructors

T1 a

Instances

Monad T1

Methods

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

(>>) :: T1 a -> T1 b -> T1 b

return :: a -> T1 a

fail :: String -> T1 a

Functor T1

Methods

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

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

Applicative T1

Methods

pure :: a -> T1 a

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

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

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

Foldable T1

Methods

fold :: Monoid m => T1 m -> m

foldMap :: Monoid m => (a -> m) -> T1 a -> m

foldr :: (a -> b -> b) -> b -> T1 a -> b

foldr' :: (a -> b -> b) -> b -> T1 a -> b

foldl :: (b -> a -> b) -> b -> T1 a -> b

foldl' :: (b -> a -> b) -> b -> T1 a -> b

foldr1 :: (a -> a -> a) -> T1 a -> a

foldl1 :: (a -> a -> a) -> T1 a -> a

toList :: T1 a -> [a]

null :: T1 a -> Bool

length :: T1 a -> Int

elem :: Eq a => a -> T1 a -> Bool

maximum :: Ord a => T1 a -> a

minimum :: Ord a => T1 a -> a

sum :: Num a => T1 a -> a

product :: Num a => T1 a -> a

Traversable T1

Methods

traverse :: Applicative f => (a -> f b) -> T1 a -> f (T1 b)

sequenceA :: Applicative f => T1 (f a) -> f (T1 a)

mapM :: Monad m => (a -> m b) -> T1 a -> m (T1 b)

sequence :: Monad m => T1 (m a) -> m (T1 a)

Generic1 T1

Associated Types

type Rep1 (T1 :: * -> *) :: * -> *

Methods

from1 :: T1 a -> Rep1 T1 a

to1 :: Rep1 T1 a -> T1 a

Bounded a => Bounded (T1 a)

Methods

minBound :: T1 a

maxBound :: T1 a

Eq a => Eq (T1 a)

Methods

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

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

Data a => Data (T1 a)

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> T1 a -> c (T1 a)

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (T1 a)

toConstr :: T1 a -> Constr

dataTypeOf :: T1 a -> DataType

dataCast1 :: Typeable (* -> *) t => (forall d. Data d => c (t d)) -> Maybe (c (T1 a))

dataCast2 :: Typeable (* -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (T1 a))

gmapT :: (forall b. Data b => b -> b) -> T1 a -> T1 a

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> T1 a -> r

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> T1 a -> r

gmapQ :: (forall d. Data d => d -> u) -> T1 a -> [u]

gmapQi :: Int -> (forall d. Data d => d -> u) -> T1 a -> u

gmapM :: Monad m => (forall d. Data d => d -> m d) -> T1 a -> m (T1 a)

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> T1 a -> m (T1 a)

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> T1 a -> m (T1 a)

Ord a => Ord (T1 a)

Methods

compare :: T1 a -> T1 a -> Ordering

(<) :: T1 a -> T1 a -> Bool

(<=) :: T1 a -> T1 a -> Bool

(>) :: T1 a -> T1 a -> Bool

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

max :: T1 a -> T1 a -> T1 a

min :: T1 a -> T1 a -> T1 a

Read a => Read (T1 a)

Methods

readsPrec :: Int -> ReadS (T1 a)

readList :: ReadS [T1 a]

readPrec :: ReadPrec (T1 a)

readListPrec :: ReadPrec [T1 a]

Show a => Show (T1 a)

Methods

showsPrec :: Int -> T1 a -> ShowS

show :: T1 a -> String

showList :: [T1 a] -> ShowS

Generic (T1 a)

Associated Types

type Rep (T1 a) :: * -> *

Methods

from :: T1 a -> Rep (T1 a) x

to :: Rep (T1 a) x -> T1 a

Semigroup a => Semigroup (T1 a)

Methods

(<>) :: T1 a -> T1 a -> T1 a

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

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

Monoid a => Monoid (T1 a)

Methods

mempty :: T1 a

mappend :: T1 a -> T1 a -> T1 a

mconcat :: [T1 a] -> T1 a

type Rep1 T1

type Rep1 T1 = D1 (MetaData "T1" "Numeric.Tuple" "easytensor-0.4.0.0-Fjq1YCsNiDYFELhVj4IBRg" True) (C1 (MetaCons "T1" PrefixI False) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) Par1))

type Rep (T1 a)

type Rep (T1 a) = D1 (MetaData "T1" "Numeric.Tuple" "easytensor-0.4.0.0-Fjq1YCsNiDYFELhVj4IBRg" True) (C1 (MetaCons "T1" PrefixI False) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 a)))

data T2 a b

Constructors

T2 a b

Instances

Bifunctor T2

Methods

bimap :: (a -> b) -> (c -> d) -> T2 a c -> T2 b d

first :: (a -> b) -> T2 a c -> T2 b c

second :: (b -> c) -> T2 a b -> T2 a c

Monoid a => Monad (T2 a)

Methods

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

(>>) :: T2 a a -> T2 a b -> T2 a b

return :: a -> T2 a a

fail :: String -> T2 a a

Functor (T2 a)

Methods

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

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

Monoid a => Applicative (T2 a)

Methods

pure :: a -> T2 a a

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

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

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

Foldable (T2 a)

Methods

fold :: Monoid m => T2 a m -> m

foldMap :: Monoid m => (a -> m) -> T2 a a -> m

foldr :: (a -> b -> b) -> b -> T2 a a -> b

foldr' :: (a -> b -> b) -> b -> T2 a a -> b

foldl :: (b -> a -> b) -> b -> T2 a a -> b

foldl' :: (b -> a -> b) -> b -> T2 a a -> b

foldr1 :: (a -> a -> a) -> T2 a a -> a

foldl1 :: (a -> a -> a) -> T2 a a -> a

toList :: T2 a a -> [a]

null :: T2 a a -> Bool

length :: T2 a a -> Int

elem :: Eq a => a -> T2 a a -> Bool

maximum :: Ord a => T2 a a -> a

minimum :: Ord a => T2 a a -> a

sum :: Num a => T2 a a -> a

product :: Num a => T2 a a -> a

Traversable (T2 a)

Methods

traverse :: Applicative f => (a -> f b) -> T2 a a -> f (T2 a b)

sequenceA :: Applicative f => T2 a (f a) -> f (T2 a a)

mapM :: Monad m => (a -> m b) -> T2 a a -> m (T2 a b)

sequence :: Monad m => T2 a (m a) -> m (T2 a a)

Generic1 (T2 a)

Associated Types

type Rep1 (T2 a :: * -> *) :: * -> *

Methods

from1 :: T2 a a -> Rep1 (T2 a) a

to1 :: Rep1 (T2 a) a -> T2 a a

(Bounded a, Bounded b) => Bounded (T2 a b)

Methods

minBound :: T2 a b

maxBound :: T2 a b

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

Methods

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

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

(Data b, Data a) => Data (T2 a b)

Methods

gfoldl :: (forall d c. Data d => c (d -> c) -> d -> c c) -> (forall g. g -> c g) -> T2 a b -> c (T2 a b)

gunfold :: (forall c r. Data c => c (c -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (T2 a b)

toConstr :: T2 a b -> Constr

dataTypeOf :: T2 a b -> DataType

dataCast1 :: Typeable (* -> *) t => (forall d. Data d => c (t d)) -> Maybe (c (T2 a b))

dataCast2 :: Typeable (* -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (T2 a b))

gmapT :: (forall c. Data c => c -> c) -> T2 a b -> T2 a b

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> T2 a b -> r

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> T2 a b -> r

gmapQ :: (forall d. Data d => d -> u) -> T2 a b -> [u]

gmapQi :: Int -> (forall d. Data d => d -> u) -> T2 a b -> u

gmapM :: Monad m => (forall d. Data d => d -> m d) -> T2 a b -> m (T2 a b)

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> T2 a b -> m (T2 a b)

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> T2 a b -> m (T2 a b)

(Ord b, Ord a) => Ord (T2 a b)

Methods

compare :: T2 a b -> T2 a b -> Ordering

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

(<=) :: T2 a b -> T2 a b -> Bool

(>) :: T2 a b -> T2 a b -> Bool

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

max :: T2 a b -> T2 a b -> T2 a b

min :: T2 a b -> T2 a b -> T2 a b

(Read b, Read a) => Read (T2 a b)

Methods

readsPrec :: Int -> ReadS (T2 a b)

readList :: ReadS [T2 a b]

readPrec :: ReadPrec (T2 a b)

readListPrec :: ReadPrec [T2 a b]

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

Methods

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

show :: T2 a b -> String

showList :: [T2 a b] -> ShowS

Generic (T2 a b)

Associated Types

type Rep (T2 a b) :: * -> *

Methods

from :: T2 a b -> Rep (T2 a b) x

to :: Rep (T2 a b) x -> T2 a b

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

Methods

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

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

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

(Monoid a, Monoid b) => Monoid (T2 a b)

Methods

mempty :: T2 a b

mappend :: T2 a b -> T2 a b -> T2 a b

mconcat :: [T2 a b] -> T2 a b

AsTuple (a, b) (T2 a b)

Methods

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

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

type Rep1 (T2 a)

type Rep1 (T2 a) = D1 (MetaData "T2" "Numeric.Tuple" "easytensor-0.4.0.0-Fjq1YCsNiDYFELhVj4IBRg" False) (C1 (MetaCons "T2" PrefixI False) ((:*:) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 a)) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) Par1)))

type Rep (T2 a b)

type Rep (T2 a b) = D1 (MetaData "T2" "Numeric.Tuple" "easytensor-0.4.0.0-Fjq1YCsNiDYFELhVj4IBRg" False) (C1 (MetaCons "T2" PrefixI False) ((:*:) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 a)) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 b))))

data T3 a b c

Constructors

T3 a b c

Instances

Bifunctor (T3 a)

Methods

bimap :: (a -> b) -> (c -> d) -> T3 a a c -> T3 a b d

first :: (a -> b) -> T3 a a c -> T3 a b c

second :: (b -> c) -> T3 a a b -> T3 a a c

(Monoid a, Monoid b) => Monad (T3 a b)

Methods

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

(>>) :: T3 a b a -> T3 a b b -> T3 a b b

return :: a -> T3 a b a

fail :: String -> T3 a b a

Functor (T3 a b)

Methods

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

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

(Monoid a, Monoid b) => Applicative (T3 a b)

Methods

pure :: a -> T3 a b a

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

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

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

Foldable (T3 a b)

Methods

fold :: Monoid m => T3 a b m -> m

foldMap :: Monoid m => (a -> m) -> T3 a b a -> m

foldr :: (a -> b -> b) -> b -> T3 a b a -> b

foldr' :: (a -> b -> b) -> b -> T3 a b a -> b

foldl :: (b -> a -> b) -> b -> T3 a b a -> b

foldl' :: (b -> a -> b) -> b -> T3 a b a -> b

foldr1 :: (a -> a -> a) -> T3 a b a -> a

foldl1 :: (a -> a -> a) -> T3 a b a -> a

toList :: T3 a b a -> [a]

null :: T3 a b a -> Bool

length :: T3 a b a -> Int

elem :: Eq a => a -> T3 a b a -> Bool

maximum :: Ord a => T3 a b a -> a

minimum :: Ord a => T3 a b a -> a

sum :: Num a => T3 a b a -> a

product :: Num a => T3 a b a -> a

Traversable (T3 a b)

Methods

traverse :: Applicative f => (a -> f b) -> T3 a b a -> f (T3 a b b)

sequenceA :: Applicative f => T3 a b (f a) -> f (T3 a b a)

mapM :: Monad m => (a -> m b) -> T3 a b a -> m (T3 a b b)

sequence :: Monad m => T3 a b (m a) -> m (T3 a b a)

Generic1 (T3 a b)

Associated Types

type Rep1 (T3 a b :: * -> *) :: * -> *

Methods

from1 :: T3 a b a -> Rep1 (T3 a b) a

to1 :: Rep1 (T3 a b) a -> T3 a b a

(Bounded a, Bounded b, Bounded c) => Bounded (T3 a b c)

Methods

minBound :: T3 a b c

maxBound :: T3 a b c

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

Methods

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

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

(Data c, Data b, Data a) => Data (T3 a b c)

Methods

gfoldl :: (forall d e. Data d => c (d -> e) -> d -> c e) -> (forall g. g -> c g) -> T3 a b c -> c (T3 a b c)

gunfold :: (forall d r. Data d => c (d -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (T3 a b c)

toConstr :: T3 a b c -> Constr

dataTypeOf :: T3 a b c -> DataType

dataCast1 :: Typeable (* -> *) t => (forall d. Data d => c (t d)) -> Maybe (c (T3 a b c))

dataCast2 :: Typeable (* -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (T3 a b c))

gmapT :: (forall d. Data d => d -> d) -> T3 a b c -> T3 a b c

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> T3 a b c -> r

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> T3 a b c -> r

gmapQ :: (forall d. Data d => d -> u) -> T3 a b c -> [u]

gmapQi :: Int -> (forall d. Data d => d -> u) -> T3 a b c -> u

gmapM :: Monad m => (forall d. Data d => d -> m d) -> T3 a b c -> m (T3 a b c)

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> T3 a b c -> m (T3 a b c)

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> T3 a b c -> m (T3 a b c)

(Ord c, Ord b, Ord a) => Ord (T3 a b c)

Methods

compare :: T3 a b c -> T3 a b c -> Ordering

(<) :: T3 a b c -> T3 a b c -> Bool

(<=) :: T3 a b c -> T3 a b c -> Bool

(>) :: T3 a b c -> T3 a b c -> Bool

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

max :: T3 a b c -> T3 a b c -> T3 a b c

min :: T3 a b c -> T3 a b c -> T3 a b c

(Read c, Read b, Read a) => Read (T3 a b c)

Methods

readsPrec :: Int -> ReadS (T3 a b c)

readList :: ReadS [T3 a b c]

readPrec :: ReadPrec (T3 a b c)

readListPrec :: ReadPrec [T3 a b c]

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

Methods

showsPrec :: Int -> T3 a b c -> ShowS

show :: T3 a b c -> String

showList :: [T3 a b c] -> ShowS

Generic (T3 a b c)

Associated Types

type Rep (T3 a b c) :: * -> *

Methods

from :: T3 a b c -> Rep (T3 a b c) x

to :: Rep (T3 a b c) x -> T3 a b c

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

Methods

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

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

stimes :: Integral b => b -> T3 a b c -> T3 a b c

(Monoid a, Monoid b, Monoid c) => Monoid (T3 a b c)

Methods

mempty :: T3 a b c

mappend :: T3 a b c -> T3 a b c -> T3 a b c

mconcat :: [T3 a b c] -> T3 a b c

AsTuple (a, b, c) (T3 a b c)

Methods

toTuple :: (a, b, c) -> T3 a b c

fromTuple :: T3 a b c -> (a, b, c)

type Rep1 (T3 a b)

type Rep1 (T3 a b) = D1 (MetaData "T3" "Numeric.Tuple" "easytensor-0.4.0.0-Fjq1YCsNiDYFELhVj4IBRg" False) (C1 (MetaCons "T3" PrefixI False) ((:*:) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 a)) ((:*:) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 b)) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) Par1))))

type Rep (T3 a b c)

type Rep (T3 a b c) = D1 (MetaData "T3" "Numeric.Tuple" "easytensor-0.4.0.0-Fjq1YCsNiDYFELhVj4IBRg" False) (C1 (MetaCons "T3" PrefixI False) ((:*:) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 a)) ((:*:) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 b)) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 c)))))

data T4 a b c d

Constructors

T4 a b c d

Instances

Bifunctor (T4 a b)

Methods

bimap :: (a -> b) -> (c -> d) -> T4 a b a c -> T4 a b b d

first :: (a -> b) -> T4 a b a c -> T4 a b b c

second :: (b -> c) -> T4 a b a b -> T4 a b a c

(Monoid a, Monoid b, Monoid c) => Monad (T4 a b c)

Methods

(>>=) :: T4 a b c a -> (a -> T4 a b c b) -> T4 a b c b

(>>) :: T4 a b c a -> T4 a b c b -> T4 a b c b

return :: a -> T4 a b c a

fail :: String -> T4 a b c a

Functor (T4 a b c)

Methods

fmap :: (a -> b) -> T4 a b c a -> T4 a b c b

(<$) :: a -> T4 a b c b -> T4 a b c a

(Monoid a, Monoid b, Monoid c) => Applicative (T4 a b c)

Methods

pure :: a -> T4 a b c a

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

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

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

Foldable (T4 a b c)

Methods

fold :: Monoid m => T4 a b c m -> m

foldMap :: Monoid m => (a -> m) -> T4 a b c a -> m

foldr :: (a -> b -> b) -> b -> T4 a b c a -> b

foldr' :: (a -> b -> b) -> b -> T4 a b c a -> b

foldl :: (b -> a -> b) -> b -> T4 a b c a -> b

foldl' :: (b -> a -> b) -> b -> T4 a b c a -> b

foldr1 :: (a -> a -> a) -> T4 a b c a -> a

foldl1 :: (a -> a -> a) -> T4 a b c a -> a

toList :: T4 a b c a -> [a]

null :: T4 a b c a -> Bool

length :: T4 a b c a -> Int

elem :: Eq a => a -> T4 a b c a -> Bool

maximum :: Ord a => T4 a b c a -> a

minimum :: Ord a => T4 a b c a -> a

sum :: Num a => T4 a b c a -> a

product :: Num a => T4 a b c a -> a

Traversable (T4 a b c)

Methods

traverse :: Applicative f => (a -> f b) -> T4 a b c a -> f (T4 a b c b)

sequenceA :: Applicative f => T4 a b c (f a) -> f (T4 a b c a)

mapM :: Monad m => (a -> m b) -> T4 a b c a -> m (T4 a b c b)

sequence :: Monad m => T4 a b c (m a) -> m (T4 a b c a)

Generic1 (T4 a b c)

Associated Types

type Rep1 (T4 a b c :: * -> *) :: * -> *

Methods

from1 :: T4 a b c a -> Rep1 (T4 a b c) a

to1 :: Rep1 (T4 a b c) a -> T4 a b c a

(Bounded a, Bounded b, Bounded c, Bounded d) => Bounded (T4 a b c d)

Methods

minBound :: T4 a b c d

maxBound :: T4 a b c d

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

Methods

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

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

(Data d, Data c, Data b, Data a) => Data (T4 a b c d)

Methods

gfoldl :: (forall e f. Data e => c (e -> f) -> e -> c f) -> (forall g. g -> c g) -> T4 a b c d -> c (T4 a b c d)

gunfold :: (forall e r. Data e => c (e -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (T4 a b c d)

toConstr :: T4 a b c d -> Constr

dataTypeOf :: T4 a b c d -> DataType

dataCast1 :: Typeable (* -> *) t => (forall e. Data e => c (t e)) -> Maybe (c (T4 a b c d))

dataCast2 :: Typeable (* -> * -> *) t => (forall e f. (Data e, Data f) => c (t e f)) -> Maybe (c (T4 a b c d))

gmapT :: (forall e. Data e => e -> e) -> T4 a b c d -> T4 a b c d

gmapQl :: (r -> r' -> r) -> r -> (forall e. Data e => e -> r') -> T4 a b c d -> r

gmapQr :: (r' -> r -> r) -> r -> (forall e. Data e => e -> r') -> T4 a b c d -> r

gmapQ :: (forall e. Data e => e -> u) -> T4 a b c d -> [u]

gmapQi :: Int -> (forall e. Data e => e -> u) -> T4 a b c d -> u

gmapM :: Monad m => (forall e. Data e => e -> m e) -> T4 a b c d -> m (T4 a b c d)

gmapMp :: MonadPlus m => (forall e. Data e => e -> m e) -> T4 a b c d -> m (T4 a b c d)

gmapMo :: MonadPlus m => (forall e. Data e => e -> m e) -> T4 a b c d -> m (T4 a b c d)

(Ord d, Ord c, Ord b, Ord a) => Ord (T4 a b c d)

Methods

compare :: T4 a b c d -> T4 a b c d -> Ordering

(<) :: T4 a b c d -> T4 a b c d -> Bool

(<=) :: T4 a b c d -> T4 a b c d -> Bool

(>) :: T4 a b c d -> T4 a b c d -> Bool

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

max :: T4 a b c d -> T4 a b c d -> T4 a b c d

min :: T4 a b c d -> T4 a b c d -> T4 a b c d

(Read d, Read c, Read b, Read a) => Read (T4 a b c d)

Methods

readsPrec :: Int -> ReadS (T4 a b c d)

readList :: ReadS [T4 a b c d]

readPrec :: ReadPrec (T4 a b c d)

readListPrec :: ReadPrec [T4 a b c d]

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

Methods

showsPrec :: Int -> T4 a b c d -> ShowS

show :: T4 a b c d -> String

showList :: [T4 a b c d] -> ShowS

Generic (T4 a b c d)

Associated Types

type Rep (T4 a b c d) :: * -> *

Methods

from :: T4 a b c d -> Rep (T4 a b c d) x

to :: Rep (T4 a b c d) x -> T4 a b c d

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

Methods

(<>) :: T4 a b c d -> T4 a b c d -> T4 a b c d

sconcat :: NonEmpty (T4 a b c d) -> T4 a b c d

stimes :: Integral b => b -> T4 a b c d -> T4 a b c d

(Monoid a, Monoid b, Monoid c, Monoid d) => Monoid (T4 a b c d)

Methods

mempty :: T4 a b c d

mappend :: T4 a b c d -> T4 a b c d -> T4 a b c d

mconcat :: [T4 a b c d] -> T4 a b c d

AsTuple (a, b, c, d) (T4 a b c d)

Methods

toTuple :: (a, b, c, d) -> T4 a b c d

fromTuple :: T4 a b c d -> (a, b, c, d)

type Rep1 (T4 a b c)

type Rep1 (T4 a b c) = D1 (MetaData "T4" "Numeric.Tuple" "easytensor-0.4.0.0-Fjq1YCsNiDYFELhVj4IBRg" False) (C1 (MetaCons "T4" PrefixI False) ((:*:) ((:*:) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 a)) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 b))) ((:*:) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 c)) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) Par1))))

type Rep (T4 a b c d)

type Rep (T4 a b c d) = D1 (MetaData "T4" "Numeric.Tuple" "easytensor-0.4.0.0-Fjq1YCsNiDYFELhVj4IBRg" False) (C1 (MetaCons "T4" PrefixI False) ((:*:) ((:*:) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 a)) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 b))) ((:*:) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 c)) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 d)))))

data T5 a b c d e

Constructors

T5 a b c d e

Instances

Bifunctor (T5 a b c)

Methods

bimap :: (a -> b) -> (c -> d) -> T5 a b c a c -> T5 a b c b d

first :: (a -> b) -> T5 a b c a c -> T5 a b c b c

second :: (b -> c) -> T5 a b c a b -> T5 a b c a c

(Monoid a, Monoid b, Monoid c, Monoid d) => Monad (T5 a b c d)

Methods

(>>=) :: T5 a b c d a -> (a -> T5 a b c d b) -> T5 a b c d b

(>>) :: T5 a b c d a -> T5 a b c d b -> T5 a b c d b

return :: a -> T5 a b c d a

fail :: String -> T5 a b c d a

Functor (T5 a b c d)

Methods

fmap :: (a -> b) -> T5 a b c d a -> T5 a b c d b

(<$) :: a -> T5 a b c d b -> T5 a b c d a

(Monoid a, Monoid b, Monoid c, Monoid d) => Applicative (T5 a b c d)

Methods

pure :: a -> T5 a b c d a

(<*>) :: T5 a b c d (a -> b) -> T5 a b c d a -> T5 a b c d b

(*>) :: T5 a b c d a -> T5 a b c d b -> T5 a b c d b

(<*) :: T5 a b c d a -> T5 a b c d b -> T5 a b c d a

Foldable (T5 a b c e)

Methods

fold :: Monoid m => T5 a b c e m -> m

foldMap :: Monoid m => (a -> m) -> T5 a b c e a -> m

foldr :: (a -> b -> b) -> b -> T5 a b c e a -> b

foldr' :: (a -> b -> b) -> b -> T5 a b c e a -> b

foldl :: (b -> a -> b) -> b -> T5 a b c e a -> b

foldl' :: (b -> a -> b) -> b -> T5 a b c e a -> b

foldr1 :: (a -> a -> a) -> T5 a b c e a -> a

foldl1 :: (a -> a -> a) -> T5 a b c e a -> a

toList :: T5 a b c e a -> [a]

null :: T5 a b c e a -> Bool

length :: T5 a b c e a -> Int

elem :: Eq a => a -> T5 a b c e a -> Bool

maximum :: Ord a => T5 a b c e a -> a

minimum :: Ord a => T5 a b c e a -> a

sum :: Num a => T5 a b c e a -> a

product :: Num a => T5 a b c e a -> a

Traversable (T5 a b c d)

Methods

traverse :: Applicative f => (a -> f b) -> T5 a b c d a -> f (T5 a b c d b)

sequenceA :: Applicative f => T5 a b c d (f a) -> f (T5 a b c d a)

mapM :: Monad m => (a -> m b) -> T5 a b c d a -> m (T5 a b c d b)

sequence :: Monad m => T5 a b c d (m a) -> m (T5 a b c d a)

Generic1 (T5 a b c d)

Associated Types

type Rep1 (T5 a b c d :: * -> *) :: * -> *

Methods

from1 :: T5 a b c d a -> Rep1 (T5 a b c d) a

to1 :: Rep1 (T5 a b c d) a -> T5 a b c d a

(Bounded a, Bounded b, Bounded c, Bounded d, Bounded e) => Bounded (T5 a b c d e)

Methods

minBound :: T5 a b c d e

maxBound :: T5 a b c d e

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

Methods

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

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

(Data e, Data d, Data c, Data b, Data a) => Data (T5 a b c d e)

Methods

gfoldl :: (forall f g. Data f => c (f -> g) -> f -> c g) -> (forall g. g -> c g) -> T5 a b c d e -> c (T5 a b c d e)

gunfold :: (forall f r. Data f => c (f -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (T5 a b c d e)

toConstr :: T5 a b c d e -> Constr

dataTypeOf :: T5 a b c d e -> DataType

dataCast1 :: Typeable (* -> *) t => (forall f. Data f => c (t f)) -> Maybe (c (T5 a b c d e))

dataCast2 :: Typeable (* -> * -> *) t => (forall f g. (Data f, Data g) => c (t f g)) -> Maybe (c (T5 a b c d e))

gmapT :: (forall f. Data f => f -> f) -> T5 a b c d e -> T5 a b c d e

gmapQl :: (r -> r' -> r) -> r -> (forall f. Data f => f -> r') -> T5 a b c d e -> r

gmapQr :: (r' -> r -> r) -> r -> (forall f. Data f => f -> r') -> T5 a b c d e -> r

gmapQ :: (forall f. Data f => f -> u) -> T5 a b c d e -> [u]

gmapQi :: Int -> (forall f. Data f => f -> u) -> T5 a b c d e -> u

gmapM :: Monad m => (forall f. Data f => f -> m f) -> T5 a b c d e -> m (T5 a b c d e)

gmapMp :: MonadPlus m => (forall f. Data f => f -> m f) -> T5 a b c d e -> m (T5 a b c d e)

gmapMo :: MonadPlus m => (forall f. Data f => f -> m f) -> T5 a b c d e -> m (T5 a b c d e)

(Ord e, Ord d, Ord c, Ord b, Ord a) => Ord (T5 a b c d e)

Methods

compare :: T5 a b c d e -> T5 a b c d e -> Ordering

(<) :: T5 a b c d e -> T5 a b c d e -> Bool

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

(>) :: T5 a b c d e -> T5 a b c d e -> Bool

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

max :: T5 a b c d e -> T5 a b c d e -> T5 a b c d e

min :: T5 a b c d e -> T5 a b c d e -> T5 a b c d e

(Read e, Read d, Read c, Read b, Read a) => Read (T5 a b c d e)

Methods

readsPrec :: Int -> ReadS (T5 a b c d e)

readList :: ReadS [T5 a b c d e]

readPrec :: ReadPrec (T5 a b c d e)

readListPrec :: ReadPrec [T5 a b c d e]

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

Methods

showsPrec :: Int -> T5 a b c d e -> ShowS

show :: T5 a b c d e -> String

showList :: [T5 a b c d e] -> ShowS

Generic (T5 a b c d e)

Associated Types

type Rep (T5 a b c d e) :: * -> *

Methods

from :: T5 a b c d e -> Rep (T5 a b c d e) x

to :: Rep (T5 a b c d e) x -> T5 a b c d e

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

Methods

(<>) :: T5 a b c d e -> T5 a b c d e -> T5 a b c d e

sconcat :: NonEmpty (T5 a b c d e) -> T5 a b c d e

stimes :: Integral b => b -> T5 a b c d e -> T5 a b c d e

(Monoid a, Monoid b, Monoid c, Monoid d, Monoid e) => Monoid (T5 a b c d e)

Methods

mempty :: T5 a b c d e

mappend :: T5 a b c d e -> T5 a b c d e -> T5 a b c d e

mconcat :: [T5 a b c d e] -> T5 a b c d e

AsTuple (a, b, c, d, e) (T5 a b c d e)

Methods

toTuple :: (a, b, c, d, e) -> T5 a b c d e

fromTuple :: T5 a b c d e -> (a, b, c, d, e)

type Rep1 (T5 a b c d)

type Rep1 (T5 a b c d) = D1 (MetaData "T5" "Numeric.Tuple" "easytensor-0.4.0.0-Fjq1YCsNiDYFELhVj4IBRg" False) (C1 (MetaCons "T5" PrefixI False) ((:*:) ((:*:) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 a)) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 b))) ((:*:) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 c)) ((:*:) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 d)) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) Par1)))))

type Rep (T5 a b c d e)

type Rep (T5 a b c d e) = D1 (MetaData "T5" "Numeric.Tuple" "easytensor-0.4.0.0-Fjq1YCsNiDYFELhVj4IBRg" False) (C1 (MetaCons "T5" PrefixI False) ((:*:) ((:*:) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 a)) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 b))) ((:*:) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 c)) ((:*:) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 d)) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 e))))))

data T6 a b c d e f

Constructors

T6 a b c d e f

Instances

Bifunctor (T6 a b c d)

Methods

bimap :: (a -> b) -> (c -> d) -> T6 a b c d a c -> T6 a b c d b d

first :: (a -> b) -> T6 a b c d a c -> T6 a b c d b c

second :: (b -> c) -> T6 a b c d a b -> T6 a b c d a c

(Monoid a, Monoid b, Monoid c, Monoid d, Monoid e) => Monad (T6 a b c d e)

Methods

(>>=) :: T6 a b c d e a -> (a -> T6 a b c d e b) -> T6 a b c d e b

(>>) :: T6 a b c d e a -> T6 a b c d e b -> T6 a b c d e b

return :: a -> T6 a b c d e a

fail :: String -> T6 a b c d e a

Functor (T6 a b c d e)

Methods

fmap :: (a -> b) -> T6 a b c d e a -> T6 a b c d e b

(<$) :: a -> T6 a b c d e b -> T6 a b c d e a

(Monoid a, Monoid b, Monoid c, Monoid d, Monoid e) => Applicative (T6 a b c d e)

Methods

pure :: a -> T6 a b c d e a

(<*>) :: T6 a b c d e (a -> b) -> T6 a b c d e a -> T6 a b c d e b

(*>) :: T6 a b c d e a -> T6 a b c d e b -> T6 a b c d e b

(<*) :: T6 a b c d e a -> T6 a b c d e b -> T6 a b c d e a

Foldable (T6 a b c d e)

Methods

fold :: Monoid m => T6 a b c d e m -> m

foldMap :: Monoid m => (a -> m) -> T6 a b c d e a -> m

foldr :: (a -> b -> b) -> b -> T6 a b c d e a -> b

foldr' :: (a -> b -> b) -> b -> T6 a b c d e a -> b

foldl :: (b -> a -> b) -> b -> T6 a b c d e a -> b

foldl' :: (b -> a -> b) -> b -> T6 a b c d e a -> b

foldr1 :: (a -> a -> a) -> T6 a b c d e a -> a

foldl1 :: (a -> a -> a) -> T6 a b c d e a -> a

toList :: T6 a b c d e a -> [a]

null :: T6 a b c d e a -> Bool

length :: T6 a b c d e a -> Int

elem :: Eq a => a -> T6 a b c d e a -> Bool

maximum :: Ord a => T6 a b c d e a -> a

minimum :: Ord a => T6 a b c d e a -> a

sum :: Num a => T6 a b c d e a -> a

product :: Num a => T6 a b c d e a -> a

Traversable (T6 a b c d e)

Methods

traverse :: Applicative f => (a -> f b) -> T6 a b c d e a -> f (T6 a b c d e b)

sequenceA :: Applicative f => T6 a b c d e (f a) -> f (T6 a b c d e a)

mapM :: Monad m => (a -> m b) -> T6 a b c d e a -> m (T6 a b c d e b)

sequence :: Monad m => T6 a b c d e (m a) -> m (T6 a b c d e a)

Generic1 (T6 a b c d e)

Associated Types

type Rep1 (T6 a b c d e :: * -> *) :: * -> *

Methods

from1 :: T6 a b c d e a -> Rep1 (T6 a b c d e) a

to1 :: Rep1 (T6 a b c d e) a -> T6 a b c d e a

(Bounded a, Bounded b, Bounded c, Bounded d, Bounded e, Bounded f) => Bounded (T6 a b c d e f)

Methods

minBound :: T6 a b c d e f

maxBound :: T6 a b c d e f

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

Methods

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

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

(Data f, Data e, Data d, Data c, Data b, Data a) => Data (T6 a b c d e f)

Methods

gfoldl :: (forall g h. Data g => c (g -> h) -> g -> c h) -> (forall g. g -> c g) -> T6 a b c d e f -> c (T6 a b c d e f)

gunfold :: (forall g r. Data g => c (g -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (T6 a b c d e f)

toConstr :: T6 a b c d e f -> Constr

dataTypeOf :: T6 a b c d e f -> DataType

dataCast1 :: Typeable (* -> *) t => (forall g. Data g => c (t g)) -> Maybe (c (T6 a b c d e f))

dataCast2 :: Typeable (* -> * -> *) t => (forall g h. (Data g, Data h) => c (t g h)) -> Maybe (c (T6 a b c d e f))

gmapT :: (forall g. Data g => g -> g) -> T6 a b c d e f -> T6 a b c d e f

gmapQl :: (r -> r' -> r) -> r -> (forall g. Data g => g -> r') -> T6 a b c d e f -> r

gmapQr :: (r' -> r -> r) -> r -> (forall g. Data g => g -> r') -> T6 a b c d e f -> r

gmapQ :: (forall g. Data g => g -> u) -> T6 a b c d e f -> [u]

gmapQi :: Int -> (forall g. Data g => g -> u) -> T6 a b c d e f -> u

gmapM :: Monad m => (forall g. Data g => g -> m g) -> T6 a b c d e f -> m (T6 a b c d e f)

gmapMp :: MonadPlus m => (forall g. Data g => g -> m g) -> T6 a b c d e f -> m (T6 a b c d e f)

gmapMo :: MonadPlus m => (forall g. Data g => g -> m g) -> T6 a b c d e f -> m (T6 a b c d e f)

(Ord f, Ord e, Ord d, Ord c, Ord b, Ord a) => Ord (T6 a b c d e f)

Methods

compare :: T6 a b c d e f -> T6 a b c d e f -> Ordering

(<) :: T6 a b c d e f -> T6 a b c d e f -> Bool

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

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

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

max :: T6 a b c d e f -> T6 a b c d e f -> T6 a b c d e f

min :: T6 a b c d e f -> T6 a b c d e f -> T6 a b c d e f

(Read f, Read e, Read d, Read c, Read b, Read a) => Read (T6 a b c d e f)

Methods

readsPrec :: Int -> ReadS (T6 a b c d e f)

readList :: ReadS [T6 a b c d e f]

readPrec :: ReadPrec (T6 a b c d e f)

readListPrec :: ReadPrec [T6 a b c d e f]

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

Methods

showsPrec :: Int -> T6 a b c d e f -> ShowS

show :: T6 a b c d e f -> String

showList :: [T6 a b c d e f] -> ShowS

Generic (T6 a b c d e f)

Associated Types

type Rep (T6 a b c d e f) :: * -> *

Methods

from :: T6 a b c d e f -> Rep (T6 a b c d e f) x

to :: Rep (T6 a b c d e f) x -> T6 a b c d e f

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

Methods

(<>) :: T6 a b c d e f -> T6 a b c d e f -> T6 a b c d e f

sconcat :: NonEmpty (T6 a b c d e f) -> T6 a b c d e f

stimes :: Integral b => b -> T6 a b c d e f -> T6 a b c d e f

(Monoid a, Monoid b, Monoid c, Monoid d, Monoid e, Monoid f) => Monoid (T6 a b c d e f)

Methods

mempty :: T6 a b c d e f

mappend :: T6 a b c d e f -> T6 a b c d e f -> T6 a b c d e f

mconcat :: [T6 a b c d e f] -> T6 a b c d e f

AsTuple (a, b, c, d, e, f) (T6 a b c d e f)

Methods

toTuple :: (a, b, c, d, e, f) -> T6 a b c d e f

fromTuple :: T6 a b c d e f -> (a, b, c, d, e, f)

type Rep1 (T6 a b c d e)

type Rep1 (T6 a b c d e) = D1 (MetaData "T6" "Numeric.Tuple" "easytensor-0.4.0.0-Fjq1YCsNiDYFELhVj4IBRg" False) (C1 (MetaCons "T6" PrefixI False) ((:*:) ((:*:) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 a)) ((:*:) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 b)) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 c)))) ((:*:) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 d)) ((:*:) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 e)) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) Par1)))))

type Rep (T6 a b c d e f)

type Rep (T6 a b c d e f) = D1 (MetaData "T6" "Numeric.Tuple" "easytensor-0.4.0.0-Fjq1YCsNiDYFELhVj4IBRg" False) (C1 (MetaCons "T6" PrefixI False) ((:*:) ((:*:) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 a)) ((:*:) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 b)) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 c)))) ((:*:) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 d)) ((:*:) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 e)) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 f))))))

data T7 a b c d e f g

Constructors

T7 a b c d e f g

Instances

Bifunctor (T7 a b c d e)

Methods

bimap :: (a -> b) -> (c -> d) -> T7 a b c d e a c -> T7 a b c d e b d

first :: (a -> b) -> T7 a b c d e a c -> T7 a b c d e b c

second :: (b -> c) -> T7 a b c d e a b -> T7 a b c d e a c

(Monoid a, Monoid b, Monoid c, Monoid d, Monoid e, Monoid f) => Monad (T7 a b c d e f)

Methods

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

(>>) :: T7 a b c d e f a -> T7 a b c d e f b -> T7 a b c d e f b

return :: a -> T7 a b c d e f a

fail :: String -> T7 a b c d e f a

Functor (T7 a b c d e f)

Methods

fmap :: (a -> b) -> T7 a b c d e f a -> T7 a b c d e f b

(<$) :: a -> T7 a b c d e f b -> T7 a b c d e f a

(Monoid a, Monoid b, Monoid c, Monoid d, Monoid e, Monoid f) => Applicative (T7 a b c d e f)

Methods

pure :: a -> T7 a b c d e f a

(<*>) :: T7 a b c d e f (a -> b) -> T7 a b c d e f a -> T7 a b c d e f b

(*>) :: T7 a b c d e f a -> T7 a b c d e f b -> T7 a b c d e f b

(<*) :: T7 a b c d e f a -> T7 a b c d e f b -> T7 a b c d e f a

Foldable (T7 a b c d e f)

Methods

fold :: Monoid m => T7 a b c d e f m -> m

foldMap :: Monoid m => (a -> m) -> T7 a b c d e f a -> m

foldr :: (a -> b -> b) -> b -> T7 a b c d e f a -> b

foldr' :: (a -> b -> b) -> b -> T7 a b c d e f a -> b

foldl :: (b -> a -> b) -> b -> T7 a b c d e f a -> b

foldl' :: (b -> a -> b) -> b -> T7 a b c d e f a -> b

foldr1 :: (a -> a -> a) -> T7 a b c d e f a -> a

foldl1 :: (a -> a -> a) -> T7 a b c d e f a -> a

toList :: T7 a b c d e f a -> [a]

null :: T7 a b c d e f a -> Bool

length :: T7 a b c d e f a -> Int

elem :: Eq a => a -> T7 a b c d e f a -> Bool

maximum :: Ord a => T7 a b c d e f a -> a

minimum :: Ord a => T7 a b c d e f a -> a

sum :: Num a => T7 a b c d e f a -> a

product :: Num a => T7 a b c d e f a -> a

Traversable (T7 a b c d e f)

Methods

traverse :: Applicative f => (a -> f b) -> T7 a b c d e f a -> f (T7 a b c d e f b)

sequenceA :: Applicative f => T7 a b c d e f (f a) -> f (T7 a b c d e f a)

mapM :: Monad m => (a -> m b) -> T7 a b c d e f a -> m (T7 a b c d e f b)

sequence :: Monad m => T7 a b c d e f (m a) -> m (T7 a b c d e f a)

Generic1 (T7 a b c d e f)

Associated Types

type Rep1 (T7 a b c d e f :: * -> *) :: * -> *

Methods

from1 :: T7 a b c d e f a -> Rep1 (T7 a b c d e f) a

to1 :: Rep1 (T7 a b c d e f) a -> T7 a b c d e f a

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

Methods

minBound :: T7 a b c d e f g

maxBound :: T7 a b c d e f g

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

Methods

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

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

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

Methods

gfoldl :: (forall h i. Data h => c (h -> i) -> h -> c i) -> (forall h. h -> c h) -> T7 a b c d e f g -> c (T7 a b c d e f g)

gunfold :: (forall h r. Data h => c (h -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (T7 a b c d e f g)

toConstr :: T7 a b c d e f g -> Constr

dataTypeOf :: T7 a b c d e f g -> DataType

dataCast1 :: Typeable (* -> *) t => (forall h. Data h => c (t h)) -> Maybe (c (T7 a b c d e f g))

dataCast2 :: Typeable (* -> * -> *) t => (forall h i. (Data h, Data i) => c (t h i)) -> Maybe (c (T7 a b c d e f g))

gmapT :: (forall h. Data h => h -> h) -> T7 a b c d e f g -> T7 a b c d e f g

gmapQl :: (r -> r' -> r) -> r -> (forall h. Data h => h -> r') -> T7 a b c d e f g -> r

gmapQr :: (r' -> r -> r) -> r -> (forall h. Data h => h -> r') -> T7 a b c d e f g -> r

gmapQ :: (forall h. Data h => h -> u) -> T7 a b c d e f g -> [u]

gmapQi :: Int -> (forall h. Data h => h -> u) -> T7 a b c d e f g -> u

gmapM :: Monad m => (forall h. Data h => h -> m h) -> T7 a b c d e f g -> m (T7 a b c d e f g)

gmapMp :: MonadPlus m => (forall h. Data h => h -> m h) -> T7 a b c d e f g -> m (T7 a b c d e f g)

gmapMo :: MonadPlus m => (forall h. Data h => h -> m h) -> T7 a b c d e f g -> m (T7 a b c d e f g)

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

Methods

compare :: T7 a b c d e f g -> T7 a b c d e f g -> Ordering

(<) :: T7 a b c d e f g -> T7 a b c d e f g -> Bool

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

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

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

max :: T7 a b c d e f g -> T7 a b c d e f g -> T7 a b c d e f g

min :: T7 a b c d e f g -> T7 a b c d e f g -> T7 a b c d e f g

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

Methods

readsPrec :: Int -> ReadS (T7 a b c d e f g)

readList :: ReadS [T7 a b c d e f g]

readPrec :: ReadPrec (T7 a b c d e f g)

readListPrec :: ReadPrec [T7 a b c d e f g]

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

Methods

showsPrec :: Int -> T7 a b c d e f g -> ShowS

show :: T7 a b c d e f g -> String

showList :: [T7 a b c d e f g] -> ShowS

Generic (T7 a b c d e f g)

Associated Types

type Rep (T7 a b c d e f g) :: * -> *

Methods

from :: T7 a b c d e f g -> Rep (T7 a b c d e f g) x

to :: Rep (T7 a b c d e f g) x -> T7 a b c d e f g

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

Methods

(<>) :: T7 a b c d e f g -> T7 a b c d e f g -> T7 a b c d e f g

sconcat :: NonEmpty (T7 a b c d e f g) -> T7 a b c d e f g

stimes :: Integral b => b -> T7 a b c d e f g -> T7 a b c d e f g

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

Methods

mempty :: T7 a b c d e f g

mappend :: T7 a b c d e f g -> T7 a b c d e f g -> T7 a b c d e f g

mconcat :: [T7 a b c d e f g] -> T7 a b c d e f g

AsTuple (a, b, c, d, e, f, g) (T7 a b c d e f g)

Methods

toTuple :: (a, b, c, d, e, f, g) -> T7 a b c d e f g

fromTuple :: T7 a b c d e f g -> (a, b, c, d, e, f, g)

type Rep1 (T7 a b c d e f)

type Rep1 (T7 a b c d e f) = D1 (MetaData "T7" "Numeric.Tuple" "easytensor-0.4.0.0-Fjq1YCsNiDYFELhVj4IBRg" False) (C1 (MetaCons "T7" PrefixI False) ((:*:) ((:*:) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 a)) ((:*:) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 b)) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 c)))) ((:*:) ((:*:) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 d)) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 e))) ((:*:) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 f)) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) Par1)))))

type Rep (T7 a b c d e f g)

type Rep (T7 a b c d e f g) = D1 (MetaData "T7" "Numeric.Tuple" "easytensor-0.4.0.0-Fjq1YCsNiDYFELhVj4IBRg" False) (C1 (MetaCons "T7" PrefixI False) ((:*:) ((:*:) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 a)) ((:*:) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 b)) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 c)))) ((:*:) ((:*:) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 d)) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 e))) ((:*:) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 f)) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 g))))))

data T8 a b c d e f g h

Constructors

T8 a b c d e f g h

Instances

Bifunctor (T8 a b c d e f)

Methods

bimap :: (a -> b) -> (c -> d) -> T8 a b c d e f a c -> T8 a b c d e f b d

first :: (a -> b) -> T8 a b c d e f a c -> T8 a b c d e f b c

second :: (b -> c) -> T8 a b c d e f a b -> T8 a b c d e f a c

(Monoid a, Monoid b, Monoid c, Monoid d, Monoid e, Monoid f, Monoid g) => Monad (T8 a b c d e f g)

Methods

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

(>>) :: T8 a b c d e f g a -> T8 a b c d e f g b -> T8 a b c d e f g b

return :: a -> T8 a b c d e f g a

fail :: String -> T8 a b c d e f g a

Functor (T8 a b c d e f g)

Methods

fmap :: (a -> b) -> T8 a b c d e f g a -> T8 a b c d e f g b

(<$) :: a -> T8 a b c d e f g b -> T8 a b c d e f g a

(Monoid a, Monoid b, Monoid c, Monoid d, Monoid e, Monoid f, Monoid g) => Applicative (T8 a b c d e f g)

Methods

pure :: a -> T8 a b c d e f g a

(<*>) :: T8 a b c d e f g (a -> b) -> T8 a b c d e f g a -> T8 a b c d e f g b

(*>) :: T8 a b c d e f g a -> T8 a b c d e f g b -> T8 a b c d e f g b

(<*) :: T8 a b c d e f g a -> T8 a b c d e f g b -> T8 a b c d e f g a

Foldable (T8 a b c d e f g)

Methods

fold :: Monoid m => T8 a b c d e f g m -> m

foldMap :: Monoid m => (a -> m) -> T8 a b c d e f g a -> m

foldr :: (a -> b -> b) -> b -> T8 a b c d e f g a -> b

foldr' :: (a -> b -> b) -> b -> T8 a b c d e f g a -> b

foldl :: (b -> a -> b) -> b -> T8 a b c d e f g a -> b

foldl' :: (b -> a -> b) -> b -> T8 a b c d e f g a -> b

foldr1 :: (a -> a -> a) -> T8 a b c d e f g a -> a

foldl1 :: (a -> a -> a) -> T8 a b c d e f g a -> a

toList :: T8 a b c d e f g a -> [a]

null :: T8 a b c d e f g a -> Bool

length :: T8 a b c d e f g a -> Int

elem :: Eq a => a -> T8 a b c d e f g a -> Bool

maximum :: Ord a => T8 a b c d e f g a -> a

minimum :: Ord a => T8 a b c d e f g a -> a

sum :: Num a => T8 a b c d e f g a -> a

product :: Num a => T8 a b c d e f g a -> a

Traversable (T8 a b c d e f g)

Methods

traverse :: Applicative f => (a -> f b) -> T8 a b c d e f g a -> f (T8 a b c d e f g b)

sequenceA :: Applicative f => T8 a b c d e f g (f a) -> f (T8 a b c d e f g a)

mapM :: Monad m => (a -> m b) -> T8 a b c d e f g a -> m (T8 a b c d e f g b)

sequence :: Monad m => T8 a b c d e f g (m a) -> m (T8 a b c d e f g a)

Generic1 (T8 a b c d e f g)

Associated Types

type Rep1 (T8 a b c d e f g :: * -> *) :: * -> *

Methods

from1 :: T8 a b c d e f g a -> Rep1 (T8 a b c d e f g) a

to1 :: Rep1 (T8 a b c d e f g) a -> T8 a b c d e f g a

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

Methods

minBound :: T8 a b c d e f g h

maxBound :: T8 a b c d e f g h

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

Methods

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

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

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

Methods

gfoldl :: (forall i j. Data i => c (i -> j) -> i -> c j) -> (forall i. i -> c i) -> T8 a b c d e f g h -> c (T8 a b c d e f g h)

gunfold :: (forall i r. Data i => c (i -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (T8 a b c d e f g h)

toConstr :: T8 a b c d e f g h -> Constr

dataTypeOf :: T8 a b c d e f g h -> DataType

dataCast1 :: Typeable (* -> *) t => (forall i. Data i => c (t i)) -> Maybe (c (T8 a b c d e f g h))

dataCast2 :: Typeable (* -> * -> *) t => (forall i j. (Data i, Data j) => c (t i j)) -> Maybe (c (T8 a b c d e f g h))

gmapT :: (forall i. Data i => i -> i) -> T8 a b c d e f g h -> T8 a b c d e f g h

gmapQl :: (r -> r' -> r) -> r -> (forall i. Data i => i -> r') -> T8 a b c d e f g h -> r

gmapQr :: (r' -> r -> r) -> r -> (forall i. Data i => i -> r') -> T8 a b c d e f g h -> r

gmapQ :: (forall i. Data i => i -> u) -> T8 a b c d e f g h -> [u]

gmapQi :: Int -> (forall i. Data i => i -> u) -> T8 a b c d e f g h -> u

gmapM :: Monad m => (forall i. Data i => i -> m i) -> T8 a b c d e f g h -> m (T8 a b c d e f g h)

gmapMp :: MonadPlus m => (forall i. Data i => i -> m i) -> T8 a b c d e f g h -> m (T8 a b c d e f g h)

gmapMo :: MonadPlus m => (forall i. Data i => i -> m i) -> T8 a b c d e f g h -> m (T8 a b c d e f g h)

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

Methods

compare :: T8 a b c d e f g h -> T8 a b c d e f g h -> Ordering

(<) :: T8 a b c d e f g h -> T8 a b c d e f g h -> Bool

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

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

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

max :: T8 a b c d e f g h -> T8 a b c d e f g h -> T8 a b c d e f g h

min :: T8 a b c d e f g h -> T8 a b c d e f g h -> T8 a b c d e f g h

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

Methods

readsPrec :: Int -> ReadS (T8 a b c d e f g h)

readList :: ReadS [T8 a b c d e f g h]

readPrec :: ReadPrec (T8 a b c d e f g h)

readListPrec :: ReadPrec [T8 a b c d e f g h]

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

Methods

showsPrec :: Int -> T8 a b c d e f g h -> ShowS

show :: T8 a b c d e f g h -> String

showList :: [T8 a b c d e f g h] -> ShowS

Generic (T8 a b c d e f g h)

Associated Types

type Rep (T8 a b c d e f g h) :: * -> *

Methods

from :: T8 a b c d e f g h -> Rep (T8 a b c d e f g h) x

to :: Rep (T8 a b c d e f g h) x -> T8 a b c d e f g h

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

Methods

(<>) :: T8 a b c d e f g h -> T8 a b c d e f g h -> T8 a b c d e f g h

sconcat :: NonEmpty (T8 a b c d e f g h) -> T8 a b c d e f g h

stimes :: Integral b => b -> T8 a b c d e f g h -> T8 a b c d e f g h

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

Methods

mempty :: T8 a b c d e f g h

mappend :: T8 a b c d e f g h -> T8 a b c d e f g h -> T8 a b c d e f g h

mconcat :: [T8 a b c d e f g h] -> T8 a b c d e f g h

AsTuple (a, b, c, d, e, f, g, h) (T8 a b c d e f g h)

Methods

toTuple :: (a, b, c, d, e, f, g, h) -> T8 a b c d e f g h

fromTuple :: T8 a b c d e f g h -> (a, b, c, d, e, f, g, h)

type Rep1 (T8 a b c d e f g)

type Rep1 (T8 a b c d e f g) = D1 (MetaData "T8" "Numeric.Tuple" "easytensor-0.4.0.0-Fjq1YCsNiDYFELhVj4IBRg" False) (C1 (MetaCons "T8" PrefixI False) ((:*:) ((:*:) ((:*:) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 a)) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 b))) ((:*:) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 c)) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 d)))) ((:*:) ((:*:) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 e)) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 f))) ((:*:) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 g)) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) Par1)))))

type Rep (T8 a b c d e f g h)

type Rep (T8 a b c d e f g h) = D1 (MetaData "T8" "Numeric.Tuple" "easytensor-0.4.0.0-Fjq1YCsNiDYFELhVj4IBRg" False) (C1 (MetaCons "T8" PrefixI False) ((:*:) ((:*:) ((:*:) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 a)) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 b))) ((:*:) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 c)) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 d)))) ((:*:) ((:*:) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 e)) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 f))) ((:*:) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 g)) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 h))))))

data T9 a b c d e f g h i

Constructors

T9 a b c d e f g h i

Instances

Bifunctor (T9 a b c d e f g)

Methods

bimap :: (a -> b) -> (c -> d) -> T9 a b c d e f g a c -> T9 a b c d e f g b d

first :: (a -> b) -> T9 a b c d e f g a c -> T9 a b c d e f g b c

second :: (b -> c) -> T9 a b c d e f g a b -> T9 a b c d e f g a c

(Monoid a, Monoid b, Monoid c, Monoid d, Monoid e, Monoid f, Monoid g, Monoid h) => Monad (T9 a b c d e f g h)

Methods

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

(>>) :: T9 a b c d e f g h a -> T9 a b c d e f g h b -> T9 a b c d e f g h b

return :: a -> T9 a b c d e f g h a

fail :: String -> T9 a b c d e f g h a

Functor (T9 a b c d e f g h)

Methods

fmap :: (a -> b) -> T9 a b c d e f g h a -> T9 a b c d e f g h b

(<$) :: a -> T9 a b c d e f g h b -> T9 a b c d e f g h a

(Monoid a, Monoid b, Monoid c, Monoid d, Monoid e, Monoid f, Monoid g, Monoid h) => Applicative (T9 a b c d e f g h)

Methods

pure :: a -> T9 a b c d e f g h a

(<*>) :: T9 a b c d e f g h (a -> b) -> T9 a b c d e f g h a -> T9 a b c d e f g h b

(*>) :: T9 a b c d e f g h a -> T9 a b c d e f g h b -> T9 a b c d e f g h b

(<*) :: T9 a b c d e f g h a -> T9 a b c d e f g h b -> T9 a b c d e f g h a

Foldable (T9 a b c d e f g h)

Methods

fold :: Monoid m => T9 a b c d e f g h m -> m

foldMap :: Monoid m => (a -> m) -> T9 a b c d e f g h a -> m

foldr :: (a -> b -> b) -> b -> T9 a b c d e f g h a -> b

foldr' :: (a -> b -> b) -> b -> T9 a b c d e f g h a -> b

foldl :: (b -> a -> b) -> b -> T9 a b c d e f g h a -> b

foldl' :: (b -> a -> b) -> b -> T9 a b c d e f g h a -> b

foldr1 :: (a -> a -> a) -> T9 a b c d e f g h a -> a

foldl1 :: (a -> a -> a) -> T9 a b c d e f g h a -> a

toList :: T9 a b c d e f g h a -> [a]

null :: T9 a b c d e f g h a -> Bool

length :: T9 a b c d e f g h a -> Int

elem :: Eq a => a -> T9 a b c d e f g h a -> Bool

maximum :: Ord a => T9 a b c d e f g h a -> a

minimum :: Ord a => T9 a b c d e f g h a -> a

sum :: Num a => T9 a b c d e f g h a -> a

product :: Num a => T9 a b c d e f g h a -> a

Traversable (T9 a b c d e f g h)

Methods

traverse :: Applicative f => (a -> f b) -> T9 a b c d e f g h a -> f (T9 a b c d e f g h b)

sequenceA :: Applicative f => T9 a b c d e f g h (f a) -> f (T9 a b c d e f g h a)

mapM :: Monad m => (a -> m b) -> T9 a b c d e f g h a -> m (T9 a b c d e f g h b)

sequence :: Monad m => T9 a b c d e f g h (m a) -> m (T9 a b c d e f g h a)

Generic1 (T9 a b c d e f g h)

Associated Types

type Rep1 (T9 a b c d e f g h :: * -> *) :: * -> *

Methods

from1 :: T9 a b c d e f g h a -> Rep1 (T9 a b c d e f g h) a

to1 :: Rep1 (T9 a b c d e f g h) a -> T9 a b c d e f g h a

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

Methods

minBound :: T9 a b c d e f g h i

maxBound :: T9 a b c d e f g h i

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

Methods

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

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

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

Methods

gfoldl :: (forall j k. Data j => c (j -> k) -> j -> c k) -> (forall j. j -> c j) -> T9 a b c d e f g h i -> c (T9 a b c d e f g h i)

gunfold :: (forall j r. Data j => c (j -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (T9 a b c d e f g h i)

toConstr :: T9 a b c d e f g h i -> Constr

dataTypeOf :: T9 a b c d e f g h i -> DataType

dataCast1 :: Typeable (* -> *) t => (forall j. Data j => c (t j)) -> Maybe (c (T9 a b c d e f g h i))

dataCast2 :: Typeable (* -> * -> *) t => (forall j k. (Data j, Data k) => c (t j k)) -> Maybe (c (T9 a b c d e f g h i))

gmapT :: (forall j. Data j => j -> j) -> T9 a b c d e f g h i -> T9 a b c d e f g h i

gmapQl :: (r -> r' -> r) -> r -> (forall j. Data j => j -> r') -> T9 a b c d e f g h i -> r

gmapQr :: (r' -> r -> r) -> r -> (forall j. Data j => j -> r') -> T9 a b c d e f g h i -> r

gmapQ :: (forall j. Data j => j -> u) -> T9 a b c d e f g h i -> [u]

gmapQi :: Int -> (forall j. Data j => j -> u) -> T9 a b c d e f g h i -> u

gmapM :: Monad m => (forall j. Data j => j -> m j) -> T9 a b c d e f g h i -> m (T9 a b c d e f g h i)

gmapMp :: MonadPlus m => (forall j. Data j => j -> m j) -> T9 a b c d e f g h i -> m (T9 a b c d e f g h i)

gmapMo :: MonadPlus m => (forall j. Data j => j -> m j) -> T9 a b c d e f g h i -> m (T9 a b c d e f g h i)

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

Methods

compare :: T9 a b c d e f g h i -> T9 a b c d e f g h i -> Ordering

(<) :: T9 a b c d e f g h i -> T9 a b c d e f g h i -> Bool

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

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

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

max :: T9 a b c d e f g h i -> T9 a b c d e f g h i -> T9 a b c d e f g h i

min :: T9 a b c d e f g h i -> T9 a b c d e f g h i -> T9 a b c d e f g h i

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

Methods

readsPrec :: Int -> ReadS (T9 a b c d e f g h i)

readList :: ReadS [T9 a b c d e f g h i]

readPrec :: ReadPrec (T9 a b c d e f g h i)

readListPrec :: ReadPrec [T9 a b c d e f g h i]

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

Methods

showsPrec :: Int -> T9 a b c d e f g h i -> ShowS

show :: T9 a b c d e f g h i -> String

showList :: [T9 a b c d e f g h i] -> ShowS

Generic (T9 a b c d e f g h i)

Associated Types

type Rep (T9 a b c d e f g h i) :: * -> *

Methods

from :: T9 a b c d e f g h i -> Rep (T9 a b c d e f g h i) x

to :: Rep (T9 a b c d e f g h i) x -> T9 a b c d e f g h i

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

Methods

(<>) :: T9 a b c d e f g h i -> T9 a b c d e f g h i -> T9 a b c d e f g h i

sconcat :: NonEmpty (T9 a b c d e f g h i) -> T9 a b c d e f g h i

stimes :: Integral b => b -> T9 a b c d e f g h i -> T9 a b c d e f g h i

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

Methods

mempty :: T9 a b c d e f g h i

mappend :: T9 a b c d e f g h i -> T9 a b c d e f g h i -> T9 a b c d e f g h i

mconcat :: [T9 a b c d e f g h i] -> T9 a b c d e f g h i

AsTuple (a, b, c, d, e, f, g, h, i) (T9 a b c d e f g h i)

Methods

toTuple :: (a, b, c, d, e, f, g, h, i) -> T9 a b c d e f g h i

fromTuple :: T9 a b c d e f g h i -> (a, b, c, d, e, f, g, h, i)

type Rep1 (T9 a b c d e f g h)

type Rep1 (T9 a b c d e f g h) = D1 (MetaData "T9" "Numeric.Tuple" "easytensor-0.4.0.0-Fjq1YCsNiDYFELhVj4IBRg" False) (C1 (MetaCons "T9" PrefixI False) ((:*:) ((:*:) ((:*:) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 a)) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 b))) ((:*:) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 c)) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 d)))) ((:*:) ((:*:) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 e)) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 f))) ((:*:) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 g)) ((:*:) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 h)) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) Par1))))))

type Rep (T9 a b c d e f g h i)

type Rep (T9 a b c d e f g h i) = D1 (MetaData "T9" "Numeric.Tuple" "easytensor-0.4.0.0-Fjq1YCsNiDYFELhVj4IBRg" False) (C1 (MetaCons "T9" PrefixI False) ((:*:) ((:*:) ((:*:) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 a)) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 b))) ((:*:) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 c)) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 d)))) ((:*:) ((:*:) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 e)) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 f))) ((:*:) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 g)) ((:*:) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 h)) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 i)))))))

class AsTuple a b | a -> b, b -> a where

Minimal complete definition

toTuple, fromTuple

Methods

toTuple :: a -> b

fromTuple :: b -> a

Instances

AsTuple () T0

Methods

toTuple :: () -> T0

fromTuple :: T0 -> ()

AsTuple (a, b) (T2 a b)

Methods

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

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

AsTuple (a, b, c) (T3 a b c)

Methods

toTuple :: (a, b, c) -> T3 a b c

fromTuple :: T3 a b c -> (a, b, c)

AsTuple (a, b, c, d) (T4 a b c d)

Methods

toTuple :: (a, b, c, d) -> T4 a b c d

fromTuple :: T4 a b c d -> (a, b, c, d)

AsTuple (a, b, c, d, e) (T5 a b c d e)

Methods

toTuple :: (a, b, c, d, e) -> T5 a b c d e

fromTuple :: T5 a b c d e -> (a, b, c, d, e)

AsTuple (a, b, c, d, e, f) (T6 a b c d e f)

Methods

toTuple :: (a, b, c, d, e, f) -> T6 a b c d e f

fromTuple :: T6 a b c d e f -> (a, b, c, d, e, f)

AsTuple (a, b, c, d, e, f, g) (T7 a b c d e f g)

Methods

toTuple :: (a, b, c, d, e, f, g) -> T7 a b c d e f g

fromTuple :: T7 a b c d e f g -> (a, b, c, d, e, f, g)

AsTuple (a, b, c, d, e, f, g, h) (T8 a b c d e f g h)

Methods

toTuple :: (a, b, c, d, e, f, g, h) -> T8 a b c d e f g h

fromTuple :: T8 a b c d e f g h -> (a, b, c, d, e, f, g, h)

AsTuple (a, b, c, d, e, f, g, h, i) (T9 a b c d e f g h i)

Methods

toTuple :: (a, b, c, d, e, f, g, h, i) -> T9 a b c d e f g h i

fromTuple :: T9 a b c d e f g h i -> (a, b, c, d, e, f, g, h, i)

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

Map each element of the structure to a monoid, and combine the results.

This function differs from Data.Foldable.foldMap in that uses foldl' instead of foldr inside. This makes this function suitable for Monoids with strict mappend operation. For example,

foldMap' Sum $ take 1000000000 ([1..] :: [Int])

runs in constant memory, whereas normal foldMap would cause a memory leak there.