Rebase.Data.Biapplicative

A bifunctor is a type constructor that takes two type arguments and is a functor in both arguments. That is, unlike with Functor, a type constructor such as Either does not need to be partially applied for a Bifunctor instance, and the methods in this class permit mapping functions over the Left value or the Right value, or both at the same time.

Formally, the class Bifunctor represents a bifunctor from Hask -> Hask.

Intuitively it is a bifunctor where both the first and second arguments are covariant.

The class definition of a Bifunctor p uses the QuantifiedConstraints language extension to quantify over the first type argument a in its context. The context requires that p a must be a Functor for all a. In other words a partially applied Bifunctor must be a Functor. This makes Functor a superclass of Bifunctor such that a function with a Bifunctor constraint may use fmap in its implementation. Functor has been a quantified superclass of Bifunctor since base-4.18.0.0.

You can define a Bifunctor by either defining bimap or by defining both first and second. The second method must agree with fmap:

second ≡ fmap

From this it follows that:

second id ≡ id

If you supply bimap, you should ensure that:

bimap id id ≡ id

If you supply first and second, ensure:

first id ≡ id
second id ≡ id

If you supply both, you should also ensure:

bimap f g ≡ first f . second g

These ensure by parametricity:

bimap  (f . g) (h . i) ≡ bimap f h . bimap g i
first  (f . g) ≡ first  f . first  g
second (f . g) ≡ second f . second g

Traverse a Traversable container in a Biapplicative.

traverseBia satisfies the following properties:

Pairing

traverseBia (,) t = (t, t)

Composition

traverseBia (Biff . bimap g h . f) = Biff . bimap (traverse g) (traverse h) . traverseBia f

traverseBia (Tannen . fmap f . g) = Tannen . fmap (traverseBia f) . traverse g

Naturality

 t . traverseBia f = traverseBia (t . f)

for every biapplicative transformation t.

A biapplicative transformation from a Biapplicative P to a Biapplicative Q is a function

t :: P a b -> Q a b

preserving the Biapplicative operations. That is,

• t (bipure x y) = bipure x y

• t (x <<*>> y) = t x <<*>> t y

Performance note

traverseBia is fairly efficient, and uses compiler rewrite rules to be even more efficient for a few important types like []. However, if performance is critical, you might consider writing a container-specific implementation.

Lift ternary functions

Perform all the Biapplicative actions in a Traversable container and produce a container with all the results.

sequenceBia = traverseBia id

A version of traverseBia that doesn't care how the traversal is done.

traverseBia = traverseBiaWith traverse