fp-small - npm Package Compare versions

Comparing version 1.0.0 to 1.0.1

dist/Either/index.js

+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+var Right = exports.Right = function Right(x) {
+  return {
+    map: function map(f) {
+      return Right(f(x));
+    },
+    fold: function fold(_, g) {
+      return g(x);
+    },
+    chain: function chain(f) {
+      return f(x);
+    },
+    ap: function ap(b2) {
+      return b2.map(x);
+    },
+    inspect: function inspect() {
+      return "Right(" + x + ")";
+    },
+    of: function of(x) {
+      return Right(x);
+    }
+  };
+};
+
+var Left = exports.Left = function Left(x) {
+  return {
+    map: function map(_) {
+      return Left(x);
+    },
+    fold: function fold(f, _) {
+      return f(x);
+    },
+    chain: function chain(_) {
+      return Left(x);
+    },
+    ap: function ap(_) {
+      return Left(x);
+    },
+    inspect: function inspect() {
+      return "Left(" + x + ")";
+    }
+  };
+};
+
+var tryCatch = exports.tryCatch = function tryCatch(fn) {
+  for (var _len = arguments.length, args = Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) {
+    args[_key - 1] = arguments[_key];
+  }
+
+  try {
+    return Right(fn.apply(undefined, args));
+  } catch (e) {
+    return Left(e);
+  }
+};
+
+var fromNullable = exports.fromNullable = function fromNullable(x) {
+  return x == null ? Left() : Right(x);
+};

dist/fp/index.js

+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+
+function _toConsumableArray(arr) { if (Array.isArray(arr)) { for (var i = 0, arr2 = Array(arr.length); i < arr.length; i++) { arr2[i] = arr[i]; } return arr2; } else { return Array.from(arr); } }
+
+var curry = exports.curry = function curry(fn) {
+  var len = fn.length;
+  return function $curry() {
+    for (var _len = arguments.length, args = Array(_len), _key = 0; _key < _len; _key++) {
+      args[_key] = arguments[_key];
+    }
+
+    return args.length < len ? curry(fn.bind.apply(fn, [null].concat(args))) : fn.call.apply(fn, [null].concat(args));
+  };
+};
+
+var compose = exports.compose = function compose() {
+  for (var _len2 = arguments.length, fns = Array(_len2), _key2 = 0; _key2 < _len2; _key2++) {
+    fns[_key2] = arguments[_key2];
+  }
+
+  return function () {
+    for (var _len3 = arguments.length, args = Array(_len3), _key3 = 0; _key3 < _len3; _key3++) {
+      args[_key3] = arguments[_key3];
+    }
+
+    return fns.reduceRight(function (acc, next) {
+      return [next.call.apply(next, [null].concat(_toConsumableArray(acc)))];
+    }, args)[0];
+  };
+};

dist/index.js

+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+
+var _Task = require("./Task");
+
+Object.defineProperty(exports, "Task", {
+  enumerable: true,
+  get: function get() {
+    return _interopRequireDefault(_Task).default;
+  }
+});
+
+var _Either = require("./Either");
+
+Object.defineProperty(exports, "Either", {
+  enumerable: true,
+  get: function get() {
+    return _interopRequireDefault(_Either).default;
+  }
+});
+
+var _Maybe = require("./Maybe");
+
+Object.defineProperty(exports, "Maybe", {
+  enumerable: true,
+  get: function get() {
+    return _interopRequireDefault(_Maybe).default;
+  }
+});
+
+var _fp = require("./fp");
+
+Object.keys(_fp).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function get() {
+      return _fp[key];
+    }
+  });
+});
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

dist/Maybe/index.js

+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+
+var _createClass = 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); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }();
+
+function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
+
+var Maybe = function () {
+  function Maybe(x) {
+    _classCallCheck(this, Maybe);
+
+    this.x = x;
+  }
+
+  _createClass(Maybe, [{
+    key: "map",
+    value: function map(f) {
+      return this.isNothing ? this : Maybe.of(f(this.x));
+    }
+  }, {
+    key: "inspect",
+    value: function inspect() {
+      return "Maybe(" + (this.isNothing ? "Nothing" : this.x) + ")";
+    }
+  }, {
+    key: "ap",
+    value: function ap(f) {
+      return this.isNothing ? this : f.map(this.x);
+    }
+  }, {
+    key: "fold",
+    value: function fold(f) {
+      return this.isNothing ? this.x : f(this.x);
+    }
+  }, {
+    key: "chain",
+    value: function chain(f) {
+      return this.map(f).fold(function (x) {
+        return x;
+      });
+    }
+  }, {
+    key: "isNothing",
+    get: function get() {
+      return this.x == null;
+    }
+  }], [{
+    key: "of",
+    value: function of(x) {
+      return new Maybe(x);
+    }
+  }]);
+
+  return Maybe;
+}();
+
+exports.default = Maybe;

dist/Task/index.js

+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+
+var _createClass = 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); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }();
+
+var _2 = require("..");
+
+function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
+
+var Task = function () {
+  function Task(fork) {
+    _classCallCheck(this, Task);
+
+    this.fork = fork;
+  }
+
+  _createClass(Task, [{
+    key: "inspect",
+    value: function inspect() {
+      return "Task(?)";
+    }
+  }, {
+    key: "map",
+
+
+    // ----- Functor (Task a)
+    value: function map(fn) {
+      var _this = this;
+
+      return new Task(function (reject, resolve) {
+        return _this.fork(reject, (0, _2.compose)(resolve, fn));
+      });
+    }
+
+    // ----- Applicative (Task a)
+
+  }, {
+    key: "ap",
+    value: function ap(f) {
+      return this.chain(function (fn) {
+        return f.map(fn);
+      });
+    }
+
+    // ----- Monad (Task a)
+
+  }, {
+    key: "chain",
+    value: function chain(fn) {
+      var _this2 = this;
+
+      return new Task(function (reject, resolve) {
+        return _this2.fork(reject, function (x) {
+          return fn(x).fork(reject, resolve);
+        });
+      });
+    }
+  }, {
+    key: "join",
+    value: function join() {
+      return this.chain(function (x) {
+        return x;
+      });
+    }
+  }], [{
+    key: "rejected",
+    value: function rejected(x) {
+      return new Task(function (reject, _) {
+        return reject(x);
+      });
+    }
+
+    // ----- Pointed (Task a)
+
+  }, {
+    key: "of",
+    value: function of(x) {
+      return new Task(function (_, resolve) {
+        return resolve(x);
+      });
+    }
+  }]);
+
+  return Task;
+}();
+
+exports.default = Task;

package.json

 {
   "name": "fp-small",
-  "version": "1.0.0",
+  "version": "1.0.1",
   "description": "A small functional programming library",
@@ -5,0 +5,0 @@ "main": "dist/index.js",

New alerts

Major refactor

Supply chain risk

Package has recently undergone a major refactor. It may be unstable or indicate significant internal changes. Use caution when updating to versions that include significant changes.

Fixed alerts

Empty package

Supply chain risk

Package does not contain any code. It may be removed, is name squatting, or the result of a faulty package publish.

Improved metrics

Total package byte prevSize

10018

283.1%

Number of package files

8

166.67%

Lines of code

241

Infinity%

No dependency changes