     return v
   }
 
-  public var value: T {
-    if currentState != DeferredState.Completed.rawValue
-    {
-      dispatch_group_wait(group, DISPATCH_TIME_FOREVER)
-    }
-    return v
-  }
-}
-
-
+  public /* private(set) */ var value: T {
+    get {
+      if currentState != DeferredState.Completed.rawValue { dispatch_group_wait(group, DISPATCH_TIME_FOREVER) }
+      return v
+    }
+    set {
+      setValue(newValue, trapOnFailure: true)
+    }
+  }
+}
+
+public func delay(ns: Int) -> Deferred<Void>
+{
+  return Deferred(value: ()).delay(ns)
+}
+
+public func delay(µs µs: Int) -> Deferred<Void>
+{
+  return delay(µs*1000)
+}
+
+public func delay(ms ms: Int) -> Deferred<Void>
+{
+  return delay(ms*1_000_000)
+}
+
+public func delay(seconds s: NSTimeInterval) -> Deferred<Void>
+{
+  return delay(Int(s*1e9))
+}
+
+extension Deferred
+{
+  public func delay(ns: Int) -> Deferred
+  {
+    if ns < 0 { return self }
+
+    let delayed = Deferred<T>()
+    delayed.setState(.Running)
+    let delay = dispatch_time(DISPATCH_TIME_NOW, Int64(ns>0 ? ns:0))
+    dispatch_after(delay, dispatch_get_global_queue(qos_class_self(), 0)) {
+      if self.currentState == DeferredState.Completed.rawValue
+      {
+        delayed.value = self.v
+        return
+      }
+
+      dispatch_group_notify(self.group, dispatch_get_global_queue(qos_class_self(), 0)) {
+        delayed.value = self.v
+      }
+    }
+
+    return delayed
+  }
+
+  public func delay(µs µs: Int) -> Deferred
+  {
+    return delay(µs*1000)
+  }
+
+  public func delay(ms ms: Int) -> Deferred
+  {
+    return delay(ms*1_000_000)
+  }
+
+  public func delay(seconds s: NSTimeInterval) -> Deferred
+  {
+    return delay(Int(s*1e9))
+  }
+}
 
 // MARK: Notify: chain asynchronous tasks with input parameters and no return values.
 

    self.notify(queue) {
      (result: T) -> Void in
      deferred.setState(.Running)
      deferred.setValue(task(result))
    }
    return deferred
  }

    }
  }
  
  private func setValue(result: T, trapOnFailure: Bool = true)
  { // A very simple turnstile to ensure only one thread can succeed
    if setState(.Assigning)
    {
      v = result
      guard setState(.Completed) else { fatalError("Could not complete assignment of result in \(__FUNCTION__)") }
      // The result is now available for the world
    }
    else if trapOnFailure { fatalError("Probable attempt at setting a Deferred value twice with \(__FUNCTION__)") }
  }

  // MARK: public interface
