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 и первого закона, поэтому вам нужно только проверить, выполняется ли первое условие.

phantom :: (Functor f, Contravariant f) => f a -> f b Source

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

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

fmap      f ≡ phantom
contramap f ≡ phantom

(>$<) :: Contravariant f => (a -> b) -> f b -> f a infixl 4 Source

Это инфиксное алиас для contramap.

(>$$<) :: Contravariant f => f b -> (a -> b) -> f a infixl 4 Source

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

($<) :: Contravariant f => f b -> b -> f a infixl 4 Source

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

newtype Predicate a Source

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 Исходный код

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