Question

I usually use Scala with SLF4J through the Loggable wrapper in LiftWeb. This works decently well with the exception of the quite common method made up only from 1 chain of expressions.

So if you want to add logging to such a method, the simply beautiful, no curly brackets

def method1():Z = a.doX(x).doY(y).doZ()

must become:

def method1():Z = {
  val v = a.doX(x).doY(y).doZ()
  logger.info("the value is %s".format(v))
  v
}

Not quite the same, is it? I gave it a try to solve it with this:

class ChainableLoggable[T](val v:T){
  def logInfo(logger:Logger, msg:String, other:Any*):T = {
    logger.info(msg.format(v, other))
    v
  }
}
implicit def anyToChainableLogger[T](v:T):ChainableLoggable[T] = new ChainableLoggable(v)

Now I can use a simpler form

 def method1():Z = a.doX(x).doY(y).doZ() logInfo(logger, "the value is %s") 

However 1 extra object instantiation and an implicit from Any starts to look like a code stink.

Does anyone know of any better solution? Or maybe I shouldn’t even bother with this?

Answer 1

Scala 2.10 has just a solution for you – that’s a new feature Value Class which allows you to gain the same effect as the implicit wrappers provide but with no overhead coming from instantiation of those wrapper classes. To apply it you’ll have to rewrite your code like so:

implicit class ChainableLoggable[T](val v : T) extends AnyVal {
  def logInfo(logger:Logger, msg:String, other:Any*) : T = {
    logger.info(msg.format(v, other))
    v
  }
}

Under the hood the compiler will transform the logInfo into an analogue of Java’s common “util” static method by prepending your v : T to it’s argument list and updating its usages accordingly – see, nothing gets instantiated.