     
     /// Run `block` after `self` is completed with specific queue.
     public final func then<R>(queue: dispatch_queue_t, _ block: (Result) -> R) -> SDTask<R> {
-        let task = SDTask<R>(queue: queue, suspend: nil) { block(self.result) }
+        var storage: Result!
+        let task = SDTask<R>(queue: queue, suspend: nil) { block(storage) }
         return _lck.synchronized {
             if _result == nil {
-                _notify.append(task)
+                _notify.append {
+                    storage = $0
+                    task.signal()
+                }
             } else {
+                storage = _result
                 task.signal()
             }
             return task

    
    /// Suspend if `result` satisfies `predicate` with specific queue.
    public final func suspend(queue: dispatch_queue_t, _ predicate: (Result) -> Bool) -> SDTask<Result> {
        let task = SDTask<Result>(queue: queue, suspend: predicate) { self.result }
        return _lck.synchronized {
            if _result == nil {
                _notify.append(task)
            } else {
                task.signal()
            }
            return task

    
    private let sem: dispatch_semaphore_t = dispatch_semaphore_create(0)
    
    private var _notify: [(Result) -> Void] = []
    
    private var _lck: SDSpinLock = SDSpinLock()
    private var _result: Result?
