how to keep return value when logging in scala

Question

When programming in java, I always log input parameter and return value of a method, but in scala, the last line of a method is the return value. so I have to do something like:

def myFunc() = {
  val rs = calcSomeResult()
  logger.info("result is:" + rs)
  rs
}

in order to make it easy, I write a utility:

class LogUtil(val f: (String) => Unit) {
 def logWithValue[T](msg: String, value: T): T = { f(msg); value }
}

object LogUtil {
  def withValue[T](f: String => Unit): ((String, T) => T) = new LogUtil(f).logWithValue _
}

Then I used it as:

val rs = calcSomeResult()
withValue(logger.info)("result is:" + rs, rs) 

it will log the value and return it. it works for me,but seems wierd. as I am a old java programmer, but new to scala, I don't know whether there is a more idiomatic way to do this in scala.

---

thanks for your help, now I create a better util using Kestrel combinator metioned by romusz

object LogUtil {
  def kestrel[A](x: A)(f: A => Unit): A = { f(x); x }
  def logV[A](f: String => Unit)(s: String, x: A) = kestrel(x) { y => f(s + ": " + y)}
}

I add f parameter so that I can pass it a logger from slf4j, and the test case is:

class LogUtilSpec extends FlatSpec with ShouldMatchers {
  val logger = LoggerFactory.getLogger(this.getClass())
  import LogUtil._

"LogUtil" should "print log info and keep the value, and the calc for value should only be called once" in {
  def calcValue = { println("calcValue"); 100 } // to confirm it's called only once 
  val v = logV(logger.info)("result is", calcValue)
  v should be === 100
  }
}

Answer 1

Compiling all the answers, pros and cons, I came up with this (context is a Play application):

import play.api.LoggerLike

object LogUtils {

implicit class LogAny2[T](val value : T) extends AnyVal {

    def @@(str : String)(implicit logger : LoggerLike) : T = {
        logger.debug(str);
        value
    }

    def @@(f : T => String)(implicit logger : LoggerLike) : T = {
        logger.debug(f(value))
        value
    }
}

As you can see, LogAny is an AnyVal so there shouldn't be any overhead of new object creation.

You can use it like this:

scala> import utils.LogUtils._
scala> val a = 5
scala> val b = 7
scala> implicit val logger = play.api.Logger

scala> val c = a + b @@ { c => s"result of $a + $b = $c" }
c: Int = 12

Or if you don't need a reference to the result, just use:

scala> val c = a + b @@ "Finished this very complex calculation"
c: Int = 12

Any downsides to this implementation?

Edit:

I've made this available with some improvements in a gist here

Answer 2

Let's say you already have a base class for all you loggers:

abstract class Logger {
  def info(msg:String):Unit
}

Then you could extend String with the @@ logging method:

object ExpressionLog {
  // default logger
  implicit val logger = new Logger { 
    def info(s:String) {println(s)}
  }

  // adding @@ method to all String objects
  implicit def stringToLog (msg: String) (implicit logger: Logger) = new {
    def @@ [T] (exp: T) = {
      logger.info(msg + " = " + exp)
      exp
    }
  }
}

To use the logging you'd have to import members of ExpressionLog object and then you could easily log expressions using the following notation:

import ExpressionLog._

def sum (a:Int, b:Int) = "sum result" @@ (a+b)
val c = sum("a" @@ 1, "b" @@2)

Will print:

a = 1
b = 2
sum result = 3

This works because every time when you call a @@ method on a String compiler realises that String doesn't have the method and silently converts it into an object with anonymous type that has the @@ method defined (see stringToLog). As part of the conversion compiler picks the desired logger as an implicit parameter, this way you don't have to keep passing on the logger to the @@ every time yet you retain full control over which logger needs to be used every time.

As far as precedence goes when @@ method is used in infix notation it has the highest priority making it easier to reason about what will be logged.

So what if you wanted to use a different logger in one of your methods? This is very simple:

import ExpressionLog.{logger=>_,_}  // import everything but default logger
// define specific local logger 
// this can be as simple as: implicit val logger = new MyLogger
implicit val logger = new Logger { 
  var lineno = 1
  def info(s:String) {
    println("%03d".format(lineno) + ": " + s) 
    lineno+=1
  }
}

// start logging
def sum (a:Int, b:Int) = a+b
val c = "sum result" @@ sum("a" @@ 1, "b" @@2)

Will output:

001: a = 1
002: b = 2
003: sum result = 3

Answer 3

If you like a more generic approach better, you could define

implicit def idToSideEffect[A](a: A) = new {
  def withSideEffect(fun: A => Unit): A = { fun(a); a }
  def |!>(fun: A => Unit): A = withSideEffect(fun) // forward pipe-like
  def tap(fun: A => Unit): A = withSideEffect(fun) // public demand & ruby standard
}

and use it like

calcSomeResult() |!> { rs => logger.info("result is:" + rs) }

calcSomeResult() tap println

Answer 4

What you're looking for is called Kestrel combinator (K combinator): Kxy = x. You can do all kinds of side-effect operations (not only logging) while returning the value passed to it. Read https://github.com/raganwald/homoiconic/blob/master/2008-10-29/kestrel.markdown#readme

In Scala the simplest way to implement it is:

  def kestrel[A](x: A)(f: A => Unit): A = { f(x); x }

Then you can define your printing/logging function as:

def logging[A](x: A) = kestrel(x)(println)
def logging[A](s: String, x: A) = kestrel(x){ y => println(s + ": " + y) }

And use it like:

logging(1 + 2) + logging(3 + 4)

your example function becomes a one-liner:

def myFunc() = logging("result is", calcSomeResult())

If you prefer OO notation you can use implicits as shown in other answers, but the problem with such approach is that you'll create a new object every time you want to log something, which may cause performance degradation if you do it often enough. But for completeness, it looks like this:

implicit def anyToLogging[A](a: A) = new {
  def log = logging(a)
  def log(msg: String) = logging(msg, a)
}

Use it like:

def myFunc() = calcSomeResult().log("result is")

Answer 5

You have the basic idea right--you just need to tidy it up a little bit to make it maximally convenient.

class GenericLogger[A](a: A) {
  def log(logger: String => Unit)(str: A => String): A = { logger(str(a)); a }
}
implicit def anything_can_log[A](a: A) = new GenericLogger(a)

Now you can

scala> (47+92).log(println)("The answer is " + _)
The answer is 139
res0: Int = 139

This way you don't need to repeat yourself (e.g. no rs twice).

Answer 6

Starting Scala 2.13, the chaining operation tap can be used to apply a side effect (in this case some logging) on any value while returning the original value:

def tap[U](f: (A) => U): A

For instance:

scala> val a = 42.tap(println)
42
a: Int = 42

or in our case:

import scala.util.chaining._

def myFunc() = calcSomeResult().tap(x => logger.info(s"result is: $x"))