为什么不是扩展 Functor 逆变的 Phantom 类？

Question

我在玩Data.Functor.Contravariant。 phantom 方法引起了我的注意：

phantom :: (Functor f, Contravariant f) => f a -> f b
phantom x = () <$ x $< ()

或者，更具体地说，它的注释：

如果f 既是Functor 又是Contravariant，那么当你考虑到每个类的规律时，它实际上不能以任何有意义的能力使用它的论点。 这种方法非常有用。在这两种情况都存在且合法的情况下，我们有以下法律：fmap f ≡ phantom、contramap f ≡ phantom

既然fmap f ≡ contramap f ≡ phantom，为什么我们需要Contravariant 和Functor 实例？换一种方式做这件事不是更方便：为一个类Phantom创建一个实例，它引入了phantom方法，然后自动派生Functor的实例和Contravariant？

class Phantom f where
    phantom :: f a -> f b

instance Phantom f => Functor f where
    fmap _f = phantom

instance Phantom f => Contravariant f where
    contramap _f = phantom

在实现Contravariant 和@ 的实例时，我们将免除程序员重写此phantom 两次（以实现fmap 和contramap，即const phantom，如注释中所述）的必要性987654350@。我们将允许编写一个实例而不是两个！此外，对我来说，为所有 4 种差异情况提供类似乎很好且惯用：Functor、Contravariant、Invariant（然而，some 建议使用Profunctor 接口而不是Invariant），以及Phantom.

另外，这不是更高效的方法吗？ () <$ x $< () 需要两次遍历（只要我们可以遍历一个幻像函子......），只要程序员可以更快地执行这个转换。据我了解，当前的phantom 方法不能被覆盖。

那么，为什么库开发者不选择这种方式呢？目前的设计和我所说的设计的优缺点是什么？

Answer 1

有很多类型是 Functor 的实例而不是 Phantom 的实例，同样是逆变的。对于此类类型，由于实例重叠，您建议的结构将是一个大问题。

instance Phantom f => Functor f

并不意味着“如果 f 是 Phantom 那么它也是 Functor”。在类型类解析期间只搜索实例头，约束稍后出现。这与open world assumption 有关。所以你要为f 声明一个 Functor 实例，这是一个完全不受约束的类型变量，它将与所有其他可能的实例声明重叠。

Answer 2

为了避免 amalloy 提到的重叠实例，您可以定义一个可以与 DerivingVia 一起使用的新类型：

{-# LANGUAGE DerivingVia #-}

import Data.Functor.Contravariant hiding (phantom)

class (Functor f, Contravariant f) => Phantom f where
  phantom :: f a -> f b

newtype WrappedPhantom f a = WrappedPhantom (f a)

instance Phantom f => Phantom (WrappedPhantom f) where
  phantom (WrappedPhantom x) = WrappedPhantom (phantom x)

instance Phantom f => Functor (WrappedPhantom f) where
  fmap _ = phantom

instance Phantom f => Contravariant (WrappedPhantom f) where
  contramap _ = phantom

-- example of usage:

data SomePhantom a = SomePhantom
  deriving (Functor, Contravariant) via WrappedPhantom SomePhantom

instance Phantom SomePhantom where
  phantom SomePhantom = SomePhantom

它不如自动拥有实例方便，但它仍然意味着您不必手动实现 Functor 和逆变器实例。

Answer 3

你真正能做的最好的事情是这样的：

class (Functor f, Contravariant f) => Phantom f where
  phantom :: f a -> f b
  phantom x = () <$ x $< ()

问题是人们可能不会对花时间实例化类感兴趣。