Significantly improve the performance of `Collection<FutureType>.flat…

…ten`.

This further halves the runtime in vapor/template-kit#50 from 0.1s to 50ms.

Sources/Async/Future+Flatten.swift

@@ -60,27 +60,40 @@ extension Collection where Element: FutureType {
             return eventLoop.newSucceededFuture(result: [])
         }
 
-        var promises = [EventLoopPromise<Element.Expectation>]()
-        for future in self {
-            let promise = eventLoop.newPromise(of: Element.Expectation.self)
-            promises.append(promise)
+        let resultPromise: EventLoopPromise<[Element.Expectation]> = eventLoop.newPromise()
+        var promiseFulfilled = false
+
+        let expectedCount = self.count
+        var fulfilledCount = 0
+        var results = Array<Element.Expectation?>(repeating: nil, count: expectedCount)
+        for (index, future) in self.enumerated() {
             future.addAwaiter { result in
-                switch result {
-                case .success(let value):
-                    promise.succeed(result: value)
-                case .error(let error):
-                    promise.fail(error: error)
+                let work: () -> Void = {
+                    guard !promiseFulfilled else { return }
+                    switch result {
+                    case .success(let result):
+                        results[index] = result
+                        fulfilledCount += 1
+
+                        if fulfilledCount == expectedCount {
+                            promiseFulfilled = true
+                            // Forcibly unwrapping is okay here, because we know that each result has been filled.
+                            resultPromise.succeed(result: results.map { $0! })
+                        }
+                    case .error(let error):
+                        promiseFulfilled = true
+                        resultPromise.fail(error: error)
+                    }
+                }
+
+                if future.eventLoop === eventLoop {
+                    work()
+                } else {
+                    eventLoop.execute(work)
                 }
             }
         }
-        let futures = promises.map { $0.futureResult }
-        return Future<[Element.Expectation]>.reduce(
-            into: [],
-            futures,
-            eventLoop: eventLoop
-        ) { partialResult, nextElement in
-            return partialResult.append(nextElement)
-        }
+        return resultPromise.futureResult
     }
 }
 

Sources/Async/FutureType.swift

@@ -10,6 +10,9 @@ public protocol FutureType {
     /// This future's result type.
     typealias Result = FutureResult<Expectation>
 
+    /// The event loop this future is fulfilled on.
+    var eventLoop: EventLoop { get }
+
     /// Adds a new awaiter to this `Future` that will be called when the result is ready.
     func addAwaiter(callback: @escaping FutureResultCallback<Expectation>)
 }