Data.Pair

Type constructor class for pair-like things. Generalizes zip. 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

Methods

pair

Source

:: PairTy f Form a pair-like value (generalizes zip)

Instances

Pair IO

Pair Endo

Pair Id

Pair ((->) u)

Monoid u => Pair ((,) u)

Monoid o => Pair (Const o)

(Pair f, Pair g) => Pair (f :*: g)

(Arrow ~>, Monoid_f (Flip ~> o)) => Pair (Flip ~> o)

(Arrow ~>, Unpair f, Pair g) => Pair (Arrw ~> f g)

apPair :: (Applicative h, Pair f) => PairTy (h :. f)

Source

Handy for Pair instances

ppPair :: (Functor g, Pair g, Pair f) => PairTy (g :. f)

Source

Handy for Pair instances

arPair :: (Arrow ~>, Unpair f, Pair g) => PairTy (Arrw ~> f g)

Source

Pairing of Arrw values. Warning: definition uses arr, so only use if your arrow has a working arr.

Unpairings

type UnpairTy f = forall a b. f (a, b) -> (f a, f b)

Source

Type of unpair method. Generalizes unzip.

class Unpair f where

Source

Dissectable as pairs. Minimal instance definition: either (a) unpair or (b) both of pfst and psnd. A standard template to substitute any Functor f. But watch out for effects!

   instance Functor f => Unpair f where {pfst = fmap fst; psnd = fmap snd}

Methods

unpair

Source

:: UnpairTy f

Deconstruct pair-like value

pfst

Source

::
=> f (a, b)
-> f a	First part of pair-like value

psnd

Source

::
=> f (a, b)
-> f b	Second part of pair-like value

Instances

Unpair []

Unpair Endo

Unpair Id

Unpair (Const a)

Dual unpairings

class Copair f where

Source

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

   instance Cofunctor f => Copair f where
     { cofst = cofmap fst ; cosnd = cofmap snd }

Methods

cofst

Source

::
=> f a
-> f (a, b)	Pair-like value from first part

cosnd

Source

::
=> f b
-> f (a, b)	Pair-like value from second part

Instances

Copair Endo

Copair (Const e)

(Copair f, Copair g) => Copair (f :*: g)

Arrow ~> => Copair (Flip ~> o)

(Functor h, Copair f) => Copair (h :. f)

copair :: (Copair f, Monoid_f f) => PairTy f

Source

Pairing of Copair values. Combines contribution of each.

Produced by Haddock version 2.3.0