     {
         return Signal<T> { [weak triggerSignal] progress, fulfill, reject, configure in
             
-            let signalName = self.name
-            
-            self.progress { (_, progressValue: T) in
-                progress(progressValue)
-            }
-
-            let triggerSignalName = triggerSignal!.name
-            let cancelError = _RKError(.CancelledByTriggerSignal, "Signal=\(signalName) is cancelled by takeUntil(\(triggerSignalName)).")
-            
-            triggerSignal?.progress { [weak self] (_, progressValue: U) in
-                if let self_ = self {
-                    self_.cancel(error: cancelError)
-                }
-            }.success { [weak self] in
-                if let self_ = self {
-                    self_.cancel(error: cancelError)
-                }
-            }.failure { [weak self] (error: NSError?, isCancelled: Bool) -> Void in
-                if let self_ = self {
-                    self_.cancel(error: cancelError)
-                }
-            }
-            
-            _bind(fulfill, reject, configure, self)
+            if let triggerSignal = triggerSignal {
+
+                self.progress { (_, progressValue: T) in
+                    progress(progressValue)
+                }
+
+                let cancelError = _RKError(.CancelledByTriggerSignal, "Signal=\(self.name) is cancelled by takeUntil(\(triggerSignal.name)).")
+                
+                triggerSignal.progress { [weak self] _ in
+                    if let self_ = self {
+                        self_.cancel(error: cancelError)
+                    }
+                }.then { [weak self] _ -> Void in
+                    if let self_ = self {
+                        self_.cancel(error: cancelError)
+                    }
+                }
+                
+                _bind(fulfill, reject, configure, self)
+            }
+            else {
+                let cancelError = _RKError(.CancelledByTriggerSignal, "Signal=\(self.name) is cancelled by takeUntil() with `triggerSignal` already been deinited.")
+                self.cancel(error: cancelError)
+            }
             
         }.name("\(self.name)-takeUntil")
     }

        
    }
    
    // NOTE: newSignal should capture selfSignal
    configure.pause = { upstreamSignal.pause(); return }
    configure.resume = { upstreamSignal.resume(); return }
    configure.cancel = { upstreamSignal.cancel(); return }

            
            _bind(nil, reject, configure, self)
            
        }.name("\(self.name)-mapAccumulate")
    }
    
    public func take(maxCount: Int) -> Signal
