Data.Functor.Contravariant

class Contravariant (f :: Type -> Type) where Источник

Класс контравариантных функторов.

Если в Haskell можно считать, что Functor содержит или производит значения, то контравариантный функтор — это функтор, который можно представить как потребляющий значения.

В качестве примера рассмотрим тип функций-предикатов a -> Bool. Одним из таких предикатов может быть negative x = x < 0, который определяет, являются ли целые числа отрицательными. Однако этот предикат можно повторно использовать в других ситуациях, если у нас есть способ преобразовать значения в целые числа. Например, мы можем применить предикат negative к банковскому балансу человека и выяснить, использует ли он в данный момент овердрафт:

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

Каждый экземпляр должен удовлетворять следующим законам:

Тождественность

contramap id = id

Композиция

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

Обратите внимание: второй закон следует из свободной теоремы для типа contramap и первого закона, поэтому достаточно проверить выполнение первого условия.

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

phantom :: (Functor f, Contravariant f) => f a -> f b Исходный код

Если f является одновременно Functor и Contravariant, то с учётом законов каждого из этих классов он фактически не может осмысленно использовать свой аргумент.

Этот метод на удивление полезен. Если существуют оба экземпляра и они корректны, выполняются следующие законы:

fmap      f ≡ phantom
contramap f ≡ phantom

(>$<) :: Contravariant f => (a -> b) -> f b -> f a infixl 4 Исходный код

Это инфиксный псевдоним для contramap.

(>$$<) :: Contravariant f => f b -> (a -> b) -> f a infixl 4 Исходный код

Это инфиксная версия contramap с переставленными аргументами.

($<) :: Contravariant f => f b -> b -> f a infixl 4 Исходный код

Это >$ с переставленными аргументами.

newtype Predicate a Исходный код

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

mempty :: Predicate a
mempty = _ -> True

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

newtype Comparison a Исходный код

Задаёт полный порядок на типе согласно compare.

Типы не проверяют выполнение этого условия. Вы должны самостоятельно убедиться, что переданные значения задают допустимые полные порядки.

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

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

defaultComparison :: Ord a => Comparison a Исходный код

Сравнение с помощью compare.

newtype Equivalence a Исходный код

Этот тип данных представляет отношение эквивалентности.

Предполагается, что отношения эквивалентности удовлетворяют трём законам:

Рефлексивность

getEquivalence f a a = True

Симметричность

getEquivalence f a b = getEquivalence f b a

Транзитивность

Если getEquivalence f a b и getEquivalence f b c оба являются True, то таким же является и getEquivalence f a c.

Одни лишь типы не обеспечивают соблюдение этих законов, поэтому вам придётся проверять их самостоятельно.

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

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

defaultEquivalence :: Eq a => Equivalence a Исходный код

Проверка эквивалентности с помощью ==.

Примечание: Экземпляры для Double и Float нарушают рефлексивность для NaN.

comparisonEquivalence :: Comparison a -> Equivalence a Исходный код

newtype Op a b Исходный код

Двойственные функциональные стрелки.