     public func map<U>(accumulate initialValue: U, _ accumulateClosure: (accumulatedValue: U, newValue: T) -> U) -> Signal<U>
     {
         return Signal<U> { progress, fulfill, reject, configure in
+            
             var accumulatedValue: U = initialValue
             
             self.progress { p in

    
    /// map using newValue only & bind to transformed Signal
    /// a.k.a `Rx.flatMap()`
    public func map<U>(transform: T -> Signal<U>) -> Signal<U>
    {
        return Signal<U> { progress, fulfill, reject, configure in
            
            var innerSignal: Signal<U>?
            
            self.progress { (_, progressValue: T) in
                innerSignal = transform(progressValue)
                innerSignal?.progress { (_, progressValue: U) in
                    progress(progressValue)
                }
            }.success { (value: T) -> Void in
                innerSignal = transform(value)
                innerSignal?.progress { (_, progressValue: U) in
                    fulfill(progressValue)
                }
            }
            
            _bind(nil, reject, configure, self)

            
            self.progress { (_, progressValue: T) in
                count++

                if count <= skipCount { return }
                
                progress(progressValue)
            }
            
            _bind(fulfill, reject, configure, self)
