                                                 return controllerObject[myController][myAction]
 
                                         # Once we've gotten all the handles on the functions we need
-                                        # to call, we can concat it to all previous promises. 
-                                        endPromiseArray = promiseArray.concat actionHandles
-
-                                        # We need to guarantee these functions will run sequentially,
-                                        # piping the output from the previous one to the next one.
-                                        #
-                                        # It turns out that _.reduce is sort of designed for *exactly that*
-                                        #
-                                        # This should converge on one final promise. 
-                                        finalPromise = _.reduce endPromiseArray, (cur, next) ->
-                                                cur.then(next)
+                                        # to call, we can concat it to all previous promises. Afterwards
+                                        # we want these to run sequentially, so we use the reduce function
+                                        # to run them, then converge into a single, final promise. 
+                                        finalPromise =
+                                                do
+                                                        _.chain promiseArray
+                                                        .concat actionHandles
+                                                        .reduce (cur, next) ->
+                                                                cur.then next
+                                                        .value
 
                                         # Everything should be done.  We can finally render a template
                                         # or return back JSON depending on what they did on that last function

                                                
                        # As stated above, wrapper will return a new function based on what 
                        # we send in for "allRoutes"
                        app[method](endpoint, wrapper(allRoutes))

                        # helper-variable. 
                        endpoint = routeComponent[1]


                        allRoutes = actionString.split ' '
                        # I was having a bit of trouble with scopign and not-copying, and since
                        # we're already utilizing lodash, I might as well take advantage of the
                        # deep-copy function they have so as to guarantee it won't be a problem
                        # in the future

                        # This is a thunk'd funciton.  I was having some issues with the "allRoutes"
                        # variable not being the one I needed, and it turns out that it was shallow
