         })
         return p.future
     }
-    public func executeAfterDelay<C:CompletionType>(secs : NSTimeInterval,  block: () throws -> C) -> Future<C.T> {
+    
+    internal func _executeAfterDelay<C:CompletionType>(secs : NSTimeInterval, block: () throws -> C) -> Future<C.T> {
         let nanosecsDouble = secs * NSTimeInterval(NSEC_PER_SEC)
         let nanosecs = Int64(nanosecsDouble)
-        return self._executeAfterDelay(nanosecs: nanosecs,block:block)
+        let p = Promise<C.T>()
+        let popTime = dispatch_time(DISPATCH_TIME_NOW, nanosecs)
+        let q = self.underlyingQueue ?? Executor.defaultQ
+        dispatch_after(popTime, q, {
+            p.completeWithBlock {
+                return try block()
+            }
+        })
+        return p.future
+    }
+    public func executeAfterDelay<C:CompletionType>(secs : NSTimeInterval,  block: () throws -> C) -> Future<C.T> {
+        return self._executeAfterDelay(secs,block:block)
     }
     
     public func executeAfterDelay<__Type>(secs : NSTimeInterval,  block: () throws -> __Type) -> Future<__Type> {

        let nsecLeeway = leeway * Double(NSEC_PER_SEC)
        
        let timer = dispatch_source_create(DISPATCH_SOURCE_TYPE_TIMER, 0, 0, self.relatedQueue)
        dispatch_source_set_timer(timer, wallTimeWithDate(date), UInt64(nsecInterval), UInt64(nsecLeeway))
        
        dispatch_source_set_event_handler(timer) { () -> Void in
            self.execute(action)

        }
    }
    

    public func executeAt<C:CompletionType>(date : NSDate,  block: () throws -> C) -> Future<C.T> {
        return self._executeAt(date,block:block)
    }

    public func executeAt<__Type>(date : NSDate,  block: () throws -> __Type) -> Future<__Type> {
        return self.executeAt(date) { () -> Completion<__Type> in
            return .Success(try block())
        }
    }
    
    /**
     repeatExecution
     
