在 Scala 中管理灵活、类型化、不可变数据结构的正确方法是什么？

Question

现在我有这样的课程：

abstract class Record {
  // Required fields
  val productCode:Option[String]
  val price:Option[Double]

  // Optional fields
  val notes:Option[String] = None
  val used:Option[Boolean] = Option(false)
}

然后创建它们：

val r = new Record {
  override val productCode = Option("abc")
  override val price = Option(32.12)
}

需要注意的几点：

1. 我将 Option 用于非可选字段，以便 一种。我不必记住哪些字段是可选的 湾。我可以在不更改界面的情况下更改哪些字段是可选的
2. Option 的东西增加了很多噪音。我希望它不存在，但我也不想使用空值。当我使用该结构时，考虑到所有对 getOrElse 的调用时尤其如此。 （我敢打赌，该语言有一种巧妙的方式来声明性地自动装箱。）

3. 如果子类混合了新字段，例如：

   override val List(productCode, price, discount) = fields // fields is a List

不会编译，因为discount 没有在超类中定义，因此没有覆盖。我不确定是否有办法做到这一点。

我的主要问题是：

1. 是否有更好的整体方法来管理不可变数据结构？
2. 是否有一种直接的方法可以复制记录并仅更改一个值而无需编写样板代码？

例如（伪代码}：

val r2 = r.clone { override val used = true }

我听说 2.8 为案例类引入了类似的东西，但是在一种鼓励不可变数据结构的语言中，我会惊讶地发现这在 2.8 之前并不容易。我还在 2.7 中。

Answer 1

这似乎是 2.8 中解决的一个问题：

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

val joe = Employee("Joe", 25)
val bob = joe copy (name = "Bob")

将此与默认值结合起来，您给出的示例可以很容易地重写为案例类，我认为这是实现不可变数据类型的“正确”方式。 （我不确定 scala 是否如此，但来自 ocaml/haskell，这似乎是正确的。）

在 2.7 中，您将不得不实现一大堆辅助函数：

def asUsed(r: Record): Record = {
  Record(r.productCode, r.price, r.nodes, Some(true))
}

哎呀。他们真的应该快点 2.8...

Answer 2

克隆实例没有简单的方法。 FWIW，不可变数据结构通常很深。例如，List 类只有两个成员：hd 和 tl。列表通过链接成员而增长。

您克隆此类结构，方法是创建最少数量的新数据结构，并尽可能多地引用旧数据结构。通常，这是通过 递归。

您可以在本书Purely Functional Data Structures 中了解更多信息。本书所依据的paper 是免费提供的。

您可以在此处查找 Scala 问题，了解处理 Option 数据的有趣方法。很遗憾，对于您的其他问题，我没有任何解决方案。

Answer 3

将Option 用于非可选字段对我来说似乎很疯狂：为什么？

Answer 4

正如已经说过的，在当前（2.7）Scala 中没有直接的方法可以做到这一点，但从我的角度来看，使用构建器模式可以很容易地做到这一点。演示代码：

abstract class Record {
  // Required fields
  val productCode:Option[String]
  val price:Option[Double]

  // Optional fields
  val notes:Option[String] = None
  val used:Option[Boolean] = Option(false)
}
class RecordBuilder{
  private var _productCode:Option[String] = null
  private var _price:Option[Double] = null

  // Optional fields
  private var _notes:Option[String] = None
  private var _used:Option[Boolean] = Option(false)

  def productCode(in:Option[String]) : RecordBuilder = {
    _productCode = in
    this
  }
  def price(in : Option[Double]) : RecordBuilder = {
    _price = in
    this
  }
  def notes(in:Option[String]) : RecordBuilder = {
    _notes = in
    this
  }
  def used (in : Option[Boolean]) : RecordBuilder = {
    _used = in
    this
  }

  def create() : Record  =  {
   val r =  new Record = {
      override productCode = _productCode
      override price = _price
      override notes = _notes
      override used  = _used

    }
  r
}
}
object Record{
  def from(in:Record) : RecordBuilder = {
    val r = new RecordBuilder
    r.productCode(in.productCode).price(in.price).notes(in.notes)
    .used(in.used)
  }
}
object Test {
  def main(args:Array[String]) = {
    val r = new Record {
    override val productCode = Option("abc")
    override val price = Option(32.12)}
  }
  val r1 = Record.from(r).used(true).create
}

Answer 5

镜头是对不可变数据结构进行操作的绝佳工具。见this question。