What are type classes in Scala useful for?

by

One use case, as requested…

Imagine you have a list of things, could be integers, floating point numbers, matrices, strings, waveforms, etc. Given this list, you want to add the contents.

One way to do this would be to have some Addable trait that must be inherited by every single type that can be added together, or an implicit conversion to an Addable if dealing with objects from a third party library that you can’t retrofit interfaces to.

This approach becomes quickly overwhelming when you also want to begin adding other such operations that can be done to a list of objects. It also doesn’t work well if you need alternatives (for example; does adding two waveforms concatenate them, or overlay them?) The solution is ad-hoc polymorphism, where you can pick and chose behaviour to be retrofitted to existing types.

For the original problem then, you could implement an Addable type class:

trait Addable[T] {
  def zero: T
  def append(a: T, b: T): T
}
//yup, it's our friend the monoid, with a different name!

You can then create implicit subclassed instances of this, corresponding to each type that you wish to make addable:

implicit object IntIsAddable extends Addable[Int] {
  def zero = 0
  def append(a: Int, b: Int) = a + b
}

implicit object StringIsAddable extends Addable[String] {
  def zero = ""
  def append(a: String, b: String) = a + b
}

//etc...

The method to sum a list then becomes trivial to write…

def sum[T](xs: List[T])(implicit addable: Addable[T]) =
  xs.FoldLeft(addable.zero)(addable.append)

//or the same thing, using context bounds:

def sum[T : Addable](xs: List[T]) = {
  val addable = implicitly[Addable[T]]
  xs.FoldLeft(addable.zero)(addable.append)
}

The beauty of this approach is that you can supply an alternative definition of some typeclass, either controlling the implicit you want in scope via imports, or by explicitly providing the otherwise implicit argument. So it becomes possible to provide different ways of adding waveforms, or to specify modulo arithmetic for integer addition. It’s also fairly painless to add a type from some 3rd-party library to your typeclass.

Incidentally, this is exactly the approach taken by the 2.8 collections API. Though the sum method is defined on TraversableLike instead of on List, and the type class is Numeric (it also contains a few more operations than just zero and append)

More Related Contents:

  1. Implicit keyword before a parameter in anonymous function in Scala
  2. Is there a way to control which implicit conversion will be the default used?
  3. Scala: Implicit parameter resolution precedence
  4. In scala 2 or 3, is it possible to debug implicit resolution process in runtime?
  5. Using context bounds “negatively” to ensure type class instance is absent from scope
  6. Why is this implicit ambiguity behaviour happening?
  7. What is Scala’s yield?
  8. What is the difference between JavaConverters and JavaConversions in Scala?
  9. Scala Futures – built in timeout?
  10. How to define a custom aggregation function to sum a column of Vectors?
  11. Better way to convert a string field into timestamp in Spark
  12. If an Int can’t be null, what does null.asInstanceOf[Int] mean?
  13. Stream vs Views vs Iterators
  14. How to use Scala’s this typing, abstract types, etc. to implement a Self type?
  15. No configuration setting found for key ‘akka.version’
  16. Run custom task automatically before/after standard task
  17. scala – Any vs underscore in generics
  18. How to force IntelliJ IDEA to reload dependencies from build.sbt after they changed?
  19. Scala : fold vs foldLeft
  20. How do I access default parameter values via Scala reflection?
  21. How do I make a function involving futures tail recursive?
  22. How do I cast a variable in Scala?
  23. What is the forSome keyword in Scala for?
  24. Why to use empty parentheses in Scala if we can just use no parentheses to define a function which does not need any arguments?
  25. Scala: Parallel collection in object initializer causes a program to hang
  26. Equivalent to Ruby’s #tap method in Scala [duplicate]
  27. Is there an equivalent to SuppressWarnings in Scala?
  28. Why isn’t Validation a Monad?
  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