                 }
             }.success { (value: T) -> Void in
                 innerSignal = transform(value)
-                innerSignal?.progress { [weak innerSignal] (_, progressValue: U) in
+                innerSignal?.progress { (_, progressValue: U) in
                     fulfill(progressValue)
                 }
             }

        }
    }
    
    public func takeUntil<U>(takeUntilSignal: Signal<U>) -> Signal
    {
        return Signal<T>(name: "\(self.name)-takeUntil") { [weak takeUntilSignal] progress, fulfill, reject, configure in
            
            let signalName = self.name
            

                progress(progressValue)
            }

            let triggerSignalName = triggerSignal!.name
            let cancelError = _RKError(.CancelledByTakeUntil, "Signal=\(signalName) is cancelled by takeUntil(\(triggerSignalName)).")
            
            triggerSignal?.progress { [weak self] (_, progressValue: U) in
                if let self_ = self {
                    self_.cancel(error: cancelError)
                }
