Question

我想在数据集上运行转换列表。这些转换的输入和输出在类型方面始终相同，因此我可以任意选择一个订单。最后，我想评估不同订单的执行情况（输出数据的质量，计算性能等）。所以我给程序一个文件，其中每行包含一个函数标识符，我按这样运行：

// read lines of file into plan
for (x <- plan) {

  val temp : myDataType

  x match {
    case "Func_A" => temp = myData.map(y => funcA(y))
    case "Func_B" => temp = myData.map(y => funcB(y))
    ...
  }

  myData = temp
}

myDataType是不可变的集合，迫使我使用这些临时变量。 plan可能包含20行/函数标识符，这将导致大量复制操作。所以我正在寻找更好的解决方案。我的梦想是将所有map函数链接起来，其中write只是一个收集统计信息并将其写入光盘的函数，不需要临时变量：

plan match {
  case "Plan_A" => myData.map(x => funcB(x)).map(x => funcA(x)).map(...).write
  case "Plan_B" => myData.map(x => funcA(x)).map(...).map(x => funcA(x)).write
  ...
}

然而，在这种情况下，我需要提前知道所有（至少我想尝试的）排列，并且会有很多（20多个函数）。我还研究了编译时/运行时代码生成，但对我来说看起来有点过分了。

所以也许你有一些想法如何解决这个问题更优雅。

Answer 1

我认为这里有两件事需要解决。

将功能链接在一起
获取一系列功能

注意：为简单起见，我假设您在Int上操作，因此函数类型为Int => Int。你说你要映射到相同的类型。

1。链

假设您有一系列功能和一些数据，您可以执行以下操作：

...
val plan: Seq[Int => Int] = ... // see my second point
...
val myData = List(1, 2, 3, 4) // immutable List

// Can use compose instead of andThen
val compositeFunc = plan.foldLeft((i: Int) => i)(_ andThen _)
val newData = myData map compositeFunc

请注意，您可以使用andThen或compose（https://twitter.github.io/scala_school/pattern-matching-and-functional-composition.html）

2。获得一系列功能（计划）

您可以通过多种方式执行此操作：

在代码中的某个地图中定义它们
在代码中定义它们并使用反射
在运行时编译它们

地图中的静态定义

class MyFunctions {
  def f1(i: Int): Int = i * 2
  def f2(i: Int): Int = i * i
  def f3(i: Int): Int = i * i * i

  // Hardcoded map from string to function name
  // Avoids any reflection
  val funMap = Map[String, (Int) => Int](
    "f1" -> f1,
    "f2" -> f2,
    "f3" -> f3
  )
}

val funcs = new MyFunctions

val myData = List(1, 2, 3, 4) // immutable List

// Assume you read these from your file
val planFromFile = List("f1", "f3", "f2") // String function names

// Get functions using the hardcoded map
val plan = planFromFile map (name => funcs.funMap(name))

// Can use compose instead of andThen
val compositeFunc = plan.foldLeft((i: Int) => i)(_ andThen _)

// Map the function composition to your data
val newData = myData map compositeFunc

使用反射

import scala.reflect.runtime.{universe => ru}

class MyFunctions {
  def f1(i: Int): Int = i * 2
  def f2(i: Int): Int = i * i
  def f3(i: Int): Int = i * i * i
}

val funcs = new MyFunctions

val myData = List(1, 2, 3, 4) // immutable List

// Assume you read these from your file
val planFromFile = List("f1", "f3", "f2") // String function names

// Acts as a function wrapper that wraps a MethodMirror
// Note that all functions in Scala are objects ((Int => Int) is shorthand for Function1 ...)
class WrappedFunction(mirror: reflect.runtime.universe.MethodMirror) extends (Int => Int) {
  override def apply(v1: Int): Int = mirror(v1).asInstanceOf[Int]
}

// Returns function wrappers for each string
// Note for simplicity there is no code dealing with missing function , errors etc.
def getFunctions(names: Seq[String]): Seq[Int => Int] =
  names.map(s => new WrappedFunction(ru.runtimeMirror(funcs.getClass.getClassLoader)
    .reflect(funcs)
    .reflectMethod(ru.typeOf[MyFunctions]
      .decl(ru.TermName(s)).asMethod)))


val reflectedFunctions = getFunctions(planFromFile)

// Compose them from the generated functions
val compositeFunc2 = reflectedFunctions.foldLeft((i: Int) => i)(_ andThen _)

// Generate data
val newData2 = myData map compositeFunc2

我没有谈到在运行时编译，我假设这不是你的用例。

您还可以组合这些方法并使用反射生成地图。

编辑显然你也可以使用模式匹配而不是那个地图..这样的事情：

def fromName(name: String): Int => Int = name match {
    case "f1" => f1
    case "f2" => f2
    case "f3" => f3
    case _ => throw new IllegalArgumentException("booooom!")
}

有关反射的详细信息，请参阅文档：http://docs.scala-lang.org/overviews/reflection/overview.html

置换函数调用

1 个答案:

1。链

2。获得一系列功能（计划）