maybe monad

https://gist.github.com/timcharper/2712916

by Maslow

HTML

<h2>objects</h2>

<ul>
    <li><span data-bind="text:objectHappy"></span>

    </li>
    <li>undefined <span data-bind="text:objectUndefined"></span>

    </li>
    <li>chained <span data-bind="text:objectChained"></span>

    </li>
</ul>

<h2>functions</h2>

<ul>
    <li>function:<span data-bind="text:functionHappy"></span>
    </li>
    <li>function undefined:<span data-bind="text:functionUndefined"></span>
    </li>
    <li>sub:<span data-bind="text:subHappy"></span>
    </li>
</ul>

<h2>numbers</h2>

<ul>
    <li>happy:<span data-bind="text:numberHappy"></span>

    </li>
    <li>prototype toString:<span data-bind="text:numberString"></span>

    </li>
</ul>

<h2> arrays</h2>

<span data-bind="text:arrayHappy"></span>
<h2> combos </h2>
<ul>
    <li> array.index.functionProperty.().stringy <span data-bind="text:chainAll"></span></li>
    <li> null[2].func.().stringy <span data-bind="text:chainRootUndefined"></span></li>
    
</ul>

JavaScript

function type(obj) {
    var obj_type = typeof obj;
    return ({
        is: function (type) {
            return obj_type === type;
        },
        is_object: function () {
            return obj_type === "object";
        },
        is_func: function () {
            return obj_type === "function";
        },
        is_string: function () {
            return obj_type === "string";
        }
    });
};


function maybe(item) {
    return ({
        result: function (accessor, __default) {
            if (!item) return type(accessor).is_func() ? __default : accessor;
            else return type(accessor).is_func() ? accessor(item) : item;
        },

        _: function (accessor) {
            if (!accessor && type(item).is_func()) {

                return maybe(item());
            }
            if (!item) return maybe(null);
            if (type(accessor).is_string()) {
                if (item.hasOwnProperty(accessor)) return maybe(item[accessor]);
                var result = item[accessor];
                if (result) return maybe(item[accessor].call(item));

                return maybe(result);
            }
            if (type(accessor).is_func()) {

                return maybe(accessor(item));
            }

            return maybe(item[accessor]);
        }
    });
};

var Model = function () {
    var self = this;
    var sideEffect = 'failure';
    var testObject = {
        stringy: 'success stringy',
        number: 4,
        arr: [0, 1, 2],
        func: function () {
            return {
                stringy: 'nested function object success'
            };
        },
        sub: function () {
            sideEffect = 'success sideEffect';
        }
    };

    self.objectHappy = maybe(testObject)._('stringy').result() || 'failure';
    self.objectUndefined = maybe(testObject)._('abc').result() || 'success';
    self.objectChained = maybe(testObject)._('abc')._(0).result() || 'success';
    self.functionHappy =...