[go-nuts] [ANN] Finite State Machine (easy to use)

Hi,

I've been playing with state machines for my projects as well, although
they are absolutely not the formal FSMs.
You can check it at https://github.com/tchap/go-statemachine. It's pretty
small but I find it quite useful. It can make your code much easier to read
and understand.

Regards,
Ondra Kupka

I am not sure, but I think this looks interesting. I can't see me using
now. You probably need some large software with complex behaviour to have a
use for such a thing as this.

By the way, there's also Ragel http://www.complang.org/ragel/
That works on input strings. Perhaps you can use it to run on commands
coming from a channel, instead?

Hi,
go-statemachine is in fact not really supposed to be used as you would use typical FSM. It's just for structuring your Go code and doing synchronization, not for using FSM from your code, so it's really something completely different. But the spirit of state machines is there :-) Sorry if I confused you :-)

Regards,
Ondra Kupka

Hi,

Your FSM looks interesting for certain use cases, although I think channels
are the way to go to make thins thread safe in go (passing the structs over
a channel, which is thread safe by nature.)

My FSM is not at all meant to be used in the same cases. It's primary use
is to replace several dependent boolean state variables, for example
open/closed and locked/unlocked for a door. These variables is much better
combined into a simple FSM to track valid combinations (locked and closed
is a strange combination for example.) Here is some sample code on how to
use it:

fsm := NewFSM(
     "locked",
     Events{
         {Name: "unlock", Src: []string{"locked"}, Dst: "unlocked"},
         {Name: "open", Src: []string{"unlocked"}, Dst: "open"},
         {Name: "close", Src: []string{"open"}, Dst: "unlocked"},
         {Name: "lock", Src: []string{"unlocked"}, Dst: "locked"},
     },
     Callbacks{},
)

fsm.Event("unlock")
fsm.Event("open")
fsm.Event("close")
fsm.Event("lock")

Proper error checking needs to be done on the Event() method to see if the
transition was valid, but I removed it hear to make it easier to read the
example.

I believe both our FSMs have use cases, but I started this thread as an
announcement of my new package so please keep the discussions of
go-statemachine in another thread.

Best Regards,
Max

Hi,
Yeah, sorry if I spammed this ANN, I guess I should have used another
thread.

Anyway, I see that you just return an error when there is a transition in
progress (correct me if I am mistaken).
How would you use this in Go, as a private field in a struct and then you
do synchronization on top of it?
Because it is not thread-safe as far as I understand. Or do you have a
completely different use case
where you don't need to synchronize?

Regards,
Ondra Kupka

No problem with that, just wanted to make sure this thread was kept on
topic. :)

As far a synchronization goes it's an area I haven't put much thought into.
This version is meant to be used in a single thread, but I would be
interested to hear about ideas on making it thread safe!

Can you describe a use case of my FSM in a threaded situation, or provide
some example code of it?

Best,
Max

Hi Max,
   I've been using your looplab go fsm and it works great. However, I'm
stuck on what makes sense to use your code in a continuous loop. Something
like:
for {
     switch fsm.Current() {
     case "InitS":
          // Do initS things...
     case "WorkingS":
          // Do working steps
    }
}
It seems like you've already got that "inside" and fsm.Current() doesn't
seem necessary. But I want it to keep looping through states and responding
accordingly.

I'd love any suggestions you might have.

Thanks,
Dave

The project was just added to the Go projects wiki page under data
structures - other: http://code.google.com/p/go-wiki/wiki/Projects

I have also added continuous integration at
drone.io: https://drone.io/github.com/looplab/fsm

/Max