How does type Dynamic work and how to use it?

by

Scalas type Dynamic allows you to call methods on objects that don’t exist or in other words it is a replica of “method missing” in dynamic languages.

It is correct, scala.Dynamic doesn’t have any members, it is just a marker interface – the concrete implementation is filled-in by the compiler. As for Scalas String Interpolation feature there are well defined rules describing the generated implementation. In fact, one can implement four different methods:

  • selectDynamic – allows to write field accessors: foo.bar
  • updateDynamic – allows to write field updates: foo.bar = 0
  • applyDynamic – allows to call methods with arguments: foo.bar(0)
  • applyDynamicNamed – allows to call methods with named arguments: foo.bar(f = 0)

To use one of these methods it is enough to write a class that extends Dynamic and to implement the methods there:

class DynImpl extends Dynamic {
  // method implementations here
}

Furthermore one need to add a

import scala.language.dynamics

or set the compiler option -language:dynamics because the feature is hidden by default.

selectDynamic

selectDynamic is the easiest one to implement. The compiler translates a call of foo.bar to foo.selectDynamic("bar"), thus it is required that this method has an argument list expecting a String:

class DynImpl extends Dynamic {
  def selectDynamic(name: String) = name
}

scala> val d = new DynImpl
d: DynImpl = DynImpl@6040af64

scala> d.foo
res37: String = foo

scala> d.bar
res38: String = bar

scala> d.selectDynamic("foo")
res54: String = foo

As one can see, it is also possible to call the dynamic methods explicitly.

updateDynamic

Because updateDynamic is used to update a value this method needs to return Unit. Furthermore, the name of the field to update and its value are passed to different argument lists by the compiler:

class DynImpl extends Dynamic {

  var map = Map.empty[String, Any]

  def selectDynamic(name: String) =
    map get name getOrElse sys.error("method not found")

  def updateDynamic(name: String)(value: Any) {
    map += name -> value
  }
}

scala> val d = new DynImpl
d: DynImpl = DynImpl@7711a38f

scala> d.foo
java.lang.RuntimeException: method not found

scala> d.foo = 10
d.foo: Any = 10

scala> d.foo
res56: Any = 10

The code works as expected – it is possible to add methods at runtime to the code. On the other side, the code isn’t typesafe anymore and if a method is called that doesn’t exist this must be handled at runtime as well. In addition this code is not as useful as in dynamic languages because it is not possible to create the methods that should be called at runtime. This means that we can’t do something like

val name = "foo"
d.$name

where d.$name would be transformed to d.foo at runtime. But this is not that bad because even in dynamic languages this is a dangerous feature.

Another thing to note here, is that updateDynamic needs to be implemented together with selectDynamic. If we don’t do this we will get a compile error – this rule is similar to the implementation of a Setter, which only works if there is a Getter with the same name.

applyDynamic

The ability to call methods with arguments is provided by applyDynamic:

class DynImpl extends Dynamic {
  def applyDynamic(name: String)(args: Any*) =
    s"method '$name' called with arguments ${args.mkString("'", "', '", "'")}"
}

scala> val d = new DynImpl
d: DynImpl = DynImpl@766bd19d

scala> d.ints(1, 2, 3)
res68: String = method 'ints' called with arguments '1', '2', '3'

scala> d.foo()
res69: String = method 'foo' called with arguments ''

scala> d.foo
<console>:19: error: value selectDynamic is not a member of DynImpl

The name of the method and its arguments again are separated to different parameter lists. We can call arbitrary methods with an arbitrary number of arguments if we want but if we want to call a method without any parentheses we need to implement selectDynamic.

Hint: It is also possible to use apply-syntax with applyDynamic:

scala> d(5)
res1: String = method 'apply' called with arguments '5'

applyDynamicNamed

The last available method allows us to name our arguments if we want:

class DynImpl extends Dynamic {

  def applyDynamicNamed(name: String)(args: (String, Any)*) =
    s"method '$name' called with arguments ${args.mkString("'", "', '", "'")}"
}

scala> val d = new DynImpl
d: DynImpl = DynImpl@123810d1

scala> d.ints(i1 = 1, i2 = 2, 3)
res73: String = method 'ints' called with arguments '(i1,1)', '(i2,2)', '(,3)'

The difference in the method signature is that applyDynamicNamed expects tuples of the form (String, A) where A is an arbitrary type.

All of the above methods have in common that their parameters can be parameterized:

class DynImpl extends Dynamic {

  import reflect.runtime.universe._

  def applyDynamic[A : TypeTag](name: String)(args: A*): A = name match {
    case "sum" if typeOf[A] =:= typeOf[Int] =>
      args.asInstanceOf[Seq[Int]].sum.asInstanceOf[A]
    case "concat" if typeOf[A] =:= typeOf[String] =>
      args.mkString.asInstanceOf[A]
  }
}

scala> val d = new DynImpl
d: DynImpl = DynImpl@5d98e533

scala> d.sum(1, 2, 3)
res0: Int = 6

scala> d.concat("a", "b", "c")
res1: String = abc

Luckily, it is also possible to add implicit arguments – if we add a TypeTag context bound we can easily check the types of the arguments. And the best thing is that even the return type is correct – even though we had to add some casts.

But Scala would not be Scala when there is no way to find a way around such flaws. In our case we can use type classes to avoid the casts:

object DynTypes {
  sealed abstract class DynType[A] {
    def exec(as: A*): A
  }

  implicit object SumType extends DynType[Int] {
    def exec(as: Int*): Int = as.sum
  }

  implicit object ConcatType extends DynType[String] {
    def exec(as: String*): String = as.mkString
  }
}

class DynImpl extends Dynamic {

  import reflect.runtime.universe._
  import DynTypes._

  def applyDynamic[A : TypeTag : DynType](name: String)(args: A*): A = name match {
    case "sum" if typeOf[A] =:= typeOf[Int] =>
      implicitly[DynType[A]].exec(args: _*)
    case "concat" if typeOf[A] =:= typeOf[String] =>
      implicitly[DynType[A]].exec(args: _*)
  }

}

While the implementation doesn’t look that nice, its power can’t be questioned:

scala> val d = new DynImpl
d: DynImpl = DynImpl@24a519a2

scala> d.sum(1, 2, 3)
res89: Int = 6

scala> d.concat("a", "b", "c")
res90: String = abc

At the top of all, it is also possible to combine Dynamic with macros:

class DynImpl extends Dynamic {
  import language.experimental.macros

  def applyDynamic[A](name: String)(args: A*): A = macro DynImpl.applyDynamic[A]
}
object DynImpl {
  import reflect.macros.Context
  import DynTypes._

  def applyDynamic[A : c.WeakTypeTag](c: Context)(name: c.Expr[String])(args: c.Expr[A]*) = {
    import c.universe._

    val Literal(Constant(defName: String)) = name.tree

    val res = defName match {
      case "sum" if weakTypeOf[A] =:= weakTypeOf[Int] =>
        val seq = args map(_.tree) map { case Literal(Constant(c: Int)) => c }
        implicitly[DynType[Int]].exec(seq: _*)
      case "concat" if weakTypeOf[A] =:= weakTypeOf[String] =>
        val seq = args map(_.tree) map { case Literal(Constant(c: String)) => c }
        implicitly[DynType[String]].exec(seq: _*)
      case _ =>
        val seq = args map(_.tree) map { case Literal(Constant(c)) => c }
        c.abort(c.enclosingPosition, s"method '$defName' with args ${seq.mkString("'", "', '", "'")} doesn't exist")
    }
    c.Expr(Literal(Constant(res)))
  }
}

scala> val d = new DynImpl
d: DynImpl = DynImpl@c487600

scala> d.sum(1, 2, 3)
res0: Int = 6

scala> d.concat("a", "b", "c")
res1: String = abc

scala> d.noexist("a", "b", "c")
<console>:11: error: method 'noexist' with args 'a', 'b', 'c' doesn't exist
              d.noexist("a", "b", "c")
                       ^

Macros give us back all compile time guarantees and while it is not that useful in the above case, maybe it can be very useful for some Scala DSLs.

If you want to get even more information about Dynamic there are some more resources:

More Related Contents:

  1. What’s the difference between => , ()=>, and Unit=>
  2. What is the purpose of type ascriptions in Scala?
  3. What is the advantage of using abstract classes instead of traits?
  4. Split 1 column into 3 columns in spark scala
  5. Provide schema while reading csv file as a dataframe
  6. How to flatmap a nested Dataframe in Spark
  7. How to read files from resources folder in Scala?
  8. Scala return statements in anonymous functions
  9. Scala – printing arrays
  10. What is the difference between `##` and `hashCode`?
  11. Scala: Why does Seq.contains take an Any argument, instead of an argument of the sequence type?
  12. When to use val or def in Scala traits?
  13. How to add “provided” dependencies back to run/test tasks’ classpath?
  14. Why are scala functions limited to 22 parameters?
  15. Method Override with Scala 3 Macros
  16. Replace missing values with mean – Spark Dataframe
  17. How to calculate the size of dataframe in bytes in Spark?
  18. Why does partition parameter of SparkContext.textFile not take effect?
  19. Can I zip more than two lists together in Scala?
  20. Usages of Null / Nothing / Unit in Scala
  21. Cross product in Scala
  22. Spark Scala list folders in directory
  23. Spark-Monotonically increasing id not working as expected in dataframe?
  24. Reading in multiple files compressed in tar.gz archive into Spark [duplicate]
  25. What is the fastest way to write Fibonacci function in Scala?
  26. forall in Scala
  27. Scala asInstanceOf with parameterized types
  28. How do I run an sbt main class from the shell as normal command-line program?
  29. Akka-Stream implementation slower than single threaded implementation
  30. Spark ML VectorAssembler returns strange output

Leave a Comment