         }
     }
     
-    private func wallTimeWithDate(date: NSDate) -> 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, 0)
-    }
-
+
+    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
      

        }
        return p.future
    }

    
    internal func _executeAfterDelay<C:CompletionType>(nanosecs n: Int64, block: () throws -> C) -> Future<C.T> {
        let p = Promise<C.T>()
        let popTime = dispatch_time(DISPATCH_TIME_NOW, n)
        let q = self.underlyingQueue ?? Executor.defaultQ
        dispatch_after(popTime, q, {
            p.completeWithBlock {

        })
        return p.future
    }
    
    internal func _executeAfterDelay<C:CompletionType>(secs : NSTimeInterval, block: () throws -> C) -> Future<C.T> {
        let nanosecsDouble = secs * NSTimeInterval(NSEC_PER_SEC)
        let nanosecs = Int64(nanosecsDouble)
        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> {
