9

After going through a few examples, I have to say, I fail to understand what the F-Bounded polymorphic brings.

To use the example from scala school (https://twitter.github.io/scala_school/advanced-types.html#fbounded)

They explain that they need some F-Bounded type so that the subclass can return the subtype. So they do something like this: 

trait Container[A <: Container[A]] extends Ordered[A]
class MyContainer extends Container[MyContainer] {
  def compare(that: MyContainer) = 0
}

But I don't see what is the gain of using this kind of type when you could use something like this: 

trait Container[A] extends Ordered[A]
class MyContainer extends Container[MyContainer] {
  def compare(other: MyContainer) = 0
}

Any explanation is very welcomed

Thanks

Andrey Tyukin
  • 43,673
  • 4
  • 57
  • 93
jeremie
  • 971
  • 9
  • 19

2 Answers2

6

The advantage would come when it looks something like this:

trait Container[A <: Container[A]] extends Ordered[A] {
  def clone: A
  def pair: (A, A) = (clone, clone)
}

class MyContainer extends Container[MyContainer] {
  def clone = new MyContainer
}

Now you get pair for free, and you get the correct return type. Without something like this you must manually override every single method that returns the same type (lots of pointless boilerplate), or you lose specificity in your types as soon as you call a non-overridden method.

Rex Kerr
  • 166,841
  • 26
  • 322
  • 407
  • 1
    I think I got Nishan's point and to me it makes sense, but the part you're talking about, is the part that confuses me. From your example, you could define A like that: trait Container[A] and get the same result. You won't have to overwrite the pair function in the sublcass – jeremie Mar 30 '15 at 15:44
  • Oh, never mind, I just got it. If you do trait Container[A], you cannot guaranty that from in the subclass the returned type A is of type Container. Thanks a lot – jeremie Mar 30 '15 at 19:05
1

In Scala you can make your type parameters constrained by a type bound. Here in your first method you are making your type parameter making upper bound with sub class of Container.

By using your 1st method you can't pass parameter in Container class which is not sub class of your Container class.

In your 2nd example you can pass parameter type instance of any class. So here your are not restricting anything while in 1st example you are restricting type sub type of Container class.

Nishan
  • 375
  • 3
  • 16