为自定义镜头编写类别实例

Question

我一直在阅读这篇文章，以了解镜片。 我知道这与Edward Knett的镜头包不同，但它对基础知识很有用。

所以，A Lens定义如下：

type Lens a b = (a -> b, b -> a -> a)

已经提到Lenses形成一个类别，我一直在尝试为Category类型类创建一个实例。 首先，我为函数编写了类型定义：

(.) :: Lens y z -> Lens x y -> Lens x z
id :: Lens x x

在此之后，我只是整天凝视它。 编写它的定义的思维过程究竟是什么？

Answer 1

我发现这篇文章 （来自Scratch的镜头，由Joseph Abrahamson拍摄的fpcomplete）非常好，它从你开始使用的镜头的相同表示开始，为它定义构图并继续沿着路径进行更类似于镜头的表现

编辑：在做这类事情时，我发现类型漏洞非常好：

(<.>):: Lens y z -> Lens x y -> Lens x z
(getA,setA) <.> (getB,setB) = (_,_)

所以现在我们有2个洞，元组中的第一个说（输出清理）：

Found hole ‘_’ with type: x -> z
...
Relevant bindings include
  setB :: y -> x -> x
  getB :: x -> y
  setA :: z -> y -> y
  getA :: y -> z
  (<.>) :: Lens y z -> Lens x y -> Lens x z

仔细观察绑定，我们已经拥有了我们需要的东西！ getB :: x -> y和getA :: y -> z与函数组合(.) :: (b -> c) -> (a -> b) -> a -> c

所以我们很乐意插入这个：

(<.>):: Lens y z -> Lens x y -> Lens x z
(getA,setA) <.> (getB,setB) = (getA . getB, _)

并继续使用第二类孔，其中说：

Found hole ‘_’ with type: z -> x -> x
Relevant bindings include
  setB :: y -> x -> x
  getB :: x -> y
  setA :: z -> y -> y
  getA :: y -> z

我们最相似的事情是setA :: z -> y -> y ，我们首先插入一个lambda，捕获参数：

(getA,setA) <.> (getB,setB) = (getA . getB, \z x -> _)

将您的类型孔更改为：

Found hole ‘_’ with type: x
Relevant bindings include
  x :: x
  z :: z
  setB :: y -> x -> x
  getB :: x -> y
  setA :: z -> y -> y
  getA :: y -> z

我们可以插入x哪种类型的检查，但不会给我们想要的东西（设置时没有任何反应）。 唯一可以给我们一个x其他绑定是setB ，所以我们插入：

(getA,setA) <.> (getB,setB) = (getA . getB, \z x -> setB _ _)

我们的第一个洞说：

Found hole ‘_’ with type: y
Relevant bindings include
  x :: x
  z :: z
  setB :: y -> x -> x
  getB :: x -> y
  setA :: z -> y -> y
  getA :: y -> z

所以我们需要一个y，看看范围是什么， getB可以给我们一个y如果我们给它一个x ，我们碰巧有，但这会导致我们无用的镜头再做任何事情。 另一种方法是使用setA ：

(getA,setA) <.> (getB,setB) = (getA . getB, \z x -> setB (setA _ _) _)

（从这里加速一点事情）同样，第一洞想要一些z型的东西，他碰巧将其作为我们lambda的参数：

(getA,setA) <.> (getB,setB) = (getA . getB, \z x -> setB (setA z _) _)

要填充y类型的第一个类型的洞，我们可以使用getB :: x -> y为它提供lambda的参数：

(getA,setA) <.> (getB,setB) = (getA . getB, \z x -> setB (setA z (getB x)) _)

这留下了一个剩余类型的洞，可以简单地用x代替，导致最终的定义：

(<.>):: Lens y z -> Lens x y -> Lens x z
(getA,setA) <.> (getB,setB) = (getA . getB, \z x -> setB (setA z (getB x)) x)

您可以尝试为自己定义id ，如果需要，可以使用类型孔和hoogle

Answer 2

试试这个：

(.) :: Lens y z -> Lens x y -> Lens x z
(getZfromY , setZinY) . (getYfromX , setYinX) = (getZfromX , setZinX)
             where getZfromX someX = ...
                   setZinX someZ someX = ...

这个想法是：结合两个吸气剂来制造新的吸气剂，并将两个吸气剂结合起来制造一个新的吸气剂。

为了身份，请考虑：

id :: Lens x x
id = (getXfromX , setXinX)
    where getXfromX someX = ...
          setXinX newX oldX = ...

Answer 3

这似乎是一个相当直接的过程。 但是还需要检查你是否得到了一个类别 - 这需要等式推理 - 因为，例如，至少还有一种方法来实现类型为x->x->x的id的setter - 只有其中一个会生成一个类别。

所以，让我们从获得正确类型的函数开始。

Lens y z -> Lens x y -> Lens x z ==
(y->z, z->y->y) -> (x->y, y->x->x) -> (x->z, z->x->x)

似乎很清楚如何从x->y和y->z - 得到x->z 。 那么，你有办法来构建新的x从旧x和新的y ，和一种方式来获得老y从老x ，所以如果你可以构建新的y从z老y ，你做。

(.) (yz, zyy) (xy, yxx) = (yz . xy, \z x -> yxx (zyy z (xy x)) x)

同样的id：

Lens x x ==
(x->x, x->x->x)

所以

id = (id, const)

到目前为止这么好，类型检查。 现在让我们检查一下我们是否有类别。 有一条法律：

f . id = f = id . f

检查一种方式（有点非正式，所以需要记住.和id引用f . id和fg . id不同内容）：

f . id = (fg, fs) . (id, const) =
(fg . id, \z x -> const (fs z (id x)) x) =
(fg, \z x -> fs z (id x)) = (fg, fs)

检查另一种方式：

id . f = (id, const) . (fg, fs) =
(id . fg, \z x -> fs (const z (fg x)) x) =
(fg, \z x -> fs z x) = (fg, fs)