CODEWITHSUNDEEP
scalaimplicitscala-reflectscalametadotty
tribbloid
tribbloid

Reputation: 3838

In scala 2 or 3, is it possible to debug implicit resolution process in runtime?

In scala language, implicit resolution is often done in compile-time and sometimes throws obfuscating error information, one famous example of such error is when shapeless Generic throws error information like:

error: could not find implicit value for parameter encoder: CsvEncoder[Foo]

(see https://books.underscore.io/shapeless-guide/shapeless-guide.html for detail)

A solution to this problem is to run implicit resolution algorithm (should be a graph query algorithm internally) in runtime, this has at least 2 benefits:

So my question is, does this feature exist in Scala 2.x or Dotty? Or is it on the roadmap?

Thanks a lot for your opinion.

Upvotes: 2

Views: 1572

Answers (1)

Dmytro Mitin
Dmytro Mitin

Reputation: 51648

You can debug implicits at compile time:

  1. switch on compiler flag -Xlog-implicits

  2. try to resolve implicits manually (maybe specifying type parameters as well) and see compile errors

     implicitly[...](...manually...)

  3. use scala.reflect

     println(reify { implicitly[...] }.tree)

    (or switch on compiler flag -Xprint:typer) in order to see how implicits are resolved

  4. use IDE functionality to show implicits

    https://github.com/ljwagerfield/debugging-scala-implicits-in-intellij

    https://www.jetbrains.com/help/idea/edit-scala-code.html

  5. using macros with compiler internals you can debug implicit resolution

    Is there a type-class that checks for existence of at least one implicit of a type?

    create an ambiguous low priority implicit

    Using the "Prolog in Scala" to find available type class instances

    Finding the second matching implicit

    How to summon a `given` member?

    shapeless/package.scala (def cachedImplicitImpl[T](implicit tTag: WeakTypeTag[T]): Tree = ...)

If you're developing a type class don't forget to use annotations @implicitNotFound and @implicitAmbiguous.

You can always postpone compilation of your program till runtime. So instead of program

object App {
  def main(args: Array[String]): Unit = {
    println("test") // test
  }
}

you can have

import scala.reflect.runtime.currentMirror
import scala.reflect.runtime.universe._
import scala.tools.reflect.ToolBox
val toolbox = currentMirror.mkToolBox()

toolbox.eval(q"""
  object App {
    def main(args: Array[String]): Unit = {
      println("test")
    }
  }

  App.main(Array())
""") // test

And instead of

implicitly[Numeric[Int]]

you can have

toolbox.compile(q"""
  implicitly[Numeric[Int]]
""")

or

toolbox.inferImplicitValue(
  toolbox.typecheck(tq"Numeric[Int]", mode = toolbox.TYPEmode).tpe, 
  silent = false
)

But it's too optimistic to think that postponing program compilation till runtime you'll be able to debug implicits easier at runtime rather than at compile time. Actually postponing program compilation till runtime you add one level of indirection more i.e. make things harder to debug.

Upvotes: 13

Related Questions