Data.Type.Product.Dual

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.

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

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

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

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

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

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

(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.

(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.

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

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 = ØC

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 (:>>) :: 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.