node package manager

Introducing npm Enterprise add-ons. Integrate third-party dev tools into npm…


promises with very simple semantics and high performance

Dead-Simple Promises, js

Yet another future/promise implementation for Javascript.

The distinction of this one is very simple semantics, supported by some equational laws, and a pretty fast implementation. The goal is to have promises that can wrap every single async call in an IO-heavy node application and still survive the speed hit, together with being relatively no-brainer to use.

Currently, the hit is around 40% for pure in-process workloads and much lower with intermittent syscalls. See slake bench.

On the other hand, it is not compatible with Promises/A+. Continuations are not invoked strictly after .then method returns (they could be invoked during that call), which means the burden of not smashing the stack is on the user. As a minor divergence, .then also handles only chaining of success: onError registers failure listeners, as this operation has imperative semantics.

TODO, but the single source file is short and documented. It also includes some laws the promises satisfy.

Given a path, return paths and sizes of filesystem objects for the filesystem subtree:

var promise = require('dead-simple-promises'),
    fsp     = promise.owrap(require('fs')),
    util    = require('util');
function fileSizes (path) {
  return fsp.stat(path).then(function (stat) {
    if (stat.isDirectory()) {
      return fsp.readdir(path).then(function (files) {
        for (var i = 0; i < files.length; i++) {
          files[i] = fileSizes(path + "/" + files[i]);
        return promise.seq(files).then(function (subtree) {
          return { path: path, stat: stat.size, sub: subtree }
    } else {
      return promise( { path: path, size: stat.size } );
fileSizes (wherever)
  .then (function (tree) { console.log ('x', tree); })
  .onError (function (err) { console.error (err); })
require! { promise: \dead-simple-promises, util }
fsp = promise.owrap require \fs
file-sizes = (path) ->
  {size}: stat <- fsp.stat path .then
    files <- fsp.readdir path .then
    files |> map -> file-sizes "#path/#it"
          |> promise.seq |> (.then -> {path, size, sub: it})
  else promise {path, size}
file-sizes wherever .then     (util.inspect >> console.log)
                    .on-error console.error