Fix issue with Futures created from Promises

When a Future created from a Promise would enter crashed state later
along a synchronous pipeline, the original Promise would catch the error
and change its state to rejected. That rejection would never be handled,
and cause the Promise to swallow it, triggering the unhandledRejection
events in some Promise implementations.

Related to #150 and #224.

src/internal/utils.mjs

@@ -1,5 +1,8 @@
 import show from 'sanctuary-show';
 
+/* istanbul ignore next: non v8 compatibility */
+var setImmediate = typeof setImmediate === 'undefined' ? setImmediateFallback : setImmediate;
+
 export {show};
 export function noop(){}
 export function moop(){ return this }
@@ -28,6 +31,12 @@ export function partial3(f, a, b, c){
   };
 }
 
+export function setImmediateFallback(f, x){
+  return setTimeout(f, 0, x);
+}
+
 export function raise(x){
-  throw x;
+  setImmediate(function rethrowErrorDelayedToEscapePromiseCatch(){
+    throw x;
+  });
 }

test/unit/0.utils.mjs

@@ -70,4 +70,17 @@ describe('fn', function (){
 
   });
 
+  describe('.setImmediateFallback()', function (){
+
+    it('calls the function with a value in under 25ms', function (done){
+      var t = setTimeout(done, 25, new Error('Time is up'));
+      fn.setImmediateFallback(function (x){
+        expect(x).to.equal(42);
+        clearTimeout(t);
+        done();
+      }, 42);
+    });
+
+  });
+
 });

test/unit/2.methods.mjs

@@ -1,8 +1,25 @@
 import show from 'sanctuary-show';
 import {testMethod, futureArg, functionArg} from '../util/props';
-import {eq, noop, throws, error} from '../util/util';
+import {eq, noop, error} from '../util/util';
 import {mock as instance} from '../util/futures';
 
+function raises (done, fn, expected){
+  if(typeof process.rawListeners !== 'function'){
+    done();
+    return;
+  }
+
+  var listeners = process.rawListeners('uncaughtException');
+  process.removeAllListeners('uncaughtException');
+  process.once('uncaughtException', function (actual){
+    listeners.forEach(function (f){ process.on('uncaughtException', f) });
+    eq(actual, expected);
+    done();
+  });
+
+  fn();
+}
+
 describe('Future prototype', function (){
 
   describe('and()', function (){
@@ -79,10 +96,10 @@ describe('Future prototype', function (){
       mock.fork(a, b);
     });
 
-    it('throws the interpretation crash value', function (){
+    it('throws the interpretation crash value', function (done){
       var mock = Object.create(instance);
       mock._interpret = function (rec){ rec(error) };
-      throws(function (){ return mock.fork(noop, noop) }, error);
+      raises(done, function (){ return mock.fork(noop, noop) }, error);
     });
   });
 
@@ -184,10 +201,10 @@ describe('Future prototype', function (){
       mock.value(res);
     });
 
-    it('throws when _interpret calls the rejection callback', function (){
+    it('throws when _interpret calls the rejection callback', function (done){
       var mock = Object.create(instance);
       mock._interpret = function (rec, rej){rej(1)};
-      throws(mock.value.bind(mock, noop), new Error(
+      raises(done, mock.value.bind(mock, noop), new Error(
         'Future#value was called on a rejected Future\n' +
         '  Rejection: 1\n' +
         '  Future: ' + show(instance)