Data.Functor.Prod

Generalize the standard two-functor Product to the product of n-functors. Intuitively, this means:

Product f g a ~~ (f a, g a)

Prod '[]        a ~~  Const () a
Prod '[f]       a ~~ (f a)
Prod '[f, g]    a ~~ (f a, g a)
Prod '[f, g, h] a ~~ (f a, g a, h a)
    ⋮

n-tuples of functors.

data Prod :: [* -> *] -> * -> * where

Product of n functors.

Constructors

Unit :: Prod '[] a

Cons :: f a -> Prod fs a -> Prod (f ': fs) a

Instances

(Functor f, Functor (Prod fs)) => Functor (Prod ((:) (* -> *) f fs))

Inductively defined instance: Functor (Prod (f ': fs)).

Methods

fmap :: (a -> b) -> Prod (((* -> *) ': f) fs) a -> Prod (((* -> *) ': f) fs) b

(<$) :: a -> Prod (((* -> *) ': f) fs) b -> Prod (((* -> *) ': f) fs) a

Functor (Prod ([] (* -> *)))

Inductively defined instance: Functor (Prod '[]).

Methods

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

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

(Applicative f, Applicative (Prod fs)) => Applicative (Prod ((:) (* -> *) f fs))

Inductively defined instance: Applicative (Prod (f ': fs)).

Methods

pure :: a -> Prod (((* -> *) ': f) fs) a

(<*>) :: Prod (((* -> *) ': f) fs) (a -> b) -> Prod (((* -> *) ': f) fs) a -> Prod (((* -> *) ': f) fs) b

liftA2 :: (a -> b -> c) -> Prod (((* -> *) ': f) fs) a -> Prod (((* -> *) ': f) fs) b -> Prod (((* -> *) ': f) fs) c

(*>) :: Prod (((* -> *) ': f) fs) a -> Prod (((* -> *) ': f) fs) b -> Prod (((* -> *) ': f) fs) b

(<*) :: Prod (((* -> *) ': f) fs) a -> Prod (((* -> *) ': f) fs) b -> Prod (((* -> *) ': f) fs) a

Applicative (Prod ([] (* -> *)))

Inductively defined instance: Applicative (Prod '[]).

Methods

pure :: a -> Prod [* -> *] a

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

liftA2 :: (a -> b -> c) -> Prod [* -> *] a -> Prod [* -> *] b -> Prod [* -> *] c

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

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

(Foldable f, Foldable (Prod fs)) => Foldable (Prod ((:) (* -> *) f fs))

Inductively defined instance: Foldable (Prod (f ': fs)).

Methods

fold :: Monoid m => Prod (((* -> *) ': f) fs) m -> m

foldMap :: Monoid m => (a -> m) -> Prod (((* -> *) ': f) fs) a -> m

foldr :: (a -> b -> b) -> b -> Prod (((* -> *) ': f) fs) a -> b

foldr' :: (a -> b -> b) -> b -> Prod (((* -> *) ': f) fs) a -> b

foldl :: (b -> a -> b) -> b -> Prod (((* -> *) ': f) fs) a -> b

foldl' :: (b -> a -> b) -> b -> Prod (((* -> *) ': f) fs) a -> b

foldr1 :: (a -> a -> a) -> Prod (((* -> *) ': f) fs) a -> a

foldl1 :: (a -> a -> a) -> Prod (((* -> *) ': f) fs) a -> a

toList :: Prod (((* -> *) ': f) fs) a -> [a]

null :: Prod (((* -> *) ': f) fs) a -> Bool

length :: Prod (((* -> *) ': f) fs) a -> Int

elem :: Eq a => a -> Prod (((* -> *) ': f) fs) a -> Bool

maximum :: Ord a => Prod (((* -> *) ': f) fs) a -> a

minimum :: Ord a => Prod (((* -> *) ': f) fs) a -> a

sum :: Num a => Prod (((* -> *) ': f) fs) a -> a

product :: Num a => Prod (((* -> *) ': f) fs) a -> a

Foldable (Prod ([] (* -> *)))

Inductively defined instance: Foldable (Prod '[]).

Methods

fold :: Monoid m => Prod [* -> *] m -> m

foldMap :: Monoid m => (a -> m) -> Prod [* -> *] a -> m

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

foldr' :: (a -> b -> b) -> b -> Prod [* -> *] a -> b

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

foldl' :: (b -> a -> b) -> b -> Prod [* -> *] a -> b

foldr1 :: (a -> a -> a) -> Prod [* -> *] a -> a

foldl1 :: (a -> a -> a) -> Prod [* -> *] a -> a

toList :: Prod [* -> *] a -> [a]

null :: Prod [* -> *] a -> Bool

length :: Prod [* -> *] a -> Int

elem :: Eq a => a -> Prod [* -> *] a -> Bool

maximum :: Ord a => Prod [* -> *] a -> a

minimum :: Ord a => Prod [* -> *] a -> a

sum :: Num a => Prod [* -> *] a -> a

product :: Num a => Prod [* -> *] a -> a

(Traversable f, Traversable (Prod fs)) => Traversable (Prod ((:) (* -> *) f fs))

Inductively defined instance: Traversable (Prod (f ': fs)).

Methods

traverse :: Applicative f => (a -> f b) -> Prod (((* -> *) ': f) fs) a -> f (Prod (((* -> *) ': f) fs) b)

sequenceA :: Applicative f => Prod (((* -> *) ': f) fs) (f a) -> f (Prod (((* -> *) ': f) fs) a)

mapM :: Monad m => (a -> m b) -> Prod (((* -> *) ': f) fs) a -> m (Prod (((* -> *) ': f) fs) b)

sequence :: Monad m => Prod (((* -> *) ': f) fs) (m a) -> m (Prod (((* -> *) ': f) fs) a)

Traversable (Prod ([] (* -> *)))

Inductively defined instance: Traversable (Prod '[]).

Methods

traverse :: Applicative f => (a -> f b) -> Prod [* -> *] a -> f (Prod [* -> *] b)

sequenceA :: Applicative f => Prod [* -> *] (f a) -> f (Prod [* -> *] a)

mapM :: Monad m => (a -> m b) -> Prod [* -> *] a -> m (Prod [* -> *] b)

sequence :: Monad m => Prod [* -> *] (m a) -> m (Prod [* -> *] a)

(Eq1 f, Eq1 (Prod fs)) => Eq1 (Prod ((:) (* -> *) f fs))

Inductively defined instance: Eq1 (Prod (f ': fs)).

Methods

liftEq :: (a -> b -> Bool) -> Prod (((* -> *) ': f) fs) a -> Prod (((* -> *) ': f) fs) b -> Bool

Eq1 (Prod ([] (* -> *)))

Inductively defined instance: Eq1 (Prod '[]).

Methods

liftEq :: (a -> b -> Bool) -> Prod [* -> *] a -> Prod [* -> *] b -> Bool

(Ord1 f, Ord1 (Prod fs)) => Ord1 (Prod ((:) (* -> *) f fs))

Inductively defined instance: Ord1 (Prod (f ': fs)).

Methods

liftCompare :: (a -> b -> Ordering) -> Prod (((* -> *) ': f) fs) a -> Prod (((* -> *) ': f) fs) b -> Ordering

Ord1 (Prod ([] (* -> *)))

Inductively defined instance: Ord1 (Prod '[]).

Methods

liftCompare :: (a -> b -> Ordering) -> Prod [* -> *] a -> Prod [* -> *] b -> Ordering

(Show1 f, Show1 (Prod fs)) => Show1 (Prod ((:) (* -> *) f fs))

Inductively defined instance: Show1 (Prod (f ': fs)).

Methods

liftShowsPrec :: (Int -> a -> ShowS) -> ([a] -> ShowS) -> Int -> Prod (((* -> *) ': f) fs) a -> ShowS

liftShowList :: (Int -> a -> ShowS) -> ([a] -> ShowS) -> [Prod (((* -> *) ': f) fs) a] -> ShowS

Show1 (Prod ([] (* -> *)))

Inductively defined instance: Show1 (Prod '[]).

Methods

liftShowsPrec :: (Int -> a -> ShowS) -> ([a] -> ShowS) -> Int -> Prod [* -> *] a -> ShowS

liftShowList :: (Int -> a -> ShowS) -> ([a] -> ShowS) -> [Prod [* -> *] a] -> ShowS

(Alternative f, Alternative (Prod fs)) => Alternative (Prod ((:) (* -> *) f fs))

Inductively defined instance: Alternative (Prod (f ': fs)).

Methods

empty :: Prod (((* -> *) ': f) fs) a

(<|>) :: Prod (((* -> *) ': f) fs) a -> Prod (((* -> *) ': f) fs) a -> Prod (((* -> *) ': f) fs) a

some :: Prod (((* -> *) ': f) fs) a -> Prod (((* -> *) ': f) fs) [a]

many :: Prod (((* -> *) ': f) fs) a -> Prod (((* -> *) ': f) fs) [a]

Alternative (Prod ([] (* -> *)))

Inductively defined instance: Alternative (Prod '[]).

Methods

empty :: Prod [* -> *] a

(<|>) :: Prod [* -> *] a -> Prod [* -> *] a -> Prod [* -> *] a

some :: Prod [* -> *] a -> Prod [* -> *] [a]

many :: Prod [* -> *] a -> Prod [* -> *] [a]

(Eq1 f, Eq a, Eq1 (Prod fs)) => Eq (Prod ((:) (* -> *) f fs) a)

Inductively defined instance: Eq (Prod (f ': fs)).

Methods

(==) :: Prod (((* -> *) ': f) fs) a -> Prod (((* -> *) ': f) fs) a -> Bool

(/=) :: Prod (((* -> *) ': f) fs) a -> Prod (((* -> *) ': f) fs) a -> Bool

Eq a => Eq (Prod ([] (* -> *)) a)

Inductively defined instance: Eq (Prod '[]).

Methods

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

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

(Ord1 f, Ord a, Ord1 (Prod fs)) => Ord (Prod ((:) (* -> *) f fs) a)

Inductively defined instance: Ord (Prod (f ': fs)).

Methods

compare :: Prod (((* -> *) ': f) fs) a -> Prod (((* -> *) ': f) fs) a -> Ordering

(<) :: Prod (((* -> *) ': f) fs) a -> Prod (((* -> *) ': f) fs) a -> Bool

(<=) :: Prod (((* -> *) ': f) fs) a -> Prod (((* -> *) ': f) fs) a -> Bool

(>) :: Prod (((* -> *) ': f) fs) a -> Prod (((* -> *) ': f) fs) a -> Bool

(>=) :: Prod (((* -> *) ': f) fs) a -> Prod (((* -> *) ': f) fs) a -> Bool

max :: Prod (((* -> *) ': f) fs) a -> Prod (((* -> *) ': f) fs) a -> Prod (((* -> *) ': f) fs) a

min :: Prod (((* -> *) ': f) fs) a -> Prod (((* -> *) ': f) fs) a -> Prod (((* -> *) ': f) fs) a

Ord a => Ord (Prod ([] (* -> *)) a)

Inductively defined instance: Ord (Prod '[]).

Methods

compare :: Prod [* -> *] a -> Prod [* -> *] a -> Ordering

(<) :: Prod [* -> *] a -> Prod [* -> *] a -> Bool

(<=) :: Prod [* -> *] a -> Prod [* -> *] a -> Bool

(>) :: Prod [* -> *] a -> Prod [* -> *] a -> Bool

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

max :: Prod [* -> *] a -> Prod [* -> *] a -> Prod [* -> *] a

min :: Prod [* -> *] a -> Prod [* -> *] a -> Prod [* -> *] a

(Show1 f, Show a, Show1 (Prod fs)) => Show (Prod ((:) (* -> *) f fs) a)

Inductively defined instance: Show (Prod (f ': fs)).

Methods

showsPrec :: Int -> Prod (((* -> *) ': f) fs) a -> ShowS

show :: Prod (((* -> *) ': f) fs) a -> String

showList :: [Prod (((* -> *) ': f) fs) a] -> ShowS

Show a => Show (Prod ([] (* -> *)) a)

Inductively defined instance: Show (Prod '[]).

Methods

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

show :: Prod [* -> *] a -> String

showList :: [Prod [* -> *] a] -> ShowS

zeroTuple :: Prod '[] a

The unit of the product.

oneTuple :: f a -> Prod '[f] a

Lift a functor to a 1-tuple.

fromProduct :: Product f g a -> Prod '[f, g] a

Conversion from a standard Product

toProduct :: Prod '[f, g] a -> Product f g a

Conversion to a standard Product

Flat product of functor products

prod :: Prod ls a -> Prod rs a -> Prod (ls ++ rs) a

Flat product of products.

Lifting functions

uncurryn :: Curried (Prod fs a -> r a) -> Prod fs a -> r a

Like uncurry but using Prod instead of pairs. Can be thought of as a family of functions:

uncurryn :: r a -> Prod '[] a
uncurryn :: (f a -> r a) -> Prod '[f] a
uncurryn :: (f a -> g a -> r a) -> Prod '[f, g] a
uncurryn :: (f a -> g a -> h a -> r a) -> Prod '[f, g, h] a
        ⋮

Type-level helpers

type family l ++ r :: [k] where ...

Type-level, poly-kinded, list-concatenation.

Equations

'[] ++ ys = ys

(x ': xs) ++ ys = x ': (xs ++ ys)

type family Curried t where ...

Prod '[f, g, h] a -> r is the type of the uncurried form of a function f a -> g a -> h a -> r. Curried moves from the former to the later. E.g.

Curried (Prod '[]  a    -> r) = r a
Curried (Prod '[f] a    -> r) = f a -> r a
Curried (Prod '[f, g] a -> r) = f a -> g a -> r a

Equations

Curried (Prod '[] a -> r a) = r a

Curried (Prod (f ': fs) a -> r a) = f a -> Curried (Prod fs a -> r a)