Scala dependency injection: alternatives to implicit parameters

Spread the love

Question Description

Please pardon the length of this question.

I often need to create some contextual information at one layer of my code, and consume that information elsewhere. I generally find myself using implicit parameters:

def foo(params)(implicit cx: MyContextType) = ...

implicit val context = makeContext()

This works, but requires the implicit parameter to be passed around a lot, polluting the method signatures of layer after layout of intervening functions, even if they don’t care about it themselves.

def foo(params)(implicit cx: MyContextType) = ... bar() ...
def bar(params)(implicit cx: MyContextType) = ... qux() ...
def qux(params)(implicit cx: MyContextType) = ... ged() ...
def ged(params)(implicit cx: MyContextType) = ... mog() ...
def mog(params)(implicit cx: MyContextType) = cx.doStuff(params)

implicit val context = makeContext()

I find this approach ugly, but it does have one advantage though: it’s type safe. I know with certainty that mog will receive a context object of the right type, or it wouldn’t compile.

It would alleviate the mess if I could use some form of “dependency injection” to locate the relevant context. The quotes are there to indicate that this is different from the usual dependency injection patterns found in Scala.

The start point foo and the end point mog may exist at very different levels of the system. For example, foo might be a user login controller, and mog might be doing SQL access. There may be many users logged in at once, but there’s only one instance of the SQL layer. Each time mog is called by a different user, a different context is needed. So the context can’t be baked into the receiving object, nor do you want to merge the two layers in any way (like the Cake Pattern). I’d also rather not rely on a DI/IoC library like Guice or Spring. I’ve found them very heavy and not very well suited to Scala.

So what I think I need is something that lets mog retrieve the correct context object for it at runtime, a bit like a ThreadLocal with a stack in it:

def foo(params) =
def bar(params) = ...qux()...
def qux(params) = ...ged()...
def ged(params) = ...mog()...
def mog(params) = { val cx = retrieveContext(); cx.doStuff(params) }

val context = makeContext()
usingContext(context) { foo(params) }

But that would fall as soon as asynchronous actor was involved anywhere in the chain. It doesn’t matter which actor library you use, if the code runs on a different thread then it loses the ThreadLocal.

So… is there a trick I’m missing? A way of passing information contextually in Scala that doesn’t pollute the intervening method signatures, doesn’t bake the context into the receiver statically, and is still type-safe?

Practice As Follows

The Scala standard library includes something like your hypothetical “usingContext” called DynamicVariable. This question has some information about it When we should use scala.util.DynamicVariable? . DynamicVariable does use a ThreadLocal under the hood so many of your issues with ThreadLocal will remain.

The reader monad is a functional alternative to explicitly passing an environment The Reader monad can be found in Scalaz However, the ReaderMonad does “pollute” your signatures in that their types must change and in general monadic programming can cause a lot of restructuring to your code plus extra object allocations for all the closures may not sit well if performance or memory is a concern.

Neither of these techniques will automatically share a context over an actor message send.

Leave a Comment

This site uses Akismet to reduce spam. Learn how your comment data is processed.