1 trait CalculatorFunction {
 2   def name: String
 3 
 4   def call(parameters: Seq[Int]): Int
 5 }
 6 
 7 class CalculatorContext {
 8 ...
 9   private val functions = mutable.Map.empty[String, CalculatorFunction]
10 
11   def getFunction(name: String): Option[CalculatorFunction] = functions.get(name)
12 
13   def registerFunction(calculatorFunction: CalculatorFunction) = functions.put(calculatorFunction.name, calculatorFunction)
14 }

1 case class CallFunctionExpr(name: String, parameters: List[Expr]) extends Expr {
2   override def eval(implicit context: CalculatorContext) = context.getFunction(name).map {
3     function =>
4       function.call(parameters.map(_.eval))
5   }.getOrElse {
6     throw new RuntimeException(s"Function $name not defined")
7   }
8 }

1 object ASTParser extends StdTokenParsers {
2 ...
3   def term: Parser[Expr] = "(" ~> expr <~ ")" | "-" ~> expr ^^ NegExpr |
4     ident ~ "(" ~ repsep(expr, ",") ~ ")" ^^ {
5       case name ~ _ ~ parameters ~ _ => CallFunctionExpr(name, parameters)
6     } | 
7     ident ^^ VarGetExpr | 
8     numericLit ^^ (str => LiteralExpr(str.toInt))
9 ...

 1 case class AdaptedFunction() extends StaticAnnotation
 2 
 3 object FunctionAdapter {
 4   def generateCalculatorFunctions[T]: Seq[CalculatorFunction] = macro generateCalculatorFunctions_impl[T]
 5 
 6   def generateCalculatorFunctions_impl[T: c.WeakTypeTag](c: Context): c.Expr[Seq[CalculatorFunction]] = {
 7     import c.universe._
 8 
 9     reify {
10       Seq()
11     }
12   }
13 }

 1 object FunctionAdapter {
 2   def generateCalculatorFunctions[T]: Seq[CalculatorFunction] = macro generateCalculatorFunctions_impl[T]
 3 
 4   def generateCalculatorFunctions_impl[T: c.WeakTypeTag](c: Context): c.Expr[Seq[CalculatorFunction]] = {
 5     import c.universe._
 6 
 7     def createFunction(): c.Expr[CalculatorFunction] = {
 8 
 9       reify {
10         new CalculatorFunction {
11           override def name = ???
12 
13           override def call(parameters: Seq[Int]) = ???
14         }
15       }
16     }
17 
18     val func1 = createFunction()
19     val func2 = createFunction()
20 
21     reify {
22       Seq(func1.splice, func2.splice)
23     }
24   }
25 }

 1 object FunctionAdapter {
 2   def generateCalculatorFunctions[T]: Seq[CalculatorFunction] = macro generateCalculatorFunctions_impl[T]
 3 
 4   def generateCalculatorFunctions_impl[T: c.WeakTypeTag](c: Context): c.Expr[Seq[CalculatorFunction]] = {
 5     import c.universe._
 6 
 7     def createFunction(): c.Expr[CalculatorFunction] = {
 8 
 9       reify {
10         new CalculatorFunction {
11           override def name = ???
12 
13           override def call(parameters: Seq[Int]) = ???
14         }
15       }
16     }
17 
18     val funcs = List(createFunction(), createFunction())
19     c.Expr[Seq[CalculatorFunction]](Apply(Select(Ident(newTermName("Seq")), newTermName("apply")), funcs.map(_.tree)))
20   }
21 }

 1 object FunctionAdapter {
 2   def generateCalculatorFunctions[T]: Seq[CalculatorFunction] = macro generateCalculatorFunctions_impl[T]
 3 
 4   def generateCalculatorFunctions_impl[T: c.WeakTypeTag](c: Context): c.Expr[Seq[CalculatorFunction]] = {
 5     import c.universe._
 6 
 7     val companioned = weakTypeOf[T].typeSymbol
 8     val companionSymbol = companioned.companionSymbol
 9 
10     def createFunction(method: MethodSymbol): c.Expr[CalculatorFunction] = {
11 
12       val nameExpr = c.literal(method.name.encoded)
13       reify {
14         new CalculatorFunction {
15           override def name = nameExpr.splice
16 
17           override def call(parameters: Seq[Int]) = ???
18         }
19       }
20     }
21 
22     val funcs = companioned.typeSignature.members.filter {
23       member =>
24         member.isMethod && member.annotations.exists(_.tpe == typeOf[AdaptedFunction])
25     }.map {
26       member =>
27         createFunction(member.asMethod)
28     }.toList
29     c.Expr[Seq[CalculatorFunction]](Apply(Select(Ident(newTermName("Seq")), newTermName("apply")), funcs.map(_.tree)))
30   }
31 }

 1     def createFunction(method: MethodSymbol): c.Expr[CalculatorFunction] = {
 2 
 3       val nameExpr = c.literal(method.name.encoded)
 4 
 5       if (method.returnType != definitions.IntTpe) {
 6         c.abort(method.pos, "Method has to return an Int")
 7       }
 8       method.paramss.flatten.foreach {
 9         param =>
10           if (param.typeSignature != definitions.IntTpe) {
11             c.abort(param.pos, "Only Int parameters are supported")
12           }
13       }
14 
15       reify {
16         new CalculatorFunction {
17           override def name = nameExpr.splice
18 
19           override def call(parameters: Seq[Int]) = {
20 
21             ???
22           }
23         }
24       }
25     }

 1     def createFunction(method: MethodSymbol): c.Expr[CalculatorFunction] = {
 2 
 3       val nameExpr = c.literal(method.name.encoded)
 4 
 5       if (method.returnType != definitions.IntTpe) {
 6         c.abort(method.pos, "Method has to return an Int")
 7       }
 8       val parameterNames = method.paramss.flatten.map {
 9         param =>
10           if (param.typeSignature != definitions.IntTpe) {
11             c.abort(param.pos, "Only Int parameters are supported")
12           }
13           param.name.toTermName
14       }
15 
16       val parameterItName = newTermName("parameterIt")
17       val parameterItDecl = ValDef(Modifiers(), parameterItName, TypeTree(),
18                                     Select(Ident(newTermName("parameters")), newTermName("iterator")))
19       val parameterItNext = Apply(Select(Ident(parameterItName), newTermName("next")), Nil)
20       val decls = parameterNames.map {
21         parameterName =>
22           ValDef(Modifiers(), parameterName, TypeTree(), parameterItNext)
23 
24       }
25 
26       val call = Apply(Select(Ident(companionSymbol), method.name.toTermName), parameterNames.map(Ident(_)))
27       val callImpl = c.Expr[Int](Block(parameterItDecl :: decls, call))
28       reify {
29         new CalculatorFunction {
30           override def name = nameExpr.splice
31 
32           override def call(parameters: Seq[Int]) = callImpl.splice
33         }
34       }
35     }