A generic finite state machine with a listener

#!ek9
defines module site.structure.fsm

  defines type

    FSM of Integer

  defines function

    FSMListener() of type T as abstract
      ->
        fromState as T
        toState as T

  defines class

    FSM of type T
      currentState as T: T()
      listener as FSMListener of T?

      FSM()
        -> initialState as T
        require initialState?
        currentState: initialState
        listener: () is FSMListener of T as function
          require fromState? and toState?

      default private FSM()

      setState()
        -> newState as T
        require newState?
        if listener?
          listener(currentState, newState)
        currentState: newState

      getState()
        <- rtn as T: currentState

      setListener()
        -> listenerToAdd as FSMListener of T
        require listenerToAdd?
        listener: listenerToAdd

      default operator ?

  defines program

    Driver()
      myListener <- () is FSMListener of Integer as function
        stdout <- Stdout()
        require fromState? and toState?
        stdout.println(`Changing from ${fromState} to ${toState}`)

      myMachine <- FSM(2)
      myMachine.setListener(myListener)
      myMachine.setState(5)

Changing from 2 to 5