 
     // MARK: - Thenable
 
-    public func then<N>(
-        onFulfilled: Optional<(value: V) -> Promise<N>> = nil,
-        onRejected: Optional<(reason: NSError) -> Promise<N>> = nil
-        ) -> Promise<N> {
-            
-            let subPromise = Promise<N>()
-            
+    public func then(
+        onFulfilled: Optional<(value: V) -> Void> = nil,
+        onRejected: Optional<(reason: NSError) -> Void> = nil
+        ) -> Self {
+            
+            let subPromise = self.dynamicType()
+            
+            switch self.state {
+            case .Fulfilled:
+                subPromise.onFulfilled(self.value!)
+            case .Rejected:
+                subPromise.onRejected(self.reason!)
+            default:
+                break
+            }
             
             return subPromise
     }
+    
     /*
     public func then<N, T: Thenable where T.ValueType == N, T.ReasonType == NSError, T.ReturnType == T>(
         onFulfilled: Optional<(value: V) -> T> = nil,

        return subPromise
    }
    
    public func then(
        onFulfilled: Optional<(value: V) -> Void> = nil,
        onRejected: Optional<(reason: NSError) -> Void> = nil
        ) -> Promise<V> {
            return Promise<V>()
    }
}
    // MARK: - Thenable enhance
    
    public func then<N>(
        #onFulfilled: (value: V) -> N,
        onRejected: (reason: NSError) -> N
        ) -> Promise<N>
    {
        let subPromise = Promise<N>()
        
        switch self.state {
        case .Fulfilled:
            subPromise.resolve(value: onFulfilled(value: self.value!))
        case .Rejected:
            subPromise.resolve(value: onRejected(reason: self.reason!))
        default:
            break
        }
