Type constructor class for pair-like things. Here are some standard instance templates you can fill in. They're not defined in the general forms below, because they would lead to a lot of overlap.

    instance Applicative f => Pair f where
        pair = liftA2 (,)
    instance (Applicative h, Pair f) => Pair (h :. f) where
        pair = apPair
    instance (Functor g, Pair g, Pair f) => Pair (g :. f)
        where pair = ppPair
    instance (Arrow (~>), Unpair f, Pair g) => Pair (Arrw (~>) f g) where
        pair = arPair
    instance (Monoid_f h, Copair h) => Pair h where
        pair = copair

Also, if you have a type constructor that's a Functor and a Pair, here is a way to define '(*)' for Applicative:

    (<*>) = pairWith ($)

Minimum definitions for instances.

Unpairpable. Minimal instance definition: either (a) unpair or (b) both of fsts and snds. A standard template to substitute any Functor f. But watch out for effects!

     instance Functor f => Unpair f where {fsts = fmap fst; snds = fmap snd}

Dual to Unpair. Especially handy for contravariant functors (Cofunctor) . Use this template (filling in f) :

    instance Cofunctor f => Copair f where
      { cofsts = cofmap fst ; cosnds = cofmap snd }