Unrolled into futures (time is slipping slipping slipping into the future)

unrolled_future_config.js

function createAcceptFunc(deferred, valuesDict, setupInfo) {
    return function (value) {
        valuesDict.set(setupInfo.bindingClass, value);
        deferred.resolve();
    };
}


function createRejectFunc(deferred, errorDict, setupInfo) {
    return function (value) {
        errorsDict.set(setupInfo.bindingClass, value);
        deferred.resolve();
    };
}


function createFutureOperation (setupInfo, errorsDict, valuesDict) {
    return function () {
        var innerDeferred = q.defer();
        
        var acceptFunc = createAcceptFunc(innerDeferred, valuesDict, setupInfo);
        var rejectFunc = createRejectFunc(innerDeferred, errorsDict, setupInfo);
        
        if(setupInfo.direction === 'write') {
            device.write(setupInfo.address, setupInfo.value, rejectFunc, acceptFunc)
        } else if (setupInfo.direction === 'read') {
            device.read(setupInfo.address, rejectFunc, acceptFunc);
        }
        
        return innerDeferred.promise;
    }
}

function createFutureOperations (setupInfos, errorsDict, valuesDict) {
    return setupInfos.map(function (setupInfo) {
        return createFutureOperation(setupInfo, errorsDict, valuesDict)
    });
}

function executeSetup (setupInfos) {
    var deferred = q.defer();
    var values = dict();
    var errors = dict();
    var futures = createFutureOperations(setupInfos, errors, values);
    
    async.eachSeries(
        futures,
        function (future, callback) {
            future().then(callback);
        },
        function (err) {
            deferred.resolve({errors: errors, values: values});
        }
    );

    return deferred.promise;
}