Copyright  (C) 20072015 Edward Kmett 

License  BSDstyle (see the file LICENSE) 
Maintainer  Edward Kmett <ekmett@gmail.com> 
Stability  provisional 
Portability  portable 
Safe Haskell  Safe 
Language  Haskell98 
Contravariant
functors, sometimes referred to colloquially as Cofunctor
,
even though the dual of a Functor
is just a Functor
. As with Functor
the definition of Contravariant
for a given ADT is unambiguous.
Synopsis
 class Contravariant f where
 phantom :: (Functor f, Contravariant f) => f a > f b
 (>$<) :: Contravariant f => (a > b) > f b > f a
 (>$$<) :: Contravariant f => f b > (a > b) > f a
 ($<) :: Contravariant f => f b > b > f a
 newtype Predicate a = Predicate {
 getPredicate :: a > Bool
 newtype Comparison a = Comparison {
 getComparison :: a > a > Ordering
 defaultComparison :: Ord a => Comparison a
 newtype Equivalence a = Equivalence {
 getEquivalence :: a > a > Bool
 defaultEquivalence :: Eq a => Equivalence a
 comparisonEquivalence :: Comparison a > Equivalence a
 newtype Op a b = Op {
 getOp :: b > a
Contravariant Functors
class Contravariant f where Source #
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 reuse 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 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:
contramap id = id contramap f . contramap g = contramap (g . f)
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.
Instances
phantom :: (Functor f, Contravariant f) => f a > f b Source #
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
Operators
(>$<) :: Contravariant f => (a > b) > f b > f a infixl 4 Source #
This is an infix alias for contramap
.
(>$$<) :: Contravariant f => f b > (a > b) > f a infixl 4 Source #
This is an infix version of contramap
with the arguments flipped.
($<) :: Contravariant f => f b > b > f a infixl 4 Source #
This is >$
with its arguments flipped.
Predicates
Predicate  

Comparisons
newtype Comparison a Source #
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.
Comparison  

Instances
defaultComparison :: Ord a => Comparison a Source #
Compare using compare
.
Equivalence Relations
newtype Equivalence a Source #
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
and getEquivalence
f a b
are both getEquivalence
f b cTrue
then so is getEquivalence
f a c
The types alone do not enforce these laws, so you'll have to check them yourself.
Equivalence  

Instances
defaultEquivalence :: Eq a => Equivalence a Source #
comparisonEquivalence :: Comparison a > Equivalence a Source #
Dual arrows
Dual function arrows.
Instances
Contravariant (Op a) Source #  
Monoid r => Decidable (Op r) Source #  
Monoid r => Divisible (Op r) Source #  
Category Op Source #  
Floating a => Floating (Op a b) Source #  
Fractional a => Fractional (Op a b) Source #  
Num a => Num (Op a b) Source #  
Semigroup a => Semigroup (Op a b) Source #  
Monoid a => Monoid (Op a b) Source #  