Scala 中编译时对象创建的语法糖

Question

假设我

trait fooTrait[T] {
  def fooFn(x: T, y: T) : T 
}

希望用户能够使用自己定义的 fooFn 主体快速声明 fooTrait 的新实例。理想情况下，我想要一些类似的

val myFoo : fooTrait[T] = newFoo((x:T, y:T) => x+y) 

工作。但是，我不能这样做，

def newFoo[T](f: (x:T, y:T) => T) = new fooTrait[T] { def fooFn(x:T, y:T):T = f(x,y); }

因为这使用了闭包，因此当程序多次运行时会产生不同的对象。我真正需要的是能够获取 newFoo 返回的对象的 classOf ，然后使其可以在不同的机器上构造。我该怎么办？

如果您对用例感兴趣，我正在尝试为 Hadoop 编写一个 Scala 包装器，它允许您执行

IO("Data") --> ((x: Int, y: Int) => (x, x+y)) --> IO("Out")

中间的东西需要转换为实现特定接口的类，然后可以在不同的接口上实例化机器（执行相同的 jar 文件）仅通过类名。

请注意，Scala 使用转换 (x:Int) => 的语法糖做了正确的事情。 x+5 为 Function1 的实例。我的问题是我是否可以在不破坏 Scala 内部结构的情况下复制它。如果这是 lisp（正如我习惯的那样），这将是一个微不足道的编译时宏...:sniff:

Answer 1

这是一个与您在问题中列出的语法相匹配并序列化/执行匿名函数的版本。请注意，这会序列化 Function2 对象的状态，以便可以在另一台计算机上恢复序列化版本。仅类名是不够的，如下所示的解决方案。

您应该创建自己的编码/解码函数，即使只是包含您自己的 Base64 实现（不依赖 Sun 的 Hotspot）。

object SHadoopImports {
    import java.io._

    implicit def functionToFooString[T](f:(T,T)=>T) = {
        val baos = new ByteArrayOutputStream()
        val oo = new ObjectOutputStream(baos)
        oo.writeObject(f)
        new sun.misc.BASE64Encoder().encode(baos.toByteArray())
    }

    implicit def stringToFun(s: String) = {
        val decoder = new sun.misc.BASE64Decoder();
        val bais = new ByteArrayInputStream(decoder.decodeBuffer(s))
        val oi = new ObjectInputStream(bais)  
        val f = oi.readObject()
        new {
            def fun[T](x:T, y:T): T = f.asInstanceOf[Function2[T,T,T]](x,y)
        }
    }
}

// I don't really know what this is supposed to do
// just supporting the given syntax
case class IO(src: String) {
    import SHadoopImports._
    def -->(s: String) = new {
        def -->(to: IO) = {
            val IO(snk) = to
            println("From: " + src)
            println("Applying (4,5): " + s.fun(4,5))
            println("To: " + snk)
        }
    }
}

object App extends Application {
  import SHadoopImports._

  IO("MySource") --> ((x:Int,y:Int)=>x+y) --> IO("MySink")
  println
  IO("Here") --> ((x:Int,y:Int)=>x*y+y) --> IO("There")
}

/*
From: MySource
Applying (4,5): 9
To: MySink

From: Here
Applying (4,5): 25
To: There
*/

为了让自己相信类名不足以在另一台机器上使用该函数，请考虑下面的代码，它创建了 100 个不同的函数。计算文件系统上的类并进行比较。

object App extends Application {
  import SHadoopImports._

  for (i <- 1 to 100) {
      IO(i + ": source") --> ((x:Int,y:Int)=>(x*i)+y) --> IO("sink")
  }
}

Answer 2

快速建议：为什么不尝试创建一个隐式 def 将 FunctionN 对象转换为 --> 所期望的特征？方法。

我确实希望您不必为此使用任何宏！