typecat
Version:
A tiny functional programming library for TypeScript that provides Option (Some/None) and Either(Left/Right) with functor map, applicative map and monad flatmap
224 lines • 7.63 kB
JavaScript
;
var __extends = (this && this.__extends) || (function () {
var extendStatics = function (d, b) {
extendStatics = Object.setPrototypeOf ||
({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };
return extendStatics(d, b);
};
return function (d, b) {
extendStatics(d, b);
function __() { this.constructor = d; }
d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
};
})();
var __generator = (this && this.__generator) || function (thisArg, body) {
var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
function verb(n) { return function (v) { return step([n, v]); }; }
function step(op) {
if (f) throw new TypeError("Generator is already executing.");
while (_) try {
if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
if (y = 0, t) op = [op[0] & 2, t.value];
switch (op[0]) {
case 0: case 1: t = op; break;
case 4: _.label++; return { value: op[1], done: false };
case 5: _.label++; y = op[1]; op = [0]; continue;
case 7: op = _.ops.pop(); _.trys.pop(); continue;
default:
if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
if (t[2]) _.ops.pop();
_.trys.pop(); continue;
}
op = body.call(thisArg, _);
} catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
}
};
Object.defineProperty(exports, "__esModule", { value: true });
exports.id = function (a) { return a; };
var Option = (function () {
function Option() {
}
return Option;
}());
exports.Option = Option;
var Some = (function (_super) {
__extends(Some, _super);
function Some(a) {
var _this = this;
if (a === undefined || a === null)
throw TypeError("Some can't be initated with undefined or null");
_this = _super.call(this) || this;
_this._value = a;
return _this;
}
Some.prototype.fmap = function (f) {
return new Some(f(this._value));
};
Some.prototype.applyMap = function (a) {
if (a instanceof None)
return new None();
var f = this._value;
return new Some(f(a._value));
};
Some.prototype.flatMap = function (f) {
return f(this._value);
};
Some.prototype.get = function () {
return this._value;
};
Some.prototype.getOrElse = function (defaultValue) {
return this._value;
};
Some.prototype[Symbol.iterator] = function () {
return __generator(this, function (_a) {
switch (_a.label) {
case 0: return [4, this._value];
case 1:
_a.sent();
return [2];
}
});
};
return Some;
}(Option));
exports.Some = Some;
var None = (function (_super) {
__extends(None, _super);
function None() {
return _super.call(this) || this;
}
None.prototype.fmap = function (f) {
return new None();
};
None.prototype.applyMap = function (a) {
return new None();
};
None.prototype.flatMap = function (f) {
return new None();
};
None.prototype.get = function () {
throw TypeError('Value not exist in None');
};
None.prototype.getOrElse = function (defaultValue) {
return defaultValue;
};
None.prototype[Symbol.iterator] = function () {
return __generator(this, function (_a) {
return [2];
});
};
return None;
}(Option));
exports.None = None;
var Either = (function () {
function Either() {
}
return Either;
}());
exports.Either = Either;
var Left = (function (_super) {
__extends(Left, _super);
function Left(a) {
var _this = this;
if (a === undefined || a === null)
throw TypeError("Left can't be initated with undefined or null");
_this = _super.call(this) || this;
_this._left = a;
_this._right = undefined;
return _this;
}
Left.prototype.fmap = function (f) {
return new Left(this._left);
};
Left.prototype.applyMap = function (f) {
return new Left(this._left);
};
Left.prototype.flatMap = function (f) {
return new Left(this._left);
};
Left.prototype.get = function () {
throw TypeError('Value not exist in Left');
};
Left.prototype.getOrElse = function (defaultValue) {
return defaultValue;
};
Left.prototype.getLeft = function () {
return this._left;
};
Left.prototype.getLeftOrElse = function (defaultValue) {
return this._left;
};
Left.prototype[Symbol.iterator] = function () {
return __generator(this, function (_a) {
return [2];
});
};
return Left;
}(Either));
exports.Left = Left;
var Right = (function (_super) {
__extends(Right, _super);
function Right(a) {
var _this = this;
if (a === undefined || a === null)
throw TypeError("Right can't be initated with undefined or null");
_this = _super.call(this) || this;
_this._left = undefined;
_this._right = a;
return _this;
}
Right.prototype.fmap = function (f) {
return new Right(f(this._right));
};
Right.prototype.applyMap = function (a) {
if (a instanceof Left)
return a;
else {
var f = this._right;
return new Right(f(a._right));
}
};
Right.prototype.flatMap = function (f) {
return f(this._right);
};
Right.prototype.get = function () {
return this._right;
};
Right.prototype.getOrElse = function (defaultValue) {
return this._right;
};
Right.prototype.getLeft = function () {
throw TypeError('Left value not exist in Right');
};
Right.prototype.getLeftOrElse = function (defaultValue) {
return defaultValue;
};
Right.prototype[Symbol.iterator] = function () {
return __generator(this, function (_a) {
return [2, this._right];
});
};
return Right;
}(Either));
exports.Right = Right;
var triplePlusF = function (a) { return function (b) { return function (c) { return a + b + c; }; }; };
var triplePlus = new Some(triplePlusF);
var a = new Some(2);
var b = new Some(3);
var c = new Some(4);
var d = new None();
var plusedA = triplePlus
.applyMap(a)
.applyMap(b)
.applyMap(c);
console.log(plusedA);
console.log('plusedA is Option? ', plusedA instanceof Option);
var ra = plusedA.get();
console.log(ra);
//# sourceMappingURL=index.js.map