21

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()
foo(params)

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()
foo(params)

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) = ...bar()...
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?

Marcus Downing
  • 10,054
  • 10
  • 63
  • 85

5 Answers5

11

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 http://debasishg.blogspot.com/2010/12/case-study-of-cleaner-composition-of.html. The Reader monad can be found in Scalaz http://code.google.com/p/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.

Community
  • 1
  • 1
James Iry
  • 19,367
  • 3
  • 64
  • 56
  • It's amazing what gems are hidden in the standard Scala library. I'd never heard of `DynamicVariable`. – Marcus Downing Dec 09 '11 at 00:40
  • Hi Marcus! Please reconsider the use of Dynamic. Rethink what you are trying to achieve. – AndreasScheinert Dec 09 '11 at 13:46
  • Can you explain your objection? Are you saying there's something wrong with the implementation of `DynamicVariable`, or with the whole idea? I think my question was quite clear on what I'm looking for - perhaps even too verbose. The consensus on the web seems to be to look at the code of `DynamicVariable` as a starting point, rather than simply accepting it as it is; and it doesn't do *everything* I wanted (I'll need to figure out a solution to crossing thread boundaries with actors). But it comes very close, and with a little careful wrapping code can be made both type-safe and null-safe. – Marcus Downing Dec 09 '11 at 15:14
  • From my limited reading and even more limited understanding, the _reader monad_ appears to be something different: it's treating monadically the various environmental factors going into a calculation, but not getting those values to the right area in the first place.It does occur to me that `DynamicVariable` should be treated as a monad - perhaps the addition of a `toOption` method would be all it needs - rather than taking its status for granted. – Marcus Downing Dec 11 '11 at 00:26
  • The reader monad is basically a clever trick to hide the plumbing of passing context around. Or, another way to look at is that the reader monad is the read-only half of the state monad which is itself a clever trick to hide the plumbing of passing immutable values that can be "changed" (transformed to new values) before passing them on to other functions. – James Iry Dec 14 '11 at 17:12
  • DynamicVariables are sometimes useful but they have downsides. For instance, they make it harder to test the affected methods in isolation. Also, if abused they become really no better than ThreadLocals - global variables that are isolated to single threads. – James Iry Dec 14 '11 at 17:18
  • The effect of DynamicVariable on testability - and in fact on proper program flow in general - is definitely a risk, but one that's mitigated by being careful about how it's used. – Marcus Downing Dec 16 '11 at 15:29
7

A little late to the party, but have you considered using implicit parameters to your classes constructors? 

class Foo(implicit biz:Biz) {
   def f() = biz.doStuff
}
class Biz {
   def doStuff = println("do stuff called")
}

If you wanted to have a new biz for each call to f() you could let the implicit parameter be a function returning a new biz:

class Foo(implicit biz:() => Biz) {
   def f() = biz().doStuff
}

Now you simply need to provide the context when constructing Foo. Which you can do like this:

trait Context {
    private implicit def biz = () => new Biz
    implicit def foo = new Foo // The implicit parameter biz will be resolved to the biz method above
}

class UI extends Context {
    def render = foo.f()
}

Note that the implicit biz method will not be visible in UI. So we basically hide away those details :)

I wrote a blog post about using implicit parameters for dependency injection which can be found here (shameless self promotion ;) )

Emil L
  • 20,219
  • 3
  • 44
  • 65
2

I think that the dependency injection from lift does what you want. See the wiki for details using the doWith () method.

Note that you can use it as a separate library, even if you are not running lift.

fmpwizard
  • 2,758
  • 1
  • 22
  • 24
  • That certainly looks closer than anything else I've seen. I'll see if I can get it to do what I need. I don't see anything in there to address the threading/actors question, but it's possible I haven't fully understood it yet. – Marcus Downing Dec 08 '11 at 18:04
1

You asked this just about a year ago, but here's another possibility. If you only ever need to call one method:

def fooWithContext(cx: MyContextType)(params){
    def bar(params) = ... qux() ...
    def qux(params) = ... ged() ...
    def ged(params) = ... mog() ...
    def mog(params) = cx.doStuff(params)
    ... bar() ...
}

fooWithContext(makeContext())(params)

If you need all the methods to be externally visible:

case class Contextual(cx: MyContextType){
    def foo(params) = ... bar() ...
    def bar(params) = ... qux() ...
    def qux(params) = ... ged() ...
    def ged(params) = ... mog() ...
    def mog(params) = cx.doStuff(params)
}

Contextual(makeContext()).foo(params)

This is basically the cake pattern, except that if all your stuff fits into a single file, you don't need all the messy trait stuff to combine it into one object: you can just nest them. Doing it this way also makes cx properly lexically scoped, so you don't end up with funny behavior when you use futures and actors and such. I suspect that if you use the new AnyVal, you could even do away with the overhead of allocating the Contextual object.

If you want to split your stuff into multiple files using traits, you only really need a single trait per file to hold everything and put the MyContextType properly in scope, if you don't need the fancy replaceable-components-via-inheritance thing most cake pattern examples have. 

// file1.scala
case class Contextual(cx: MyContextType) with Trait1 with Trait2{
    def foo(params) = ... bar() ...
    def bar(params) = ... qux() ...
}

// file2.scala
trait Trait1{ self: Contextual =>
    def qux(params) = ... ged() ...
    def ged(params) = ... mog() ...
}

// file3.scala
trait Trait2{ self: Contextual =>
    def mog(params) = cx.doStuff(params)
}

// file4.scala
Contextual(makeContext()).foo(params)

It looks kinda messy in a small example, but remember, you only need to split it off into a new trait if the code is getting too big to sit comfortable in one file. By that point your files are reasonably big, so an extra 2 lines of boilerplate on a 200-500 line file is not so bad really.

EDIT:

This works with asynchronous stuff too

case class Contextual(cx: MyContextType){
    def foo(params) = ... bar() ...
    def bar(params) = ... qux() ...
    def qux(params) = ... ged() ...
    def ged(params) = ... mog() ...
    def mog(params) = Future{ cx.doStuff(params) }
    def mog2(params) = (0 to 100).par.map(x => x * cx.getSomeValue )
    def mog3(params) = Props(new MyActor(cx.getSomeValue))
}

Contextual(makeContext()).foo(params)

It Just Works using nesting. I'd be impressed if you could get similar functionality working with DynamicVariable.

You'd need a special subclass of Future that stores the current DynamicVariable.value when created, and hook into the ExecutionContext's prepare() or execute() method to extract the value and properly set up the DynamicVariable before executing the Future.

Then you'd need a special scala.collection.parallel.TaskSupport to do something similar in order to get parallel collections working. And a special akka.actor.Props in order to do something similar for that.

Every time there's a new mechanism of creating asynchronous tasks, DynamicVariable based implementations will break and you'll have weird bugs where you end up pulling up the wrong Context. Every time you add a new DynamicVariable to keep track of, you'll need to patch all your special executors to properly set/unset this new DynamicVariable. Using nesting you can just let lexical closure take care of all of this for you.

(I think Futures, collections.parallel and Props count as "layers in between that aren't my code")

Li Haoyi
  • 15,330
  • 17
  • 80
  • 137
1

Similar to the implicit approach, with Scala Macros you can do auto-wiring of objects using constructors - see my MacWire project (and excuse the self-promotion).

MacWire also has scopes (quite customisable, a ThreadLocal implementation is provided). However, I don't think you can propagate context across actor calls with a library - you need to carry some identifier around. This can be e.g. through a wrapper for sending actor messages, or more directly with the message.

Then as long as the identifier is unique per request/session/whatever your scope is, it's just a matter of looking things up in a map via a proxy (like the MacWire scopes do, the "identifier" here isn't needed as it is stored in the ThreadLocal).

adamw
  • 8,038
  • 4
  • 28
  • 32