ts-option
Version:
Scala like Option type for TypeScript
246 lines (245 loc) • 7.26 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 __());
};
})();
Object.defineProperty(exports, "__esModule", { value: true });
var Option = /** @class */ (function () {
function Option() {
}
return Option;
}());
exports.Option = Option;
var Some = /** @class */ (function (_super) {
__extends(Some, _super);
function Some(value) {
var _this = _super.call(this) || this;
_this.value = value;
return _this;
}
Some.prototype.exists = function (p) {
return p(this.value);
};
Some.prototype.filter = function (p) {
return p(this.value) ? this : exports.none;
};
Some.prototype.filterNot = function (p) {
return p(this.value) ? exports.none : this;
};
Some.prototype.flatMap = function (f) {
return f(this.value);
};
Some.prototype.fold = function ( /* ifEmpty: () => B) */) {
var _this = this;
return function (f) { return f(_this.value); };
};
Some.prototype.forAll = function (p) {
return p(this.value);
};
Some.prototype.forComprehension = function () {
var fns = [];
for (var _i = 0; _i < arguments.length; _i++) {
fns[_i] = arguments[_i];
}
var result = this;
for (var i = 0; i < fns.length - 1; ++i) {
result = result.flatMap(fns[i]);
}
return result.map(fns[fns.length - 1]);
};
Some.prototype.forEach = function (f) {
return f(this.value);
};
Object.defineProperty(Some.prototype, "get", {
get: function () {
return this.value;
},
enumerable: true,
configurable: true
});
Some.prototype.getOrElse = function ( /* defaultValue: () => A) */) {
return this.value;
};
Some.prototype.getOrElseValue = function ( /* defaultValue: A */) {
return this.value;
};
Object.defineProperty(Some.prototype, "isDefined", {
get: function () {
return true;
},
enumerable: true,
configurable: true
});
Object.defineProperty(Some.prototype, "isEmpty", {
get: function () {
return false;
},
enumerable: true,
configurable: true
});
Some.prototype.map = function (f) {
return some(f(this.value));
};
Some.prototype.match = function (matcher) {
return matcher.some(this.value);
};
Object.defineProperty(Some.prototype, "nonEmpty", {
get: function () {
return true;
},
enumerable: true,
configurable: true
});
Some.prototype.orElse = function ( /* alternative: () => Option<A> */) {
return this;
};
Some.prototype.orElseValue = function ( /* alternative: Option<A> */) {
return this;
};
Object.defineProperty(Some.prototype, "orNull", {
get: function () {
return this.value;
},
enumerable: true,
configurable: true
});
Object.defineProperty(Some.prototype, "orUndefined", {
get: function () {
return this.value;
},
enumerable: true,
configurable: true
});
Object.defineProperty(Some.prototype, "toArray", {
get: function () {
return [this.value];
},
enumerable: true,
configurable: true
});
Some.prototype.toString = function () {
return 'Some(' + this.value + ')';
};
return Some;
}(Option));
exports.Some = Some;
var None = /** @class */ (function (_super) {
__extends(None, _super);
function None() {
return _super !== null && _super.apply(this, arguments) || this;
}
None.prototype.exists = function ( /* p: (_: A) => boolean */) {
return false;
};
None.prototype.filter = function ( /* p: (_: A) => boolean */) {
return this;
};
None.prototype.filterNot = function ( /* p: (_: A) => boolean */) {
return this;
};
None.prototype.flatMap = function ( /* f: (_: A) => Option<B> */) {
return exports.none;
};
None.prototype.fold = function (ifEmpty) {
return function () { return ifEmpty(); };
};
None.prototype.forAll = function ( /* p: (_: A) => boolean */) {
return true;
};
None.prototype.forComprehension = function ( /* ...fns: ((x: any) => Option<any>)[] */) {
return exports.none;
};
None.prototype.forEach = function () {
// do nothing.
};
Object.defineProperty(None.prototype, "get", {
get: function () {
throw new Error('No such element.');
},
enumerable: true,
configurable: true
});
None.prototype.getOrElse = function (defaultValue) {
return defaultValue();
};
None.prototype.getOrElseValue = function (defaultValue) {
return defaultValue;
};
Object.defineProperty(None.prototype, "isDefined", {
get: function () {
return false;
},
enumerable: true,
configurable: true
});
Object.defineProperty(None.prototype, "isEmpty", {
get: function () {
return true;
},
enumerable: true,
configurable: true
});
None.prototype.map = function ( /* f: (_: A) => B */) {
return exports.none;
};
None.prototype.match = function (matcher) {
return matcher.none();
};
Object.defineProperty(None.prototype, "nonEmpty", {
get: function () {
return false;
},
enumerable: true,
configurable: true
});
None.prototype.orElse = function (alternative) {
return alternative();
};
None.prototype.orElseValue = function (alternative) {
return alternative;
};
Object.defineProperty(None.prototype, "orNull", {
get: function () {
return null;
},
enumerable: true,
configurable: true
});
Object.defineProperty(None.prototype, "orUndefined", {
get: function () {
return undefined;
},
enumerable: true,
configurable: true
});
Object.defineProperty(None.prototype, "toArray", {
get: function () {
return [];
},
enumerable: true,
configurable: true
});
None.prototype.toString = function () {
return 'None';
};
return None;
}(Option));
exports.None = None;
function some(value) {
return new Some(value);
}
exports.some = some;
exports.none = new None();
function option(value) {
return value === null || typeof value === 'undefined' ? exports.none : some(value);
}
exports.option = option;