@dillonkearns/elm-graphql/examples/src/subscription/node_modules/flow-static-land/lib/Task.js

<img src="https://cdn.jsdelivr.net/gh/martimatix/logo-graphqelm/logo.svg" alt="dillonearns/elm-graphql logo" width="40%" align="right">

'use strict';

Object.defineProperty(exports, "__esModule", {
  value: true
});

var _slicedToArray = function () { function sliceIterator(arr, i) { var _arr = []; var _n = true; var _d = false; var _e = undefined; try { for (var _i = arr[Symbol.iterator](), _s; !(_n = (_s = _i.next()).done); _n = true) { _arr.push(_s.value); if (i && _arr.length === i) break; } } catch (err) { _d = true; _e = err; } finally { try { if (!_n && _i["return"]) _i["return"](); } finally { if (_d) throw _e; } } return _arr; } return function (arr, i) { if (Array.isArray(arr)) { return arr; } else if (Symbol.iterator in Object(arr)) { return sliceIterator(arr, i); } else { throw new TypeError("Invalid attempt to destructure non-iterable instance"); } }; }();

exports.inj = inj;
exports.prj = prj;
exports.runTask = runTask;
exports.unsafePerformTask = unsafePerformTask;
exports.map = map;
exports.ap = ap;
exports.of = of;
exports.chain = chain;
exports.empty = empty;
exports.concat = concat;
exports.after = after;
exports.tryTask = tryTask;

var _HKT = require('./HKT');

var _Eff = require('./Eff');

var eff = _interopRequireWildcard(_Eff);

var _Either = require('./Either');

var either = _interopRequireWildcard(_Either);

function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } else { var newObj = {}; if (obj != null) { for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) newObj[key] = obj[key]; } } newObj.default = obj; return newObj; } }

function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }

var IsTask = function IsTask() {
  _classCallCheck(this, IsTask);
};

// A Task is a computation which yields an effect E and a value A


function inj(a) {
  return a;
}

function prj(fa) {
  return fa;
}

function runTask(fut) {
  return eff.inj(prj(fut));
}

function unsafePerformTask(fut) {
  return prj(fut)();
}

function map(f, fa) {
  return inj(function () {
    return unsafePerformTask(fa).then(f);
  });
}

// the derived implementation
//   return chain(f => map(f, fa), fab)
// will not execute the futures in parallel
function ap(fab, fa) {
  return inj(function () {
    return Promise.all([unsafePerformTask(fab), unsafePerformTask(fa)]).then(function (_ref) {
      var _ref2 = _slicedToArray(_ref, 2),
          f = _ref2[0],
          a = _ref2[1];

      return f(a);
    });
  });
}

function of(a) {
  return inj(function () {
    return Promise.resolve(a);
  });
}

function chain(f, fa) {
  return inj(function () {
    return unsafePerformTask(fa).then(function (a) {
      return unsafePerformTask(f(a));
    });
  });
}

var noop = function noop() {};

// Returns a Task that will never resolve
function empty() {
  return inj(function () {
    return new Promise(noop);
  });
}

// Selects the earlier of the two futures
function concat(x, y) {
  return inj(function () {
    return new Promise(function (resolve, reject) {
      var done = false;
      var guard = function guard(f) {
        return function (a) {
          if (!done) {
            done = true;
            f(a);
          }
        };
      };
      unsafePerformTask(x).then(guard(resolve), guard(reject));
      unsafePerformTask(y).then(guard(resolve), guard(reject));
    });
  });
}

// Returns a Task which yields `a` after `delay` milliseconds
function after(delay, a) {
  return inj(function () {
    return new Promise(function (resolve) {
      setTimeout(function () {
        resolve(a);
      }, delay);
    });
  });
}

// Catches a possible error returning it as an Either
function tryTask(fa) {
  return inj(function () {
    return unsafePerformTask(fa).then(either.right, either.left);
  });
}

if (false) {
  // eslint-disable-line
  ({
    map: map,
    ap: ap,
    of: of,
    chain: chain,
    empty: empty,
    concat: concat
  });
}