@bitty/maybe/dist/Maybe.esm.js

Maybe

import isFalsy from '@bitty/falsy';
import isNullish from '@bitty/nullish';

var None = {
    _kind: 'None',
    alt: function (fn) { return fn(); },
    map: function () { return None; },
    then: function () { return None; },
    chain: function () { return None; },
    isNone: function () { return true; },
    isSome: function () { return false; },
    match: function (_a) {
        var none = _a.none;
        return none();
    },
    fold: function (onLeft) { return onLeft(); },
    getOrElse: function (onLeft) { return onLeft(); },
    unwrap: function () { return null; },
};

function isMaybe(value) {
    return (value === null || value === void 0 ? void 0 : value._kind) === 'Some' || value === None;
}

function Some(value) {
    return {
        _kind: 'Some',
        alt: function () { return Some(value); },
        map: function (fn) { return Some(fn(value)); },
        then: function (fn) {
            var valueOrMaybe = fn(value);
            return isMaybe(valueOrMaybe) ? valueOrMaybe : Some(valueOrMaybe);
        },
        chain: function (fn) { return fn(value); },
        match: function (_a) {
            var some = _a.some;
            return some(value);
        },
        fold: function (_, onSome) { return onSome(value); },
        isNone: function () { return false; },
        isSome: function () { return true; },
        getOrElse: function () { return value; },
        unwrap: function () { return value; },
    };
}

function fromFalsy(value) {
    return isFalsy(value) ? None : Some(value);
}

function fromNullish(value) {
    return isNullish(value) ? None : Some(value);
}

function fromPredicate(predicate) {
    return function (value) { return (predicate(value) ? Some(value) : None); };
}

function tryCatch(fn) {
    try {
        return Some(fn());
    }
    catch (error) {
        return None;
    }
}

export { None, Some, fromFalsy, fromNullish, fromPredicate, tryCatch };
//# sourceMappingURL=Maybe.esm.js.map