Data.Functor.Contravariant.Compat

This is >$ with its arguments flipped.

This is an infix version of contramap with the arguments flipped.

This is an infix alias for contramap.

Compare using compare.

Check for equivalence with ==.

Note: The instances for Double and Float violate reflexivity for NaN.

If f is both Functor and Contravariant 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 ≡ phantom
contramap f ≡ phantom

Defines a total ordering on a type as per compare.

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

The class of contravariant functors.

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

As an example, consider the type of predicate functions a -> Bool. One such predicate might be negative 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 values to integers. For instance, we can use the negative 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 :: (a' -> a) -> (Predicate a -> Predicate a')
  contramap f (Predicate p) = Predicate (p . f)
                                         |   `- First, map the input...
                                         `----- then apply the predicate.

overdrawn :: Predicate Person
overdrawn = contramap personBankBalance negative

Any instance should be subject to the following laws:

Identity

contramap id = id

Composition

contramap (g . f) = contramap f . contramap g

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

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

If

getEquivalence f a b

and

getEquivalence f b c

are both

True

then so is

getEquivalence f a c

.

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

Dual function arrows.