Hey, thanks for all the great work. I really like using State Machine DSL in my daily work. I have created an IntelliJ plugin to visualize the StateMachine. While I'm waiting for the review process by IntelliJ to complete for it to publicly available, could you share your opinion/ feedback on my work here https://github.com/nvinayshetty/StateArts

~~Is it possible to attach data to states and events using the DSL? I've been avoiding using Mobius or RxRedux for implementing state machines as part of UI architecture and just writing my own. I'd like to use this DSL to describe my state machines for the sake of formalization and reusability, but I can't see a way to make my states and events meaningful in terms of attaching data to them. Should I just write my own DSL that suits my needs? :[~~

~~Edit: For clarification, my pain point is when I'm declaring states to transition to. The transitionTo builder method wants a state instance, but the state instance, in my case, can only be constructed once an event with a payload is received and parsed. Is it possible to access the event that caused the transition when declaring the transitionTo, perhaps in the scope of on<SomeEvent> { ... }?~~

Turns out you can optionally specify the presence of an event parameter for the lambda of on<SomeEvent> { ... }. Sneaky.

Another question, then - are SideEffects triggering new Events supported with this DSL? I don't see an obvious way to dispatch new events in onTransition { ... } since the state machine isn't created yet.

which repository is in it ? i tried putting in android studio but i get gradle reporting that it cannot resolve it?

Failed to resolve: com.tinder:state-machine:0.0.1

im using these ones:

 jcenter()

        maven { url 'https://maven.fabric.io/public' }
        mavenCentral()
        google()

add @StateMachineDsl, so that onEnter{} could not be called inside on {}

but it modified the api, so probably it can not be merged, just an idea to share

Changelog

• Add Swift implementation

Updated README

Preview: https://github.com/Tinder/StateMachine/blob/a1892cca28b5d5712f984261cb67630c3a2213fc/README.md

It would be nice if the state machine could allow for multiple side effects on an transition. For example one (always used) side effect of logging the transition and one highly specialized for the stateA ---> stateB transition (caused by eventC)

I image the call site to look something like this:

 state<MachineState.INOPERATIVE> {
        on<Event.OnPacket> {
            if (it.fancyVariable === 123) {
                transitionTo(MachineState.STARTING,
                        listOf(SideEffect.FrobnicateBar(it.requestTime),
                               SideEffect.WriteStateTransition()))
            } else {
                dontTransition()
            }
        }
    }

To also allow the old style of only specifying one side effect it seems like I would need to overload StateMachine.StateDefinitionBuilder.transitionTo() and dontTransition()

I would be happy to try this (given some pointers on where to start).

any chance to set this one file library to a more open license, e.g. MIT, Apache 2, etc.? it's neat but that license makes it basically unusable to almost every commercial application. i wonder if that is truly necessary for this particular library. have a nice day

Hi, so I was wondering if there's a recommended way to have more than one SideEffect for a transition? Is it simply repeating a transitionTo to the destination state but with different SideEffects?

And yes, I realize I could just simply have unique SideEffects for each transition, but that would lead to a lot of repeated code in my case. If I'm missing anything please let me know. Thanks!

For example (see // THIS comments):

val stateMachine = StateMachine.create<State, Event, SideEffect> {
    initialState(State.Solid)
    state<State.Solid> {
        on<Event.OnMelted> {
            transitionTo(State.Liquid, SideEffect.LogMelted)
            transitionTo(State.Liquid, SideEffect.LogOtherLiquidInfo) // THIS
        }
    }
    state<State.Liquid> {
        on<Event.OnFroze> {
            transitionTo(State.Solid, SideEffect.LogFrozen)
        }
        on<Event.OnVaporized> {
            transitionTo(State.Gas, SideEffect.LogVaporized)
        }
    }
    state<State.Gas> {
        on<Event.OnCondensed> {
            transitionTo(State.Liquid, SideEffect.LogCondensed)
            transitionTo(State.Liquid, SideEffect.LogOtherLiquidInfo)  // THIS
        }
    }
    onTransition {
        val validTransition = it as? StateMachine.Transition.Valid ?: return@onTransition
        when (validTransition.sideEffect) {
            SideEffect.LogMelted -> logger.log(ON_MELTED_MESSAGE)
            SideEffect.LogFrozen -> logger.log(ON_FROZEN_MESSAGE)
            SideEffect.LogVaporized -> logger.log(ON_VAPORIZED_MESSAGE)
            SideEffect.LogCondensed -> logger.log(ON_CONDENSED_MESSAGE)
            SideEffect.LogOtherLiquidInfo-> logger.log(ON_OTHER_LIQUID_INFO)  // THIS
        }
    }
}

As proposed in https://github.com/Tinder/StateMachine/issues/9, invalid transition should cause an exception. In my opinion, current behavior (returning Invalid object) is a good solution, however users should be able to enable throwing exceptions in such cases.

When a state definition is missing, exception is thrown with message: Required value is null. This fix adds more meaningful error message.

An example of missing state definition:

            private val stateMachine = StateMachine.create<String, Int, Nothing> {
                initialState(STATE_A)
                state(STATE_A) {
                    on(EVENT_1) {
                        transitionTo(STATE_B)
                    }
                }
                // Missing STATE_B definition.
            }

Error is thrown here:

stateMachine.transition(EVENT_1) // transition to `STATE_B` which is not handled.

Hello guys! Finite-state machine in theory has a "final states" For example simple task "Sequence of 1 and 0 contain odd 0 and even 1" has only one final state in graph. Will be better extend this example for handling this possibility.

Also sometimes we should reset our state machine to init state.

What do u think about this changes or it is unnecessary?

Hi,

I have implemented and ad-hoc Bluetooth connection state machine based on states and events (no need for SideEffects / actions for the moment). I was thinking about switching that state machine to a version created using this library.

Is it possible to create such state machine, or as a minimum I should have at least 1 SideEffect (a dummy one for example)?

Thanks in advance.

Wanted to say thanks for developing this state machine library! Are there plans in the future to add support for calling suspending functions from within the handlers? Right now to workaround this we need to do something like

state<State.MyState> {
  on<Event.MyEvent> {
    runBlocking {
      mySuspendingFunction()
    }
  }
}

Would be nice to just be able to call mySuspendingFunction() from directly within the event handler.

Also, is the version 0.3.0 going to be published to maven? It looks like the most recent version on maven is 0.2.0 https://mvnrepository.com/artifact/com.tinder.statemachine/statemachine.

Those event are present in an android version of the state machine and are missed in iOS version, so it is not possible to use the same logic between platforms.

Thank you for your amazing library I have a problem with onEnter at initialState.

It's my code :

   val machine = StateMachine.create<State, Event, SideEffect> {
   initialState(State.INIT)
   
   state<State.INIT> {
      onEnter {
         println("onEnter INIT")
      }
      
      on<Event.E1> {
         println("onE1 INIT")
         transitionTo(State.INITIALIZED)
      }
   }
   
   state<State.INITIALIZED> {
      onEnter {
         println("enter initialized")
      }
      
      on<Event.E1> {
         transitionTo(State.FINAL)
      }
      
      onExit {
         println("exit initialized")
      }
   }
   
   state<State.FINAL> {
      onEnter {
         println("onFinal")
      }
   }
   
   
}


machine.transition(Event.E1)
machine.transition(Event.E1)

sealed class State {
   object INIT : State()
   object INITIALIZED : State()
   object FINAL : State()
}

sealed class Event {
   object E1 : Event()
}

sealed class SideEffect {
   
}

Result:

onE1 INIT enter initialized exit initialized onFinal

I can't see any ways to store and restore states of state machine. Especially I'm interested in restoring state with specific side effects. How do you usually do it?