Question

有人可以帮我理解这个/给我一些阅读材料吗？以下工作正常：

type F a b = Functor f => f a -> f b
fComp :: F b c -> F a b -> F a c
fComp f f' = f . f'

但如果我改为编写fComp = (.)，则类型检查器会抱怨：

Couldn't match type ‘b0 -> f c’
              with ‘forall (f1 :: * -> *). Functor f1 => f1 b -> f1 c’

（这个具体的例子并不是特别有用;我只是试图缩小研究镜头时出现的例子。）

Answer 1

fComp具有更高级别的类型，并且更高级别类型的类型推断非常有限。如果我们扩展类型同义词，它可能会更容易理解（但更长！）。

fComp :: forall f a b c. Functor f => 
                (forall f1. Functor f1 => f1 b -> f1 c) ->
                (forall f2. Functor f2 => f2 a -> f2 b) ->
                (f a -> f c)

此类型签名中明确指定了较高级别的f和f'类型。这使得类型推断开始已经知道f和f'的类型，因此能够将它们与.类型统一起来。

但是，如果您摆脱f和f'，则.必须采用的类型未知。不幸的是，系统无法推断出更高级别的类型，因此您会遇到类型错误。

本质上，编译器无法创建更高级别的类型来填充类型推断期间的未知数，并且必须依赖于程序员注释，我们需要名称（f和f'）和用于获取这些注释的类型签名。

更容易理解的例子是更高级别的id函数：

myId :: (forall a. a) -> (forall b. b)

定义myId x = id x编译，但myId = id给出以下错误：

/home/tikhon/Documents/so/eta-expansion-needed.hs:11:8:
    Couldn't match type ‘b’ with ‘forall a. a’
      ‘b’ is a rigid type variable bound by
          the type signature for myId :: (forall a. a) -> b
          at /home/tikhon/Documents/so/eta-expansion-needed.hs:11:1
    Expected type: (forall a. a) -> b
      Actual type: b -> b
    In the expression: id
    In an equation for ‘myId’: myId = id
Failed, modules loaded: none.

（请注意，forall b. (forall a. a) -> b与(forall a. a) -> (forall b. b)相同。）

Answer 2

让我使用类似System-F的表示法重写示例，其中我们也传递类型。下面，\\代表类型抽象（大lambda），以及字典抽象。此外，@代表类型/字典应用程序。

在此之前，请回忆一下(.)：

的类型

(.) :: forall a b c . (b -> a) -> (c -> b) -> (c -> a)

这是带注释的代码（当心，不是为了胆小的人）：

fComp :: F b c -> F a b -> F a c
fComp (f :: forall f1. Functor f1 => f1 b -> f1 c)
      (f':: forall f2. Functor f2 => f2 a -> f2 b) 
   = \\ ff :: (* -> *) ->
     \\ ffD :: Functor ff ->
     ((.) @ (ff c) @ (ff b) @ (ff a))   -- instantiated composition
     (f  @ ff @ ffD)                    -- first argument of (.)
     (f' @ ff @ ffD)                    -- second argument of (.)

（高于我假装a，b，c是类型常量，以避免进一步的类型级lambda。）

重要部分：

f和f'正在特定类型中使用。也就是说，它们在被送到(.)之前被应用于类型级参数。
(.)在类型级别应用于类型（ff c等），这些类型不是f和f'

正如您所看到的，原始代码远非微不足道。类型推断能够添加所需的类型级lambda和应用程序。添加完成后，我们不能简单地再签订fComp。

在pointfree变体中，类型推断需要做的不仅仅是在有意义的情况下。虽然fComp的第一个参数属于F a b类型，但(.)的第一个参数必须是x -> y形式，F a b = forall g . ...不统一。实际上，没有办法成功解决下面的打字尝试：

fComp :: F b c -> F a b -> F a c
fComp 
   = \\ ff :: (* -> *) ->
     \\ ffD :: Functor ff ->
     ((.) @ ???a @ ???b @ ???c)

上面没有???a，......可以导致想要的类型。

唯一的可能性是实例化隐藏在forall类型中的F x y - 量化变量，但要做到这一点，我们需要点。编译器可能会为您扩展该代码，以便出现点，从理论上讲可以实例化，但实际上不会。

（另外，在Haskell中eta扩展并不总是有效：例如seq (undefined::()->()) 3循环，而seq (\x->(undefined::()->()) x) 3返回3）。

为什么这个eta扩展是必要的？

2 个答案: