Ecosyste.ms: Awesome
An open API service indexing awesome lists of open source software.
https://github.com/marcoonroad/sporadic
Composable Concurrency Abstractions for JavaScript. :railway_track: :rhinoceros: :train: :vertical_traffic_light:
https://github.com/marcoonroad/sporadic
async-await channels concurrency coroutines javascript promises reactive-programming streams
Last synced: about 1 month ago
JSON representation
Composable Concurrency Abstractions for JavaScript. :railway_track: :rhinoceros: :train: :vertical_traffic_light:
- Host: GitHub
- URL: https://github.com/marcoonroad/sporadic
- Owner: marcoonroad
- License: mit
- Created: 2018-12-17T03:21:26.000Z (over 5 years ago)
- Default Branch: master
- Last Pushed: 2024-04-04T18:49:10.000Z (2 months ago)
- Last Synced: 2024-04-04T19:53:43.034Z (2 months ago)
- Topics: async-await, channels, concurrency, coroutines, javascript, promises, reactive-programming, streams
- Language: JavaScript
- Homepage: https://sporadic.marcoonroad.dev
- Size: 803 KB
- Stars: 18
- Watchers: 2
- Forks: 3
- Open Issues: 17
-
Metadata Files:
- Readme: README.md
- License: LICENSE
- Support: support/index.js
Lists
- awesome-javascript - sporadic - Composable concurrency abstractions (such as streams, coroutines and Go-like channels) on top of promises, for Node and browser engines. (Control Flow / Runner)
- awesome-javascript-cn - sporadic
- awesome-javascript - sporadic - Composable concurrency abstractions (such as streams, coroutines and Go-like channels) on top of promises, for Node and browser engines. (Control Flow / Runner)
- awesome-javascript - sporadic - Composable Concurrency Abstractions for JavaScript. ` 📝 a year ago ` (Control Flow [🔝](#readme))
- awesome-javascript-builds-project - sporadic - Composable concurrency abstractions (such as streams, coroutines and Go-like channels) on top of promises, for Node and browser engines. (Control Flow / Runner)
- A-collection-of-awesome-browser-side-JavaScript-libraries-resources-and-shiny-things. - sporadic - Composable concurrency abstractions (such as streams, coroutines and Go-like channels) on top of promises, for Node and browser engines. (Control Flow / Runner)
- awesome-javascript - sporadic
README
# sporadic
Composable Concurrency Abstractions for JavaScript.
---
## Example
```javascript
#!/usr/bin/env node
(async () => {
const sporadic = require('sporadic')
const channel = await sporadic.channels.open()
const wasReceivedPromise = sporadic.channels.send(channel, "Hello, World!")
const messagePromise = sporadic.channels.receive(channel)
const promises = [ wasReceivedPromise, messagePromise ]
const [ wasReceived, message ] = await Promise.all(promises)
console.log(wasReceived) // ==> true
console.log(message) // ==> Hello, World!
})()
```
---
## Installation
Through UNPKG (for browsers):
```html
```
Through NPM:
```shell
$ npm install sporadic
```
---
To install the development snapshot, use `npm link`.
For example, on this cloned repository:
```shell
$ npm link .
```
And then, on your project:
```shell
$ npm link sporadic
```
Stable releases are tags in the branch `release`. The `master` branch here is
only to track the next releases, please don't rely too much on that branch. All
the hard work is made on the `development` branch.
## Documentation
For every submodule within this `sporadic` library, there's an API documentation
available at the directory `docs/` under the filename `SUBMODULE.md`, where
`SUBMODULE` stands for the submodule provided with this library (yes, I know the
redundancy :joy:). Each submodule corresponds to a concurrency abstraction.
Currently, the following abstractions are implemented:
- [sporadic.streams][1], an abstraction for reactive streams made of multiple
publishers and multiple subscribers. The subscription process is implicit,
the reference for the stream object is all that is needed.
- [sporadic.channels][2], an abstraction for synchronous queues made of many
producers and consumers. This concurrent data type is a bare minimal tool for
pipelines of chained producers and consumers.
- [sporadic.coroutines][3], an abstraction for suspendable subroutines. Such
abstraction also behaves as a task/promise whenever we wait for the final
coroutine result (but keep in mind that coroutines can "loop" forever). It's kinda
like the JavaScript generators, with the sole difference of being asynchronous
instead synchronous calls (and thus, allowing us to mix asynchronous I/O with that).
[1]: https://marcoonroad.github.io/sporadic/streams
[2]: https://marcoonroad.github.io/sporadic/channels
[3]: https://marcoonroad.github.io/sporadic/coroutines
## Remarks
PRs & Issues are always welcome :house:! Feel free to open one :v:!
Happy hacking :computer:!
## License
[](https://app.fossa.io/projects/git%2Bgithub.com%2Fmarcoonroad%2Fsporadic?ref=badge_large)