     
     public func whenFailure(callback: @escaping (Error) -> ()) {
         _whenComplete {
-            if case .failure(let e) = self.value {
+            if case .failure(let e) = self.value! {
                 callback(e)
             }
             return CallbackList()
         }
     }
+    
+    public func whenComplete(callback: @escaping (FutureValue<T>) -> ()) {
+        _whenComplete {
+            callback(self.value!)
+            return CallbackList()
+        }
+    }
+
     
     /// Internal:  Set the value and return a list of callbacks that should be invoked as a result.
     fileprivate func _setValue(value: FutureValue<T>) -> CallbackList {
         assert(eventLoop.inEventLoop)
-        switch self.value {
-        case .incomplete:
+        if self.value == nil {
             self.value = value
             self._fullfilled.store(true)
             let callbacks = self.callbacks
             self.callbacks = CallbackList()
             return callbacks
-        default:
-            return CallbackList()
-        }
+        }
+        return CallbackList()
     }
 }
 

            precondition(!eventLoop.inEventLoop, "wait() must not be called when on the EventLoop")
        }
        
        var v: FutureValue <T> = .incomplete
        let lock = ConditionLock(value: 0)
        _whenComplete { () -> CallbackList in
            lock.lock()

    
    public func whenSuccess(callback: @escaping (T) -> ()) {
        _whenComplete {
            if case .success(let t) = self.value! {
                callback(t)
            }
            return CallbackList()
