- [Advanced](#advanced)

- [Subscribing To Store Changes](#subscribing-to-store-changes)

- [Connecting Store Updates To Widgets](#connecting-store-updates-to-widgets)

- [Transforming Executor Arguments](#transforming-executor-arguments)

- [Optimistic Update Pattern](#optimistic-update-pattern)

- [Executing Concurrent Commands](#executing-concurrent-commands)

The result object contains the following:

* The `payload` passed to the process

* A function to execute an additional `process`.

The array of `Commands` are executed in sequence by the store until the last Command is completed or a `Command` throws an error. These processes often represent an application behavior. For example adding a todo in a simple todo application which will be made up with multiple discreet commands.

function addTodoProcessCallback(error, result) {

if (error) {

// do something with the error

}

// possible additional state changes by running another process using result.executor(otherProcess)

}

The `Process` creates a deferred executor by passing the `store` instance `addTodoProcess(store)` which can be executed immediately by passing the `payload`, `addTodoProcess(store)(payload)`. Or more often passed to your widgets and used to initiate state changes on user interactions. The `payload` argument for the `executor` is required and is passed to each of the `Process`'s commands in a `payload` argument.

const StoreContainer = createStoreContainer<State>();

An optional `transformer` can be passed to a process that is used to transform the `executor`s payload to the `command` payload type. The return type of the `transformer` must match the `command` `payload` type of the `process`. The argument type of the `executor` is inferred from transformers `payload` type.

function addTodoCallback(error, result) {

if (error) {

result.executor(handleAddTodoErrorProcess);

}

}

postTodoCommand,

calculateCountsCommand

],

* `addTodoCommand`: Adds the new todo into the application state

The `Process` callback provides a hook to apply generic/global functionality across multiple or all processes used within an application. This is done using higher order functions that wrap the process' local `callback` using the error and result payload to decorate or perform an action for all processes it is used for.

`callback` decorators can be composed together to combine multiple units of functionality, such that in the example below `myProcess` would run the `error` and `result` through the `collector`, `logger` and then `snapshot` callbacks.

The `createProcessWith` higher order function can be used to specify `callback` decorators that need to be applied across multiple `processes`. The function accepts an array of `callback` decorators and returns a new `createProcess` factory function that will automatically apply the decorators to any process that it creates.

const myProcess = customCreateProcess([ commandOne, commandTwo ]);

const myCallbackDecorator = createCallbackDecorator(myCallback);