      - returns: A new promise, combining this promise and the one returned from `then`.
      */
     public func then<U>(on queue: dispatch_queue_t? = nil, then: (Value) throws -> Promise<U>) -> Promise<U> {
-        let thenPromise = Promise<U> { thenPromise in
+        return Promise<U>(parent: self) { (_, fulfill, reject) in
             success { value in
                 Promise.dispatch(on: queue) {
                     do {
                         let nextPromise = try then(value)
-                        nextPromise.success(thenPromise.fulfill).failure(thenPromise.reject)
+                        nextPromise.success(fulfill).failure(reject)
                     } catch {
-                        thenPromise.reject(error)
+                        reject(error)
                     }
                 }
-            }.failure(thenPromise.reject)
-        }
-        
-        thenPromise.parent = self
-        nonCancelledChildrenCount += 1
-        return thenPromise
+            }.failure(reject)
+        }
     }
     
     /**

    /**
     Adds a success callback to the promise.
     
     This callback will be called once this promise has been fulfilled.
     
     - parameter callback: The callback to call when the promise is fulfilled.
     
     - returns: This promise, allowing to chain multiple callbacks together.
     */
    public func success(callback: SucceededCallback?) -> Self {
        guard callback != nil else {
            return self
        }
        
        switch status {
        case .Fulfilled(let result):
            callback!(result)
            
        case .Rejected:
            break

     */
    public func map<U>(converter: (Value) -> U) -> Promise<U> {
        return then { converter($0) }
    }
    
    /**
     Converts the current promise into an `ActionPromise`.
     
     This is a convenience method that calls the `then` method to convert to an `ActionPromise`.
     
     - returns: The mapped `ActionPromise`.
     */
    public func mapToActionPromise() -> ActionPromise {
        return then { (_) -> Void in }
    }
    
    /**
