Debugging functional code in Scala

Question

Debugging functional code is definitely more tricky than debugging imperative code. See discussions here, here and here. "Functional" debugging should support inspecting the return value of functions/closures/monads. Do any debuggers/IDEs have (plan to have) the ability to inspect intermediate return values?

For example, to debug this line in Scala, I should be able to step through 4 function invocations and inspect the returned value at each step before returning r

val r=(ls filter (_>1) sort (_<_) zipWithIndex) filter {v=>(v._2)%2==0} map{_._1}

Answer 1

I think everybody's advice to break this thing down to more manageable chunks is the best approach. One trick for debugging smaller expressions is to steal Ruby's tap function, as described here. "tap" allows you to stick an expression in the middle of a chain like this, and perhaps print out some debug values, like so:

val ls = List(1,2,3).map(_ * 2)
                .tap(soFar => println("So far: " + soFar))
                .map(_ * 2)
println(ls)

This will print out:

So far: List(2, 4, 6)
List(4, 8, 12)

It helps me every once in a while.

Answer 2

In a purely functional setting, stepping through is not nearly as useful as you might think. Since everything is composed of pure functions, you can just test those pieces individually using a process of elimination. In a lazy evaluation setting, stepping through code is even less useful.

Debugging programs in Haskell, for example, you would not at all be interested in tracing function calls. What you are interested in is a trace of intermediate function return values. It would be a very useful feature in any functional language to be able to give such a trace for any expression.

Answer 3

I know being concise is very nice, and I agree with you that IDEs should help with the debugging in these situations. But for the time being I have changed my coding style to assist with debugging. In my personal style I would have implemented your example as:

val noZeroLs = ls.filter(_>1)
val sortedLs = noZeroLs.sort(_<_)
val indexedNoZeroLs = sortedLs.zipWithIndex
val everySecondIndexedL = indexedNoZeroLs.filter(v => (v._2) % 2 == 0)
val everySecondL = everySecondIndexedL.map(_._1)

Coming up with meaningful names is difficult/laborious, but it does help you identify silly bugs; may help others to understand what is going on; and definitely helps with debugging.

Answer 4

My approach to this problem is to break the expression down into parts binding the results to vals in the REPL. When I am satisfied I may even write a test case that does the same I did in the REPL so that I am sure things stay as I want and so that I or somebody else can come back later and see a more explicit version.

The ability to use the repl to explore coupled with nice and easy to use testing toolkits has made debuggers all but obsolete for me.

Of course YMMV.

Answer 5

Starting Scala 2.13, the chaining operation tap, as mentioned in Adam Rabung's answer, has been included in the standard library, and can be used for debugging by printing intermediate versions of a pipeline:

import scala.util.chaining._

scala> val ls = List(1,2,3).map(_ * 2).tap(println).map(_ * 2).tap(println)
List(2, 4, 6)
List(4, 8, 12)
ls: List[Int] = List(4, 8, 12)

---

The tap chaining operation applies a side effect (in this case println) on a value (in this case a List) while returning the original value:

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

Answer 6

If you don't have an IDE, you can still use this tool I wrote:

https://github.com/JohnReedLOL/scala-trace-debug

To print the intermediary values, you can take this example:

val result=(lists.filter(_>1).sort(_<_).zipWithIndex).filter{v=>(v._2)%2==0}.map{_._1}

And add traces to it:

import scala.trace.implicitlyTraceable
val result=(lists.filter(_>1).out.sort(_<_).println.zipWithIndex).filter{v=>(v._2)%2==0}.out.map{_._1}.out

An implicit conversion allows you to print.