Question

在scala中，我有一个返回值的函数列表。执行函数的顺序很重要，因为函数n的参数是函数n-1的输出。

这提示使用foldLeft，例如：

val base: A
val funcs: Seq[Function[A, A]]

funcs.foldLeft(base)(x, f) => f(x)

（详细信息：类型A实际上是Spark DataFrame）。

但是，每个函数的结果是互斥的，最后我想要每个函数的所有结果的并集。这提示使用map，例如：

funcs.map(f => f(base)).reduce(_.union(_)

但是这里每个函数都应用于base，这不是我想要的。

简短：有序函数的可变长度列表需要返回相等长度的返回值的列表，其中每个值n-1是函数n的输入（从{{1}开始） } base）。这样就可以连接结果值。

我怎样才能做到这一点？

修改例如：

n=0

这适用于任意数量的函数（例如case class X(id:Int, value:Int) val base = spark.createDataset(Seq(X(1, 1), X(2, 2), X(3, 3), X(4, 4), X(5, 5))).toDF def toA = (x: DataFrame) => x.filter('value.mod(2) === 1).withColumn("value", lit("a")) def toB = (x: DataFrame) => x.withColumn("value", lit("b")) val a = toA(base) val remainder = base.join(a, Seq("id"), "leftanti") val b = toB(remainder) a.union(b) +---+-----+ | id|value| +---+-----+ | 1| a| | 3| a| | 5| a| | 2| b| | 4| b| +---+-----+，toA ... toB。每次计算前一个结果的剩余部分并传递给下一个函数函数。最后，联合应用于所有结果。

Answer 1

Seq已经有一个方法scanLeft可以开箱即用：

funcs.scanLeft(base)((acc, f) => f(acc)).tail

如果您不想要scanLeft，请务必删除base结果的第一个元素。

仅使用foldLeft也可以：

funcs.foldLeft((base, List.empty[A])){ case ((x, list), f) => 
  val res = f(x)
  (res, res :: list) 
}._2.reverse.reduce(_.union(_))

或者：

funcs.foldLeft((base, Vector.empty[A])){ case ((x, list), f) => 
  val res = f(x)
  (res, list :+ res) 
}._2.reduce(_.union(_))

诀窍是累积到Seq内的fold。

示例：

scala> val base = 7
base: Int = 7

scala> val funcs: List[Int => Int] = List(_ * 2, _ + 3)
funcs: List[Int => Int] = List($$Lambda$1772/1298658703@7d46af18, $$Lambda$1773/107346281@5470fb9b)

scala> funcs.foldLeft((base, Vector.empty[Int])){ case ((x, list), f) => 
     |   val res = f(x)
     |   (res, list :+ res) 
     | }._2
res8: scala.collection.immutable.Vector[Int] = Vector(14, 17)

scala> .reduce(_ + _)
res9: Int = 31

Answer 2

我有一个使用普通集合的简化解决方案，但同样的原则适用。

val list: List[Int] = List(1, 2, 3, 4, 5)
val funcs: Seq[Function[List[Int], List[Int]]] = Seq(times2, by2)

funcs.foldLeft(list) { case(collection, func) => func(collection) } foreach println // prints 1 2 3 4 5

def times2(l: List[Int]): List[Int] = l.map(_ * 2)

def by2(l: List[Int]): List[Int] = l.map(_ / 2)

如果您希望将单个减少的值作为最终输出，则此解决方案不成立，例如单Int;因此这适用于： F[B] -> F[B] -> F[B]而不是F[B] -> F[B] -> B;虽然我想这就是你需要的。

带有因变量的Scala映射

2 个答案: