37

我似乎找不到任何关于在实际示例中使用什么镜头的解释。Hackage 页面中的这个简短段落是我找到的最接近的：

该模块提供了一种方便的方式来访问和更新结构的元素。它与 Data.Accessors 非常相似，但更通用且依赖项更少。我特别喜欢它在状态单子中处理嵌套结构的干净程度。

那么，它们是用来做什么的呢？与其他方法相比，它们有哪些优点和缺点？为什么需要它们？

4

3 回答 3

52

它们提供了对数据更新的清晰抽象，并且从来没有真正“需要”。他们只是让您以不同的方式推理问题。

在一些命令式/“面向对象”的编程语言（如 C）中，您有一些值集合的熟悉概念（我们称它们为“结构”）以及标记集合中每个值的方法（标签通常称为“字段” ）。这导致了这样的定义：

typedef struct { /* defining a new struct type */
  float x; /* field */
  float y; /* field */
} Vec2;

typedef struct {
  Vec2 col1; /* nested structs */
  Vec2 col2;
} Mat2;

然后，您可以像这样创建这个新定义的类型的值：

Vec2 vec = { 2.0f, 3.0f };
/* Reading the components of vec */
float foo = vec.x;
/* Writing to the components of vec */
vec.y = foo;

Mat2 mat = { vec, vec };
/* Changing a nested field in the matrix */
mat.col2.x = 4.0f;

同样在 Haskell 中，我们有数据类型：

data Vec2 =
  Vec2
  { vecX :: Float
  , vecY :: Float
  }

data Mat2 =
  Mat2
  { matCol1 :: Vec2
  , matCol2 :: Vec2
  }

然后像这样使用此数据类型：

let vec  = Vec2 2 3
    -- Reading the components of vec
    foo  = vecX vec
    -- Creating a new vector with some component changed.
    vec2 = vec { vecY = foo }

    mat = Mat2 vec2 vec2

但是，在 Haskell 中，没有简单的方法可以更改数据结构中的嵌套字段。这是因为您需要围绕正在更改的值重新创建所有包装对象，因为 Haskell 值是不可变的。如果你在 Haskell 中有一个像上面这样的矩阵，并且想要改变矩阵的右上单元格，你必须这样写：

    mat2 = mat { matCol2 = (matCol2 mat) { vecX = 4 } }

它有效，但看起来很笨拙。所以，有人想出的，基本上是这样的：如果你把两个东西组合在一起：一个值的“getter”（像vecX和matCol2上面一样）和一个相应的函数，给定 getter 所属的数据结构，可以创建一个更改了该值的新数据结构，您可以做很多整洁的事情。例如：

data Data = Data { member :: Int }

-- The "getter" of the member variable
getMember :: Data -> Int
getMember d = member d

-- The "setter" or more accurately "updater" of the member variable
setMember :: Data -> Int -> Data
setMember d m = d { member = m }

memberLens :: (Data -> Int, Data -> Int -> Data)
memberLens = (getMember, setMember)

镜头的实现方式有很多种；对于本文，假设一个镜头类似于上面：

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

即它是某种类型的 getter 和 setter 的组合，a它具有 type 的字段b，所以memberLens上面将是 a Lens Data Int。这让我们做什么？

好吧，让我们首先创建两个简单的函数，从镜头中提取 getter 和 setter：

getL :: Lens a b -> a -> b
getL (getter, setter) = getter

setL :: Lens a b -> a -> b -> a
setL (getter, setter) = setter

现在，我们可以开始抽象一些东西了。让我们再次考虑上面的情况，我们想要修改一个“两层深”的值。我们添加一个带有另一个镜头的数据结构：

data Foo = Foo { subData :: Data }

subDataLens :: Lens Foo Data
subDataLens = (subData, \ f s -> f { subData = s }) -- short lens definition

现在，让我们添加一个组成两个镜头的函数：

(#) :: Lens a b -> Lens b c -> Lens a c
(#) (getter1, setter1) (getter2, setter2) =
    (getter2 . getter1, combinedSetter)
    where
      combinedSetter a x =
        let oldInner = getter1 a
            newInner = setter2 oldInner x
        in setter1 a newInner

代码写得很快，但我认为它的作用很清楚：getter 是简单组合的；你得到内部数据值，然后你读取它的字段。设置器，当它应该a用新的内部字段值改变某个值时x，首先检索旧的内部数据结构，设置它的内部字段，然后用新的内部数据结构更新外部数据结构。

现在，让我们创建一个简单地增加镜头值的函数：

increment :: Lens a Int -> a -> a
increment l a = setL l a (getL l a + 1)

如果我们有这段代码，它的作用就很清楚了：

d = Data 3
print $ increment memberLens d -- Prints "Data 4", the inner field is updated.

现在，因为我们可以合成镜头，我们也可以这样做：

f = Foo (Data 5)
print $ increment (subDataLens#memberLens) f
-- Prints "Foo (Data 6)", the innermost field is updated.

所有镜头包所做的本质上是将镜头的概念——“setter”和“getter”组合成一个简洁的包，使它们易于使用。在一个特定的镜头实现中，可以这样写：

with (Foo (Data 5)) $ do
  subDataLens . memberLens $= 7

因此，您非常接近 C 版本的代码；在数据结构树中修改嵌套值变得非常容易。

镜头不过是这样：一种修改部分数据的简单方法。因为它们使推理某些概念变得非常容易，所以它们在您拥有大量数据结构且必须以各种方式相互交互的情况下得到广泛使用。

有关镜头的优缺点，请参阅最近关于 SO 的问题。

于 2012-05-28T17:58:09.977 回答
13

镜头以统一的组合方式提供了编辑数据结构的便捷方法。

许多程序都是围绕以下操作构建的：

  • 查看（可能是嵌套的）数据结构的组件
  • 更新（可能是嵌套的）数据结构的字段

镜头为查看和编辑结构提供语言支持，以确保您的编辑一致；编辑可以很容易地组成；并且可以使用相同的代码来查看结构的各个部分，以及更新结构的各个部分。

因此，镜头可以轻松地将程序从视图写入结构；并从结构返回到这些结构的视图（和编辑器）。他们清理了很多记录访问器和设置器的混乱。

皮尔斯等人。普及的镜头，例如在他们的Quotient Lenses 论文中，以及 Haskell 的实现现在被广泛使用（例如fclabels和数据访问器）。

对于具体的用例，请考虑：

  • 图形用户界面，用户以结构化的方式编辑信息
  • 解析器和漂亮的打印机
  • 编译器
  • 同步更新数据结构
  • 数据库和模式

在许多其他情况下，您拥有世界的数据结构模型，以及对该数据的可编辑视图。

于 2012-05-28T17:39:29.387 回答
6

另外需要注意的是，镜头实现了一个非常通用的“字段访问和更新”概念，这一点经常被忽视。可以为各种事物编写镜头，包括类似函数的对象。理解这一点需要一些抽象的思维，所以让我向你展示一个镜头的力量的例子：

at :: (Eq a) => a -> Lens (a -> b) b

使用at您实际上可以访问和操作具有多个参数的函数，具体取决于先前的参数。请记住，这Lens是一个类别。对于本地调整功能或其他事情，这是一个非常有用的习语。

您还可以通过属性或替代表示访问数据：

polar :: (Floating a, RealFloat a) => Lens (Complex a) (a, a)
mag   :: (RealFloat a) => Lens (Complex a) a

您可以进一步编写镜头来访问傅立叶变换信号的各个波段等等。

于 2012-05-28T20:13:26.020 回答