How does implicit conversions between scala-java collections work? How is it possible that it is sufficient to import some package?

Question

import scala.collection.JavaConversions._
val j: java.util.Map[String, String] = Map("a" -> "b")
print (j)

How does it work? In other words I am dying to know how import of some library (JavaConversions here) can help in making some conversions. After all, I didn't call any conversion function.
How does it work?

Answer 1

You can always see how implicits are resolved using reify

import scala.jdk.CollectionConverters._
import scala.reflect.runtime.universe.reify

println(reify{
  Map("a" -> "b").asJava
}.tree)
//CollectionConverters.MapHasAsJava(Predef.Map.apply(Predef.ArrowAssoc("a").$minus$greater("b"))).asJava

So with implicits brought by the import of scala.jdk.CollectionConverters._ the line

val j: java.util.Map[String, String] = Map("a" -> "b").asJava

is transformed into

val j: java.util.Map[String, String] =
  CollectionConverters.MapHasAsJava(Map("a" -> "b")).asJava

This rewriting (implicit resolution) occurs at compile time using static types, but methods .MapHasAsJava(..), .asJava are called as always at runtime using dynamic dispatch.

Similarly, with former version of Scala

import scala.collection.JavaConversions._

println(reify{
  val j: java.util.Map[String, String] = Map("a" -> "b")
}.tree)
//val j: Map[Predef.String, Predef.String] = JavaConversions.mapAsJavaMap(Predef.Map.apply(Predef.ArrowAssoc("a").$minus$greater("b")));

means that the line

val j: java.util.Map[String, String] = Map("a" -> "b")

is transformed into

val j: java.util.Map[String, String] =
  JavaConversions.mapAsJavaMap(Map("a" -> "b"))