Scala : 'implicitly' and type parameter

Question

I'm having a little trouble understanding the following phenomenon:

trait Trait[A] {
  def traitType: String
}

object Trait {
  implicit val stringTrait: Trait[String] = new Trait[String] {
    def traitType: String = "string"
  }

  implicit val intTrait: Trait[Int] = new Trait[Int] {
    def traitType: String = "int"
  }
}

class Media[A] {
  // works
  def mediaType(implicit t: Trait[A]): String = t.traitType
  // does not compile
  def mediaType: String = implicitly[Trait[A]].traitType
}

object Main {
  def main(args: Array[String]) {
    val a = new Media[String]
    val b = new Media[Int]

    println(a.mediaType)
    println(b.mediaType)
  }
}

In the above snippet I show 2 different implementations of the mediaType method (I comment one of them out when compiling the code). However the version using implicitly does not compile? I get the following error message:

impl.scala:19: error: could not find implicit value for parameter e: Trait[A]
  def mediaType: String = implicitly[Trait[A]].traitType
                                    ^
one error found

I do understand that there is no implicit value of Trait[A] available. I don't understand why A does not get resolved to the type Media gets instantiated with. I think I'm thinking too much in terms of C++ templates here and I would be very grateful if someone could give me a pointer into the right direction.

Regards, raichoo

score 10 · Accepted Answer · answered May 20 '11 at 20:49

Compiler needs evidence, that there exist implicit Trait instance for the A. In first mediaType implementation you declare this requirement. But in the second implementation, from the compiler's point of view, there is no such guarantee. So in order to make it work you should ask users of Media class to provide it. You can make this with context bound:

class Media[A : Trait] {
  def mediaType: String = implicitly[Trait[A]].traitType
}

This can also be written more explicitly:

class Media[A](implicit val evidence: Trait[A]) {
  def mediaType: String = implicitly[Trait[A]].traitType
}

So in other words default constructor requires implicit evidence and users would not be able to instantiate Media class without providing it (explicitly or implicitly).

So the class picks up the Trait[A] value from the implicit context where it's instantiated? — Cristian Vrabie, Aug 08 '13 at 13:44
(as opposed to the mediaType method with implicit parameter which would pick up the value from context where it is called) — Cristian Vrabie, Aug 08 '13 at 14:06

score 2 · Answer 2 · edited May 23 '17 at 11:46

If you want this version to compile:

def mediaType: String = implicitly[Trait[A]].traitType

then the implicit instance of Trait[A] needs to be passed along, e.g. when a new instance of Media is created. Try defining Media as follows instead:

class Media[A](implicit private val t: Trait[A]) {
  def mediaType: String = t.traitType
}

An almost equivalent definition using a context bound is this one:

class Media[A: Trait] {
  def mediaType: String = implicitly[Trait[A]].traitType
}

That being said, if what you're trying to do is keep more information about the type parameter of a parametrized type, you may want to use Manifests instead of your own mechanism. They would provide you with full type information on A at runtime, including if A is itself a parametrized type:

scala> class Media[A](implicit val aManifest: Manifest[A])
defined class Media

scala> new Media[Int].aManifest
res0: Manifest[Int] = Int

scala> new Media[Seq[(Int, String)]].aManifest        
res1: Manifest[Seq[(Int, String)]] = scala.collection.Seq[scala.Tuple2[Int, java.lang.String]]

The above code is just an example. I know about Manifests, thanks :) — raichoo, May 20 '11 at 21:02
@raichoo Yes, I'd just like to avoid that new users read your question, feel “inspired,” and start deriving their own Manifest-like variant from it… — Jean-Philippe Pellet, May 20 '11 at 21:06

Scala : 'implicitly' and type parameter

2 Answers2

Linked