이렇게 직접적인 Promise 구현은 못 봤어요.

        var Promise = (function () {
            var state = { pending: 0, resolved: 1, rejected: 2 };

            var Promise = function (asyncTask) {
                var asyncState = state.pending;
                var hasSolution = false;

                var asyncResult = [];
                var asyncError = [];
                var projectA = null;
                var projectB = null;
                var represent = { resolve: null, reject: null };

                var resolve = function () {
                    asyncState = state.resolved;
                    asyncResult = arguments;
                    if (hasSolution) {
                        if (typeof projectA === 'function') {
                            asyncPlan(projectA, arguments);
                        }
                        else {
                            represent.resolve.apply(undefined, arguments);
                        }
                    }
                };

                var reject = function () {
                    asyncState = state.rejected;
                    asyncError = arguments;
                    if (hasSolution) {
                        if (typeof projectB === 'function') {
                            asyncPlan(projectB, arguments);
                        }
                        else {
                            represent.reject.apply(undefined, arguments);
                        }
                    }
                };

                this.then = function (successPlan, failurePlan) {
                    hasSolution = true;
                    switch (asyncState) {
                        case state.pending:
                            projectA = successPlan;
                            projectB = failurePlan;
                            return new Promise(function (resolve, reject) {
                                represent.resolve = resolve;
                                represent.reject = reject;
                            });
                        case state.resolved:
                            if (typeof successPlan === 'function') {
                                return syncPlan(successPlan, asyncResult);
                            }
                            else {
                                return Promise.resolve.apply(undefined, asyncResult);
                            }
                        case state.rejected:
                            if (typeof failurePlan === 'function') {
                                return syncPlan(failurePlan, asyncError);
                            }
                            else {
                                return Promise.reject.apply(undefined, asyncError);
                            }
                    }
                };

                var syncPlan = function (plan, argus) {
                    var result = undefined;
                    try {
                        result = plan.apply(undefined, argus);
                    }
                    catch (error) {
                        return Promise.reject(error);
                    }

                    if (result instanceof Promise) {
                        return result;
                    }
                    else {
                        return Promise.resolve(result);
                    }
                };

                var asyncPlan = function (plan, argus) {
                    var result = undefined;
                    try {
                        result = plan.apply(undefined, argus);
                    }
                    catch (error) {
                        represent.reject.call(undefined, error);
                    }

                    if (result instanceof Promise) {
                        result.then(function () {
                            represent.resolve.apply(undefined, arguments);
                        }, function () {
                            represent.reject.apply(undefined, arguments);
                        });
                    }
                    else {
                        represent.resolve.call(undefined, result);
                    }
                };

                this.catch = function (failurePlan) {
                    return this.then(undefined, failurePlan);
                };

                try {
                    asyncTask(resolve, reject);
                }
                catch (error) {
                    reject(error);
                }
            };

            Promise.resolve = function () {
                var argus = arguments;
                return new Promise(function (resolve) {
                    resolve.apply(undefined, argus);
                });
            };

            Promise.reject = function () {
                var argus = arguments;
                return new Promise(function (none, reject) {
                    reject.apply(undefined, argus);
                });
            }

            return Promise;
        })();