Advantages of F-bounded polymorphism over typeclass for return-current-type problem

by

F-Bounded is a great example of what a type system is capable of express, even simpler ones, like the Java one. But, a typeclass would always be safer and better alternative.

What do we mean with safer? Simply, that we can not break the contract of returning exactly the same type. Which can be done for the two forms of F-Bounded polymorphism (quite easily).

F-bounded polymorphism by type member

This one is pretty easy to break, since we only need to lie about the type member.

trait Pet {
  type P <: Pet
  def name: String 
  def renamed(newName: String): P
}

final case class Dog(name: String) extends Pet {
  override type P = Dog
  override def renamed(newName: String): Dog = Dog(newName)
}

final case class Cat(name: String) extends Pet {
  override type P = Dog // Here we break it.
  override def renamed(newName: String): Dog = Dog(newName)
}

Cat("Luis").renamed(newName = "Mario")
// res: Dog = Dog("Mario")

F-bounded polymorphism by type parameter

This one is a little bit harder to break, since the this: A enforces that the extending class is the same. However, we only need to add an additional layer of inheritance.

trait Pet[P <: Pet[P]] { this: P =>
  def name: String 
  def renamed(newName: String): P
}

class Dog(override val name: String) extends Pet[Dog] {
  override def renamed(newName: String): Dog = new Dog(newName)

  override def toString: String = s"Dog(${name})"
}

class Cat(name: String) extends Dog(name) // Here we break it.

new Cat("Luis").renamed(newName = "Mario")
// res: Dog = Dog(Mario)

Nevertheless, it is clear that the typeclass approach is more complex and has more boilerplate; Also, one can argue that to break F-Bounded, you have to do it intentionally. Thus, if you are OK with the problems of F-Bounded and do not like to deal with the complexity of a typeclass then it is still a valid solution.

Also, we should note that even the typeclass approach can be broken by using things like asInstanceOf or reflection.

BTW, it is worth mentioning that if instead of returning a modified copy, you want to modify the current object and return itself to allow chaining of calls (like a traditional Java builder), you can (should) use this.type.

trait Pet {
  def name: String

  def renamed(newName: String): this.type
}

final class Dog(private var _name: String) extends Pet {
  override def name: String = _name

  override def renamed(newName: String): this.type = {
    this._name = newName
    this
  }

  override def toString: String = s"Dog(${name})"
}

val d1 = Dog("Luis")
// d1: Dog = Dog(Luis)

val d2 = d1.renamed(newName = "Mario")
// d2: Dog = Dog(Mario)

d1 eq d2
// true

d1
// d1: Dog = Dog(Mario)

More Related Contents:

  1. Scala double definition (2 methods have the same type erasure)
  2. Using context bounds “negatively” to ensure type class instance is absent from scope
  3. Why is this implicit ambiguity behaviour happening?
  4. How do I get an instance of the type class associated with a context bound?
  5. scala f-bounded types explanation
  6. Scalaz Bind[Seq] typeclass
  7. What are Scala context and view bounds?
  8. Best way to merge two maps and sum the values of same key?
  9. (Why) do we need to call cache or persist on a RDD
  10. Return in Scala
  11. Difference between reduce and foldLeft/fold in functional programming (particularly Scala and Scala APIs)?
  12. Abort early in a fold
  13. Generating a class from string and instantiating it in Scala 2.10
  14. Why is “Unable to find encoder for type stored in a Dataset” when creating a dataset of custom case class?
  15. Append a column to Data Frame in Apache Spark 1.3
  16. Processing multiple files as independent RDD’s in parallel
  17. MatchError while accessing vector column in Spark 2.0
  18. Spark: what’s the best strategy for joining a 2-tuple-key RDD with single-key RDD?
  19. How do I list all files in a subdirectory in scala?
  20. Why does the Scala compiler disallow overloaded methods with default arguments?
  21. How do you do dependency injection with the Cake pattern without hardcoding?
  22. How to get ClassTag form TypeTag, or both at same time?
  23. Why is it possible to declare variable with same name in the REPL?
  24. Difference between fold and foldLeft or foldRight?
  25. Get TypeTag[A] from Class[A]
  26. In Scala, what exactly does ‘val a: A = _’ (underscore) mean?
  27. Spark: long delay between jobs
  28. How to use IntelliJ with Play Framework and Scala
  29. Spark column string replace when present in other column (row)
  30. Scala variable argument list with call-by-name possible?

Leave a Comment