Try catch utility so optimization still occurs in the calling function. lol?

attempt.js

'use strict';

function attempt(fn) {
    return Object.create({
        'fail': function (onError) {
            try {
                fn();
            }
            catch (e) {
                return onError(e);
            }
        }
    });
}

exports = module.exports = attempt;

usage.md

Example:

attempt(function () {
    JSON.parse();
}).
fail(function (e) {
    console.error(e);
});

Creating new objects, closures, and functions are unlikely to be faster, especially since the try/catch will prevent them from being inlined. First, a refactor:

function attempt(fn) {
    return {
        fail: function (reject) {
            try {
                fn();
            catch (err) {
                reject(err);
            }
        }
    }
}

A few confusing bits as a consumer:

1. You have to invoke fail to execute the intended behavior. Could be moot or obvious, just interesting side-effect.
2. The consumer needs to wrap the intended behavior in order to reconcile both callbacks/"re-join" the result:

function fallable() {
    // Do work.
    callback(null, JSON.parse(/* data from closure? */));
}

attempt(fallable).fail(callback);

Either way, I think it's worth trying out if it helps inlining.