126

假设我有以下两个case classes：

case class Address(street: String, city: String, state: String, zipCode: Int)
case class Person(firstName: String, lastName: String, address: Address)

和以下Person类实例：

val raj = Person("Raj", "Shekhar", Address("M Gandhi Marg", 
                                           "Mumbai", 
                                           "Maharashtra", 
                                           411342))

现在，如果我想更新zipCode的raj话，我将不得不这样做：

val updatedRaj = raj.copy(address = raj.address.copy(zipCode = raj.address.zipCode + 1))

随着更多级别的嵌套，这变得更加丑陋。有没有更简洁的方法（比如 Clojure 的update-in）来更新这样的嵌套结构？

4

7 回答 7

188

有趣的是没有人添加镜头，因为它们是为这种东西制造的。所以，这是一篇关于它的 CS 背景论文，这是一个简要介绍在 Scala 中使用镜头的博客，这是 Scalaz 的镜头实现，这是一些使用它的代码，这看起来很像你的问题。而且，为了减少样板，这是一个为案例类生成 Scalaz 镜头的插件。

对于奖励积分，这是另一个涉及镜头的 SO question，以及Tony Morris 的一篇论文。

镜头最重要的是它们是可组合的。所以一开始它们有点麻烦，但你使用它们的次数越多，它们就会越来越受欢迎。此外，它们非常适合可测试性，因为您只需要测试单个镜头，并且可以认为它们的组成是理所当然的。

因此，根据此答案末尾提供的实现，这是使用镜头的方法。首先，声明镜头以更改地址中的邮政编码和人员中的地址：

val addressZipCodeLens = Lens(
    get = (_: Address).zipCode,
    set = (addr: Address, zipCode: Int) => addr.copy(zipCode = zipCode))

val personAddressLens = Lens(
    get = (_: Person).address, 
    set = (p: Person, addr: Address) => p.copy(address = addr))

现在，组合它们以获得一个可以改变人的邮政编码的镜头：

val personZipCodeLens = personAddressLens andThen addressZipCodeLens

最后，使用那个镜头来改变 raj：

val updatedRaj = personZipCodeLens.set(raj, personZipCodeLens.get(raj) + 1)

或者，使用一些语法糖：

val updatedRaj = personZipCodeLens.set(raj, personZipCodeLens(raj) + 1)

甚至：

val updatedRaj = personZipCodeLens.mod(raj, zip => zip + 1)

下面是这个例子中使用的简单实现，取自 Scalaz：

case class Lens[A,B](get: A => B, set: (A,B) => A) extends Function1[A,B] with Immutable {
  def apply(whole: A): B   = get(whole)
  def updated(whole: A, part: B): A = set(whole, part) // like on immutable maps
  def mod(a: A, f: B => B) = set(a, f(this(a)))
  def compose[C](that: Lens[C,A]) = Lens[C,B](
    c => this(that(c)),
    (c, b) => that.mod(c, set(_, b))
  )
  def andThen[C](that: Lens[B,C]) = that compose this
}
于 2011-04-08T16:02:17.307 回答
95

拉链

Huet 的 Zipper提供了对不可变数据结构的方便遍历和“变异”。Scalaz 为Stream( scalaz.Zipper ) 和Tree( scalaz.TreeLoc ) 提供拉链。事实证明，zipper 的结构可以自动从原始数据结构推导出来，其方式类似于代数表达式的符号微分。

但这对您的 Scala 案例类有何帮助？好吧，Lukas Rytz 最近对 scalac 的扩展进行了原型设计，该扩展将自动为带注释的案例类创建拉链。我将在这里重现他的示例：

scala> @zip case class Pacman(lives: Int = 3, superMode: Boolean = false) 
scala> @zip case class Game(state: String = "pause", pacman: Pacman = Pacman()) 
scala> val g = Game() 
g: Game = Game("pause",Pacman(3,false))

// Changing the game state to "run" is simple using the copy method:
scala> val g1 = g.copy(state = "run") 
g1: Game = Game("run",Pacman(3,false))

// However, changing pacman's super mode is much more cumbersome (and it gets worse for deeper structures):
scala> val g2 = g1.copy(pacman = g1.pacman.copy(superMode = true))
g2: Game = Game("run",Pacman(3,true))

// Using the compiler-generated location classes this gets much easier: 
scala> val g3 = g1.loc.pacman.superMode set true
g3: Game = Game("run",Pacman(3,true)

因此，社区需要说服 Scala 团队，应该继续这项工作并将其集成到编译器中。

顺便说一句，Lukas 最近发布了一个版本的 Pacman，用户可以通过 DSL 进行编程。不过，看起来他没有使用修改后的编译器，因为我看不到任何@zip注释。

树重写

在其他情况下，您可能希望根据某种策略（自上而下、自下而上）并基于与结构中某个点的值匹配的规则，对整个数据结构应用某种转换。经典的例子是将 AST 转换为一种语言，可能是为了评估、简化或收集信息。Kiama支持重写，请参阅RewriterTests中的示例，并观看此视频。这里有一个片段可以激发你的胃口：

// Test expression
val e = Mul (Num (1), Add (Sub (Var ("hello"), Num (2)), Var ("harold")))

// Increment every double
val incint = everywheretd (rule { case d : Double => d + 1 })
val r1 = Mul (Num (2), Add (Sub (Var ("hello"), Num (3)), Var ("harold")))
expect (r1) (rewrite (incint) (e))

请注意，Kiama 跨出类型系统来实现这一点。

于 2010-10-10T13:35:38.107 回答
12

使用镜头的有用工具：

只是想补充一点，基于 Scala 2.10 宏的Macrocosm和Rillit项目提供了动态镜头创建。

使用瑞利特：

case class Email(user: String, domain: String)
case class Contact(email: Email, web: String)
case class Person(name: String, contact: Contact)

val person = Person(
  name = "Aki Saarinen",
  contact = Contact(
    email = Email("aki", "akisaarinen.fi"),
    web   = "http://akisaarinen.fi"
  )
)

scala> Lenser[Person].contact.email.user.set(person, "john")
res1: Person = Person(Aki Saarinen,Contact(Email(john,akisaarinen.fi),http://akisaarinen.fi))

使用宏观世界：

这甚至适用于当前编译运行中定义的案例类。

case class Person(name: String, age: Int)

val p = Person("brett", 21)

scala> lens[Person].name._1(p)
res1: String = brett

scala> lens[Person].name._2(p, "bill")
res2: Person = Person(bill,21)

scala> lens[Person].namexx(()) // Compilation error
于 2013-05-03T13:16:14.077 回答
10

我一直在寻找具有最佳语法和最佳功能的 Scala 库，这里没有提到的一个库是monocle，它对我来说非常好。一个例子如下：

import monocle.Macro._
import monocle.syntax._

case class A(s: String)
case class B(a: A)

val aLens = mkLens[B, A]("a")
val sLens = aLens |-> mkLens[A, String]("s")

//Usage
val b = B(A("hi"))
val newB = b |-> sLens set("goodbye") // gives B(A("goodbye"))

这些非常好，并且有很多方法可以组合镜头。例如，Scalaz 需要大量样板文件，并且编译速度快，运行良好。

要在您的项目中使用它们，只需将其添加到您的依赖项中：

resolvers ++= Seq(
  "Sonatype OSS Releases"  at "http://oss.sonatype.org/content/repositories/releases/",
  "Sonatype OSS Snapshots" at "http://oss.sonatype.org/content/repositories/snapshots/"
)

val scalaVersion   = "2.11.0" // or "2.10.4"
val libraryVersion = "0.4.0"  // or "0.5-SNAPSHOT"

libraryDependencies ++= Seq(
  "com.github.julien-truffaut"  %%  "monocle-core"    % libraryVersion,
  "com.github.julien-truffaut"  %%  "monocle-generic" % libraryVersion,
  "com.github.julien-truffaut"  %%  "monocle-macro"   % libraryVersion,       // since 0.4.0
  "com.github.julien-truffaut"  %%  "monocle-law"     % libraryVersion % test // since 0.4.0
)
于 2014-06-21T17:56:55.180 回答
8

无形的诀窍：

"com.chuusai" % "shapeless_2.11" % "2.0.0"

和：

case class Address(street: String, city: String, state: String, zipCode: Int)
case class Person(firstName: String, lastName: String, address: Address)

object LensSpec {
      import shapeless._
      val zipLens = lens[Person] >> 'address >> 'zipCode  
      val surnameLens = lens[Person] >> 'firstName
      val surnameZipLens = surnameLens ~ zipLens
}

class LensSpec extends WordSpecLike with Matchers {
  import LensSpec._
  "Shapless Lens" should {
    "do the trick" in {

      // given some values to recreate
      val raj = Person("Raj", "Shekhar", Address("M Gandhi Marg",
        "Mumbai",
        "Maharashtra",
        411342))
      val updatedRaj = raj.copy(address = raj.address.copy(zipCode = raj.address.zipCode + 1))

      // when we use a lens
      val lensUpdatedRaj = zipLens.set(raj)(raj.address.zipCode + 1)

      // then it matches the explicit copy
      assert(lensUpdatedRaj == updatedRaj)
    }

    "better yet chain them together as a template of values to set" in {

      // given some values to recreate
      val raj = Person("Raj", "Shekhar", Address("M Gandhi Marg",
        "Mumbai",
        "Maharashtra",
        411342))

      val updatedRaj = raj.copy(firstName="Rajendra", address = raj.address.copy(zipCode = raj.address.zipCode + 1))

      // when we use a compound lens
      val lensUpdatedRaj = surnameZipLens.set(raj)("Rajendra", raj.address.zipCode+1)

      // then it matches the explicit copy
      assert(lensUpdatedRaj == updatedRaj)
    }
  }
}

请注意，虽然这里的其他一些答案可以让您组合镜头以更深入地了解给定结构，但这些无形镜头（和其他库/宏）允许您组合两个不相关的镜头，这样您就可以制作将任意数量的参数设置到任意位置的镜头在你的结构中。对于复杂的数据结构，额外的组合非常有用。

于 2014-11-20T16:15:25.433 回答
7

由于它们的可组合性，镜头为严重嵌套结构的问题提供了一个非常好的解决方案。但是由于嵌套级别低，有时我觉得镜头有点太多，如果只有很少的地方嵌套更新，我不想介绍整个镜头的方法。为了完整起见，对于这种情况，这是一个非常简单/实用的解决方案：

我所做的只是modify...在顶层结构中编写一些辅助函数，它们处理丑陋的嵌套副本。例如：

case class Person(firstName: String, lastName: String, address: Address) {
  def modifyZipCode(modifier: Int => Int) = 
    this.copy(address = address.copy(zipCode = modifier(address.zipCode)))
}

我的主要目标（简化客户端的更新）已实现：

val updatedRaj = raj.modifyZipCode(_ => 41).modifyZipCode(_ + 1)

创建全套修改助手显然很烦人。但是对于内部的东西，通常可以在您第一次尝试修改某个嵌套字段时创建它们。

于 2014-09-16T14:02:40.837 回答
4

也许QuickLens 更符合您的问题。QuickLens 使用宏将 IDE 友好的表达式转换为接近原始复制语句的表达式。

给定两个示例案例类：

case class Address(street: String, city: String, state: String, zipCode: Int)
case class Person(firstName: String, lastName: String, address: Address)

和 Person 类的实例：

val raj = Person("Raj", "Shekhar", Address("M Gandhi Marg", 
                                           "Mumbai", 
                                           "Maharashtra", 
                                           411342))

您可以使用以下命令更新 raj 的邮政编码：

import com.softwaremill.quicklens._
val updatedRaj = raj.modify(_.address.zipCode).using(_ + 1)
于 2017-04-20T08:09:41.147 回答