Question

I’m implementing part of a Scala program that takes input strings of the form "functionName arg1=x1 arg2=x2 ...", parses the xi to the correct types, and then calls a corresponding Scala function functionName(x1,x2,...). The code below is an example implementation with two functions foo and bar, which take different kinds of arguments.

Notice that the types and argument names of foo and bar have to be handwritten into the code in several places: the original function definitions, defining the case classes that the parser returns, and the parsers themselves. The case classes returned by the parser also do basically nothing interesting — I’m tempted to just call foo and bar from within the parser, but I feel like that would be icky.

My question is: can this implementation be simplified? In practice, I will have many functions with complicated argument types, and I’d prefer to be able to specify those types as few times as possible, and perhaps also not have to define corresponding case classes.

type Word = String
// the original function definitions
def foo(x: Int, w: Word) = println("foo called with " + x + " and " + w)
def bar(y: Int, z: Int)  = println("bar called with " + y + " and " + z)

// the return type for the parser
abstract class Functions
case class Foo(x: Int, w: Word) extends Functions
case class Bar(y: Int, z: Int) extends Functions

object FunctionParse extends RegexParsers {
  val int = """-?\d+""".r ^^ (_.toInt)
  val word = """[a-zA-Z]\w*""".r

  val foo = "foo" ~> ("x=" ~> int) ~ ("w=" ~> word) ^^ { case x~w => Foo(x,w) }
  val bar = "bar" ~> ("y=" ~> int) ~ ("z=" ~> int) ^^ { case y~z => Bar(y,z) }
  val function = foo | bar

  def parseString(s: String) = parse(function, s)
}


def main(args: Array[String]) = {
  FunctionParse.parseString(args.mkString(" ")) match {
    case FunctionParse.Success(result, _) => result match {
      case Foo(x, w) => foo(x, w)
      case Bar(y, z) => bar(y, z)
    }
    case _ => println("sux.")
  }
}

Edit: I should note that in my case, the specific format above for the input string is not very important — I’m happy to change it (use xml or whatever) if it results in cleaner, simpler Scala code.

Answer 1

You want reflection, to put it simply. Reflection means finding out, instantiating and calling classes and methods at runtime instead of compile time. For example:

scala> val clazz = Class forName "Foo"
clazz: Class[_] = class Foo

scala> val constructors = clazz.getConstructors
constructors: Array[java.lang.reflect.Constructor[_]] = Array(public Foo(int,java.lang.String))

scala> val constructor = constructors(0)
constructor: java.lang.reflect.Constructor[_] = public Foo(int,java.lang.String)

scala> constructor.getParameter
getParameterAnnotations   getParameterTypes         

scala> val parameterTypes = constructor.getParameterTypes
parameterTypes: Array[Class[_]] = Array(int, class java.lang.String)

scala> constructor.newInstance(5: Integer, "abc")
res6: Any = Foo(5,abc)

This is all Java reflection. Scala 2.9 still doesn’t have a Scala-specific reflection interface, though one is already in development and might well be available on the next version of Scala.