         self.lock = Lock()
         self.state = .pending(Deferred(pending: pending))
         
-        resolver(weakifyFulfill(), weakifyReject())
+        resolver(weakify(Promise.fulfill), weakify(Promise.reject))
     }
 
     private init<PendingValue>(pendingPromise: Promise<PendingValue>, _ resolver: (_ resolve: @escaping (Fulfilled<Value>) -> Void, _ reject: @escaping (Error) -> Void) -> Void) {
         self.lock = Lock()
         self.state = .pending(Deferred(pendingPromise: pendingPromise))
         
-        resolver(weakifyResolve(), weakifyReject())
-    }
-    
-    private func weakifyFulfill() -> (Value) -> Void {
-        return { [weak self] (value) in
-            guard let strongSelf = self else { return }
-            
-            strongSelf.fulfill(value)
-        }
+        resolver(weakify(Promise.resolve), weakify(Promise.reject))
     }
     
     private func fulfill(_ value: Value) {

            return self == nil
        }
        
        promise(weakifyFulfill(), weakifyReject(), isCancelled)
    }
    
    public func then<ResultingValue>(on dispatcher: Dispatcher, onFulfilled: @escaping (Value) throws -> Fulfilled<ResultingValue>, onRejected: @escaping (Error) throws -> Fulfilled<ResultingValue>) -> Promise<ResultingValue> {
        return Promise<ResultingValue>(pendingPromise: self) { (resolve, reject) in
            self.onResolve(

            
        default:
            fatalError("Duplicate attempt to resolve promise")
        }
    }
    
