Implements Data.Task

.babelrc

@@ -1,5 +1,5 @@
 {
-  "presets": ["es2015"],
+  "presets": ["es2015", "es2016", "es2017"],
   "plugins": [
     "transform-function-bind",
     "transform-object-rest-spread",

Makefile

@@ -46,7 +46,7 @@ clean:
 	rm -rf core helpers data test/specs test/helpers index.js
 
 test: clean compile compile-test
-	FOLKTALE_ASSERTIONS=minimal $(mocha) --reporter spec --ui bdd test/specs
+	FOLKTALE_ASSERTIONS=minimal $(mocha) --require babel-polyfill --reporter spec --ui bdd test/specs
 
 test-browser: compile compile-test
 	$(karma) start test/karma-local.js

ROADMAP.hs

@@ -610,6 +610,7 @@ module Data.Task where
     state     :: ExecutionState 'failure 'success
     listeners :: Array (DeferredListener 'failure 'success) 
   }
+  implements Show
 
   -- Deferred.prototype.resolve(value)
   (Deferred 'f 's).resolve :: ('s) => Void
@@ -637,6 +638,9 @@ module Data.Task where
   }
   implements Functor 'success, Monad 'success, Applicative 'success, Show
 
+  -- Future.prototype.listen(listener)
+  (Future 'f 's).listen :: (DeferredListener 'f 's) => Void
+
   -- Future.prototype.bimap(onFailure, onSuccess)
   (Future 'f 's).bimap :: (('f) => 'f2, ('s) => 's2) => Future 'f2 's2
 

package.json

@@ -35,11 +35,14 @@
     "babel-eslint": "^6.0.2",
     "babel-plugin-module-alias": "^1.2.0",
     "babel-plugin-transform-assertion-comments": "^0.3.1",
+    "babel-plugin-transform-async-to-generator": "^6.8.0",
     "babel-plugin-transform-function-bind": "^6.3.13",
     "babel-plugin-transform-metamagical-comments": "^0.12.0",
     "babel-plugin-transform-object-rest-spread": "^6.3.13",
     "babel-polyfill": "^6.13.0",
     "babel-preset-es2015": "^6.3.13",
+    "babel-preset-es2016": "^6.11.3",
+    "babel-preset-es2017": "^6.14.0",
     "babel-runtime": "^6.11.6",
     "browserify": "^13.1.0",
     "es5-shim": "^4.5.9",

src/data/future/_execution-state.js

@@ -0,0 +1,51 @@
+//---------------------------------------------------------------------
+//
+// This source file is part of the Folktale project.
+//
+// See LICENCE for licence information.
+// See CONTRIBUTORS for the list of contributors to the project.
+//
+//---------------------------------------------------------------------
+
+// --[ Dependencies ]--------------------------------------------------
+const { data, show, setoid } = require('folktale/core/adt');
+
+
+// --[ Implementation ]------------------------------------------------
+
+/*~
+ * Describes the current state of a task execution/deferred/future.
+ */
+const ExecutionState = data('folktale:ExecutionState', {
+  /*~
+   * Not yet resolved.
+   */
+  Pending() {
+    return {};
+  },
+
+  /*~
+   * Resolved as cancelled.
+   */
+  Cancelled() {
+    return {};
+  },
+
+  /*~
+   * Resolved successfully, with a value.
+   */
+  Resolved(value) {
+    return { value };
+  },
+
+  /*~
+   * Resolved as a failure, with a reason.
+   */
+  Rejected(reason) {
+    return { reason };
+  }
+}).derive(show, setoid);
+
+
+// --[ Exports ]-------------------------------------------------------
+module.exports = ExecutionState;

src/data/future/_future.js

@@ -0,0 +1,283 @@
+//---------------------------------------------------------------------
+//
+// This source file is part of the Folktale project.
+//
+// See LICENCE for licence information.
+// See CONTRIBUTORS for the list of contributors to the project.
+//
+//---------------------------------------------------------------------
+
+// --[ Dependencies ]--------------------------------------------------
+const define = require('folktale/helpers/define');
+const provideAliases = require('folktale/helpers/provide-fantasy-land-aliases');
+const Deferred = require('./deferred');
+const { Pending, Resolved, Rejected } = require('./_execution-state');
+
+
+
+// --[ Implementation ]------------------------------------------------
+
+/*~
+ * Represents an eventual value, like Promise, but without a recursive
+ * `.then`.
+ */
+class Future {
+  constructor() {
+    define(this, '_state', Pending());
+    define(this, '_listeners', []);
+  }
+
+
+  // ---[ State and configuration ]------------------------------------
+  /*~
+   * The current state of the future.
+   * 
+   * ---
+   * isRequired: true
+   * category: State and configuration
+   * type: |
+   *   get (Future 'f 's) => ExecutionState 'f 's
+   */
+  get _state() {
+    throw new TypeError('Future.prototype._state should be implemented in an inherited object.');
+  }
+
+  /*~
+   * A list of listeners to notify when the future is resolved.
+   * 
+   * ---
+   * isRequired: true
+   * category: State and configuration
+   * type: |
+   *   get (Future 'f 's) => Array (DeferredListener 'f 's)
+   */
+  get _listeners() {
+    throw new TypeError('Future.prototype._listeners should be implemented in an inherited object.');
+  }
+
+
+  // ---[ Reacting to Future events ]----------------------------------
+  /*~
+   * Attaches a listener to be invoked when the Future resolves.
+   * 
+   * ---
+   * category: Reacting to Future events
+   * type: |
+   *   (Future 'f 's).(DeferredListener 'f 's) => Future 'f 's
+   */
+  listen(pattern) {
+    this._state.matchWith({
+      Pending:   ()           => this._listeners.push(pattern),
+      Cancelled: ()           => pattern.onCancelled(), 
+      Resolved:  ({ value })  => pattern.onResolved(value),
+      Rejected:  ({ reason }) => pattern.onRejected(reason)
+    });
+    return this;
+  }
+
+
+  // --[ Transforming Futures ]----------------------------------------
+  /*~
+   * Transforms the value inside a future with a monadic function.
+   * 
+   * ---
+   * category: Transforming futures
+   * type: |
+   *   (Future 'f 's).(('s) => Future 's2) => Future 'f 's2
+   */
+  chain(transformation) {
+    let deferred = new Deferred();
+    this.listen({
+      onCancelled: ()     => deferred.cancel(),
+      onRejected:  reason => deferred.reject(reason),
+      onResolved:  value  => {
+        transformation(value).listen({
+          onCancelled: ()     => deferred.cancel(),
+          onRejected:  reason => deferred.reject(reason),
+          onResolved:  value2 => deferred.resolve(value2)
+        });
+      }
+    });
+
+    return deferred.future();
+  }
+
+  /*~
+   * Transforms the value inside a future with a simple function.
+   * 
+   * ---
+   * category: Transforming futures
+   * type: |
+   *   (Future 'f 's).(('s) => 's2) => Future 'f 's2
+   */
+  map(transformation) {
+    return this.chain(value => Future.of(transformation(value)));
+  }
+
+  /*~
+   * Transforms the value inside a future with a function contained in
+   * another future.
+   * 
+   * ---
+   * category: Transforming futures
+   * type: |
+   *   (Future 'f 's).(Future 'f (('s) => 's2)) => Future 'f 's2
+   */
+  apply(future) {
+    return this.chain(fn => future.map(fn));
+  }
+
+  /*~
+   * Transforms successes and failures in a future.
+   * 
+   * ---
+   * category: Transforming futures
+   * type: |
+   *   (Future 'f 's).(('f) => 'f2, ('s) => 's2) => Future 'f2 's2
+   */
+  bimap(rejectionTransformation, successTransformation) {
+    let deferred = new Deferred();
+    this.listen({
+      onCancelled: ()     => deferred.cancel(),
+      onRejected:  reason => deferred.reject(rejectionTransformation(reason)),
+      onResolved:  value  => deferred.resolve(successTransformation(value))
+    });
+
+    return deferred.future();
+  }
+
+  /*~
+   * Transform the values of rejected futures.
+   * 
+   * ---
+   * category: Transforming values
+   * type: |
+   *   (Future 'f 's).(('f) => 'f2) => Future 'f2 's
+   */
+  mapRejection(transformation) {
+    return this.bimap(transformation, x => x);
+  }
+
+
+  // ---[ Recovering from errors ]-------------------------------------
+  /*~
+   * Transforms a rejected future into a new future.
+   * 
+   * ---
+   * category: Recovering from errors
+   * type: |
+   *   (Future 'f 's).(('f) => Future 'f2 's2) => Future 'f2 's
+   */
+  recover(handler) {
+    let deferred = new Deferred();
+    this.listen({
+      onCancelled: ()     => deferred.cancel(),
+      onResolved:  value  => deferred.resolve(value),
+      onRejected:  reason => {
+        handler(reason).listen({
+          onCancelled: ()        => deferred.cancel(),
+          onResolved:  value     => deferred.resolve(value),
+          onRejected:  newReason => deferred.reject(newReason)
+        });
+      }
+    });
+
+    return deferred.future();
+  }
+
+  willMatchWith(pattern) {
+    let deferred = new Deferred();
+    const resolve = (handler) => (value) => handler(value).listen({
+      onCancelled: ()       => deferred.cancel(),
+      onResolved:  (value)  => deferred.resolve(value),
+      onRejected:  (reason) => deferred.reject(reason) 
+    });
+    this.listen({
+      onCancelled: resolve(pattern.Cancelled),
+      onResolved:  resolve(pattern.Resolved),
+      onRejected:  resolve(pattern.Rejected)
+    });
+
+    return deferred.future();
+  }
+
+  /*~
+   * Transforms rejected futures in successes, and vice-versa.
+   * 
+   * ---
+   * category: Recovering from errors
+   * type: |
+   *   (Future 'f 's).() => Future 's 'f
+   */
+  swap() {
+    let deferred = new Deferred();
+    this.listen({
+      onCancelled: ()     => deferred.cancel(),
+      onRejected:  reason => deferred.resolve(reason),
+      onResolved:  value  => deferred.reject(value) 
+    });
+
+    return deferred.future();
+  }
+
+
+  // ---[ Debugging ]--------------------------------------------------
+  /*~
+   * Returns a textual representation of this object for debugging.
+   * 
+   * ---
+   * category: Debugging
+   * type: |
+   *   (Future 'f 's).() => String
+   */
+  toString() {
+    const listeners = this._listeners.length;
+    const state     = this._state;
+
+    return `folktale:Future(${state}, ${listeners} listeners)`;
+  }
+
+  /*~
+   * Returns a textual representation of this object for Node's REPL.
+   * 
+   * ---
+   * category: Debugging
+   * type: |
+   *   (Future 'f 's).() => String
+   */
+  inspect() {
+    return this.toString();
+  }
+}
+
+
+// ---[ Constructing futures ]-----------------------------------------
+Object.assign(Future, {
+  of(value) {
+    let result = new Future();
+    result._state = Resolved(value);
+    return result;
+  },
+
+  /*~
+   * Constructs a future containing a single rejected value.
+   * 
+   * ---
+   * category: Constructing futures
+   * type: |
+   *   (Future).('f) => Future 'f 's
+   */
+  rejected(reason) {
+    let result = new Future();
+    result._state = Rejected(reason);
+    return result;
+  }
+});
+
+
+provideAliases(Future);
+provideAliases(Future.prototype);
+
+
+// --[ Exports ]-------------------------------------------------------
+module.exports = Future;