2

镜头可以像任何普通功能一样组成。我们有：

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)

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

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

4

1 回答 1

3

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

(.) :: (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.部分，因为它是隐含的。另外，我更改了fto gfor的名称，bar以表明它与ffor不同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这就是一切正常的原因。

于 2017-09-02T04:33:38.983 回答