掌握不可变数据结构

Question

我正在学习 scala，作为一名好学生，我尝试遵守我发现的所有规则。

一条规则是：不变性！！！

所以我尝试用不可变的数据结构和值来编写所有内容，有时这真的很难。

但今天我心想：唯一重要的是对象/类不应该有可变的状态。我不必被迫以不可变的风格编写所有方法，因为这些方法不会相互影响。

我的问题：我是否正确，或者是否有任何我没有看到的问题/缺点？

编辑：

aishwarya 的代码示例：

def logLikelihood(seq: Iterator[T]): Double = {
  val sequence = seq.toList
  val stateSequence = (0 to order).toList.padTo(sequence.length,order)
  val seqPos = sequence.zipWithIndex

  def probOfSymbAtPos(symb: T, pos: Int) : Double = {
    val state = states(stateSequence(pos))
    M.log(state( seqPos.map( _._1 ).slice(0, pos).takeRight(order), symb))
  }

  val probs = seqPos.map( i => probOfSymbAtPos(i._1,i._2) )

  probs.sum
}  

说明：这是一种计算变量阶齐次马尔可夫模型的对数似然的方法。 state 的 apply 方法获取所有先前的符号和即将到来的符号，并返回这样做的概率。

正如您所看到的：整个方法只是乘以一些概率，使用变量会更容易。

Answer 1

该规则并不是真正的不变性，而是引用透明度。使用本地声明的可变变量和数组是完全可以的，因为整个程序的任何其他部分都无法观察到任何影响。

引用透明 (RT) 的原则是这样的：

如果对于所有程序 p 每次出现 e，则表达式 e 是引用透明 p 中的 可以替换为 e 的计算结果，而不影响 p 的可观察结果。

请注意，如果 e 创建并改变某些本地状态，它不会违反 RT，因为没有人可以观察到这种情况的发生。

也就是说，我非常怀疑您的 vars 实现是否更加简单。

Answer 2

函数式编程的案例之一是代码简洁并引入更数学的方法。它可以减少出现错误的可能性，并使您的代码更小、更具可读性。至于变得容易与否，确实需要你以不同的方式思考你的问题。但是，一旦您习惯了使用函数式模式进行思考，函数式模式可能会变得比命令式风格更容易。

实现完美功能并具有零可变状态确实很困难，但拥有最小可变状态非常有益。需要记住的是，一切都需要平衡地完成，而不是走极端。通过减少可变状态的数量，最终会导致编写产生意外后果的代码变得更加困难。一种常见的模式是拥有一个其值不可变的可变变量。这样身份（命名变量）和值（可以分配变量的不可变对象）是分开的。

var acc: List[Int] = Nil
// lots of complex stuff that adds values
acc ::= 1
acc ::= 2
acc ::= 3
// do loop current list
acc foreach { i => /* do stuff that mutates acc */ acc ::= i * 10 }
println( acc ) // List( 1, 2, 3, 10, 20, 30 )

foreach 正在循环我们启动 foreach 时的 acc 值。 acc 的任何突变都不会影响循环。这比 java 中的典型迭代器安全得多，其中列表可以在迭代中更改。

还有一个并发问题。 由于 JSR-133 内存模型规范，不可变对象非常有用，该规范断言对象最终成员的初始化将在任何线程对这些成员具有可见性之前发生，就这样！如果它们不是最终的，那么它们是“可变的”，并且不能保证正确的初始化。

Actor 是放置可变状态的完美场所。表示数据的对象应该是不可变的。以下面的例子为例。

object MyActor extends Actor {
  var acc: List[Int] = Nil
  def act() {
    loop {
      react {
        case i: Int => acc ::= i
        case "what is your current value" => reply( acc )
        case _ => // ignore all other messages
      }
    }
  }
}

在这种情况下，我们可以发送 acc 的值（它是一个 List ），并且不用担心同步，因为 List 是不可变的，即 List 对象的所有成员都是最终的。另外，由于不变性，我们知道没有其他参与者可以更改发送的底层数据结构，因此没有其他参与者可以更改该参与者的可变状态。

Answer 3

由于 Apocalisp 已经提到< /a> 我要引用他的内容，我将讨论代码。你说它只是乘以东西，但我没有看到这一点——它引用了至少三个外部定义的重要方法：order、states和M.log。我可以推断 order 是一个 Int，并且 states 返回一个采用 List[T] 的函数和一个 T 并返回 Double。

还有一些奇怪的事情发生...

def logLikelihood(seq: Iterator[T]): Double = {
  val sequence = seq.toList

除了定义 seqPos 之外，从未使用过序列，那么为什么要这样做呢？

  val stateSequence = (0 to order).toList.padTo(sequence.length,order)
  val seqPos = sequence.zipWithIndex

  def probOfSymbAtPos(symb: T, pos: Int) : Double = {
    val state = states(stateSequence(pos))
    M.log(state( seqPos.map( _._1 ).slice(0, pos).takeRight(order), symb))

实际上，您可以在此处使用 sequence 而不是 seqPos.map( _._1 )，因为所做的只是撤消 zipWithIndex。另外，slice(0, pos) 只是take(pos)。

  }

  val probs = seqPos.map( i => probOfSymbAtPos(i._1,i._2) )

  probs.sum
}

现在，考虑到缺少的方法，很难断言应该如何以函数式风格编写它。保留神秘方法会产生：

def logLikelihood(seq: Iterator[T]): Double = {
  import scala.collection.immutable.Queue
  case class State(index: Int, order: Int, slice: Queue[T], result: Double)

  seq.foldLeft(State(0, 0, Queue.empty, 0.0)) {
    case (State(index, ord, slice, result), symb) =>
      val state = states(order)
      val partial = M.log(state(slice, symb))
      val newSlice = slice enqueue symb
      State(index + 1, 
            if (ord == order) ord else ord + 1, 
            if (queue.size > order) newSlice.dequeue._2 else newSlice,
            result + partial)
  }.result
}

只有我怀疑 state/M.log 内容也可以成为 State 的一部分。既然我已经这样写了，我注意到其他优化。当然，您使用的滑动窗口让我想起了滑动：

seq.sliding(order).zipWithIndex.map { 
  case (slice, index) => M.log(states(index + order)(slice.init, slice.last))
}.sum

它只会从第一个元素开始，因此需要进行一些调整。不过，并不是太难。所以让我们再重写一次：

def logLikelihood(seq: Iterator[T]): Double = {
  val sequence = seq.toList
  val slices = (1 until order).map(sequence take) ::: sequence.sliding(order)
  slices.zipWithIndex.map { 
    case (slice, index) => M.log(states(index)(slice.init, slice.last))
  }.sum
}

我希望我能看到 M.log 和 states...我打赌我可以把 map 变成 < code>foldLeft 并取消这两个方法。我怀疑 states 返回的方法可以采用整个切片而不是两个参数。

不过……还不错吧？