非平凡函子的例子

Question

在 Haskell 中，函子几乎总是可以派生的，是否存在类型是函子并且满足函子定律（例如 fmap id == id）但不能根据一组简单的规则派生的情况？

那么 Foldable、Traversable、Semigroup 等呢？有没有不平凡的案例？

Answer 1

这是我偶然发现的一个有趣的论点。 （时间不早了，不知道明天会不会有感觉）

我们可以将SK可约化的证明类型构造为GADT：

infixl 9 :%:
data Term = S | K | Term :%: Term

-- small step, you can get from t to t' in one step
data Red1 t t' where
    Red1S :: Red1 (S :%: x :%: y :%: z) (x :%: z :%: (y :%: z))
    ...

现在让我们创建一个在归约链末端隐藏其函数的类型。

data Red t a where
    RedStep :: Red1 t t' -> Red t' a -> Red t a
    RedK    :: a                     -> Red K a
    RedS    :: (a -> Bool)           -> Red S a

如果t 规范化为K，则现在Red t 是Functor，但如果规范化为S 则不是——这是一个无法确定的问题。因此，也许您仍然可以遵循“简单的规则集”，但如果您允许 GADT，则这些规则必须足够强大，可以计算任何东西。

（有一个替代公式，我觉得它相当优雅，但可能不太具有说服力：如果你放弃RedK 构造函数，那么Red t 是Functor 当且仅当类型系统可以表达减少t diverges -- 有时它会发散，但你无法证明这一点，我想知道在这种情况下它是否真的是一个函子）

Answer 2

可以自动将显式空参数类型制成函子：

data T a deriving Functor

但是，隐式空的不能：

import Data.Void
data T a = K a (a -> Void)
    deriving Functor  -- fails
{-
error:
    • Can't make a derived instance of ‘Functor T’:
        Constructor ‘K’ must not use the type variable in a function argument
    • In the data declaration for ‘T’
-}

然而，

instance Functor T where
   fmap f (K x y) = absurd (y x)

可以说是一个法律实例。

有人可能会争辩说，利用底部，可以为上面的例子找到函子定律的反例。然而，在这种情况下，我想知道是否所有“标准”仿函数实例实际上都是合法的，即使存在底部也是如此。 （也许是？）

Answer 3

在问题的意义上没有非平凡的函子。所有函子都可以机械地导出为 Identity 和 Const 函子的和 (Either) 和乘积 (Tuple)。请参阅有关Functorial Algebraic Data Types 的部分以了解此构造的详细工作原理。

在更高的抽象层次上这是可行的，因为 Haskell 的类型形成了 Cartesian Closed Category，其中存在终端对象、所有乘积和所有指数。

Answer 4

这有点作弊，但我们开始吧。根据this，当类型受到限制时，仿函数不能自动派生，例如。

data A a where
    A1 :: (Ord a) => a -> A a
deriving instance Functor A -- doesn't work

事实上，如果（比如说）我们编写了一个手动版本，它也不会起作用。

instance Functor A where
    fmap f (A1 a) = A1 (f a) -- Can't deduce Ord for f a

但是，由于算法所做的所有工作都是检查不存在约束，因此我们可以引入一个类型类，每个类型都是其成员。

class C c
instance C c

现在用C 代替Ord 进行上述操作，

data B b where
    B1 :: (C b) => b -> B b

deriving instance Functor B -- doesn't work

instance Functor B where
    fmap f (B1 b) = B1 (f b) -- does work!

Answer 5

base 中有一个标准类型，称为Compose，定义如下：

newtype Compose f g a = Compose { getCompose :: f (g a) }

派生的Functor实例是这样实现的：

instance (Functor f, Functor g) => Functor (Compose f g) where
    fmap f (Compose v) = Compose (fmap (fmap f) v)

但还有另一个完全合法的例子，但行为不同：

instance (Contravariant f, Contravariant g) => Functor (Compose f g) where
    fmap f (Compose v) = Compose (contramap (contramap f) v)

对我来说，Compose 可以使用两个不同的实例这一事实表明，没有任何规则可以自动应用于涵盖所有可能的情况。