Question

我必须处理订单序列（此处为Int以简化）：

// the handleOrder methods are in fact much more complicated:
def handleOrders(prev: Double, orders: Seq[Int]): Double = prev + orders.sum
def handleOrder(prev: Double, order: Int): Double = prev / order

由于所谓的

def nextGroup(prev: Double, orders: Seq[Int]): Seq[Double]

function我得到另一个类的序列（这里为Double进行简化）。

由此我实现了两个版本。

版本1（foldLeft和显式构建器）：

def nextGroup1(prev: Double, orders: Seq[Int]): Seq[Double] = {
  import collection.mutable.Builder
  import collection.immutable.VectorBuilder
  val bld: Builder[Double, Seq[Double]] = new VectorBuilder[Double]
  var first = true
  orders.foldLeft(prev) { (prev, order) =>
    val step = if (first) handleOrders(prev, orders) else prev
    val next = handleOrder(step, order)
    first = false
    bld += next
    next
  }
  bld.result
}

版本2（var和yield构建器）：

def nextGroup2(prev: Double, orders: Seq[Int]): Seq[Double] = {
  var first = true
  var präv = prev
  for (order <- orders) yield {
    if (first) präv = handleOrders(präv, orders)
    präv = handleOrder(präv, order)
    first = false
    präv
  }
}

我想在版本1中保存显式构建器，或在版本2中保存可变var。

这可能吗？也许结合使用foldLeft和for - yield？

还有一些示例数据：

val orders = Seq(1, 2, 3)
nextGroup1(1d, orders) // => Vector(7.0, 3.5, 1.1666666666666667)
nextGroup2(1d, orders) // => List(7.0, 3.5, 1.1666666666666667)
nextGroup1(2d, orders) // => Vector(8.0, 4.0, 1.3333333333333333)
nextGroup2(2d, orders) // => List(8.0, 4.0, 1.3333333333333333)

nextGroup结果处理为Seq[Double]，因此Vector或List没有区别。

Answer 1

orders.tail.scanLeft(handleOrders(prev, orders)) { (p, o) => handleOrder(p, o) }

scanLeft与foldLeft的作用相同，但会保留所有中间结果。您可以通过排除使用head可以执行的集合的orders.tail来消除特殊情况。

是否有foldLeft和for-yield的组合？

1 个答案: