             catch let error {
                 if error.userCancelled {
                     if let didCancelClosure = self.didCancelClosure {
-                        callbackQueue.addOperationWithBlock {
+                        dispatchToCallbackQueue {
                             didCancelClosure()
                         }
                     }
                 }
                 else {
                     if let didFinishWithErrorClosure = self.didFinishWithErrorClosure {
-                        callbackQueue.addOperationWithBlock {
+                        dispatchToCallbackQueue {
                             didFinishWithErrorClosure(error)
                         }
                     }

                try await(task)
                
                if let didFinishWithValueClosure = self.didFinishWithValueClosure {
                    callbackQueue.addOperationWithBlock {
                        didFinishWithValueClosure(task.value)
                    }
                }

    private init(queue: NSOperationQueue, callbackQueue: NSOperationQueue, task: Task<V>) {
        self.task = task
        
        // prefer GCD over NSOperationQueue for main thread dispatching
        let callbackQueueIsMainOperationQueue = callbackQueue === _mainOperationQueue
        
        func dispatchToCallbackQueue(closure: () -> Void) {
            if callbackQueueIsMainOperationQueue {
                dispatch_async(_dispatch_serial_queue) {
                    dispatch_sync(_dispatch_main_queue, closure)
                }
            }
            else {
                callbackQueue.addOperationWithBlock(closure)
            }
        }
        
        //
        queue.addOperationWithBlock {
            defer {
                if let didFinishClosure = self.didFinishClosure {
                    dispatchToCallbackQueue {
                        didFinishClosure(task)
                    }
                }
