     
     /// 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 }
+        var storage: Result!
+        let task = SDTask<Result>(queue: queue, suspend: predicate) { storage }
         return _lck.synchronized {
             if _result == nil {
-                _notify.append(task)
+                _notify.append {
+                    storage = $0
+                    task.signal()
+                }
             } else {
+                storage = _result
                 task.signal()
             }
             return task

    
    /// 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) }
        return _lck.synchronized {
            if _result == nil {
                _notify.append(task)
            } else {
                task.signal()
            }
            return task

    static func createBlock(block: () -> Result, suspend: ((Result) -> Bool)?) -> (SDAtomic) -> Void {
        return { atomic in
            let _self = atomic as! SDTask<Result>
            if let result = _self._result {
                if suspend?(result) != true {
                    _self._notify.forEach { $0(result) }
                }
                _self._notify = []
            } else {
                let result = block()
                _self._lck.synchronized { _self._result = result }
                dispatch_semaphore_signal(_self.sem)
                _self.signal()
            }
        }
    }
