@andrwj/fp/either.js

"use strict";

Object.defineProperty(exports, "__esModule", {
  value: true
});
exports.Either = exports.isUndefined = exports.truth = exports.revoke = exports.identity = void 0;

var R = _interopRequireWildcard(require("ramda"));

var _isFunction = _interopRequireDefault(require("./isFunction"));

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }

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)) { var desc = Object.defineProperty && Object.getOwnPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : {}; if (desc.get || desc.set) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } } newObj["default"] = obj; return newObj; } }

function _typeof(obj) { if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") { _typeof = function _typeof(obj) { return typeof obj; }; } else { _typeof = function _typeof(obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }; } return _typeof(obj); }

function _possibleConstructorReturn(self, call) { if (call && (_typeof(call) === "object" || typeof call === "function")) { return call; } return _assertThisInitialized(self); }

function _assertThisInitialized(self) { if (self === void 0) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return self; }

function _getPrototypeOf(o) { _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf : function _getPrototypeOf(o) { return o.__proto__ || Object.getPrototypeOf(o); }; return _getPrototypeOf(o); }

function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function"); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, writable: true, configurable: true } }); if (superClass) _setPrototypeOf(subClass, superClass); }

function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); }

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; }

var identity = function identity(v) {
  return v;
};

exports.identity = identity;

var revoke = function revoke() {
  return undefined;
};

exports.revoke = revoke;

var truth = function truth(v) {
  return !!v;
};

exports.truth = truth;

var isUndefined = function isUndefined(v) {
  return Object.is(v, undefined);
};

exports.isUndefined = isUndefined;

var Either =
/*#__PURE__*/
function () {
  function Either(args) {
    _classCallCheck(this, Either);

    if (!(this instanceof Either ? this.constructor : void 0) || (this instanceof Either ? this.constructor : void 0) === Either) {
      throw new Error("no instanciation allowed for Abstract Class 'Either'");
    }

    this.value = args;
  }

  _createClass(Either, [{
    key: "inspect",
    value: function inspect(f) {
      var _inspect = "".concat(this.constructor.name, "(").concat(this.value, ")");

      Either.of(f, _isFunction["default"]).fold(function () {
        return f(_inspect);
      }, function () {
        return console.log(_inspect);
      });
      return this;
    }
  }, {
    key: Symbol.iterator,
    value:
    /*#__PURE__*/
    regeneratorRuntime.mark(function value() {
      return regeneratorRuntime.wrap(function value$(_context) {
        while (1) {
          switch (_context.prev = _context.next) {
            case 0:
              _context.next = 2;
              return this.value;

            case 2:
            case "end":
              return _context.stop();
          }
        }
      }, value, this);
    })
  }, {
    key: 'try',
    value: function _try() {
      return this;
    }
  }, {
    key: 'throw',
    value: function _throw() {
      return this;
    }
  }, {
    key: 'catch',
    value: function _catch() {
      return this;
    }
  }, {
    key: 'clone',
    value: function clone() {
      return this;
    }
  }, {
    key: 'apply',
    value: function apply() {
      return this;
    }
  }, {
    key: "tap",
    value: function tap() {
      var f = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : console.log;
      f(this.value);
      return this;
    }
  }, {
    key: "of",
    value: function of() {
      return this;
    }
  }, {
    key: "take",
    value: function take() {
      return this;
    }
  }, {
    key: "map",
    value: function map() {
      return this;
    }
  }, {
    key: "chain",
    value: function chain() {
      return this;
    }
  }, {
    key: "filter",
    value: function filter() {
      return this;
    }
  }, {
    key: "fold",
    value: function fold() {
      return this;
    }
  }, {
    key: "done",
    value: function done() {
      return this;
    }
  }, {
    key: "doneIf",
    value: function doneIf() {
      return this;
    }
  }, {
    key: "throwIf",
    value: function throwIf() {
      return this;
    }
  }]);

  return Either;
}();

exports.Either = Either;
;

Either.of = function (v, f) {
  return (0, _isFunction["default"])(f) ? f(v) ? Either.right(v) : Either.left(v) : Either.right(v);
};

Either.fromNullable = function (v) {
  return Either.of(v, truth);
};

Either.filter = function (f) {
  var cond = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : truth;
  var v = f();
  return cond(v) ? Either.right(v) : Either.left(v);
};

Either.right = R.curry(function (v) {
  return new Right(v);
});
Either.left = R.curry(function (v) {
  return new Left(v);
});

Either.done = function (v) {
  return new Done(Either.right(v));
};

Either.doneIf = function (f, v) {
  return f(v) ? Either.done(v) : Either.right(v);
};

Either["throw"] = function (v) {
  return new Throw(Either.right(v));
};

Either.throwIf = function (f, v) {
  return f(v) ? new Throw(Either.right(v)) : Either.right(v);
};

Either["try"] = function (f) {
  try {
    return Either.right(f());
  } catch (e) {
    return Either.left(e);
  }
};

var Right =
/*#__PURE__*/
function (_Either) {
  _inherits(Right, _Either);

  function Right(args) {
    _classCallCheck(this, Right);

    return _possibleConstructorReturn(this, _getPrototypeOf(Right).call(this, args));
  }

  _createClass(Right, [{
    key: 'try',
    value: function _try(f) {
      try {
        return Either.right(f(this.value));
      } catch (e) {
        return Either.left(e);
      }
    }
  }, {
    key: 'throw',
    value: function _throw() {
      return Either["throw"](this.value);
    }
  }, {
    key: 'clone',
    value: function clone(v) {
      return Either.right(isUndefined(v) ? this.value : v);
    }
  }, {
    key: 'apply',
    value: function apply(o) {
      return o.map(this.value);
    }
  }, {
    key: "of",
    value: function of(v, f) {
      return (0, _isFunction["default"])(f) ? f(v) ? Either.right(v) : Either.left(v) : Either.right(v);
    }
  }, {
    key: "take",
    value: function take() {
      return this.value;
    }
  }, {
    key: "map",
    value: function map(f) {
      return Either.right(f(this.value));
    }
  }, {
    key: "chain",
    value: function chain(f) {
      return f(this.value);
    }
  }, {
    key: "filter",
    value: function filter(f) {
      return Either.of(this.value, f);
    }
  }, {
    key: "fold",
    value: function fold() {
      var f = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : identity;
      var no_use = arguments.length > 1 ? arguments[1] : undefined;
      return f(this.value);
    }
  }, {
    key: "done",
    value: function done(v) {
      return Either.done(isUndefined(v) ? this.value : v);
    }
  }, {
    key: "doneIf",
    value: function doneIf(f, v) {
      return f(this.value) ? Either.done(isUndefined(v) ? this.value : v) : this;
    }
  }, {
    key: "throwIf",
    value: function throwIf(f, v) {
      return f(this.value) ? Either["throw"](isUndefined(v) ? this.value : v) : this;
    }
  }]);

  return Right;
}(Either); // Class Left


var Left =
/*#__PURE__*/
function (_Either2) {
  _inherits(Left, _Either2);

  function Left(args) {
    _classCallCheck(this, Left);

    return _possibleConstructorReturn(this, _getPrototypeOf(Left).call(this, args));
  }

  _createClass(Left, [{
    key: "take",
    value: function take() {
      return this.value;
    }
  }, {
    key: "fold",
    value: function fold(no_use) {
      var f = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : identity;
      return f(this.value);
    }
  }]);

  return Left;
}(Either); // 'Throw' is not Error nor Exception. It is carrier for the instance of Right to '.catch()'
// and 'Throw' does ignore all but '.catch()'. ONLY Right can throw.
// NOTE: The return value must be of Right or the caller of '.throw()'


var Throw =
/*#__PURE__*/
function (_Either3) {
  _inherits(Throw, _Either3);

  function Throw(args) {
    _classCallCheck(this, Throw);

    if (!(args instanceof Either)) throw new Error("Throw() needs instance of Either");
    return _possibleConstructorReturn(this, _getPrototypeOf(Throw).call(this, args));
  }

  _createClass(Throw, [{
    key: 'catch',
    value: function _catch(handler) {
      return (0, _isFunction["default"])(handler) ? this.value.map(handler) : this.value;
    }
  }, {
    key: "tap",
    value: function tap() {
      var f = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : console.log;

      (function recur(obj) {
        return obj && obj instanceof Either && obj.value instanceof Either ? recur(obj.value) : f(obj.value);
      })(this);

      return this;
    }
  }, {
    key: "inspect",
    value: function inspect(f) {
      var _inspect = function recur(obj) {
        return obj instanceof Either ? "".concat(obj.constructor.name, "(").concat(recur(obj.value), ")") : "".concat(obj);
      }(this);

      Either.of(f, _isFunction["default"]).fold(function () {
        return f(_inspect);
      }, function () {
        return console.log(_inspect);
      });
      return this;
    }
  }]);

  return Throw;
}(Either); // NOTE: Done is another carrier for Right and Left. Only instance of Done will ignore all method but '.take() & .fold()'


var Done =
/*#__PURE__*/
function (_Either4) {
  _inherits(Done, _Either4);

  function Done(args) {
    _classCallCheck(this, Done);

    if (!(args instanceof Either)) throw new Error("argument must be of Either");
    return _possibleConstructorReturn(this, _getPrototypeOf(Done).call(this, args));
  } // for DEBUGGING


  _createClass(Done, [{
    key: "tap",
    value: function tap() {
      var f = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : console.log;

      (function recur(obj) {
        return obj && obj instanceof Either && obj.value instanceof Either ? recur(obj.value) : f(obj.value);
      })(this);

      return this;
    }
  }, {
    key: "fold",
    value: function fold() {
      var f = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : identity;
      var g = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : identity;
      return function recur(obj) {
        return obj && obj instanceof Either && obj.value instanceof Either ? recur(obj.value) : obj.fold(f, g);
      }(this);
    }
  }, {
    key: "inspect",
    value: function inspect(f) {
      var _inspect = function recur(obj) {
        return obj instanceof Either ? "".concat(obj.constructor.name, "(").concat(recur(obj.value), ")") : "".concat(obj);
      }(this);

      Either.of(f, _isFunction["default"]).fold(function () {
        return f(_inspect);
      }, function () {
        return console.log(_inspect);
      });
      return this;
    }
  }, {
    key: "take",
    value: function take() {
      return function recur(obj) {
        return obj && obj instanceof Either && obj.value instanceof Either ? recur(obj.value) : obj.value;
      }(this);
    }
  }]);

  return Done;
}(Either);