     }
     
     fileprivate func executeDeferedCompletionHandlers() {
-        self.stateHandlers.forEach { self.executeCompletionHandler($0) }
+        self.stateHandlers.forEach(executeCompletionHandler)
         self.stateHandlers = []
     }
 
     fileprivate func executeCompletionHandler(_ handler: FutureCompletionHandler<T>) {
-        switch (handler, self.state) {
-        case (.success(let successHandler, let context), .fulfilled(let value)):
-            _ = context { successHandler(value) }()
-        case (.failure(let failureHandler, let context), .rejected(let error)):
-            _ = context { failureHandler(error) }()
-        case (.finally(let finalHandler, let context), _) where !self.state.isPending:
-            _ = context { finalHandler() }()
+        switch (handler, state) {
+        case (.success(let successHandler, let queue), .fulfilled(let value)):
+            queue.async { successHandler(value) }
+        case (.failure(let failureHandler, let queue), .rejected(let error)):
+            queue.async { failureHandler(error) }
+        case (.finally(let finalHandler, let queue), _) where !self.state.isPending:
+            queue.async { finalHandler() }
         default: break
         }
     }
     
     fileprivate func deferCompletionHandler(_ handler: FutureCompletionHandler<T>) {
-        self.stateHandlers.append(handler)
+        stateHandlers.append(handler)
     }
     
     @discardableResult
-    open func onSuccess(_ context: @escaping ExecutionContext = defaultExecutionContext, successHandler: @escaping (T) -> Void) -> Future<T> {
-        self.syncQueue.async {
-            let completionHandler = FutureCompletionHandler.success(task: successHandler, context: context)
+    public func onSuccess(on queue: DispatchQueue = DispatchQueue.main,
+                          successHandler: @escaping (T) -> Void) -> Future<T> {
+
+        syncQueue.async {
+            let completionHandler = FutureCompletionHandler.success(task: successHandler, queue: queue)
             switch self.state {
             case .pending:
                 self.deferCompletionHandler(completionHandler)

    }

    @discardableResult
    open func finally(_ context: @escaping ExecutionContext = defaultExecutionContext, handler: @escaping (Void) -> Void) -> Future<T> {
        self.syncQueue.async {
            let completionHandler = FutureCompletionHandler<T>.finally(task: handler, context: context)
            switch self.state {
            case .pending:
                self.deferCompletionHandler(completionHandler)

    }

    @discardableResult
    public func onFailure(on queue: DispatchQueue = DispatchQueue.main,
                          failureHandler: @escaping (Error) -> Void) -> Future<T> {

        self.syncQueue.async {
            let completionHandler = FutureCompletionHandler<T>.failure(task: failureHandler, queue: queue)
            switch self.state {
            case .pending:
                self.deferCompletionHandler(completionHandler)
