blocks|key|906760|text|拉链|type|unstyled|depth|inlineStyleRanges|entityRanges|data|906761|Huet's+Zipper提供了对不可变数据结构的方便的遍历和“突变”。Scalaz为Stream+(scalaz.Zipper)和Tree+(scalaz.TreeLoc)提供了拉链。事实证明，拉链的结构可以从原始数据结构自动导出，其方式类似于代数表达式的符号微分。|offset|length|style|CODE|906762|但是这对您的Scala+case类有什么帮助呢？嗯，Lukas+Rytz最近prototyped了一个scalac的扩展，它将自动为带注释的case类创建拉链。我将在这里重现他的例子：|906763|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)|code-block|syntax|javascript|906764|因此，社区需要说服Scala团队，让他们相信这项工作应该继续下去，并集成到编译器中。|906765|顺便说一句，Lukas最近published了一个版本的吃豆人，用户可以通过数字用户线编程。看起来他并没有使用修改过的编译器，因为我看不到任何@zip注释。|906766|树重写|906767|在其他情况下，您可能希望根据某种策略(自上而下、自下而上)并基于与结构中某个点的值相匹配的规则，在整个数据结构中应用一些转换。典型的例子是将AST转换为一种语言，可能是为了计算、简化或收集信息。Kiama支持Rewriting，请参阅RewriterTests中的示例，并观看此video。这里有一个片段来刺激你的胃口：|906768|//+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+%2B+1+})
val+r1+=+Mul+(Num+(2),+Add+(Sub+(Var+("hello"),+Num+(3)),+Var+("harold")))
expect+(r1)+(rewrite+(incint)+(e))|906769|请注意，Kiama+steps+outside类型系统实现了这一点。|906770|entityMap|0|LINK|mutability|MUTABLE|url|http://en.wikipedia.org/wiki/Zipper_(data_structure)|1|http://scalaz.googlecode.com/svn/continuous/latest/browse.sxr/scalaz/Zipper.scala.html|2|http://scalaz.googlecode.com/svn/continuous/latest/browse.sxr/scalaz/TreeLoc.scala.html|3|http://www.scala-lang.org/node/6622|4|http://github.com/soundrabbit/pacman/blob/master/src/main/scala/epfl/pacman/maze/Models.scala|5|http://code.google.com/p/kiama/|6|http://code.google.com/p/kiama/wiki/Rewriting|7|http://code.google.com/p/kiama/source/browse/src/org/kiama/rewriting/RewriterTests.scala#204|8|http://days2010.scala-lang.org/node/138/145|9|http://code.google.com/p/kiama/source/browse/src/org/kiama/rewriting/Rewriter.scala#313^0|0|17|6|1U|4|0|D|0|1F|D|1|20|E|2|0|12|A|3|0|0|0|1Z|4|D|9|4|0|0|2P|5|5|2W|9|6|39|D|7|3V|5|8|0|0|A|D|9|0^^$0|@$1|2|3|4|5|6|7|1Q|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|1R|8|@$D|1S|E|1T|F|G]|$D|1U|E|1V|F|G]]|9|@$D|1W|E|1X|1|1Y]|$D|1Z|E|20|1|21]|$D|22|E|23|1|24]]|A|$]]|$1|H|3|I|5|6|7|25|8|@]|9|@$D|26|E|27|1|28]]|A|$]]|$1|J|3|K|5|L|7|29|8|@]|9|@]|A|$M|N]]|$1|O|3|P|5|6|7|2A|8|@]|9|@]|A|$]]|$1|Q|3|R|5|6|7|2B|8|@$D|2C|E|2D|F|G]]|9|@$D|2E|E|2F|1|2G]]|A|$]]|$1|S|3|T|5|6|7|2H|8|@]|9|@]|A|$]]|$1|U|3|V|5|6|7|2I|8|@]|9|@$D|2J|E|2K|1|2L]|$D|2M|E|2N|1|2O]|$D|2P|E|2Q|1|2R]|$D|2S|E|2T|1|2U]]|A|$]]|$1|W|3|X|5|L|7|2V|8|@]|9|@]|A|$M|N]]|$1|Y|3|Z|5|6|7|2W|8|@]|9|@$D|2X|E|2Y|1|2Z]]|A|$]]|$1|10|3|-4|5|6|7|30|8|@]|9|@]|A|$]]]|11|$12|$5|13|14|15|A|$16|17]]|18|$5|13|14|15|A|$16|19]]|1A|$5|13|14|15|A|$16|1B]]|1C|$5|13|14|15|A|$16|1D]]|1E|$5|13|14|15|A|$16|1F]]|1G|$5|13|14|15|A|$16|1H]]|1I|$5|13|14|15|A|$16|1J]]|1K|$5|13|14|15|A|$16|1L]]|1M|$5|13|14|15|A|$16|1N]]|1O|$5|13|14|15|A|$16|1P]]]]

<h2>Zippers</h2>

<a href="http://en.wikipedia.org/wiki/Zipper_(data_structure)" rel="noreferrer">Huet's Zipper</a> provides convenient traversal and 'mutation' of an immutable data structure. Scalaz provides Zippers for <code>Stream</code> (<a href="http://scalaz.googlecode.com/svn/continuous/latest/browse.sxr/scalaz/Zipper.scala.html" rel="noreferrer">scalaz.Zipper</a>), and <code>Tree</code> (<a href="http://scalaz.googlecode.com/svn/continuous/latest/browse.sxr/scalaz/TreeLoc.scala.html" rel="noreferrer">scalaz.TreeLoc</a>). It turns out that the structure of the zipper is automatically derivable from the original data structure, in a manner that resembles symbolic differentiation of an algebraic expression.

But how does this help you with your Scala case classes? Well, Lukas Rytz recently <a href="http://www.scala-lang.org/node/6622" rel="noreferrer">prototyped</a> an extension to scalac that would automatically create zippers for annotated case classes. I'll reproduce his example here:

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

// Changing the game state to "run" is simple using the copy method:
scala&gt; 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&gt; 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&gt; val g3 = g1.loc.pacman.superMode set true
g3: Game = Game("run",Pacman(3,true)
</code></pre>

So the community needs to persuade the Scala team that this effort should be continued and integrated into the compiler.

Incidentally, Lukas recently <a href="http://github.com/soundrabbit/pacman/blob/master/src/main/scala/epfl/pacman/maze/Models.scala" rel="noreferrer">published</a> a version of Pacman, user programmable through a DSL. Doesn't look like he used the modified compiler, though, as I can't see any <code>@zip</code> annotations.

<h2>Tree Rewriting</h2>

In other circumstances, you might like to apply some transformation across the entire data structure, according to some strategy (top-down, bottom-up), and based on rules that match against the value at some point in the structure. The classical example is transforming an AST for a language, perhaps to evaluate, simplify, or collect information. <a href="http://code.google.com/p/kiama/" rel="noreferrer">Kiama</a> supports <a href="http://code.google.com/p/kiama/wiki/Rewriting" rel="noreferrer">Rewriting</a>, see the examples in <a href="http://code.google.com/p/kiama/source/browse/src/org/kiama/rewriting/RewriterTests.scala#204" rel="noreferrer">RewriterTests</a>, and watch this <a href="http://days2010.scala-lang.org/node/138/145" rel="noreferrer">video</a>. Here's a snippet to whet your appetite:

<pre><code>// 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 =&gt; d + 1 })
val r1 = Mul (Num (2), Add (Sub (Var ("hello"), Num (3)), Var ("harold")))
expect (r1) (rewrite (incint) (e))
</code></pre>

Note that Kiama <a href="http://code.google.com/p/kiama/source/browse/src/org/kiama/rewriting/Rewriter.scala#313" rel="noreferrer">steps outside</a> the type system to achieve this.

blocks|key|1121764|text|有趣的是，没有人添加镜头，因为它们是为这种东西制作的。因此，here是一篇CS背景文章，here是一个博客，简要介绍了Scala中镜头的使用，here是Scalaz的镜头实现，here是一些使用它的代码，看起来很像你的问题。此外，为了减少样板文件，可以使用here's插件为case类生成Scalaz镜头。|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|1121765|对于加分，here's另一个涉及镜头的S.O.问题，以及托尼·莫里斯的paper。|1121766|镜头的重要之处在于它们是可组合的。所以它们一开始有点笨重，但随着你使用它们的次数越来越多，它们就会越来越多。此外，它们对于可测试性也很好，因为你只需要测试单个镜头，并且可以理所当然地认为它们的组成。|1121767|因此，根据这个答案末尾提供的一个实现，这里是如何使用镜头来实现的。首先，声明镜片以更改地址中的邮政编码和人员中的地址：|1121768|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))|code-block|syntax|javascript|1121769|现在，将它们组合起来，得到一个可以改变一个人的邮政编码的镜头：|1121770|val+personZipCodeLens+=+personAddressLens+andThen+addressZipCodeLens|1121771|最后，用这个镜头改变raj：|1121772|val+updatedRaj+=+personZipCodeLens.set(raj,+personZipCodeLens.get(raj)+%2B+1)|1121773|或者，使用一些语法糖：|1121774|val+updatedRaj+=+personZipCodeLens.set(raj,+personZipCodeLens(raj)+%2B+1)|1121775|或者甚至是：|1121776|val+updatedRaj+=+personZipCodeLens.mod(raj,+zip+=>+zip+%2B+1)|1121777|下面是取自Scalaz的简单实现，用于此示例：|1121778|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
}|1121779|entityMap|0|LINK|mutability|MUTABLE|url|http://www.cis.upenn.edu/~bcpierce/papers/lenses-etapsslides.pdf|1|http://debasishg.blogspot.com/2011/01/cqrs-with-akka-actors-and-functional.html|2|http://hpaste.org/41832/lenses_for_scalaz|3|https://gist.github.com/721698|4|https://github.com/gseitz/Lensed|5|https://stackoverflow.com/questions/4562850/basic-scalaz-state-question|6|http://days2012.scala-lang.org/sites/days2012/files/morris_lenses.pdf^0|U|4|0|18|4|1|1Z|4|2|2G|4|3|3K|6|4|0|5|6|5|Z|5|6|0|0|0|0|0|0|0|0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|1S|8|@]|9|@$A|1T|B|1U|1|1V]|$A|1W|B|1X|1|1Y]|$A|1Z|B|20|1|21]|$A|22|B|23|1|24]|$A|25|B|26|1|27]]|C|$]]|$1|D|3|E|5|6|7|28|8|@]|9|@$A|29|B|2A|1|2B]|$A|2C|B|2D|1|2E]]|C|$]]|$1|F|3|G|5|6|7|2F|8|@]|9|@]|C|$]]|$1|H|3|I|5|6|7|2G|8|@]|9|@]|C|$]]|$1|J|3|K|5|L|7|2H|8|@]|9|@]|C|$M|N]]|$1|O|3|P|5|6|7|2I|8|@]|9|@]|C|$]]|$1|Q|3|R|5|L|7|2J|8|@]|9|@]|C|$M|N]]|$1|S|3|T|5|6|7|2K|8|@]|9|@]|C|$]]|$1|U|3|V|5|L|7|2L|8|@]|9|@]|C|$M|N]]|$1|W|3|X|5|6|7|2M|8|@]|9|@]|C|$]]|$1|Y|3|Z|5|L|7|2N|8|@]|9|@]|C|$M|N]]|$1|10|3|11|5|6|7|2O|8|@]|9|@]|C|$]]|$1|12|3|13|5|L|7|2P|8|@]|9|@]|C|$M|N]]|$1|14|3|15|5|6|7|2Q|8|@]|9|@]|C|$]]|$1|16|3|17|5|L|7|2R|8|@]|9|@]|C|$M|N]]|$1|18|3|-4|5|6|7|2S|8|@]|9|@]|C|$]]]|19|$1A|$5|1B|1C|1D|C|$1E|1F]]|1G|$5|1B|1C|1D|C|$1E|1H]]|1I|$5|1B|1C|1D|C|$1E|1J]]|1K|$5|1B|1C|1D|C|$1E|1L]]|1M|$5|1B|1C|1D|C|$1E|1N]]|1O|$5|1B|1C|1D|C|$1E|1P]]|1Q|$5|1B|1C|1D|C|$1E|1R]]]]

Funny that no one added lenses, since they were MADE for this kind of stuff. So, <a href="http://www.cis.upenn.edu/~bcpierce/papers/lenses-etapsslides.pdf" rel="noreferrer">here</a> is a CS background paper on it, <a href="http://debasishg.blogspot.com/2011/01/cqrs-with-akka-actors-and-functional.html" rel="noreferrer">here</a> is a blog which touch briefly on lenses use in Scala, <a href="http://hpaste.org/41832/lenses_for_scalaz" rel="noreferrer">here</a> is a lenses implementation for Scalaz and <a href="https://gist.github.com/721698" rel="noreferrer">here</a> is some code using it, which looks surprisingly like your question. And, to cut down on boiler plate, <a href="https://github.com/gseitz/Lensed" rel="noreferrer">here's</a> a plugin that generate Scalaz lenses for case classes.

For bonus points, <a href="https://stackoverflow.com/questions/4562850/basic-scalaz-state-question">here's</a> another S.O. question which touches on lenses, and a <a href="http://days2012.scala-lang.org/sites/days2012/files/morris_lenses.pdf" rel="noreferrer">paper</a> by Tony Morris.

The big deal about lenses is that they are composable. So they are a bit cumbersome at first, but they keep gaining ground the more you use them. Also, they are great for testability, since you only need to test individual lenses, and can take for granted their composition.

So, based on an implementation provided at the end of this answer, here's how you'd do it with lenses. First, declare lenses to change a zip code in an address, and an address in a person:

<pre><code>val addressZipCodeLens = Lens(
 get = (_: Address).zipCode,
 set = (addr: Address, zipCode: Int) =&gt; addr.copy(zipCode = zipCode))

val personAddressLens = Lens(
 get = (_: Person).address, 
 set = (p: Person, addr: Address) =&gt; p.copy(address = addr))
</code></pre>

Now, compose them to get a lens that changes zipcode in a person:

<pre><code>val personZipCodeLens = personAddressLens andThen addressZipCodeLens
</code></pre>

Finally, use that lens to change raj:

<pre><code>val updatedRaj = personZipCodeLens.set(raj, personZipCodeLens.get(raj) + 1)
</code></pre>

Or, using some syntactic sugar:

<pre><code>val updatedRaj = personZipCodeLens.set(raj, personZipCodeLens(raj) + 1)
</code></pre>

Or even:

<pre><code>val updatedRaj = personZipCodeLens.mod(raj, zip =&gt; zip + 1)
</code></pre>

Here's the simple implementation, taken from Scalaz, used for this example:

<pre><code>case class Lens[A,B](get: A =&gt; B, set: (A,B) =&gt; 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 =&gt; B) = set(a, f(this(a)))
 def compose[C](that: Lens[C,A]) = Lens[C,B](
 c =&gt; this(that(c)),
 (c, b) =&gt; that.mod(c, set(_, b))
 )
 def andThen[C](that: Lens[B,C]) = that compose this
}
</code></pre>

blocks|key|1121819|text|我一直在寻找语法最好、功能最好的Scala库，这里没有提到的一个库是monocle，它对我来说真的很好。下面是一个示例：|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|1121820|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+%7C->+mkLens[A,+String]("s")

//Usage
val+b+=+B(A("hi"))
val+newB+=+b+%7C->+sLens+set("goodbye")+//+gives+B(A("goodbye"))|code-block|syntax|javascript|1121821|这些都是非常好的，有很多方法来组合镜头。以Scalaz为例，它需要大量的样板文件，编译速度快，运行良好。|1121822|要在项目中使用它们，只需将以下代码添加到您的依赖项中：|1121823|resolvers+%2B%2B=+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+%2B%2B=+Seq(
++"com.github.julien-truffaut"++%25%25++"monocle-core"++++%25+libraryVersion,
++"com.github.julien-truffaut"++%25%25++"monocle-generic"+%25+libraryVersion,
++"com.github.julien-truffaut"++%25%25++"monocle-macro"+++%25+libraryVersion,+++++++//+since+0.4.0
++"com.github.julien-truffaut"++%25%25++"monocle-law"+++++%25+libraryVersion+%25+test+//+since+0.4.0
)|1121824|entityMap|0|LINK|mutability|MUTABLE|url|https://github.com/julien-truffaut/Monocle^0|Y|7|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|W|8|@]|9|@$A|X|B|Y|1|Z]]|C|$]]|$1|D|3|E|5|F|7|10|8|@]|9|@]|C|$G|H]]|$1|I|3|J|5|6|7|11|8|@]|9|@]|C|$]]|$1|K|3|L|5|6|7|12|8|@]|9|@]|C|$]]|$1|M|3|N|5|F|7|13|8|@]|9|@]|C|$G|H]]|$1|O|3|-4|5|6|7|14|8|@]|9|@]|C|$]]]|P|$Q|$5|R|S|T|C|$U|V]]]]

I've been looking around for what Scala library that has the nicest syntax and the best functionality and one library not mentioned here is <a href="https://github.com/julien-truffaut/Monocle" rel="noreferrer">monocle</a> which for me has been really good. An example follows:

<pre><code>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 |-&gt; mkLens[A, String]("s")

//Usage
val b = B(A("hi"))
val newB = b |-&gt; sLens set("goodbye") // gives B(A("goodbye"))
</code></pre>

These are very nice and there are many ways to combine the lenses. Scalaz for example demands a lot of boilerplate and this compiles quick and runs great.

To use them in your project just add this to your dependencies:

<pre><code>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
)
</code></pre>

blocks|key|1121892|text|由于其可组合的性质，镜头为大量嵌套结构的问题提供了一个非常好的解决方案。然而，由于嵌套级别较低，我有时觉得镜头有点太多了，如果只有几个地方有嵌套更新，我就不想介绍整个镜头方法。为了完整起见，这里有一个非常简单实用的解决方案：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1121893|我所做的就是在顶层结构中简单地编写几个modify...助手函数，这些函数处理丑陋的嵌套副本。例如：|offset|length|style|CODE|1121894|case+class+Person(firstName:+String,+lastName:+String,+address:+Address)+{
++def+modifyZipCode(modifier:+Int+=>+Int)+=+
++++this.copy(address+=+address.copy(zipCode+=+modifier(address.zipCode)))
}|code-block|syntax|javascript|1121895|我的主要目标(简化客户端的更新)实现了：|1121896|val+updatedRaj+=+raj.modifyZipCode(_+=>+41).modifyZipCode(_+%2B+1)|1121897|创建完整的修改帮助器显然很烦人。但对于内部内容来说，在第一次尝试修改某个嵌套字段时创建它们通常是可以的。|1121898|entityMap^0|0|J|9|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|U|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|V|8|@$D|W|E|X|F|G]]|9|@]|A|$]]|$1|H|3|I|5|J|7|Y|8|@]|9|@]|A|$K|L]]|$1|M|3|N|5|6|7|Z|8|@]|9|@]|A|$]]|$1|O|3|P|5|J|7|10|8|@]|9|@]|A|$K|L]]|$1|Q|3|R|5|6|7|11|8|@]|9|@]|A|$]]|$1|S|3|-4|5|6|7|12|8|@]|9|@]|A|$]]]|T|$]]

Due to their composable nature, lenses provide a very nice solution to the problem of heavily nested structures. However with a low level of nesting, I sometimes feel lenses are a bit too much, and I don't want to introduce the whole lenses approach if there is only few places with nested updates. For sake of completeness, here is a very simple/pragmatic solution for this case:

What I do is to simply write a few <code>modify...</code> helper functions in the top level structure, which deal with the ugly nested copy. For instance:

<pre><code>case class Person(firstName: String, lastName: String, address: Address) {
 def modifyZipCode(modifier: Int =&gt; Int) = 
 this.copy(address = address.copy(zipCode = modifier(address.zipCode)))
}
</code></pre>

My main goal (simplifying the update on client side) is achieved:

<pre><code>val updatedRaj = raj.modifyZipCode(_ =&gt; 41).modifyZipCode(_ + 1)
</code></pre>

Creating the full set of modify helpers is obviously annoying. But for internal stuff it is often okay to just create them the first time you try to modify a certain nested field.

blocks|key|907040|text|Shapeless做到了这一点：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|907041|"com.chuusai"+%25+"shapeless_2.11"+%25+"2.0.0"|code-block|syntax|javascript|907042|通过以下方式：|907043|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+%2B+1))

++++++//+when+we+use+a+lens
++++++val+lensUpdatedRaj+=+zipLens.set(raj)(raj.address.zipCode+%2B+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+%2B+1))

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

++++++//+then+it+matches+the+explicit+copy
++++++assert(lensUpdatedRaj+==+updatedRaj)
++++}
++}
}|907044|请注意，虽然这里的一些其他答案可以让您组成镜头，以更深入地了解给定的结构，但这些无形状镜头(以及其他库/宏)允许您组合两个不相关的镜头，以便您可以在结构中的任意位置设置任意数量的参数。对于复杂的数据结构，这种额外的组合非常有用。|907045|entityMap^0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|O|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|P|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|Q|8|@]|9|@]|A|$]]|$1|I|3|J|5|D|7|R|8|@]|9|@]|A|$E|F]]|$1|K|3|L|5|6|7|S|8|@]|9|@]|A|$]]|$1|M|3|-4|5|6|7|T|8|@]|9|@]|A|$]]]|N|$]]

Shapeless does the trick:

<pre><code>"com.chuusai" % "shapeless_2.11" % "2.0.0"
</code></pre>

with: 

<pre><code>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] &gt;&gt; 'address &gt;&gt; 'zipCode 
 val surnameLens = lens[Person] &gt;&gt; '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)
 }
 }
}
</code></pre>

Note that whilst some other answers here let you compose lenses to go deeper into a given structure these shapless lenses (and other libraries/macros) let you combine two unrelated lenses such that you can make lens that sets an arbitrary number of parameters into arbitrary positions in your structure. For complex data structures that additional composition is very helpful.

blocks|key|907116|text|也许QuickLens更符合你的问题。QuickLens使用宏将集成开发环境友好的表达式转换为接近原始复制语句的内容。|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|907117|给定两个示例case类：|907118|case+class+Address(street:+String,+city:+String,+state:+String,+zipCode:+Int)
case+class+Person(firstName:+String,+lastName:+String,+address:+Address)|code-block|syntax|javascript|907119|以及Person类的实例：|907120|val+raj+=+Person("Raj",+"Shekhar",+Address("M+Gandhi+Marg",+
+++++++++++++++++++++++++++++++++++++++++++"Mumbai",+
+++++++++++++++++++++++++++++++++++++++++++"Maharashtra",+
+++++++++++++++++++++++++++++++++++++++++++411342))|907121|您可以使用以下命令更新raj的zipCode：|907122|import+com.softwaremill.quicklens._
val+updatedRaj+=+raj.modify(_.address.zipCode).using(_+%2B+1)|907123|entityMap|0|LINK|mutability|MUTABLE|url|https://github.com/adamw/quicklens^0|2|9|0|0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|10|8|@]|9|@$A|11|B|12|1|13]]|C|$]]|$1|D|3|E|5|6|7|14|8|@]|9|@]|C|$]]|$1|F|3|G|5|H|7|15|8|@]|9|@]|C|$I|J]]|$1|K|3|L|5|6|7|16|8|@]|9|@]|C|$]]|$1|M|3|N|5|H|7|17|8|@]|9|@]|C|$I|J]]|$1|O|3|P|5|6|7|18|8|@]|9|@]|C|$]]|$1|Q|3|R|5|H|7|19|8|@]|9|@]|C|$I|J]]|$1|S|3|-4|5|6|7|1A|8|@]|9|@]|C|$]]]|T|$U|$5|V|W|X|C|$Y|Z]]]]

Perhaps <a href="https://github.com/adamw/quicklens" rel="nofollow noreferrer">QuickLens</a> matches your question better. QuickLens uses macro's to convert an IDE friendly expression into something that is close to the original copy statement.

Given the two example case classes:

<pre><code>case class Address(street: String, city: String, state: String, zipCode: Int)
case class Person(firstName: String, lastName: String, address: Address)
</code></pre>

and the instance of Person class:

<pre><code>val raj = Person("Raj", "Shekhar", Address("M Gandhi Marg", 
 "Mumbai", 
 "Maharashtra", 
 411342))
</code></pre>

you can update zipCode of raj with:

<pre><code>import com.softwaremill.quicklens._
val updatedRaj = raj.modify(_.address.zipCode).using(_ + 1)
</code></pre>

Say I have got following two <code>case class</code>es:

<pre><code>case class Address(street: String, city: String, state: String, zipCode: Int)
case class Person(firstName: String, lastName: String, address: Address)
</code></pre>

and the following instance of <code>Person</code> class:

<pre><code>val raj = Person("Raj", "Shekhar", Address("M Gandhi Marg", 
 "Mumbai", 
 "Maharashtra", 
 411342))
</code></pre>

Now if I want to update <code>zipCode</code> of <code>raj</code> then I will have to do:

<pre><code>val updatedRaj = raj.copy(address = raj.address.copy(zipCode = raj.address.zipCode + 1))
</code></pre>

With more levels of nesting this gets even more uglier. Is there a cleaner way (something like Clojure's <code>update-in</code>) to update such nested structures?

Cleaner way to update nested structures

集成开发环境

数据结构

编译器

Pacman

假设我有以下两个case classE：case class Address(street: String, city: String, state: String, zipCode: Int)case class Person(firstName: String, lastName: String, address:...

问更新嵌套结构的更干净的方法
EN

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问更新嵌套结构的更干净的方法EN

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问更新嵌套结构的更干净的方法
EN