Scala pass-through wrappers

Question

Very many times, I'll want to "replace" a single method of a given object.

foo: Foo
foo.bar(i) // original
foo.baz(s) // replace this implementation

I'll wind up creating a pass-through wrapper class.

class FooWrapper(foo: Foo) extends Foo {
  def bar(i: Int) = foo.bar(i)
  def baz(s: String) = foo.baz(s)
}

And then

foo: Foo
val foo2 = new FooWrapper(foo) { def baz(s: String) = ... }
foo2.bar(i)
foo2.baz(s)

This works with traits and classes, and works without modifying the source code of the type.

I use this quite a bit, particularly when adapting libraries or other bits of code.

This can get tedious with lots of methods. The other day, I wanted to replace the shutdown method on an ExecutorService instance, and I had to do this for a dozen methods.

Is this a common idiom, or is this normally done another way? I suspect this could be done nicely with a macro, though I haven't found any existing ones that do this.

Answer 1

You can achieve that with AOP (Aspect-oriented programming)

There're many libraries to do so, try this one - https://github.com/adamw/scala-macro-aop

• Note that this library is in POC stage for now so you might look for something more mature. I've put it here because I think it shows the concept very clearly.

For your example you'll have to do something like

class FooWrapper(@delegate wrapped: Foo) extends Foo {
  def baz(i: Int) = ???
}