Using the implicitly method
The most common and general approach is to use the implicitly method, defined in Predef:
def add[T: Numeric](x: T, y: T) = implicitly[Numeric[T]].plus(x,y)
Obviously, this is somewhat verbose and requires repeating the name of the type class.
Referencing the evidence parameter (don't!)
Another alternative is to use the name of the implicit evidence parameter automatically generated by the compiler:
def add[T: Numeric](x: T, y: T) = evidence$1.plus(x,y)
It's surprising that this technique is even legal, and it should not be relied upon in practice since the name of the evidence parameter could change.
Context of a Higher Kind (introducing the context
method)
Instead, one can use a beefed-up version of the implicitly
method. Note that the implicitly method is defined as
def implicitly[T](implicit e: T): T = e
This method simply relies on the compiler to insert an implicit object of the correct type from the surrounding scope into the method call, and then returns it. We can do a bit better:
def context[C[_], T](implicit e: C[T]) = e
This allows us to define our add
method as
def add[T: Numeric](x: T, y: T) = context.plus(x,y)
The context
method type parameters Numeric
and T
are inferred from the scope! Unfortunately, there are circumstances in which this context
method will not work. When a type parameter has multiple context bounds or there are multiple parameters with different context bounds, for example. We can resolve the latter problem with a slightly more complex version:
class Context[T] { def apply[C[_]]()(implicit e: C[T]) = e }
def context[T] = new Context[T]
This version requires us to specify the type parameter every time, but handles multiple type parameters.
def add[T: Numeric](x: T, y: T) = context[T]().plus(x,y)