Selfreferencing Generics

Question

I've searched a bit around but I was not able to find an example of such a structure:

Person[P <: Person[P]]

that is explained in a way I understand.

How does this resolve? It kinda looks like an endless recursion to me, but it seems I am wrong with that conclusion.

Answer 1

The structure itself is explained in the Twitter Scala School and is called F-bounded polymorphism.

// you define it like this
trait X extends Person[X]

// it then gets expanded to this
trait Person[X extends Person[X]]

This structure is used when the trait needs to have a reference to the type of the object it is extending. If the Scala school explanation is not enough you can search the internet for 'F-bounded polymorphism'

Answer 2

This is sometimes called a self type (not to be confused with Scala's explicitly typed self-references) and it is usually used in order to have method signatures that are strong enough to express that the method works with objects of the same type as the receiver.

Let's look at an example. Say, you have a base trait Animal with a generic breed method that takes another Animal and returns an Animal.

trait Animal {
  def breed(a: Animal): Animal
}

Ok, but what you actually want is a breed method that expresses that every concrete animal only breeds with animals of the same class and also returns an animal of the same class. The following implementation

class Cow extends Animal {
  def breed(c: Cow) = new Cow
}

is not possible, because this breed's signature doesn't match. Overriding is also not possible, because you would need to change the argument type covariantly, which is forbidden.

Self-types to the rescue:

trait Animal[A <: Animal[A]] {
  def breed(a: A): A
}

class Cow extends Animal[Cow] {
  def breed(c: Cow) = new Cow
}

As EECOLOR already pointed out, the type theory behind it is called F-bounded polymorphism.