Refactor to classes

.eslintrc.json

@@ -119,7 +119,6 @@
     "no-trailing-spaces": 2,
     "no-unneeded-ternary": 2,
     "object-curly-spacing": [2, "never"],
-    "operator-linebreak": [2, "before"],
     "padded-blocks": 0,
     "semi-spacing": [2, {"before": false, "after": true}],
     "space-before-blocks": [2, "never"],

README.md

@@ -67,7 +67,6 @@ getPackageName('package.json')
     * [map](#map)
     * [bimap](#bimap)
     * [chain](#chain)
-    * [recur](#recur)
     * [ap](#ap)
     * [swap](#swap)
   1. [Error handling](#error-handling)
@@ -331,19 +330,10 @@ Future.of(1)
 //> 2
 ```
 
-#### recur
-##### `#recur :: Future a b ~> (b -> Future a c) -> Future a c`
-##### `.recur :: (b -> Future a c) -> Future a b -> Future a c`
-
-An alternative version of `chain` which does not build up the cancel function.
-This is useful in the case of a never-resolving recursive computation, in
-order to prevent stack-overflow or out-of-memory errors:
-
-```js
-const recursive = () => Future.after(200, 'world').recur(recursive);
-const cancel = recursive();
-process.on('SIGINT', cancel);
-```
+Note that, due to its lazy nature, the stack and/or heap will slowly fill up as
+you chain more over the same structure. It's therefore recommended that you use
+[`chainRec`](#chainrec) in cases where you wish to `chain` recursively or
+traverse a large list (10000+ items).
 
 #### ap
 ##### `#ap :: Future a b ~> Future a (b -> c) -> Future a c`
@@ -465,13 +455,27 @@ withConnection(
 .fork(console.error, console.log)
 ```
 
-Be careful when cancelling a hooked Future. If the resource was acquired but not
-yet consumed, it will no longer be disposed. One way to work around this is to
-have the `consume` computation return a cancel function which forcefully
-disposes of the resource.
+In the case that a hooked Future is *cancelled* after the resource was acquired,
+`dispose` will be executed and immediately cancelled. This means that rejections
+which may happen during this disposal are **silently ignored**. To ensure that
+resources are disposed during cancellation, you might synchronously dispose
+resources in the `cancel` function of the disposal Future:
+
+```js
+const closeConnection = conn => Future((rej, res) => {
+
+  //We try to dispose gracefully.
+  conn.flushGracefully(err => {
+    if(err) return rej(err);
+    conn.close();
+    res();
+  });
+
+  //On cancel, we force dispose.
+  return () => conn.close();
 
-Take care when using this in combination with [`cache`](#cache). Hooking relies
-on the first operation providing a fresh resource every time it's forked.
+});
+```
 
 #### finally
 ##### `#finally :: Future a b ~> Future a c -> Future a b`

bench/cache.js

@@ -26,7 +26,7 @@ suite.add('Fluture', () => {
 });
 
 suite.add('Ramda Fantasy', () => {
-  const future = RamdaFuture.cache(Fluture.of(1));
+  const future = RamdaFuture.cache(RamdaFuture.of(1));
   addTenMaps(future);
   future.fork(noop, noop);
 });

bench/or.js

@@ -0,0 +1,28 @@
+const benchmark = require('benchmark');
+const suite = new benchmark.Suite();
+const Future = require('..');
+
+const noop = () => {};
+const a = Future.of('a');
+const b = Future.of('b');
+const _a = Future.reject('!a');
+const _b = Future.reject('!b');
+
+suite.add('res res', () => {
+  a.or(b).fork(noop, noop);
+});
+
+suite.add('rej rej', () => {
+  _a.or(_b).fork(noop, noop);
+});
+
+suite.add('rej res', () => {
+  _a.or(b).fork(noop, noop);
+});
+
+suite.add('res rej', () => {
+  a.or(_b).fork(noop, noop);
+});
+
+suite.on('complete', require('./_print'))
+suite.run()

bench/parallel.js

@@ -0,0 +1,32 @@
+const benchmark = require('benchmark');
+const suite = new benchmark.Suite();
+const Future = require('..');
+
+const noop = () => {};
+const makeArr = length => Array.from({length}, (_, i) => Future.of(i));
+const empty = makeArr(0);
+const small = makeArr(2);
+const big = makeArr(100);
+
+suite.add('Empty', () => {
+  Future.parallel(1, empty).fork(noop, noop);
+});
+
+suite.add('Small concurrent', () => {
+  Future.parallel(2, small).fork(noop, noop);
+});
+
+suite.add('Small sequential', () => {
+  Future.parallel(1, small).fork(noop, noop);
+});
+
+suite.add('Big concurrent', () => {
+  Future.parallel(Infinity, big).fork(noop, noop);
+});
+
+suite.add('Big sequential', () => {
+  Future.parallel(5, big).fork(noop, noop);
+});
+
+suite.on('complete', require('./_print'))
+suite.run()

bench/race.js

@@ -0,0 +1,26 @@
+const benchmark = require('benchmark');
+const suite = new benchmark.Suite();
+const Future = require('..');
+
+const noop = () => {};
+const a = Future.of('a');
+const b = Future.after(5, 'b');
+
+suite.add('Left winner', () => {
+  a.race(b).fork(noop, noop);
+});
+
+suite.add('Right winner', () => {
+  b.race(a).fork(noop, noop);
+});
+
+suite.add('Both fast', () => {
+  a.race(a).fork(noop, noop);
+});
+
+suite.add('Both slow', () => {
+  b.race(b).fork(noop, noop);
+});
+
+suite.on('complete', require('./_print'))
+suite.run()