# mu-ffsm

> Fluent functional state machines

Latest version **0.0.2** (published 2014-07-15) · ISC license · 0 weekly downloads

## Install

```sh
npm install mu-ffsm
pnpm add mu-ffsm
yarn add mu-ffsm
bun add mu-ffsm
```

## Health

**Score 15/100 (F)** — status: abandoned.

Positive: no vulnerabilities.

Warnings: low downloads; no types; no esm support; pre 1.0.

Negative: abandoned; low maintenance score.

## Facts

| | |
|---|---|
| Version | 0.0.2 |
| Published | 2014-07-15 |
| First published | 2014-07-15 |
| Weekly downloads | 0 |
| License | ISC |
| TypeScript types | none |
| Module format | CommonJS |
| Dependencies | 0 |
| Known vulnerabilities | 0 |
| Install scripts | no |
| Author | Jelle 'wires' Herold |
| Maintainers | wires |

## Links

- npm: https://www.npmjs.com/package/mu-ffsm
- npm.io page: https://npm.io/package/mu-ffsm

## Recent versions

- 0.0.2 (latest) — 2014-07-15

## README

# µ-ffsm: Micro fluent API helper

Very tiny helper function to construct fluent interfaces.

	> npm i mu-ffsm
	
Import

	var FFSM = require('mu-ffsm');

Create language/machine.	

```js
// internal state is an Array
var Talker = FFSM({
	0:    function() { return []; }, // TODO allow const
	talk: function(say, what) { say.push(what); return say; },
	1:    function(say, sep) { return say.join(sep || ' '); }
});
```

Construct sentences/instances:

```js
var cowboyGreeting = Talker()
	.talk('howdy')
	.talk('cowboy');

// make dramatic
console.log(cowboyGreeting(', ...'));
```

## Idea

We consider a sort of 'state machine' that maintains an internal
state of type `S`. We then consider three types of
functions on it:

- entry : `* ⟶ S`
- transition : `S ⟶ * ⟶ S`
- exit : `S ⟶ * ⟶ *`

We write the entry function as `0`, the exit function as `1` and then
name all the transition functions however we like. 

Then

```js
	var M = FFSM({
		0: function(i)    { return /* initial state */; } // entry function
		a: function(s, t) { return /* new state     */; } // transition 'a'
		b: function(s, t) { return /* new state     */; } // transition 'b'
		1: function(s, x) { return /* final value   */; } // exit function
	});
```

Now

```js
	var i = M(entry)	// x : S <- 0(entry)
		.a(trigger_0)	// y : S <- a(x, trigger_0)
		.b(trigger_1)	// z : S <- b(y, trigger_1)
		.a(trigger_2);  // i : S <- a(z, trigger_2)
```

Finally

```js
	var y = i(x);		// y <- 1(i, x)
```

So we have

- First `M(entry)` creates a new machine instance of type M.
  It's initial state derived from entry (`0(entry)`).

- Then `.a(trigger_0`) transitions the machine with transition `a` to a new
  state, using the previous state and the data from `trigger_0` to
  compute the new state.

- Similarly `.b(t_1)`, `.a(t_2)`.

- Finally, the `i(x)` call constructs an element out of
  the internal state and the argument using the exit function `1(i,x)`.

---
_Source: https://npm.io/package/mu-ffsm · Machine-readable twin of the npm.io package page. Health data is recomputed on every publish._