Extract method to independent function in Scala

Question

Given something like:

class A {
  def f(x: X) = ...
  def g(y: Y, z: Z) = ...
  ...
}

How to (automatically) extract the function(s):

object A {
  val f' = (a: A, x: X) => a.f(x)  // do this automagically for any arbitrary f
  val g' = (a: A, y: Y, z: Z) => a.g(y, z) // and deal with arity > 1 too
  ...
}

With this exact type signature (first the object, then the parameter list). Let me state the problem very clearly:

"Given a method f(x1: X1, ..., xn: Xn) defined in the context of a class A, how to automatically extract a function f' that (i) receives an instance a of type A, and (ii) a parameter list that corresponds 1:1 to the parameter list of f, viz. x1: X, ... xn: Xn, which implementation is exactly a.f(x1: X1, ..., xn: Xn)"

Or even:

Capturing the concept of extensionality of lambda-calculus, such that you automatically extract an λx.(f x) from f whenever x does not appear free in f.

This could first be tackled by finding a way access the identifiers f, g, ... without having a specific a: A (one would have a specific A later, of course). We could simply write f' or g' by hand, but let's indulge DRYness.

---

P.S. Maybe this isn't possible without runtime reflection (albeit it may be possible with Scala 2.10+ macros), since I can't seem to find a way to refer to the identifiers of f or g without a specific instance (a: A) beforehand. But it would be something like the following, without having to resort to strings:

A.getMethod("f"): Function2[A, X, ...]

I also realize that practical uses of the question may help the participants to suggest alternatives, but I'm discussing this in an abstract sense. I'm not trying to solve other problem which I've reduced to this one. I'm trying to know if this one is possible :-) Here's a very nice article to actually understand the motivation behind this question, with rants over Eta-expansions on Scala.

Answer 1

You certainly could do this at compile time with macros - I do something very like this in the preview release of ScalaMock 3 - mock objects are instances of anonymous classes where each member is implemented by an instance of a mock function. You may well be able to use it as a starting point for what you're trying to do.

Warning: ScalaMock 3 currently only works with Scala 2.10.0-M6. It doesn't work with M7 or the current development version due to breaking changes in the macro API that I haven't (yet!) had a chance to address.

Answer 2

This feels similar to Lensed project that creates lenses for Scala case classes. I believe it would be possible to modify it to create the methods you describe instead of lenses.

Answer 3

I know it's not a particularly beautiful solution, but you if you can't use macros, you could generate source code for a companion object you need and compile it in a separate build step.

def generateCompanionObject(clazz: Class[_]) = {
     val className = clazz.getName.split("\\.").last
     val firstMethod = clazz.getMethods.head//for simplicity
     val methodName = firstMethod.getName
     val parametersClasses = firstMethod.getParameterTypes.map(_.getName).toSeq

     val objectDefinition = "object " + className + " {\n" +
         generateMethodDefinition(className, methodName, parametersClasses) +
         "\n}"

     objectDefinition
 }

 def generateMethodDefinition(className: String, methodName: String, parameterClasses: Seq[String]) = {
     val newMethodName: String = "   def invoke" + methodName.capitalize + "On"

     val parameterList: String = "(o:" + className + ", " + parameterClasses.zipWithIndex.map {
         case (argClassName, index) => "arg" + index + ": " + argClassName
     }.mkString(", ") + ")"

     val generateOldMethodCall: String = "o." + methodName + parameterClasses.zipWithIndex.map {
         case (argClassName, index) => "arg" + index
     }.mkString("(", ",", ")")

     newMethodName + parameterList + " = " + generateOldMethodCall
 }

for class

class A {
   def foo(x: String, y: String) = x + y
}

it will generate

object A {
   def invokeFooOn(o:A, arg0: java.lang.String, arg1: java.lang.String) = o.foo(arg0,arg1)
}