         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_timer(timer, wallTime(date), UInt64(nsecInterval), UInt64(nsecLeeway))
         
         dispatch_source_set_event_handler(timer) { () -> Void in
             self.execute(action)

        })
        return p.future
    }
    public 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)
    }
    
    public func executeAfterDelay<__Type>(secs : NSTimeInterval,  block: () throws -> __Type) -> Future<__Type> {

        }
        return p.future
    }
    
    
    private func wallTime(date: NSDate, offset_nanosecs: Int64 = 0) -> dispatch_time_t {
        
        let (seconds, frac) = modf(date.timeIntervalSince1970)
        let nsec: Double = frac * Double(NSEC_PER_SEC)
        var walltime = timespec(tv_sec: Int(seconds), tv_nsec: Int(nsec))
        
        return dispatch_walltime(&walltime, offset_nanosecs)
    }
    
    
    internal func _executeAt<C:CompletionType>(date:NSDate, block: () throws -> C) -> Future<C.T> {
        let p = Promise<C.T>()
        let popTime = wallTime(date)
        let q = self.underlyingQueue ?? Executor.defaultQ
        dispatch_after(popTime, q, {
            p.completeWithBlock {
