Easy asynchrony with ES6

Decoupling promises from generators

It is possible to abstract away the asynchronicity or synchronocity of the code and use one generator for both types of the control flow.

For example the Stream type has a readBytes method that returns an array of bytes using calls to the readByte function. Utilizing generators we can reuse the same algorithm for both the synchronous code that deals with in-memory arrays and the asynchronous one that uses Promises to read bytes from the network or files.

function Stream(source) {
    this.source = source;
}

Stream.prototype = {
    readBytes: function*(num) {
        var bytes = [];
        for (var i = 0; i < num; i++) {
            bytes.push(yield this.source.readByte());
        }
        return bytes;
    }
};

The synchronous ArraySource can be used as the source for the stream object. ArraySource uses throw and return statements to control the program flow:

function ArraySource(rawBytes, index) {
    this.rawBytes = rawBytes;
    this.index = index || 0;
}

ArraySource.prototype = {
    readByte: function() {
        if (!this.hasMoreBytes()) {
            throw new Error('Cannot read past the end of the array.');
        }
        return this.rawBytes[this.index++];
    },
    hasMoreBytes: function() {
        return this.index < this.rawBytes.length;
    }
};

Reading bytes from this source using the Stream object can also be synchronous:

var syncSource = new ArraySource([1, 2, 3, 4, 5]);

// reading a byte from the synchronous source
print(syncSource.readByte());

var stream = new Stream(syncSource);

try {
    // reading bytes array synchronously
    var bytes = sync(stream.readBytes(4));
    print(bytes);
} catch (e) {
    print(e);
}

The second option is the FileSourceMock object that uses Promises to return bytes or report errors:

function FileSourceMock(rawBytes, index) {
    this.rawBytes = rawBytes;
    this.index = index || 0;
}

FileSourceMock.prototype = {
    readByte: function() {
        if (!this.hasMoreBytes()) {
            var err = Error('Cannot read past the end of the array.');
            return Promise.reject(err);
        }
        return Promise.resolve(this.rawBytes[this.index++]);
    },
    hasMoreBytes: function() {
        return this.index < this.rawBytes.length;
    }
};

Reading from this source requires using the asynchronous control flow but the readBytes method does not need to be modified:

var asyncSource = new FileSourceMock([1, 2, 3, 4, 5]);

// reading a byte from the asynchronous source
asyncSource.readByte().then(function (byte) {
    print(byte);
});

var stream = new Stream(asyncSource);

// reading byte array asynchronously
async(stream.readBytes(4)).then(function (bytes) {
    print(bytes);
}, function(error) {
    print(error);
});

The code above uses two strategies of executing the generator — asynchronous and synchronous.

The asynchronous flow control uses Promises to represent success and failure and the then method to continue executing generator when the promise is fulfilled.

var async = flow({
    resume: function(value, next, abort) {
        return Promise.resolve(value).then(next, abort);
    },
    finish: function(value) {
        return Promise.resolve(value);
    },
    abort: function(error) {
        return Promise.reject(error);
    }
});

The synchronous flow uses the return and throw statements to report the success or the failure. The next function which represents the flow continuation is executed synchronously passing the value returned by the previous step.

var sync = flow({
    resume: function(value, next, abort) {
        return next(value);
    },
    finish: function(value) {
        return value;
    },
    abort: function(error) {
        throw error;
    }
});

The flow function separates the generator from the type of the control flow.

function flow(controller) {
    return function wrap(generator) {
        function resume(method, previous) {
            var result, value;
            try {
                result = generator[method](previous);
            } catch (e) {
                return controller.abort(e);
            }
            value = result.value;
            // wrap inner generators in the same control flow
            if (value && typeof value.next === 'function') {
                value = wrap(value);
            }
            if (result.done) {
                return controller.finish(value);
            } else {
                return controller.resume(value, next, abort);
            }
        }
        var next = resume.bind(null, 'next');
        var abort = resume.bind(null, 'throw');
        return next();
    };
}

For a real-world use of this technique see the Low-level Bitcoin article.