The class of contravariant functors.

Whereas in Haskell, one can think of aFunctor as containing or producing values, a contravariant functor is a functor that can be thought of asconsuming values.

As an example, consider the type of predicate functionsa -> Bool. One such predicate might benegative x = x < 0, which classifies integers as to whether they are negative. However, given this predicate, we can re-use it in other situations, providing we have a way to map valuesto integers. For instance, we can use thenegative predicate on a person's bank balance to work out if they are currently overdrawn:

newtype Predicate a = Predicate { getPredicate :: a -> Bool }instance Contravariant Predicate where  contramap f (Predicate p) = Predicate (p . f)                                         |   `- First, map the input...                                         `----- then apply the predicate.overdrawn :: Predicate Personoverdrawn = contramap personBankBalance negative

Any instance should be subject to the following laws:

contramap id = idcontramap f . contramap g = contramap (g . f)

Note, that the second law follows from the free theorem of the type ofcontramap and the first law, so you need only check that the former condition holds.

Minimal complete definition

contramap

Methods

contramap :: (a -> b) -> f b -> f aSource#

(>$) :: b -> f b -> f ainfixl 4Source#

Iff is bothFunctor andContravariant then by the time you factor in the laws of each of those classes, it can't actually use its argument in any meaningful capacity.

This method is surprisingly useful. Where both instances exist and are lawful we have the following laws:

fmap f ≡phantomcontramap f ≡phantom

This is an infix alias forcontramap.

This is an infix version ofcontramap with the arguments flipped.

This is>$ with its arguments flipped.

Constructors

Defines a total ordering on a type as percompare.

This condition is not checked by the types. You must ensure that the supplied values are valid total orderings yourself.

Constructors

Compare usingcompare.

This data type represents an equivalence relation.

Equivalence relations are expected to satisfy three laws:

Reflexivity:

getEquivalence f a a = True

Symmetry:

getEquivalence f a b =getEquivalence f b a

Transitivity:

IfgetEquivalence f a b andgetEquivalence f b c are bothTrue then so isgetEquivalence f a c.

The types alone do not enforce these laws, so you'll have to check them yourself.

Constructors

Check for equivalence with==.

Note: The instances forDouble andFloat violate reflexivity forNaN.

Dual function arrows.

Constructors