 public typealias ExecutionContext = (task: Void throws -> Void) -> (Void -> Future<Void>)
 
 
-let defaultExecutionContext: ExecutionContext = { (task: Void throws -> Void) -> (Void -> Future<Void>) in
-    return {
-        let future = Future<Void>()
-        future.resolve { try task() }
-        return future
-    }
-}
+let defaultExecutionContext: ExecutionContext = onMainQueue
 
 private enum FutureCompletionHandler<T> {
     case Success(task: T -> Void, context: ExecutionContext)

        }
    }
    
    private func executeCompletionHandler(handler: FutureCompletionHandler<T>) {
        switch (handler, self.state) {
        case (.Success(let successHandler, let context), .Fulfilled(let value)):

            }
        }
        
        /*
        didSet {
            switch (self.state) {
            case .Rejected(_): fallthrough
            case .Fulfilled(_):
                
            default: break
            }
        }*/
    }
    
    private var stateHandlers: [FutureCompletionHandler<T>] = []
    
    internal init() {
        FutureCounter = FutureCounter &+ 1
        let queueName = "com.futuristics.future-queue\(FutureCounter)"
        self.syncQueue = dispatch_queue_create(queueName, DISPATCH_QUEUE_SERIAL)
    }
    
    internal func fulfill(value: T) {
        guard case .Pending = self.state else { return }
        dispatch_sync(self.syncQueue) { self.state = .Fulfilled(value) }
        dispatch_async(self.syncQueue) {
            self.executeDeferedCompletionHandlers()
        }
    }
    
    internal func reject(error: ErrorType) {
        guard case .Pending = self.state else { return }
        dispatch_sync(self.syncQueue) { self.state = .Rejected(error) }
        dispatch_async(self.syncQueue) {
            self.executeDeferedCompletionHandlers()
        }
    }
    
    internal func resolve(f: Void throws -> T) {
