How to pass an implicit argument indirectly

Question

I expect the code below to print out 1 and 2. But I get default and default. When I explicitly forward (?) the implicit value using the commented out code, I see the desired output. Can anyone explain how this works? Is what I'm trying impossible? I'm totally new to Scala. What should I read to understand this in depth?

case class Context(id: Option[String])
object Context {
  implicit val context = Context(Some("default"))
}

class ToolBuilder (id: String) {
  implicit val context = Context(Some(id))
  def extract() = ToolCreatorA.create()
}

case class ToolCreatorA(id: String)
object ToolCreatorA {
  def create() = ToolCreator.create()
  //def create()(implicit context: Context) = ToolCreator.create()
  object ToolCreator {
    def create()(implicit context: Context) = context.id.getOrElse("null")
  }
}

object Main {
  def main(args: Array[String]): Unit = {
    println(new ToolBuilder("1").extract())
    println(new ToolBuilder("2").extract())
  }
}

score 3 · Accepted Answer · edited May 23 '17 at 12:09

From the scala documentation of implicit, these are the two rules for determining value for an implicit parameter.

First, eligible are all identifiers x that can be accessed at the point of the method call without a prefix and that denote an implicit definition or an implicit parameter.

Second, eligible are also all members of companion modules of the implicit parameter’s type that are labeled implicit.

So in your case, lets first see what happens when we use def create() = ToolCreator.create(). Here, ToolCreator.create() will call create method of the companion object ToolCreator which expects an implicit Context def create()(implicit context: Context) = context.id.getOrElse("null")

Now our first rule says that, the method will look for an implicit param in all the variables it has access before the method call took place. We see that there is no available implicit variable at that point.
Then the second rule is, to look for an implicit variable in the companion object of the implicit type. In our case, the implicit is of type Context and we have a Context companion object which has a nice implicit variable defined. So that value will be picked up in the create method. object Context { implicit val context = Context(Some("default")) }
Now if we use the def create()(implicit context: Context) = ToolCreator.create() , this create method is invoked from the

class ToolBuilder (id: String) { implicit val context = Context(Some(id)) def extract() = ToolCreatorA.create() }
As you can see, here before the create method is invoked, it has a context variable available to be used as implicit. So that value will be picked up.

Useful links:

so this means that in my use case using an implicit parameter is pointless — perreal, Mar 11 '17 at 07:53
it depends, I did not understand your intention of using implicits. — Tawkir, Mar 11 '17 at 08:24
my intention is to make the implementation of ToolCreatorA transparent to the implicit parameter that I'm introducing. The actual code has some more levels until I reach the ToolCreator — perreal, Mar 11 '17 at 08:32

How to pass an implicit argument indirectly

1 Answers1