A modern programming language that makes developers happier.

kotlinlang

Screen Shot 2021-02-09 at 10.04.24 PM.png

I do not understand why casting `this`  to `S` is unchecked. Is it a bug or I miss something

probably because the compiler cannot infer it
regarding how the class uses generics
i can understand why
infinite recursion is not compiler-friendly

looks like what is known in C++ as "<https://en.wikipedia.org/wiki/Curiously_recurring_template_pattern|CRTP>" :slightly_smiling_face:

Why should `AbstractBuilder` be of type `S`?

Other way round - `S` should derive from `AbstractBuilder&lt;S&gt;`, so an instance of `AbstractBuilder&lt;S&gt;` can be downcast to `S` . _However_, someone could do:
```class A : AbstractBuilder&lt;B&gt; {}
class B : AbstractBuilder&lt;A&gt; {}```
and then the cast fails, but the JVM can't check it as it's unchecked

Ah, ugh, that looks like a pretty confusing and error-prone pattern to me.

In C++ it's quite common but you have to be careful, yes. Not sure about Kotlin

AFAIK this pattern is used in Java streams

```public interface BaseStream&lt;T, S extends BaseStream&lt;T, S&gt;&gt;```

yes, this pattern is used
no, it’s not a good idea
:wink:

all in all, the compiler tells you he cannot be sure about the cast
but if you’re sure, that’s ok
nothing is wrong

It’s called “recursive generics” in Java, and it has some purposes:
<https://vyazelenko.com/2012/03/02/recursive-generics-to-the-rescue/>
<https://www.sitepoint.com/self-types-with-javas-generics/>

Actually this pattern (with recursive generic) may be replaced with new language feature with _self types_
But it's unknown, would it be added to language or not (but we considering it)