igogo/lib/index.js

Fast Either and Maybe from Fantasy Land with Flow and TypeScript support

/**
 * igogo v1.8.2
 * Fast Either and Maybe from Fantasy Land with Flow and TypeScript support
 */

'use strict';

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

require('core-js/modules/es.symbol');
require('core-js/modules/es.symbol.description');
require('core-js/modules/es.symbol.iterator');
require('core-js/modules/es.array.iterator');
require('core-js/modules/es.array.map');
require('core-js/modules/es.object.to-string');
require('core-js/modules/es.promise');
require('core-js/modules/es.string.iterator');
require('core-js/modules/web.dom-collections.iterator');

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

function _defineProperties(target, props) {
  for (var i = 0; i < props.length; i++) {
    var descriptor = props[i];
    descriptor.enumerable = descriptor.enumerable || false;
    descriptor.configurable = true;
    if ("value" in descriptor) descriptor.writable = true;
    Object.defineProperty(target, descriptor.key, descriptor);
  }
}

function _createClass(Constructor, protoProps, staticProps) {
  if (protoProps) _defineProperties(Constructor.prototype, protoProps);
  if (staticProps) _defineProperties(Constructor, staticProps);
  return Constructor;
}

function _defineProperty(obj, key, value) {
  if (key in obj) {
    Object.defineProperty(obj, key, {
      value: value,
      enumerable: true,
      configurable: true,
      writable: true
    });
  } else {
    obj[key] = value;
  }

  return obj;
}

function _slicedToArray(arr, i) {
  return _arrayWithHoles(arr) || _iterableToArrayLimit(arr, i) || _nonIterableRest();
}

function _arrayWithHoles(arr) {
  if (Array.isArray(arr)) return arr;
}

function _iterableToArrayLimit(arr, i) {
  if (!(Symbol.iterator in Object(arr) || Object.prototype.toString.call(arr) === "[object Arguments]")) {
    return;
  }

  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"] != null) _i["return"]();
    } finally {
      if (_d) throw _e;
    }
  }

  return _arr;
}

function _nonIterableRest() {
  throw new TypeError("Invalid attempt to destructure non-iterable instance");
}

var getSet = function getSet(keyName) {
  var key = Symbol(keyName);
  return [function (instance) {
    return instance[key];
  }, function (instance, value) {
    return instance[key] = value;
  }];
};

var next = function next() {
  return {
    value: undefined,
    done: true
  };
};
var toEmptyIterator = function toEmptyIterator() {
  var _iterator;

  var iterator = (_iterator = {}, _defineProperty(_iterator, Symbol.iterator, function () {
    return iterator;
  }), _defineProperty(_iterator, "next", next), _iterator);
  return iterator;
};

var toIterator = function toIterator(getValue) {
  return (// eslint-disable-next-line no-shadow
    function toIterator() {
      var _this = this,
          _iterator;

      var _next = function next$1() {
        _next = next;
        return {
          value: getValue(_this),
          done: false
        };
      };

      var iterator = (_iterator = {}, _defineProperty(_iterator, Symbol.iterator, function () {
        return iterator;
      }), _defineProperty(_iterator, "next", function next() {
        return _next();
      }), _iterator);
      return iterator;
    }
  );
};

var EitherRight =
/*#__PURE__*/
function () {
  function EitherRight(value) {
    _classCallCheck(this, EitherRight);

    setRight(this, value);
  }

  _createClass(EitherRight, [{
    key: "map",

    /* :: +@@iterator: () => Iterator<R>; */
    value: function map(transform) {
      return this.mapR(transform);
    }
  }, {
    key: "mapR",
    value: function mapR(transform) {
      return new EitherRight(transform(getRight(this)));
    }
  }, {
    key: "mapL",
    value: function mapL() {
      return this;
    }
  }, {
    key: "bimap",
    value: function bimap(transformL, transformR) {
      return this.mapR(transformR).mapL(transformL);
    }
  }, {
    key: "mapTo",
    value: function mapTo(value) {
      return Right(value);
    }
  }, {
    key: "mapRTo",
    value: function mapRTo(value) {
      return Right(value);
    }
  }, {
    key: "mapLTo",
    value: function mapLTo() {
      return this;
    }
  }, {
    key: "bimapTo",
    value: function bimapTo(left, right) {
      return this.mapRTo(right).mapLTo(left);
    }
  }, {
    key: "chain",
    value: function chain(transform) {
      return this.chainR(transform);
    }
  }, {
    key: "chainR",
    value: function chainR(transform) {
      return transform(getRight(this));
    }
  }, {
    key: "chainL",
    value: function chainL() {
      return this;
    }
  }, {
    key: "bichain",
    value: function bichain(transformL, transformR) {
      return transformR(getRight(this));
    }
  }, {
    key: "ap",
    value: function ap(either) {
      return this.apR(either);
    }
  }, {
    key: "apR",
    value: function apR(either) {
      var _this = this;

      return either.map(function (transform) {
        return transform(getRight(_this));
      });
    }
  }, {
    key: "apL",
    value: function apL() {
      return this;
    }
  }, {
    key: "biap",
    value: function biap(either) {
      return this.apR(either);
    }
  }, {
    key: "alt",
    value: function alt() {
      return this;
    }
  }, {
    key: "or",
    value: function or() {
      return this;
    }
  }, {
    key: "and",
    value: function and(either) {
      return either;
    }
  }, {
    key: "getOr",
    value: function getOr() {
      return getRight(this);
    }
  }, {
    key: "getOrElse",
    value: function getOrElse() {
      return getRight(this);
    }
  }, {
    key: "getLeftOr",
    value: function getLeftOr(value) {
      return value;
    }
  }, {
    key: "getLeftOrElse",
    value: function getLeftOrElse(fn) {
      return fn();
    }
  }, {
    key: "getRightOr",
    value: function getRightOr() {
      return getRight(this);
    }
  }, {
    key: "getRightOrElse",
    value: function getRightOrElse() {
      return getRight(this);
    }
  }, {
    key: "reduce",
    value: function reduce(transform, or) {
      return this.reduceR(transform, or);
    }
  }, {
    key: "reduceR",
    value: function reduceR(transform, or) {
      return transform(or, getRight(this));
    }
  }, {
    key: "reduceL",
    value: function reduceL(transform, or) {
      return or;
    }
  }, {
    key: "tap",
    value: function tap(call) {
      return this.tapR(call);
    }
  }, {
    key: "tapR",
    value: function tapR(call) {
      call(getRight(this));
      return this;
    }
  }, {
    key: "tapL",
    value: function tapL() {
      return this;
    }
  }, {
    key: "tapBoth",
    value: function tapBoth(callL, callR) {
      return this.tapR(callR);
    }
  }, {
    key: "swap",
    value: function swap() {
      return new EitherLeft(getRight(this));
    }
  }, {
    key: "left",
    value: function left() {
      return this.toMaybeL();
    }
  }, {
    key: "right",
    value: function right() {
      return this.toMaybeR();
    }
  }, {
    key: "match",
    value: function match(fromRight) {
      return fromRight(getRight(this));
    }
  }, {
    key: "toMaybe",
    value: function toMaybe() {
      return this.toMaybeR();
    }
  }, {
    key: "toMaybeR",
    value: function toMaybeR() {
      return Just(getRight(this));
    }
  }, {
    key: "toMaybeL",
    value: function toMaybeL() {
      return nothing;
    }
  }, {
    key: "toMaybeLR",
    value: function toMaybeLR() {
      return this.toMaybe();
    }
  }, {
    key: "promise",
    value: function promise() {
      return Promise.resolve(getRight(this));
    }
  }, {
    key: "fold",
    value: function fold(fromLeft, fromRight) {
      return fromRight(getRight(this));
    }
  }, {
    key: "isRight",
    get: function get() {
      return true;
    }
  }, {
    key: "isLeft",
    get: function get() {
      return false;
    }
  }]);

  return EitherRight;
}();

var EitherLeft =
/*#__PURE__*/
function () {
  function EitherLeft(value) {
    _classCallCheck(this, EitherLeft);

    setLeft(this, value);
  }

  _createClass(EitherLeft, [{
    key: "map",

    /* :: +@@iterator: () => Iterator<R>; */
    value: function map() {
      return this;
    }
  }, {
    key: "mapR",
    value: function mapR() {
      return this;
    }
  }, {
    key: "mapL",
    value: function mapL(transform) {
      return new EitherLeft(transform(getLeft(this)));
    }
  }, {
    key: "bimap",
    value: function bimap(transformL, transformR) {
      return this.mapL(transformL).mapR(transformR);
    }
  }, {
    key: "mapTo",
    value: function mapTo() {
      return this;
    }
  }, {
    key: "mapRTo",
    value: function mapRTo() {
      return this;
    }
  }, {
    key: "mapLTo",
    value: function mapLTo(left) {
      return new EitherLeft(left);
    }
  }, {
    key: "bimapTo",
    value: function bimapTo(left, right) {
      return this.mapLTo(left).mapRTo(right);
    }
  }, {
    key: "mapBoth",
    value: function mapBoth(transformL, transformR) {
      return this.bimap(transformL, transformR);
    }
  }, {
    key: "chain",
    value: function chain() {
      return this;
    }
  }, {
    key: "chainR",
    value: function chainR() {
      return this;
    }
  }, {
    key: "chainL",
    value: function chainL(transform) {
      return transform(getLeft(this));
    }
  }, {
    key: "bichain",
    value: function bichain(transformL) {
      return transformL(getLeft(this));
    }
  }, {
    key: "ap",
    value: function ap() {
      return this;
    }
  }, {
    key: "apR",
    value: function apR() {
      return this;
    }
  }, {
    key: "apL",
    value: function apL(either) {
      var _this2 = this;

      return either.mapL(function (transform) {
        return transform(getLeft(_this2));
      });
    }
  }, {
    key: "biap",
    value: function biap(either) {
      return this.apL(either);
    }
  }, {
    key: "alt",
    value: function alt(either) {
      return either;
    }
  }, {
    key: "or",
    value: function or(either) {
      return either;
    }
  }, {
    key: "and",
    value: function and() {
      return this;
    }
  }, {
    key: "getOr",
    value: function getOr(value) {
      return value;
    }
  }, {
    key: "getOrElse",
    value: function getOrElse(fn) {
      return fn(getLeft(this));
    }
  }, {
    key: "getLeftOr",
    value: function getLeftOr() {
      return getLeft(this);
    }
  }, {
    key: "getLeftOrElse",
    value: function getLeftOrElse() {
      return getLeft(this);
    }
  }, {
    key: "getRightOr",
    value: function getRightOr(value) {
      return value;
    }
  }, {
    key: "getRightOrElse",
    value: function getRightOrElse(fn) {
      return fn();
    }
  }, {
    key: "reduce",
    value: function reduce(transform, or) {
      return or;
    }
  }, {
    key: "reduceR",
    value: function reduceR(transform, or) {
      return or;
    }
  }, {
    key: "reduceL",
    value: function reduceL(transform, or) {
      return transform(or, getLeft(this));
    }
  }, {
    key: "tap",
    value: function tap() {
      return this;
    }
  }, {
    key: "tapR",
    value: function tapR() {
      return this;
    }
  }, {
    key: "tapL",
    value: function tapL(call) {
      call(getLeft(this));
      return this;
    }
  }, {
    key: "tapBoth",
    value: function tapBoth(callL) {
      return this.tapL(callL);
    }
  }, {
    key: "swap",
    value: function swap() {
      return new EitherRight(getLeft(this));
    }
  }, {
    key: "left",
    value: function left() {
      return this.toMaybeL();
    }
  }, {
    key: "right",
    value: function right() {
      return this.toMaybeR();
    }
  }, {
    key: "match",
    value: function match(fromRight, fromLeft) {
      return fromLeft(getLeft(this));
    }
  }, {
    key: "toMaybe",
    value: function toMaybe() {
      return this.toMaybeR();
    }
  }, {
    key: "toMaybeR",
    value: function toMaybeR() {
      return nothing;
    }
  }, {
    key: "toMaybeL",
    value: function toMaybeL() {
      return Just(getLeft(this));
    }
  }, {
    key: "toMaybeLR",
    value: function toMaybeLR() {
      return this.toMaybeL();
    }
  }, {
    key: "promise",
    value: function promise() {
      return Promise.reject(getLeft(this));
    }
  }, {
    key: "fold",
    value: function fold(fromLeft) {
      return fromLeft(getLeft(this));
    }
  }, {
    key: "isRight",
    get: function get() {
      return false;
    }
  }, {
    key: "isLeft",
    get: function get() {
      return true;
    }
  }]);

  return EitherLeft;
}();

var _getSet = getSet('right'),
    _getSet2 = _slicedToArray(_getSet, 2),
    getRight = _getSet2[0],
    setRight = _getSet2[1];

var _getSet3 = getSet('left'),
    _getSet4 = _slicedToArray(_getSet3, 2),
    getLeft = _getSet4[0],
    setLeft = _getSet4[1];

EitherRight.prototype[Symbol.iterator] = toIterator(getRight);
EitherLeft.prototype[Symbol.iterator] = toEmptyIterator;
var Right = function Right(right) {
  return new EitherRight(right);
};
var Left = function Left(left) {
  return new EitherLeft(left);
};
var ifElse = function ifElse(condition, right, left) {
  return condition ? Right(right) : Left(left);
};

var MaybeJust =
/*#__PURE__*/
function () {
  function MaybeJust(value) {
    _classCallCheck(this, MaybeJust);

    setValue(this, value);
  }

  _createClass(MaybeJust, [{
    key: "map",

    /* :: +@@iterator: () => Iterator<T>; */
    value: function map(transform) {
      return Just(transform(getValue(this)));
    }
  }, {
    key: "mapTo",
    value: function mapTo(value) {
      return Just(value);
    }
  }, {
    key: "ap",
    value: function ap(maybe) {
      var _this = this;

      return maybe.map(function (transform) {
        return transform(getValue(_this));
      });
    }
  }, {
    key: "chain",
    value: function chain(transform) {
      return transform(getValue(this));
    }
  }, {
    key: "filter",
    value: function filter(predicate) {
      var value = getValue(this);
      return predicate(value) ? Just(value) : nothing;
    }
  }, {
    key: "tap",
    value: function tap(call) {
      call(getValue(this));
      return this;
    }
  }, {
    key: "and",
    value: function and(maybe) {
      return maybe;
    }
  }, {
    key: "or",
    value: function or() {
      return this;
    }
  }, {
    key: "alt",
    value: function alt() {
      return this;
    }
  }, {
    key: "getOr",
    value: function getOr() {
      return getValue(this);
    }
  }, {
    key: "getOrElse",
    value: function getOrElse() {
      return getValue(this);
    }
  }, {
    key: "reduce",
    value: function reduce(transform, or) {
      return transform(or, getValue(this));
    }
  }, {
    key: "match",
    value: function match(fromJust) {
      return fromJust(getValue(this));
    }
  }, {
    key: "toEither",
    value: function toEither() {
      return Right(getValue(this));
    }
  }, {
    key: "promise",
    value: function promise() {
      return Promise.resolve(getValue(this));
    }
  }, {
    key: "isJust",
    get: function get() {
      return true;
    }
  }, {
    key: "isNothing",
    get: function get() {
      return false;
    }
  }]);

  return MaybeJust;
}();

var MaybeNothing =
/*#__PURE__*/
function () {
  function MaybeNothing() {
    _classCallCheck(this, MaybeNothing);
  }

  _createClass(MaybeNothing, [{
    key: "map",

    /* :: +@@iterator: () => Iterator<T>; */
    value: function map() {
      return nothing;
    }
  }, {
    key: "mapTo",
    value: function mapTo() {
      return nothing;
    }
  }, {
    key: "ap",
    value: function ap() {
      return nothing;
    }
  }, {
    key: "chain",
    value: function chain() {
      return nothing;
    }
  }, {
    key: "filter",
    value: function filter() {
      return nothing;
    }
  }, {
    key: "tap",
    value: function tap() {
      return nothing;
    }
  }, {
    key: "and",
    value: function and() {
      return nothing;
    }
  }, {
    key: "or",
    value: function or(maybe) {
      return maybe;
    }
  }, {
    key: "alt",
    value: function alt(maybe) {
      return maybe;
    }
  }, {
    key: "getOr",
    value: function getOr(value) {
      return value;
    }
  }, {
    key: "getOrElse",
    value: function getOrElse(fn) {
      return fn();
    }
  }, {
    key: "reduce",
    value: function reduce(transform, or) {
      return or;
    }
  }, {
    key: "match",
    value: function match(fromJust, fromNothing) {
      return fromNothing();
    }
  }, {
    key: "toEither",
    value: function toEither(left) {
      return Left(left);
    }
  }, {
    key: "promise",
    value: function promise(error) {
      return Promise.reject(error);
    }
  }, {
    key: "isJust",
    get: function get() {
      return false;
    }
  }, {
    key: "isNothing",
    get: function get() {
      return true;
    }
  }]);

  return MaybeNothing;
}();

var nothing = new MaybeNothing();

var _getSet$1 = getSet('value'),
    _getSet2$1 = _slicedToArray(_getSet$1, 2),
    getValue = _getSet2$1[0],
    setValue = _getSet2$1[1];

MaybeJust.prototype[Symbol.iterator] = toIterator(getValue);
MaybeNothing.prototype[Symbol.iterator] = toEmptyIterator;
var Just = function Just(value) {
  return new MaybeJust(value);
};
var Nothing = function Nothing() {
  return nothing;
};
var fromNullable = function fromNullable(value) {
  return value == null ? nothing : Just(value);
};
var fromFalsy = function fromFalsy(value) {
  return !value ? nothing : Just(value);
};
var opt = fromNullable;
function when(predicate, value) {
  var condition = typeof predicate == 'boolean' ? predicate : predicate(value);
  return condition ? Just(value) : nothing;
}

exports.Just = Just;
exports.Left = Left;
exports.Nothing = Nothing;
exports.Right = Right;
exports.fromFalsy = fromFalsy;
exports.fromNullable = fromNullable;
exports.ifElse = ifElse;
exports.nothing = nothing;
exports.opt = opt;
exports.when = when;