base-4.20.2.0: Core data structures and operations

Copyright | (C) 2007-2015 Edward Kmett
License | BSD-style (see the file LICENSE)
Maintainer | libraries@haskell.org
Stability | provisional
Portability | portable
Safe Haskell | Trustworthy
Language | Haskell2010

Data.Functor.Contravariant

Contents

- Contravariant Functors
- Operators
- Predicates
- Comparisons
- Equivalence Relations
- Dual arrows

Description

`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.

Since: base-4.12.0.0

Synopsis

- class Contravariant (f :: Type -> Type) where
  - contramap :: (a' -> a) -> f a -> f a'
  - (>$) :: b -> f b -> f a
- 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 :: Type -> Type) 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 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.

Minimal complete definition

contramap

Methods

contramap :: (a' -> a) -> f a -> f a' Source #

(>$) :: b -> f b -> f a infixl 4 Source #

Replace all locations in the output with the same value. The default definition is ``contramap` . `const``, but this may be overridden with a more efficient version.

#### Instances

Instances details

Contravariant Comparison Source # | A `Comparison` is a `Contravariant` `Functor`, because `contramap` can apply its function argument to each input of the comparison function.
Instance details Defined in Data.Functor.Contravariant Methods contramap :: (a' -> a) -> Comparison a -> Comparison a' Source # (>$) :: b -> Comparison b -> Comparison a Source #
Contravariant Equivalence Source # | Equivalence relations are `Contravariant`, because you can apply the contramapped function to each input to the equivalence relation.
Instance details Defined in Data.Functor.Contravariant Methods contramap :: (a' -> a) -> Equivalence a -> Equivalence a' Source # (>$) :: b -> Equivalence b -> Equivalence a Source #

Contravariant Predicate Source #

A `Predicate` is a `Contravariant` `Functor`, because `contramap` can apply its function argument to the input of the predicate.

Without newtypes ``contramap` f` equals precomposing with `f` (= `(. f)`).

    contramap :: (a' -> a) -> (Predicate a -> Predicate a')
    contramap f (Predicate g) = Predicate (g . f)

Instance details Defined in Data.Functor.Contravariant Methods contramap :: (a' -> a) -> Predicate a -> Predicate a' Source # (>$) :: b -> Predicate b -> Predicate a Source #
Contravariant (Op a) Source # |
Instance details Defined in Data.Functor.Contravariant Methods contramap :: (a' -> a0) -> Op a a0 -> Op a a' Source # (>$) :: b -> Op a b -> Op a a0 Source #
Contravariant (Proxy :: Type -> Type) Source # |
Instance details Defined in Data.Functor.Contravariant Methods contramap :: (a' -> a) -> Proxy a -> Proxy a' Source # (>$) :: b -> Proxy b -> Proxy a Source #
Contravariant (U1 :: Type -> Type) Source # |
Instance details Defined in Data.Functor.Contravariant Methods contramap :: (a' -> a) -> U1 a -> U1 a' Source # (>$) :: b -> U1 b -> U1 a Source #
Contravariant (V1 :: Type -> Type) Source # |
Instance details Defined in Data.Functor.Contravariant Methods contramap :: (a' -> a) -> V1 a -> V1 a' Source # (>$) :: b -> V1 b -> V1 a Source #
Contravariant (Const a :: Type -> Type) Source # |
Instance details Defined in Data.Functor.Contravariant Methods contramap :: (a' -> a0) -> Const a a0 -> Const a a' Source # (>$) :: b -> Const a b -> Const a a0 Source #
Contravariant f => Contravariant (Alt f) Source # |
Instance details Defined in Data.Functor.Contravariant Methods contramap :: (a' -> a) -> Alt f a -> Alt f a' Source # (>$) :: b -> Alt f b -> Alt f a Source #
Contravariant f => Contravariant (Rec1 f) Source # |
Instance details Defined in Data.Functor.Contravariant Methods contramap :: (a' -> a) -> Rec1 f a -> Rec1 f a' Source # (>$) :: b -> Rec1 f b -> Rec1 f a Source #
(Contravariant f, Contravariant g) => Contravariant (Product f g) Source # |
Instance details Defined in Data.Functor.Contravariant Methods contramap :: (a' -> a) -> Product f g a -> Product f g a' Source # (>$) :: b -> Product f g b -> Product f g a Source #
(Contravariant f, Contravariant g) => Contravariant (Sum f g) Source # |
Instance details Defined in Data.Functor.Contravariant Methods contramap :: (a' -> a) -> Sum f g a -> Sum f g a' Source # (>$) :: b -> Sum f g b -> Sum f g a Source #
(Contravariant f, Contravariant g) => Contravariant (f :*: g) Source # |
Instance details Defined in Data.Functor.Contravariant Methods contramap :: (a' -> a) -> (f :*: g) a -> (f :*: g) a' Source # (>$) :: b -> (f :*: g) b -> (f :*: g) a Source #
(Contravariant f, Contravariant g) => Contravariant (f :+: g) Source # |
Instance details Defined in Data.Functor.Contravariant Methods contramap :: (a' -> a) -> (f :+: g) a -> (f :+: g) a' Source # (>$) :: b -> (f :+: g) b -> (f :+: g) a Source #
Contravariant (K1 i c :: Type -> Type) Source # |
Instance details Defined in Data.Functor.Contravariant Methods contramap :: (a' -> a) -> K1 i c a -> K1 i c a' Source # (>$) :: b -> K1 i c b -> K1 i c a Source #
(Functor f, Contravariant g) => Contravariant (Compose f g) Source # |
Instance details Defined in Data.Functor.Contravariant Methods contramap :: (a' -> a) -> Compose f g a -> Compose f g a' Source # (>$) :: b -> Compose f g b -> Compose f g a Source #
(Functor f, Contravariant g) => Contravariant (f :.: g) Source # |
Instance details Defined in Data.Functor.Contravariant Methods contramap :: (a' -> a) -> (f :.: g) a -> (f :.: g) a' Source # (>$) :: b -> (f :.: g) b -> (f :.: g) a Source #
Contravariant f => Contravariant (M1 i c f) Source # |
Instance details Defined in Data.Functor.Contravariant Methods contramap :: (a' -> a) -> M1 i c f a -> M1 i c f a' Source # (>$) :: b -> M1 i c f b -> M1 i c f a Source #

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

newtype Predicate a Source #

Constructors

Predicate |

Fields

- getPredicate :: a -> Bool

#### Instances

Instances details

Contravariant Predicate Source #

A `Predicate` is a `Contravariant` `Functor`, because `contramap` can apply its function argument to the input of the predicate.

Without newtypes ``contramap` f` equals precomposing with `f` (= `(. f)`).

    contramap :: (a' -> a) -> (Predicate a -> Predicate a')
    contramap f (Predicate g) = Predicate (g . f)

Instance details Defined in Data.Functor.Contravariant Methods contramap :: (a' -> a) -> Predicate a -> Predicate a' Source # (>$) :: b -> Predicate b -> Predicate a Source #

Monoid (Predicate a) Source #

``mempty`` on predicates always returns `True`. Without newtypes this equals ``pure` True`.

    mempty :: Predicate a
    mempty = _ -> True

Instance details Defined in Data.Functor.Contravariant Methods mempty :: Predicate a Source # mappend :: Predicate a -> Predicate a -> Predicate a Source # mconcat :: [Predicate a] -> Predicate a Source #

Semigroup (Predicate a) Source #

`(`<>`)` on predicates uses logical conjunction `(`&&`)` on the results. Without newtypes this equals ``liftA2` (&&)`.

    (<>) :: Predicate a -> Predicate a -> Predicate a
    Predicate pred <> Predicate pred' = Predicate a ->
      pred a && pred' a

Instance details Defined in Data.Functor.Contravariant Methods (<>) :: Predicate a -> Predicate a -> Predicate a Source # sconcat :: NonEmpty (Predicate a) -> Predicate a Source # stimes :: Integral b => b -> Predicate a -> Predicate a Source #

# 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.

Constructors

Comparison |

Fields

- getComparison :: a -> a -> Ordering

#### Instances

Instances details

Contravariant Comparison Source # | A `Comparison` is a `Contravariant` `Functor`, because `contramap` can apply its function argument to each input of the comparison function.
Instance details Defined in Data.Functor.Contravariant Methods contramap :: (a' -> a) -> Comparison a -> Comparison a' Source # (>$) :: b -> Comparison b -> Comparison a Source #

Monoid (Comparison a) Source #

``mempty`` on comparisons always returns `EQ`. Without newtypes this equals ``pure` (`pure` EQ)`.

    mempty :: Comparison a
    mempty = Comparison _ _ -> EQ

Instance details Defined in Data.Functor.Contravariant Methods mempty :: Comparison a Source # mappend :: Comparison a -> Comparison a -> Comparison a Source # mconcat :: [Comparison a] -> Comparison a Source #

Semigroup (Comparison a) Source #

`(`<>`)` on comparisons combines results with `(`<>`) @Ordering`. Without newtypes this equals ``liftA2` (`liftA2` (`<>`))`.

    (<>) :: Comparison a -> Comparison a -> Comparison a
    Comparison cmp <> Comparison cmp' = Comparison a a' ->
      cmp a a' <> cmp a a'

Instance details Defined in Data.Functor.Contravariant Methods (<>) :: Comparison a -> Comparison a -> Comparison a Source # sconcat :: NonEmpty (Comparison a) -> Comparison a Source # stimes :: Integral b => b -> Comparison a -> Comparison a Source #

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 ``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.

Constructors

Equivalence |

Fields

- getEquivalence :: a -> a -> Bool

#### Instances

Instances details

Contravariant Equivalence Source # | Equivalence relations are `Contravariant`, because you can apply the contramapped function to each input to the equivalence relation.
Instance details Defined in Data.Functor.Contravariant Methods contramap :: (a' -> a) -> Equivalence a -> Equivalence a' Source # (>$) :: b -> Equivalence b -> Equivalence a Source #

Monoid (Equivalence a) Source #

``mempty`` on equivalences always returns `True`. Without newtypes this equals ``pure` (`pure` True)`.

    mempty :: Equivalence a
    mempty = Equivalence _ _ -> True

Instance details Defined in Data.Functor.Contravariant Methods mempty :: Equivalence a Source # mappend :: Equivalence a -> Equivalence a -> Equivalence a Source # mconcat :: [Equivalence a] -> Equivalence a Source #

Semigroup (Equivalence a) Source #

`(`<>`)` on equivalences uses logical conjunction `(`&&`)` on the results. Without newtypes this equals ``liftA2` (`liftA2` (&&))`.

    (<>) :: Equivalence a -> Equivalence a -> Equivalence a
    Equivalence equiv <> Equivalence equiv' = Equivalence a b ->
      equiv a b && equiv' a b

Instance details Defined in Data.Functor.Contravariant Methods (<>) :: Equivalence a -> Equivalence a -> Equivalence a Source # sconcat :: NonEmpty (Equivalence a) -> Equivalence a Source # stimes :: Integral b => b -> Equivalence a -> Equivalence a Source #

defaultEquivalence :: Eq a => Equivalence a Source #

Check for equivalence with `==`.

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

comparisonEquivalence :: Comparison a -> Equivalence a Source #

# Dual arrows

newtype Op a b Source #

Dual function arrows.

Constructors

Op |

Fields

- getOp :: b -> a

#### Instances

Instances details

Category Op Source # |
Instance details Defined in Data.Functor.Contravariant Methods id :: Op a a Source # (.) :: Op b c -> Op a b -> Op a c Source #
Contravariant (Op a) Source # |
Instance details Defined in Data.Functor.Contravariant Methods contramap :: (a' -> a0) -> Op a a0 -> Op a a' Source # (>$) :: b -> Op a b -> Op a a0 Source #

Monoid a => Monoid (Op a b) Source #

``mempty` @(Op a b)` without newtypes is `mempty @(b->a)` = `_ -> mempty`.

    mempty :: Op a b
    mempty = Op _ -> mempty

Instance details Defined in Data.Functor.Contravariant Methods mempty :: Op a b Source # mappend :: Op a b -> Op a b -> Op a b Source # mconcat :: [Op a b] -> Op a b Source #

Semigroup a => Semigroup (Op a b) Source #

`(`<>`) @(Op a b)` without newtypes is `(`<>`) @(b->a)` = `liftA2 (`<>`)`. This lifts the `Semigroup` operation `(`<>`)` over the output of `a`.

    (<>) :: Op a b -> Op a b -> Op a b
    Op f <> Op g = Op a -> f a <> g a

Instance details Defined in Data.Functor.Contravariant Methods (<>) :: Op a b -> Op a b -> Op a b Source # sconcat :: NonEmpty (Op a b) -> Op a b Source # stimes :: Integral b0 => b0 -> Op a b -> Op a b Source #
Floating a => Floating (Op a b) Source # |

Instance details

Defined in Data.Functor.Contravariant

Methods

pi :: Op a b Source #

exp :: Op a b -> Op a b Source #

log :: Op a b -> Op a b Source #

sqrt :: Op a b -> Op a b Source #

(**) :: Op a b -> Op a b -> Op a b Source #

logBase :: Op a b -> Op a b -> Op a b Source #

sin :: Op a b -> Op a b Source #

cos :: Op a b -> Op a b Source #

tan :: Op a b -> Op a b Source #

asin :: Op a b -> Op a b Source #

acos :: Op a b -> Op a b Source #

atan :: Op a b -> Op a b Source #

sinh :: Op a b -> Op a b Source #

cosh :: Op a b -> Op a b Source #

tanh :: Op a b -> Op a b Source #

asinh :: Op a b -> Op a b Source #

acosh :: Op a b -> Op a b Source #

atanh :: Op a b -> Op a b Source #

log1p :: Op a b -> Op a b Source #

expm1 :: Op a b -> Op a b Source #

log1pexp :: Op a b -> Op a b Source #

log1mexp :: Op a b -> Op a b Source #

Num a => Num (Op a b) Source # |
Instance details Defined in Data.Functor.Contravariant Methods (+) :: Op a b -> Op a b -> Op a b Source # (-) :: Op a b -> Op a b -> Op a b Source # (*) :: Op a b -> Op a b -> Op a b Source # negate :: Op a b -> Op a b Source # abs :: Op a b -> Op a b Source # signum :: Op a b -> Op a b Source # fromInteger :: Integer -> Op a b Source #
Fractional a => Fractional (Op a b) Source # |
Instance details Defined in Data.Functor.Contravariant Methods (/) :: Op a b -> Op a b -> Op a b Source # recip :: Op a b -> Op a b Source # fromRational :: Rational -> Op a b Source #