Implements a simple model for executing actions which will run them in
sequence, synchronously, after advancing an FSM and committing the
initial transaction.
Note that multiple things are not yet taken into account:
* Error handling of actions (they can not currently fail)
* Retrying of actions
* Concurrency model
I started out by implementing the concurrency model similarly to the
green-threading method used in Hamingja (but using OS threads), but
slowly noticed that it may not be the best way to do that. It needs a
little bit of discussion.
Either way for most actions this method is fast enough to work for
implementing things on top of Finito's model.
Adds a test for the two most important functions in Finito's
PostgreSQL backend.
These actually require a local Postgres database to be available when
running. Currently the connection details are hardcoded in the test.
Adds the initial finito-postgres crate with type definitions for the
tables and initial functions to interact with persisted FSMs.
This is far from feature complete at this commit.
Checks in my classic, lockable door example implemented in Finito.
This does not yet contain the documentation of the door in the Haskell
version of Finito.
The implementation of this library is closely modeled after the core
abstraction in the Haskell library. This does not at all concern
itself with persistence, interpretation of effects and so on.
