Given you have an API for an specific situation that is supposed to be used somewhat like that:

interface StateMachine<S> {
    fun updateState(state: S)
}

Where

S

needs to be a class that is able to represent the state of an UI element. What would you set as the upper-bound of

S

?

// 1
interface StateMachine<S : Any>

or

// 2
interface StateMachine<S : State>

// where
interface State  // There is no specific contract expected

I would also make

State

a sealed class instead of an interface, if possible. In fact why not make the

StateMachine

itself a sealed class hierarchy and get rid of the generic parameter altogether? E.g.

sealed class Door
class OpenDoor : Door()
class ClosedDoor : Door()
// instead of
interface DoorState
class Closed : DoorState
class Open : DoorState
class Door<DoorState>

//this would make use of the state machine more type safe, and no dealing with type erasure.

Because that's completely off the point. Something I forgot to mention,

StateMachine

is an API to be implemented in multiple different contexts (thus why it's an

interface

, not a

class

). So the concrete usage would be something like you mentioned:

class MyStateMachine : StateMachine<Door> {
    // ...
}

sealed class Door [: State] {
    class OpenDoor : Door()
}

I see, that's why I have "if possible" in my answer, not knowing the full context I was just making a generic suggestion 🙂