检测（记录）Scala表达式

Question

( UPD after @krivachy.akos )

How to debug expressions in Scala? You don't have an opportunity to set a breakpoint and see local variables in most cases because inside the expression there are no variables. And usually there are no statements to which you can set a breakpoint.

One old way of debugging is to have the code instrumented. This gives an indispensable information about the internal processing of expressions.

However, in a typical logging implementation there are no direct ways of intercepting expressions. In particular, a typical logger have methods with Unit return type:

def debug(msg: =>String) {...}

To use the logger one have to rewrite concise expression in a way to be able to call logger:

Example 1 :

if you have some boolean-based rules with complex conditions and multiple evaluation paths:

val x = if(condition1(a,b)) 
          Some(production1(a,b))
        else if(condition2(c,d))
          Some(production2(a,b))
        else
          None

then it is hard to make sure it works as desired. ( It's not always possible to avoid complex rules altogether. And representation rules in OOP-style is not always good.)

Then a typical instrumentation would require introduction of some intermediate variables and blocks of code:

debug("a="+a)
debug("b="+b)
val x = if(condition1(a,b)) {
          debug("rule1 hit")
          val production = production1(a,b)
          debug("rule1 result: "+production)
          Some(production)
        } else { 
          debug("rule1 doesn't hit")
          debug("c="+c)
          debug("d="+d)
          if(condition2(c,d)){
            debug("rule2 hit")
            Some(production2(a,b))
          } else
            None
        }

Example 2 :

def f(list:List[Int]) = 
    list.
        map(_*2).
        flatMap(t =>
            (0 until t).
            map(_+1)
        )

Instrumentation will lead to some intermediate variables:

def f(list:List[Int]) = {        
    val twiced = list.map(_*2)
    debug(s"twiced = $twiced")
    val result = twiced.flatMap(t => {
        val widened = (0 until t).map(_+1)            
        debug(s"widened = $widened")
        widened
    })
    debug(s"result = $result")
    result
}

Very ugly, I suppose. And this instrumentation takes more space than the code itself. The main reason, I think, is that the logger is incompatible with an expression evaluation style.

Is there a way to log expression values in a more concise way?

Answer 1

I recently found a nice way of logging the value of an expression:

trait Logging {

    protected val loggerName = getClass.getName
    protected lazy val logger = LoggerFactory.getLogger(loggerName)

    implicit class RichExpressionForLogging[T](expr: T){
        def infoE (msg: T ⇒ String):T = {if (logger.isInfoEnabled ) logger.info (msg(expr)); expr}
        def traceE(msg: T ⇒ String):T = {if (logger.isTraceEnabled) logger.trace(msg(expr)); expr}
        def debugE(msg: T ⇒ String):T = {if (logger.isDebugEnabled) logger.debug(msg(expr)); expr}      
        def infoL (msg: String):T = {if (logger.isInfoEnabled ) logger.info (msg+expr); expr}
        def traceL(msg: String):T = {if (logger.isTraceEnabled) logger.trace(msg+expr); expr}
        def debugL(msg: String):T = {if (logger.isDebugEnabled) logger.debug(msg+expr); expr}       
    }

}

Here how it is used:

Example 1 (rules):

val x = if(condition1(a.debugL("a="),b.debugL("b="))) 
      Some(production1(a,b).debugL("rule1="))
    else if(condition2(c,d))
      Some(production2(a,b).debugL("rule2="))
    else
      None

Example 2:

def f(list:List[Int]) = 
    list.
        map(_*2).
        debugE(s"res1="+_).
        flatMap(t => (0 until t).
            map(_+1).
            debugE(s"res2="+_)).
        debugE(s"res="+_)

It can also be used everywhere in expressions:

if((a<0).debugE(s"a=$a<0="+_))

for{
    a <- f(list).debugE("f(list)="+_)
    b <- a.debugL("a=")
} yield b.debugL("b=")

Of course you should mix-in Logging trait to your class.

This kind of instrumentation doesn't hide the logic of the code.