Data.Type.Product.Lifted

Type combinators for type-level lists, where we have many functors with a single index.

Documentation

data FProd fs :: k -> * where

Constructors

ØF :: FProd Ø a

(:<<) :: !(f a) -> !(FProd fs a) -> FProd (f :< fs) a infixr 5

Instances

Witness ØC ØC (FProd k (Ø (k -> *)) a)

An empty FProd is a no-op Witness.

Associated Types

type WitnessC (ØC :: Constraint) (ØC :: Constraint) (FProd k (Ø (k -> *)) a) :: Constraint

Methods

(\\) :: ØC => (ØC -> r) -> FProd k (Ø (k -> *)) a -> r

(Known k f a, Known k (FProd k fs) a) => Known k (FProd k ((:<) (k -> *) f fs)) a

Associated Types

type KnownC (FProd k ((:<) (k -> *) f fs)) (a :: FProd k ((:<) (k -> *) f fs) -> *) (a :: FProd k ((:<) (k -> *) f fs)) :: Constraint

Methods

known :: a a

Known k (FProd k (Ø (k -> *))) a

Associated Types

type KnownC (FProd k (Ø (k -> *))) (a :: FProd k (Ø (k -> *)) -> *) (a :: FProd k (Ø (k -> *))) :: Constraint

Methods

known :: a a

ListC ((<$>) Constraint (* -> *) Functor fs) => Functor (FProd * fs)

If all f in fs are Functors, then FProd fs is a Functor.

Methods

fmap :: (a -> b) -> FProd * fs a -> FProd * fs b

(<$) :: a -> FProd * fs b -> FProd * fs a

ListC ((<$>) Constraint (* -> *) Foldable fs) => Foldable (FProd * fs)

If all f in fs are Foldables, then FProd fs is a Foldable.

Methods

fold :: Monoid m => FProd * fs m -> m

foldMap :: Monoid m => (a -> m) -> FProd * fs a -> m

foldr :: (a -> b -> b) -> b -> FProd * fs a -> b

foldr' :: (a -> b -> b) -> b -> FProd * fs a -> b

foldl :: (b -> a -> b) -> b -> FProd * fs a -> b

foldl' :: (b -> a -> b) -> b -> FProd * fs a -> b

foldr1 :: (a -> a -> a) -> FProd * fs a -> a

foldl1 :: (a -> a -> a) -> FProd * fs a -> a

toList :: FProd * fs a -> [a]

null :: FProd * fs a -> Bool

length :: FProd * fs a -> Int

elem :: Eq a => a -> FProd * fs a -> Bool

maximum :: Ord a => FProd * fs a -> a

minimum :: Ord a => FProd * fs a -> a

sum :: Num a => FProd * fs a -> a

product :: Num a => FProd * fs a -> a

(ListC ((<$>) Constraint (* -> *) Functor fs), ListC ((<$>) Constraint (* -> *) Foldable fs), ListC ((<$>) Constraint (* -> *) Traversable fs)) => Traversable (FProd * fs)

If all f in fs are Traversables, then FProd fs is a Traversable.

Methods

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

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

mapM :: Monad m => (a -> m b) -> FProd * fs a -> m (FProd * fs b)

sequence :: Monad m => FProd * fs (m a) -> m (FProd * fs a)

(Witness p q (f a), Witness s t (FProd k fs a)) => Witness (p, s) (q, t) (FProd k ((:<) (k -> *) f fs) a)

A non-empty FProd is a Witness if both its head and tail are Witnesses.

Associated Types

type WitnessC ((p, s) :: Constraint) ((q, t) :: Constraint) (FProd k ((:<) (k -> *) f fs) a) :: Constraint

Methods

(\\) :: (p, s) => ((q, t) -> r) -> FProd k (((k -> *) :< f) fs) a -> r

type WitnessC ØC ØC (FProd k (Ø (k -> *)) a)

type WitnessC ØC ØC (FProd k (Ø (k -> *)) a) = ØC

type KnownC k (FProd k ((:<) (k -> *) f fs)) a

type KnownC k (FProd k ((:<) (k -> *) f fs)) a = (Known k f a, Known k (FProd k fs) a)

type KnownC k (FProd k (Ø (k -> *))) a

type KnownC k (FProd k (Ø (k -> *))) a = ØC

type WitnessC (p, s) (q, t) (FProd k ((:<) (k -> *) f fs) a)

type WitnessC (p, s) (q, t) (FProd k ((:<) (k -> *) f fs) a) = (Witness p q (f a), Witness s t (FProd k fs a))

pattern (:>>) :: forall k f a g. f a -> g a -> FProd k ((:) (k -> *) f ((:) (k -> *) g ([] (k -> *)))) a infix 6

Construct a two element FProd. Since the precedence of (:>>) is higher than (:<<), we can conveniently write lists like:

>>> a :<< b :>> c

Which is identical to:

>>> a :<< b :<< c :<< Ø

onlyF :: f a -> FProd '[f] a

Build a singleton FProd.

(>>:) :: FProd fs a -> f a -> FProd (fs >: f) a infixl 6

snoc function. insert an element at the end of the FProd.

headF :: FProd (f :< fs) a -> f a

tailF :: FProd (f :< fs) a -> FProd fs a

initF :: FProd (f :< fs) a -> FProd (Init' f fs) a

Get all but the last element of a non-empty FProd.

lastF :: FProd (f :< fs) a -> Last' f fs a

Get the last element of a non-empty FProd.

reverseF :: FProd fs a -> FProd (Reverse fs) a

Reverse the elements of an FProd.

appendF :: FProd fs a -> FProd gs a -> FProd (fs ++ gs) a

Append two FProds.

onHeadF :: (f a -> g a) -> FProd (f :< fs) a -> FProd (g :< fs) a

Map over the head of a non-empty FProd.

onTailF :: (FProd fs a -> FProd gs a) -> FProd (f :< fs) a -> FProd (f :< gs) a

Map over the tail of a non-empty FProd.

uncurryF :: (f a -> FProd fs a -> r) -> FProd (f :< fs) a -> r

curryF :: l ~ (f :< fs) => (FProd l a -> r) -> f a -> FProd fs a -> r

indexF :: Index fs f -> FProd fs a -> f a

imapF :: (forall f. Index fs f -> f a -> f b) -> FProd fs a -> FProd fs b

Map over all elements of an FProd with access to the element's index.

ifoldMapF :: Monoid m => (forall f. Index fs f -> f a -> m) -> FProd fs a -> m

Fold over all elements of an FProd with access to the element's index.

itraverseF :: Applicative g => (forall f. Index fs f -> f a -> g (f b)) -> FProd fs a -> g (FProd fs b)

Traverse over all elements of an FProd with access to the element's index.