haskell - 组合函数时，通用量化和类型类约束会发生什么？

Question

镜头can be composed就像任何普通函数一样。我们有:

Lens' a b = forall f . Functor f => (b -> f b) -> a -> f a

现在考虑这个例子:

(.) :: Lens' Config Foo -> Lens' Foo String -> Lens' Config String

展开我们得到:

(.) :: (forall f. Functor f => (Foo -> f Foo) -> Config -> f Config)
    -> (forall f. Functor f => (String -> f String) -> Foo -> f Foo)
    -> (forall f. Functor f => (String -> f String) -> Config -> f Config)

函数组合的类型为:

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

缺乏任何通用量化和类型类约束。现在我的问题是，编译器/类型检查器如何处理这两个功能，以便函数组合运算符可以用于组合镜头？

我的猜测是，只要函数与正在组合的两个函数匹配，就可以使用通用量化的函数和类型类约束。

Answer 1

为什么我们不看看会发生什么？考虑以下值:

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

foo :: Lens' A B

bar :: Lens' B C

foo的类型和bar将扩展为:

foo :: Functor f => (B -> f B) -> A -> f A

bar :: Functor g => (C -> g C) -> B -> g B

请注意，我遗漏了 forall f.部分因为它是隐式的。另外，我改了名字f至g对于 bar以表明它与 f 不同对于 foo .

不管怎样，我们先申请(.)至foo :

(.)     ::                 (b      ->    c)    -> (a ->    b)     -> a ->    c
                            |            |         |       |         |       |
                         --------     --------     |       |         |       |
                         |      |     |      |     |       |         |       |
foo     :: Functor f => (B -> f B) -> A -> f A     |    --------     |    --------
                                                   |    |      |     |    |      |
(.) foo :: Functor f =>                           (a -> B -> f B) -> a -> A -> f A

因此，(.) foo类型为 Functor f => (a -> B -> f B) -> a -> A -> f A 。如您所见，Functor约束只是按原样复制。

现在，我们申请(.) foo至bar :

(.) foo     :: Functor f =>    (a      -> B -> f B) ->     a      -> A -> f A
                       |        |         |    | |         |         |    | |
                       |     --------     |    | |         |         |    | |
                       |     |      |     |    | |         |         |    | |
bar         :: Functor g => (C -> g C) -> B -> g B      --------     |    | |
                                                        |      |     |    | |
(.) foo bar :: Functor g =>                            (C -> g C) -> A -> g A

因此，(.) foo bar类型为 Functor g => (C -> g C) -> A -> g A这意味着它是 Lens' A C 。如您所见Functor f与 Functor g 相同这就是为什么一切顺利。