A library for Communicating Sequential Processes, built on top of async/await and the asynchronous iterable interface.
This library requires async/await and for-await-of support.
$ npm install --save @jfet97/csp
You can find the documentation here.
Below is a trivial example of usage, that plays on the standard ping-pong example.
const { Channel } = require('@jfet97/csp');
const timeout = ms => new Promise(resolve => setTimeout(resolve, ms));
const wiff = new Channel();
const waff = new Channel();
const createBall = () => ({ hits: 0, status: '' });
const createBat = async (inbound, outbound) => {
while (true) {
const ball = await inbound.take(); // wait for an incoming ball
ball.hits++;
ball.status = ball.status === 'wiff!' ? 'waff!' : 'wiff!';
console.log(`🎾 Ball hit ${ball.hits} time(s), ${ball.status}`);
await timeout(500); // assume it's going to take a bit to hit the ball
await outbound.put(ball); // smash the ball back
}
};
createBat(waff, wiff); // create a bat that will wiff waffs
createBat(wiff, waff); // create a bat that will waff wiffs
waff.put(createBall());
Channels implement the async iterable interface, so you can transform the following illustrative code:
async function process (inbound, outbound) {
while (true) {
const msg = await inbound.take();
// do stuff with msg
await outbound.put(res);
}
};into a cleaner version, thanks to the powerful for-await-of:
async function process (inbound, outbound) {
for await(const msg of inbound) {
// do stuff with msg
await outbound.put(res);
}
};Thanks to Joe Harlow for his work on this topic. If you are unfamiliar with CSP, I encourage you to see his talk where he describe a simpler version of this library as well.
Contributions are welcomed and appreciated!
- Fork this repository.
- Make your changes, documenting your new code with comments.
- Submit a pull request with a sane commit message.
Feel free to get in touch if you have any questions.
Please see the LICENSE file for more information.