execute method where method names are in a List - scala

Question

I have a List with all the methods in it example
List("method1","method2","method3")
and I have the definition for all those methods mentioned in above list
def method1(){ //definition}
def method2(){ //definition}
def method3(){ //definition}
Instead of specifying those functions to run one by one like below
method1()
method2()
method3()
I want to loop through List("method1","method2","method3") and execute those methods

Answer 1

If all of the target methods have the same type profile (same argument number/types, same return type) ...
def method1() = println("one")
def method2() = println("two")
def method3() = println("three")
... then all you need is a String-to-method translator.
val translate : Map[String,Function0[Unit]] =
Map("method3" -> method3
,"method1" -> method1
,"method2" -> method2)
usage:
List("method1","method2","method3")
.foreach(translate(_)())
//one
//two
//three

Answer 2

If method names are known at compile time you can write a macro
import scala.language.experimental.macros
import scala.reflect.macros.blackbox
def executeAll(methodNames: List[String]): Unit = macro executeAllImpl
def executeAllImpl(c: blackbox.Context)(methodNames: c.Tree): c.Tree = {
import c.universe._
c.eval(c.Expr[List[String]](c.untypecheck(methodNames)))
.foldLeft[Tree](q"()")((tree, methodName) => q"$tree; ${TermName(methodName)}()")
}
def method1(): Unit = println(1)
def method2(): Unit = println(2)
def method3(): Unit = println(3)
executeAll(List("method1","method2","method3")) //1 2 3
//Warning:scalac: {
// {
// {
// ();
// method1()
// };
// method2()
// };
// method3()
//}
or
import scala.language.experimental.macros
import scala.reflect.macros.blackbox
def executeAll(methodNames: List[String]): Unit = macro executeAllImpl
def executeAllImpl(c: blackbox.Context)(methodNames: c.Tree): c.Tree = {
import c.universe._
val calls = c.eval(c.Expr[List[String]](c.untypecheck(methodNames)))
.map(methodName => q"${TermName(methodName)}()")
q"..$calls"
}
def method1(): Unit = println(1)
def method2(): Unit = println(2)
def method3(): Unit = println(3)
executeAll(List("method1","method2","method3")) //1 2 3
//Warning:scalac: {
// method1();
// method2();
// method3()
//}
(the tree generated is slightly different but result of execution is the same).
Or if method names are known only at runtime you can use either Scala reflection
def executeAll(methodNames: List[String]): Unit = {
import scala.reflect.runtime
import scala.reflect.runtime.universe._
methodNames.foreach(methodName => {
val methodSymbol = typeOf[SomeObject.type].decl(TermName(methodName)).asMethod
runtime.currentMirror.reflect(SomeObject).reflectMethod(methodSymbol)()
})
}
object SomeObject {
def method1(): Unit = println(1)
def method2(): Unit = println(2)
def method3(): Unit = println(3)
}
val methodNames = List("method1", "method2", "method3")
executeAll(methodNames) //1 2 3
or Java reflection
def executeAll(methodNames: List[String]): Unit =
methodNames.foreach(methodName =>
SomeObject.getClass.getMethod(methodName).invoke(SomeObject)
)
object SomeObject {
def method1(): Unit = println(1)
def method2(): Unit = println(2)
def method3(): Unit = println(3)
}
val methodNames = List("method1", "method2", "method3")
executeAll(methodNames) //1 2 3