这种类型让我大吃一惊：
class Contravariant (f :: * -> *) where
contramap :: (a -> b) -> f b -> f a
然后我看了this，但与标题相反，我没有更多的开悟。
谁能解释一下什么是逆变函子以及一些例子？
【问题讨论】：
contravariant package by Tom Ellis on Oliver Charles' website，它描述了逆变函子的一个简单示例和更详细和有用的示例。
从程序员的角度来看，函子的本质是能够轻松地适应事物。我这里所说的“适配”的意思是，如果我有一个f a 并且我需要一个f b，我想要一个适合我的f a 在我的f b 形孔中的适配器。
似乎很直观，如果我可以将a 转换为b，我可能可以将f a 转换为f b。事实上，这就是 Haskell 的 Functor 类所体现的模式；如果我提供了一个a -> b 函数，那么fmap 让我可以将f a 的东西适应f b 的东西，而不用担心f 涉及的任何内容。1
当然在这里谈论参数化类型，如 list-of-x [x]、Maybe y 或 IO z，我们可以使用适配器更改的东西是 x、y 或z 在那些。如果我们想要灵活地从任何可能的函数a -> b 获取适配器，那么我们正在调整的东西当然必须同样适用于任何可能的类型。
（起初）不太直观的是，有些类型几乎可以与 functory 完全相同的方式进行调整，只是它们是“倒退的”；对于这些，如果我们想修改 f a 来满足 f b 的需求，我们实际上需要提供 b -> a 函数，而不是 a -> b 一个！
我最喜欢的具体例子其实是函数类型a -> r（a 表示参数，r 表示结果）；所有这些抽象的废话在应用于函数时都非常有意义（如果你做过任何实质性的编程，你几乎可以肯定在不知道术语或它们的广泛适用性的情况下使用了这些概念），这两个概念是如此明显在这种情况下相互对偶。
众所周知a -> r 是r 中的函子。这是有道理的；如果我有一个a -> r 并且我需要一个a -> s，那么我可以使用r -> s 函数来调整我的原始函数，只需对结果进行后处理。2
另一方面，如果我有一个a -> r 函数并且我需要一个b -> r，那么很明显我可以通过在将参数传递给原始函数之前对其进行预处理来满足我的需求。但是我用什么来预处理它们呢？原来的功能是一个黑盒子；无论我做什么，它总是期待a 输入。所以我需要将我的b 值转换为它所期望的a 值：我的预处理适配器需要一个b -> a 函数。
我们刚刚看到函数类型a -> r 是r 中的协变 函子，而a 中是逆变 函子。我认为这是说我们可以调整函数的结果，结果类型“随”适配器 r -> s 而变化，而当我们调整函数的参数时，参数类型会“以相反的方向”更改为适配器。
有趣的是，函数结果fmap 和函数参数contramap 的实现几乎完全相同：只是函数组合（. 运算符）！唯一的区别是您在哪一侧编写适配器函数：3
fmap :: (r -> s) -> (a -> r) -> (a -> s)
fmap adaptor f = adaptor . f
fmap adaptor = (adaptor .)
fmap = (.)
contramap' :: (b -> a) -> (a -> r) -> (b -> r)
contramap' adaptor f = f . adaptor
contramap' adaptor = (. adaptor)
contramap' = flip (.)
我认为每个块的第二个定义最有见地； （协变）对函数结果的映射是左侧的组合（如果我们想采用“这发生在之后”的观点，则为后组合），而对函数参数的逆变映射是右侧的组合（前-作文）。
这种直觉概括得很好；如果f x 结构可以给我们 类型为x 的值（就像a -> r 函数给我们r 值一样，至少可能），它可能是一个协变的Functor在x 中，我们可以使用x -> y 函数将其调整为f y。但是，如果一个f x 结构接收来自我们的x 类型的值（同样，就像a -> r 函数的a 类型的参数），那么它可能是一个Contravariant 仿函数和我们需要使用y -> x 函数将其调整为f y。
当您从源/目标的实施者而不是调用者的角度思考时，我发现反映这种“源是协变的，目标是逆变的”直觉很有趣。如果我尝试实现一个接收x 值的f x，我可以“调整我自己的界面”，这样我就可以改用y 值（同时仍然显示“接收通过使用x -> y 函数，x 值“与我的调用者的接口）。通常我们不会这样想。即使作为f x 的实现者，我也会考虑调整我正在调用的东西，而不是“让我的调用者的界面适应我”。但这是您可以采取的另一种观点。
我对@987654390@ 所做的唯一半真实世界使用（与通过使用右侧组合在其参数中隐式使用函数的逆变性相反，这很常见）是用于键入 Serialiser a 可以序列化 x 值。 Serialiser 必须是 Contravariant 而不是 Functor；鉴于我可以序列化 Foos，如果可以，我也可以序列化 Bars Bar -> Foo。4 但是当你意识到 Serialiser a 基本上是 a -> ByteString 时，它变得很明显；我只是在重复 a -> r 示例的一个特例。
在纯函数式编程中，“接收值”的东西没有它也回馈一些东西并没有太大用处，因此所有逆变函子往往看起来像函数，但几乎任何可以包含值的简单数据结构任意类型将是该类型参数中的协变函子。这就是为什么Functor 早早地偷走了这个好名字并被到处使用（嗯，那个和那个Functor 被认为是Monad 的基本部分，在定义Functor 之前它已经被广泛使用作为 Haskell 中的一个类）。
在命令式 OO 中，我相信逆变函子可能更常见（但不是用像 Contravariant 这样的统一框架抽象出来的），尽管它也很容易具有可变性，并且副作用意味着参数化类型不能完全成为函子（通常：您的标准容器a 既可读又可写，既是a 的发射器又是接收器，而不是意味着它既是协变的又是逆变的，事实证明这两者都不是） .
1 每个个体f 的Functor 实例说明了如何将任意函数应用于f 的特定形式，而不用担心正在应用f 的特定类型到;很好的关注点分离。
2 这个函子也是一个monad，相当于Reader monad。我不打算在这里详细讨论函子，但鉴于我的其余帖子，一个明显的问题是“a -> r 类型也是a 中的某种逆变单子吗？”。不幸的是，逆变不适用于单子（请参阅Are there contravariant monads?），但有一个类似于Applicative 的逆变：https://hackage.haskell.org/package/contravariant-1.4/docs/Data-Functor-Contravariant-Divisible.html
3 请注意，这里的contramap' 与Haskell 中实现的Contravariant 中的实际contramap 不匹配；您不能仅仅因为a 不是(->) 的最后一个类型参数，就无法在Haskell 代码中使a -> r 成为Contravariant 的实际实例。 从概念上来说它工作得很好，而且您总是可以使用新类型包装器来交换类型参数并使其成为一个实例（逆变器正是为此目的定义了Op 类型）。
4 至少对于“序列化”的定义，它不一定包括以后能够重建 Bar，因为它将序列化 a Bar 与它映射到的 Foo 相同，没有包含有关映射是什么的任何信息的方法。
【讨论】：
Functor 和 Contravariant 为代表的协变函子和反变函子。从范畴论的角度（更普遍）来看，这并不是对协变函子和反变函子的一个很好的讨论。如果您作为问题而不是作为评论提出问题，我很乐意解释这两种观点之间的联系。
首先，@haoformayor 的答案非常好，因此请认为这更像是一个附录，而不是完整的答案。
我喜欢用图表来思考 Functor（协/逆变）的一种方式。该定义体现在以下几个方面。 （我用cmap缩写contramap）
covariant contravariant
f a ─── fmap φ ───▶ f b g a ◀─── cmap φ ─── g b
▲ ▲ ▲ ▲
│ │ │ │
│ │ │ │
a ────── φ ───────▶ b a ─────── φ ──────▶ b
注意：这两个定义中唯一的变化是顶部的箭头，（以及名称，所以我可以将它们称为不同的东西）。
在谈到这些时，我总是想到的例子是函数 - 然后 f 的例子将是 type F a = forall r. r -> a（这意味着第一个参数是任意的但固定的 r），或者换句话说，所有具有公共输入的功能。
与往常一样，（协变）Functor 的实例只是 fmap ψ φ = ψ。 φ`。
其中（逆变）Functor 是具有共同结果的所有函数 - type G a = forall r. a -> r 这里是 Contravariant 实例
cmap ψ φ = φ . ψ.
这到底是什么意思
φ :: a -> b 和 ψ :: b -> c
通常因此(ψ . φ) x = ψ (φ x) 或x ↦ y = φ x 和y ↦ ψ y 是有道理的，cmap 的声明中省略的是这里
φ :: a -> b 但ψ :: <strong>c -> a</strong>
所以ψ 不能接受φ 的结果，但它可以将其参数转换为φ 可以使用的东西——因此x ↦ y = ψ x 和y ↦ φ y 是唯一正确的选择。
这反映在下图中，但在这里我们已经将具有公共源/目标的函数示例抽象为具有协变/逆变属性的东西，这是您在数学和/或haskell。
covariant
f a ─── fmap φ ───▶ f b ─── fmap ψ ───▶ f c
▲ ▲ ▲
│ │ │
│ │ │
a ─────── φ ──────▶ b ─────── ψ ──────▶ c
contravariant
g a ◀─── cmap φ ─── g b ◀─── cmap ψ ─── g c
▲ ▲ ▲
│ │ │
│ │ │
a ─────── φ ──────▶ b ─────── ψ ──────▶ c
在数学中，您通常需要一个定律来调用函子。
covariant
a f a
│ ╲ │ ╲
φ │ ╲ ψ.φ ══▷ fmap φ │ ╲ fmap (ψ.φ)
▼ ◀ ▼ ◀
b ──▶ c f b ────▶ f c
ψ fmap ψ
contravariant
a f a
│ ╲ ▲ ▶
φ │ ╲ ψ.φ ══▷ cmap φ │ ╲ cmap (ψ.φ)
▼ ◀ │ ╲
b ──▶ c f b ◀─── f c
ψ cmap ψ
相当于说
fmap ψ . fmap φ = fmap (ψ.φ)
而
cmap φ . cmap ψ = cmap (ψ.φ)
【讨论】：
您可以将Functor f 视为a 永远不会出现在“否定位置”的断言。这是这个想法的一个深奥术语：请注意，在以下数据类型中，a 似乎充当“结果”变量。
newtype IO a = IO (World -> (World, a))
newtype Identity a = Identity a
newtype List a = List (forall r. r -> (a -> List a -> r) -> r)
在每个示例中，a 都出现在积极的位置。在某种意义上，每种类型的a 代表了一个函数的“结果”。将第二个示例中的a 视为() -> a 可能会有所帮助。记住第三个示例等效于data List a = Nil | Cons a (List a) 可能会有所帮助。在像a -> List -> r 这样的回调中，a 出现在负数位置，但 回调本身 处于负数位置，因此负数和负数相乘为正数。
这个签名函数参数的方案是elaborated in this wonderful blog post。
现在请注意，这些类型中的每一个都承认Functor。这没有错！函子旨在模拟分类协变函子的概念，它“保留箭头的顺序”，即f a -> f b，而不是f b -> f a。在 Haskell 中，a 从不出现在否定位置的类型总是承认Functor。我们说这些类型在a 上是协变的。
换句话说，可以有效地将Functor 类重命名为Covariant。它们是同一个想法。
这个想法用“从不”这个词的措辞如此奇怪的原因是a 可以出现在正面和负面的位置，在这种情况下，我们说类型在a 上是不变的。 a 也永远不会出现（例如幻像类型），在这种情况下，我们说该类型在 a 上既是协变的又是逆变的——双变量。
所以对于a 从未出现在正位置的类型，我们说该类型在a 中是逆变的。每个这样的类型Foo a 都会承认instance Contravariant Foo。以下是一些示例，取自 contravariant 包：
data Void a(a是幻影)data Unit a = Unit（a又是幻影了）newtype Const constant a = Const constantnewtype WriteOnlyStateVariable a = WriteOnlyStateVariable (a -> IO ())newtype Predicate a = Predicate (a -> Bool)newtype Equivalence a = Equivalence (a -> a -> Bool)在这些示例中，a 要么是双变量的，要么只是逆变的。 a 要么永远不会出现，要么是否定的（在这些人为的示例中，a 总是出现在箭头之前，因此确定这一点非常简单）。因此，这些类型中的每一个都承认instance Contravariant。
一个更直观的练习是眯着眼睛看这些类型（表现出逆变），然后眯着眼看上面的类型（表现出协变），看看你是否能直观地看出 a 的语义差异。也许这很有帮助，或者它仍然是一种深奥的花招。
这些东西什么时候会真正有用？例如，让我们想按照他们拥有的芯片类型来划分一个 cookie 列表。我们有一个chipEquality :: Chip -> Chip -> Bool。要获得Cookie -> Cookie -> Bool，我们只需评估runEquivalence . contramap cookie2chip . Equivalence $ chipEquality。
相当冗长！但是解决新类型导致的冗长问题将是另一个问题......
【讨论】：
我知道这个答案不会像其他答案那样学术性很强，但它只是基于您会遇到的逆变器的常见实现。
首先，提示：不要像阅读优秀的'Functor's map 时那样使用f 的心理隐喻来阅读contraMap 函数类型。
你知道你的想法：
“一个包含（或产生）
t的东西”
...当您阅读 f t 之类的类型时？
好吧，在这种情况下，你需要停止这样做。
逆变函子是经典函子的“对偶”，因此，当您在contraMap 中看到f a 时，您应该想到“对偶”隐喻：
的东西
f t是一个消耗t
现在contraMap 的类型应该开始有意义了：
contraMap :: (a -> b) -> f b ...
...停在那里，类型是完全明智的：
b 的函数。b 的东西。第一个参数烹饪b。第二个参数吃掉了b。
有道理，对吧？
现在写完类型：
contraMap :: (a -> b) -> f b -> f a
所以最后这个东西必须产生一个“a”的“消费者”。
好吧，我们当然可以构建它，因为我们的第一个参数是一个以a 作为输入的函数。
函数(a -> b) 应该是构建“a 的消费者”的良好构建块。
所以contraMap 基本上可以让你创建一个新的“消费者”，就像这样（警告：传入的虚构符号）：
(takes a as input / produces b as output) ~~> (consumer of b)
contraMap 的第一个参数（即(a -> b)）。f b）。contraMap 的最终输出（知道如何使用a 的东西，即f a）。【讨论】：
关于该主题的另一种观点，仅限于被视为逆变函子的函数。 （另见this。）
Functors）a -> b 类型的函数f 可以被认为包含b 类型的值，当我们将a 类型的值提供给f 时，我们可以访问该值。
现在，可以将作为其他事物容器的事物创建为 Functors，从某种意义上说，我们可以通过将 fmap g 应用于函子本身，将函数 g 应用于其内容。
因此，f，其类型为a -> b，可以看作是b 中的函子，即(->) a 可以变成Functor。为此，我们需要在f 的“内容”上定义fmap: fmapping 函数g 本质上意味着在f 返回的任何内容上应用g（一旦输入输入a，显然），这意味着fmap g f = \x -> g (f x)，或者更简洁地说，fmap g f = g . f。
fmapping a -> b 函数 = 后处理它们的结果类型为b
最后想到：a -> b 类型的函数是b 中的函子，因为我们可以post通过函数@987654352 处理它@（其中c 只是另一种类型）。
contramapping a -> b 函数 = 预处理 输入以获得a
但是如果我们想使用函数g（c -> a 类型）来pre-处理某种类型的值c 以获得我们想要提供给f 的a 类型的值？
嗯，很明显，在这种情况下，我们希望g 在之前 f，即我们正在寻找f . g。
我们希望f . g 成为“将g 映射到f”概念的“实现”。换句话说，我们想要whichmap g f = f . g。
你猜怎么着？ whichmap其实是contramap对于函数的实现！ contramap 是您必须实现的，以使某些类型成为 Contravariant 仿函数类型类的实例。
(-> b)...实际上，Contravariant 中的 instance 并不完全是 instance Functor ((->) r) 的镜像，我相信只是因为 instance Contravariant (-> r)/instance Contravariant (flip (->) r) 是无效的语法；所以创建了另一种类型，通过
newtype Op a b = Op { getOp :: b -> a }
并且 this 是 Contravariant 的一个实例：
instance Contravariant (Op a) where
contramap f g = Op (getOp g . f)
最后两段代码取自hackage。
this 页面顶部的示例也很有启发性。
【讨论】：