A modern programming language that makes developers happier.

kotlinlang

Screenshot from 2019-01-04 00-39-09.png

Got lost in generics a bit. Is there any way to avoid unchecked cast here?

```
abstract class FSM&lt;STEP : FSM.Step&lt;DATA&gt;, DATA&gt;(firstStep: STEP) {

    var currentStep: STEP = firstStep
        private set

    fun next(data: DATA) {
        currentStep = currentStep.next(data)
    }
    
    fun prev(data: DATA) {
        currentStep = currentStep.prev(data)
    }

    interface Step&lt;DATA&gt; {
        fun next(data: DATA): Step&lt;DATA&gt;
        fun prev(data: DATA): Step&lt;DATA&gt;
    }
}
```

`currentStep.next` can return any subtype of `Step&lt;DATA` and not just `STEP`

Classic recursive generics:
```abstract class FSM&lt;STEP : FSM.Step&lt;DATA, STEP&gt;, DATA&gt;(firstStep: STEP) {

    var currentStep: STEP = firstStep
        private set

    fun next(data: DATA) {
        currentStep = currentStep.next(data)
    }

    fun prev(data: DATA) {
        currentStep = currentStep.prev(data)
    }

    interface Step&lt;DATA, S: Step&lt;DATA, S&gt;&gt; {
        fun next(data: DATA): S
        fun prev(data: DATA): S
    }
}```

Change `Step` to `Step&lt;DATA, S: Step&lt;DATA, S&gt;&gt;` and change `FSM` accordingly.

works wonders! Probably even covariant?: `Step&lt;DATA, out S : Step&lt;DATA, S&gt;&gt;`?

You could also declare the type of `currentStep` as `Step&lt;DATA&gt;`
I think complex type relations should be avoided.

True! A second working solution. The downside is, `currentStep` is public, so the usage is going to be strange. You feed your subclassed steps to FSM, but it gives you the superclass current.

Ah yeah, fair enough. Then Karel's solution is better :)