How do I get an instance of the type class associated with a context bound?

by

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)

More Related Contents:

  1. What is a “context bound” in Scala?
  2. Scala double definition (2 methods have the same type erasure)
  3. How to get ClassTag form TypeTag, or both at same time?
  4. Advantages of F-bounded polymorphism over typeclass for return-current-type problem
  5. Using context bounds “negatively” to ensure type class instance is absent from scope
  6. Why is this implicit ambiguity behaviour happening?
  7. Scalaz Bind[Seq] typeclass
  8. How to define “type disjunction” (union types)?
  9. How to define partitioning of DataFrame?
  10. In Scala, what is an “early initializer”?
  11. Case class equality in Apache Spark
  12. What is the motivation for Scala assignment evaluating to Unit rather than the value assigned?
  13. Dropping a nested column from Spark DataFrame
  14. How to model type-safe enum types?
  15. Filling gaps in timeseries Spark
  16. How to create a TypeTag manually?
  17. Weird behavior trying to convert case classes to heterogeneous lists recursively with Shapeless
  18. Forward References – why does this code compile?
  19. What does a lazy val do?
  20. Spark: Add column to dataframe conditionally
  21. How to clone a case class instance and change just one field in Scala?
  22. How to use third party libraries with Scala REPL?
  23. How do I pattern match arrays in Scala?
  24. Applying an argument list to curried function using foldLeft in Scala
  25. Scala recover or recoverWith
  26. When is @uncheckedVariance needed in Scala, and why is it used in GenericTraversableTemplate?
  27. How to create DataFrame from Scala’s List of Iterables?
  28. Howto model named parameters in method invocations with Scala macros?
  29. How is this case class match pattern working?
  30. Is it possible to have tuple assignment to variables in Scala? [duplicate]

Leave a Comment