# continuable

**Repository Path**: mirrors_creationix/continuable

## Basic Information

- **Project Name**: continuable
- **Description**: A continuable style interface to node.js
- **Primary Language**: Unknown
- **License**: Not specified
- **Default Branch**: master
- **Homepage**: None
- **GVP Project**: No

## Statistics

- **Stars**: 0
- **Forks**: 0
- **Created**: 2020-09-24
- **Last Updated**: 2026-03-01

## Categories & Tags

**Categories**: Uncategorized

**Tags**: None

## README

# Continuable

This library is a replacement for many of the core node.js libraries but using continuable style instead of node callback style.

What is continuable style you say?  Why a continuable function is an async function that returns a continuation.

For example, consider a continuable version of setTimeout, named sleep:

```js
function sleep(ms) {
  return function (callback) {
    setTimeout(callback, ms);
  }
}
```

Here, the sleep function returns a new function that accepts the callback.  That returned function is the continuation.

All continuations must accept only a callback and must call that callback with the typical node.js style `(err, args...)` pattern.

## continuable/stream

A stream in this system is an extremely simple interface at the minimum.  A readable stream is simply any object with a `.read()(callback)` continuation style method.  A writable stream is any object with a `.write(chunk)(callback)` method.

The `.read()(callback)` function will callback with `(null, chunk)` for data events.  It will call `(err)` for errors, and `()` for the end of the stream.

Likewise, you can tell a writable stream to end by passing calling `.write(null)`.

For convenience, this library comes with a `Stream` class that implements `.read()` and `.write(chunk`) where writes to the object can be read out of the object.  There is also internal buffering with high-water/low-water marks for proper flow-control.

```
var Stream = require('continuable/stream');
var stream = new Stream();

// await is a utility that suspends the current fiber and waits for the continuation to resolve.
await(stream.write("Hello"))
var greeting = await(stream.read());
```

## continuable/fs

If you want to interface with the filesystem using continuable APIs, this is your module.  It supports file streams and basic fs primitives as continuable style functions.

```js
// Copy a file using continuable and fibers
var Fiber = require('fibers');
var fs = require('continuable/fs');


Fiber(function () {
  // Create a readable stream
  var fd = await(fs.open("myfile.txt", "r"));
  var readable = new fs.ReadStream(fd);
  
  // Create a writable stream
  fd = await(fs.open("copy.txt", "w"));
  var writable = new fs.WriteStream(fd);
  
  // Pipe one stream to the other using a regular do..while loop.
  do {
    var chunk = await(readable.read());
    await(writable.write(chunk));
  } while (chunk);

}).run();
```