Dynamic mixin in Scala – is it possible?

by

I believe this is impossible to do strictly at runtime, because traits are mixed in at compile-time into new Java classes. If you mix a trait with an existing class anonymously you can see, looking at the classfiles and using javap, that an anonymous, name-mangled class is created by scalac:

class Foo {
  def bar = 5
}

trait Spam {
  def eggs = 10
}

object Main {
  def main(args: Array[String]) = {
    println((new Foo with Spam).eggs)
  }
}

scalac Mixin.scala; ls *.class returns

Foo.class Main$.class Spam$class.class
Main$$anon$1.class Main.class Spam.class

While javap Main\$\$anon\$1 returns

Compiled from "mixin.scala"

public final class Main$$anon$1 extends Foo implements Spam{
    public int eggs();
    public Main$$anon$1();
}

As you can see, scalac creates a new anonymous class that is loaded at runtime; presumably the method eggs in this anonymous class creates an instance of Spam$class and calls eggs on it, but I’m not completely sure.

However, we can do a pretty hacky trick here:

import scala.tools.nsc._;
import scala.reflect.Manifest

object DynamicClassLoader {
  private var id = 0
  def uniqueId = synchronized {  id += 1; "Klass" + id.toString }
}

class DynamicClassLoader extends 
    java.lang.ClassLoader(getClass.getClassLoader) {
  def buildClass[T, V](implicit t: Manifest[T], v: Manifest[V]) = {

    // Create a unique ID
    val id = DynamicClassLoader.uniqueId

    // what's the Scala code we need to generate this class?
    val classDef = "class %s extends %s with %s".
      format(id, t.toString, v.toString)

    println(classDef)

    // fire up a new Scala interpreter/compiler
    val settings = new Settings(null)
    val interpreter = new Interpreter(settings)

    // define this class
    interpreter.compileAndSaveRun("<anon>", classDef)

    // get the bytecode for this new class
    val bytes = interpreter.classLoader.getBytesForClass(id)

    // define the bytecode using this classloader; cast it to what we expect
    defineClass(id, bytes, 0, bytes.length).asInstanceOf[Class[T with V]]
  }

}


val loader = new DynamicClassLoader

val instance = loader.buildClass[Foo, Spam].newInstance
instance.bar
// Int = 5
instance.eggs
// Int = 10

Since you need to use the Scala compiler, AFAIK, this is probably close to the cleanest solution you could do to get this. It’s quite slow, but memoization would probably help greatly.

This approach is pretty ridiculous, hacky, and goes against the grain of the language. I imagine all sorts of weirdo bugs could creep in; people who have used Java longer than me warn of the insanity that comes with messing around with classloaders.

More Related Contents:

  1. Mixing in a trait dynamically
  2. What is the difference between a var and val definition in Scala?
  3. What is the apply function in Scala?
  4. How do I apply the enrich-my-library pattern to Scala collections?
  5. How to import build.gradle into IntelliJ
  6. How to model type-safe enum types?
  7. scala slick method I can not understand so far
  8. Difference between this and self in self-type annotations?
  9. Scala constructor overload?
  10. Instantiating immutable paired objects
  11. Change nullable property of column in spark dataframe
  12. What type to use to store an in-memory mutable data table in Scala?
  13. Result type of an implicit conversion must be more specific than AnyRef
  14. Usefulness (as in practical applications) of Currying v.s. Partial Application in Scala
  15. Perform a typed join in Scala with Spark Datasets
  16. Left Anti join in Spark?
  17. How to Define Custom partitioner for Spark RDDs of equally sized partition where each partition has equal number of elements?
  18. How does type Dynamic work and how to use it?
  19. DataFrame-ified zipWithIndex
  20. How to access parameter list of case class in a dotty macro
  21. Get a TypeTag from a Type?
  22. How to write a proper null-safe coalescing operator in scala?
  23. Can’t access Parent’s Members while dealing with Macro Annotations
  24. Why is join not possible after show operator?
  25. How do I parse command line arguments in Scala? [closed]
  26. Futures / Success race
  27. Scala start Play server in production
  28. Scala-Spark Dynamically call groupby and agg with parameter values
  29. Why does one select Scala type members with a hash instead of a dot?
  30. Scala best way of turning a Collection into a Map-by-key?

Leave a Comment