     func run() -> Result<Disposable> {
         let subscriptionResult: Result<Disposable> = self.parent.source.subscribeSafe(ObserverOf(self))
         
-        if let subscriptionResultError = subscriptionResult.error {
-            return .Error(subscriptionResultError)
-        }
-        
-        let connectResult: Result<Void> = subscriptionResult >>> {
+        return subscriptionResult >>> { Void -> Result<Void> in
             let state = self.parent.state
             
             return self.parent.lock.calculateLocked {

                        self.parent.state.count = 1
                        self.parent.state.connectableSubscription = disposable
                        return SuccessResult
                    }
                }
                else {

                    return SuccessResult
                }
            }
        } >>> {
            return success(AnonymousDisposable {
                (*subscriptionResult).dispose()
                self.parent.lock.performLocked {
                    let state = self.parent.state
                    if state.count == 1 {
                        state.connectableSubscription!.dispose()
                        self.parent.state.count = 0
                        self.parent.state.connectableSubscription = nil
                    }
                    else if state.count > 1 {
                        self.parent.state.count = state.count - 1
                    }
                    else {
                        rxFatalError("Something went wrong with RefCount disposing mechanism")
                    }
                }
            })
        }
    }

    func on(event: Event<Element>) -> Result<Void> {
