private let _source: Observable<Element>

    init(source: Observable<Element>, refCount: RefCountDisposable) {

    private let _left: Observable<Element>

    private let _right: Observable<Element>

    init(left: Observable<Element>, right: Observable<Element>) {

    init(left: Observable<Element>, right: Observable<Element>) {

    : Observable<Element>

    private let _source: Observable<Element>

    init(source: Observable<Element>, timeSpan: RxTimeInterval, count: Int, scheduler: SchedulerType) {

    typealias Handler = (ErrorType) throws -> Observable<Element>

    private let _source: Observable<Element>

    init(source: Observable<Element>, handler: Handler) {

    override func subscribeToNext(source: Observable<E>) -> Disposable {

    override func extract(observable: Observable<Element>) -> SequenceGenerator? {

extension Observable {

            -> Observable<E> {

    let _source1: Observable<E1>

    let _source2: Observable<E2>

    init(source1: Observable<E1>, source2: Observable<E2>, resultSelector: ResultSelector) {

    init(source1: Observable<E1>, source2: Observable<E2>, resultSelector: ResultSelector) {

extension Observable {

            -> Observable<E> {

    let _source1: Observable<E1>

    let _source2: Observable<E2>

    let _source3: Observable<E3>

    init(source1: Observable<E1>, source2: Observable<E2>, source3: Observable<E3>, resultSelector: ResultSelector) {

    init(source1: Observable<E1>, source2: Observable<E2>, source3: Observable<E3>, resultSelector: ResultSelector) {

    init(source1: Observable<E1>, source2: Observable<E2>, source3: Observable<E3>, resultSelector: ResultSelector) {

extension Observable {

            -> Observable<E> {

    let _source1: Observable<E1>

    let _source2: Observable<E2>

    let _source3: Observable<E3>

    let _source4: Observable<E4>

    init(source1: Observable<E1>, source2: Observable<E2>, source3: Observable<E3>, source4: Observable<E4>, resultSelector: ResultSelector) {

    init(source1: Observable<E1>, source2: Observable<E2>, source3: Observable<E3>, source4: Observable<E4>, resultSelector: ResultSelector) {

    init(source1: Observable<E1>, source2: Observable<E2>, source3: Observable<E3>, source4: Observable<E4>, resultSelector: ResultSelector) {

    init(source1: Observable<E1>, source2: Observable<E2>, source3: Observable<E3>, source4: Observable<E4>, resultSelector: ResultSelector) {

extension Observable {

            -> Observable<E> {

    let _source1: Observable<E1>

    let _source2: Observable<E2>

    let _source3: Observable<E3>

    let _source4: Observable<E4>

    let _source5: Observable<E5>

    init(source1: Observable<E1>, source2: Observable<E2>, source3: Observable<E3>, source4: Observable<E4>, source5: Observable<E5>, resultSelector: ResultSelector) {

    init(source1: Observable<E1>, source2: Observable<E2>, source3: Observable<E3>, source4: Observable<E4>, source5: Observable<E5>, resultSelector: ResultSelector) {

    init(source1: Observable<E1>, source2: Observable<E2>, source3: Observable<E3>, source4: Observable<E4>, source5: Observable<E5>, resultSelector: ResultSelector) {

    init(source1: Observable<E1>, source2: Observable<E2>, source3: Observable<E3>, source4: Observable<E4>, source5: Observable<E5>, resultSelector: ResultSelector) {

    init(source1: Observable<E1>, source2: Observable<E2>, source3: Observable<E3>, source4: Observable<E4>, source5: Observable<E5>, resultSelector: ResultSelector) {

extension Observable {

            -> Observable<E> {

    let _source1: Observable<E1>

    let _source2: Observable<E2>

    let _source3: Observable<E3>

    let _source4: Observable<E4>

    let _source5: Observable<E5>

    let _source6: Observable<E6>

    init(source1: Observable<E1>, source2: Observable<E2>, source3: Observable<E3>, source4: Observable<E4>, source5: Observable<E5>, source6: Observable<E6>, resultSelector: ResultSelector) {

    init(source1: Observable<E1>, source2: Observable<E2>, source3: Observable<E3>, source4: Observable<E4>, source5: Observable<E5>, source6: Observable<E6>, resultSelector: ResultSelector) {

    init(source1: Observable<E1>, source2: Observable<E2>, source3: Observable<E3>, source4: Observable<E4>, source5: Observable<E5>, source6: Observable<E6>, resultSelector: ResultSelector) {

    init(source1: Observable<E1>, source2: Observable<E2>, source3: Observable<E3>, source4: Observable<E4>, source5: Observable<E5>, source6: Observable<E6>, resultSelector: ResultSelector) {

    init(source1: Observable<E1>, source2: Observable<E2>, source3: Observable<E3>, source4: Observable<E4>, source5: Observable<E5>, source6: Observable<E6>, resultSelector: ResultSelector) {

    init(source1: Observable<E1>, source2: Observable<E2>, source3: Observable<E3>, source4: Observable<E4>, source5: Observable<E5>, source6: Observable<E6>, resultSelector: ResultSelector) {

extension Observable {

            -> Observable<E> {

    let _source1: Observable<E1>

    let _source2: Observable<E2>

    let _source3: Observable<E3>

    let _source4: Observable<E4>

    let _source5: Observable<E5>

    let _source6: Observable<E6>

    let _source7: Observable<E7>

    init(source1: Observable<E1>, source2: Observable<E2>, source3: Observable<E3>, source4: Observable<E4>, source5: Observable<E5>, source6: Observable<E6>, source7: Observable<E7>, resultSelector: ResultSelector) {

    init(source1: Observable<E1>, source2: Observable<E2>, source3: Observable<E3>, source4: Observable<E4>, source5: Observable<E5>, source6: Observable<E6>, source7: Observable<E7>, resultSelector: ResultSelector) {

    init(source1: Observable<E1>, source2: Observable<E2>, source3: Observable<E3>, source4: Observable<E4>, source5: Observable<E5>, source6: Observable<E6>, source7: Observable<E7>, resultSelector: ResultSelector) {

    init(source1: Observable<E1>, source2: Observable<E2>, source3: Observable<E3>, source4: Observable<E4>, source5: Observable<E5>, source6: Observable<E6>, source7: Observable<E7>, resultSelector: ResultSelector) {

    init(source1: Observable<E1>, source2: Observable<E2>, source3: Observable<E3>, source4: Observable<E4>, source5: Observable<E5>, source6: Observable<E6>, source7: Observable<E7>, resultSelector: ResultSelector) {

    init(source1: Observable<E1>, source2: Observable<E2>, source3: Observable<E3>, source4: Observable<E4>, source5: Observable<E5>, source6: Observable<E6>, source7: Observable<E7>, resultSelector: ResultSelector) {

    init(source1: Observable<E1>, source2: Observable<E2>, source3: Observable<E3>, source4: Observable<E4>, source5: Observable<E5>, source6: Observable<E6>, source7: Observable<E7>, resultSelector: ResultSelector) {

extension Observable {

            -> Observable<E> {

    let _source1: Observable<E1>

    let _source2: Observable<E2>

    let _source3: Observable<E3>

    let _source4: Observable<E4>

    let _source5: Observable<E5>

    let _source6: Observable<E6>

    let _source7: Observable<E7>

    let _source8: Observable<E8>

    init(source1: Observable<E1>, source2: Observable<E2>, source3: Observable<E3>, source4: Observable<E4>, source5: Observable<E5>, source6: Observable<E6>, source7: Observable<E7>, source8: Observable<E8>, resultSelector: ResultSelector) {

    init(source1: Observable<E1>, source2: Observable<E2>, source3: Observable<E3>, source4: Observable<E4>, source5: Observable<E5>, source6: Observable<E6>, source7: Observable<E7>, source8: Observable<E8>, resultSelector: ResultSelector) {

    init(source1: Observable<E1>, source2: Observable<E2>, source3: Observable<E3>, source4: Observable<E4>, source5: Observable<E5>, source6: Observable<E6>, source7: Observable<E7>, source8: Observable<E8>, resultSelector: ResultSelector) {

    init(source1: Observable<E1>, source2: Observable<E2>, source3: Observable<E3>, source4: Observable<E4>, source5: Observable<E5>, source6: Observable<E6>, source7: Observable<E7>, source8: Observable<E8>, resultSelector: ResultSelector) {

    init(source1: Observable<E1>, source2: Observable<E2>, source3: Observable<E3>, source4: Observable<E4>, source5: Observable<E5>, source6: Observable<E6>, source7: Observable<E7>, source8: Observable<E8>, resultSelector: ResultSelector) {

    init(source1: Observable<E1>, source2: Observable<E2>, source3: Observable<E3>, source4: Observable<E4>, source5: Observable<E5>, source6: Observable<E6>, source7: Observable<E7>, source8: Observable<E8>, resultSelector: ResultSelector) {

    init(source1: Observable<E1>, source2: Observable<E2>, source3: Observable<E3>, source4: Observable<E4>, source5: Observable<E5>, source6: Observable<E6>, source7: Observable<E7>, source8: Observable<E8>, resultSelector: ResultSelector) {

    init(source1: Observable<E1>, source2: Observable<E2>, source3: Observable<E3>, source4: Observable<E4>, source5: Observable<E5>, source6: Observable<E6>, source7: Observable<E7>, source8: Observable<E8>, resultSelector: ResultSelector) {

    override func subscribeToNext(source: Observable<E>) -> Disposable {

    override func extract(observable: Observable<E>) -> SequenceGenerator? {

    : Observable<Element>

    private let _source: Observable<S.SubjectObserverType.E>

    init(source: Observable<S.SubjectObserverType.E>, subject: S) {

    private let _source: Observable<Element>

    init(source: Observable<Element>, identifier: String?, file: String, line: UInt, function: String) {

    private let _source: Observable<Element>

    init(source: Observable<Element>, dueTime: RxTimeInterval, scheduler: SchedulerType) {

    private let _source: Observable<Element>

    init(source: Observable<Element>, selector: KeySelector, comparer: EqualityComparer) {

    private let _source: Observable<Element>

    init(source: Observable<Element>, eventHandler: EventHandler) {

    let _source: Observable<SourceType>

    init(source: Observable<SourceType>, index: Int, throwOnEmpty: Bool) {

    private let _source: Observable<Element>

    init(source: Observable<Element>, predicate: Predicate) {

    private let _source: Observable<SourceType>

    init(source: Observable<SourceType>, selector: Selector) {

    private let _source: Observable<SourceType>

    init(source: Observable<SourceType>, selector: Selector) {

    override func composeMap<R>(selector: ResultType throws -> R) -> Observable<R> {

    func run(source: Observable<S>) -> Disposable {

    private let _source: Observable<S>

    init(source: Observable<S>, maxConcurrent: Int) {

    func subscribeInner(source: Observable<O.E>) {

    func run(source: Observable<SourceType>) -> Disposable {

    private let _source: Observable<SourceType>

    init(source: Observable<SourceType>, selector: Selector) {

    private let _source: Observable<SourceType>

    init(source: Observable<SourceType>, selector: Selector) {

    private let _source: Observable<SourceType>

    init(source: Observable<SourceType>, selector: Selector) {

    private let _source: Observable<S>

    init(source: Observable<S>) {

    typealias SelectorType = (Observable<S.E>) throws -> Observable<R>

    typealias SelectorType = (Observable<S.E>) throws -> Observable<R>

    private let _source: Observable<S.SubjectObserverType.E>

    init(source: Observable<S.SubjectObserverType.E>, subjectSelector: SubjectSelectorType, selector: SelectorType) {

        -> Observable<R> {

        -> Observable<A> {

        -> Observable<[E]> {

    public func multicast<S: SubjectType, R where S.SubjectObserverType.E == E>(subjectSelector: () throws -> S, selector: (Observable<S.E>) throws -> Observable<R>)

    public func multicast<S: SubjectType, R where S.SubjectObserverType.E == E>(subjectSelector: () throws -> S, selector: (Observable<S.E>) throws -> Observable<R>)

        -> Observable<R> {

    public func refCount() -> Observable<E> {

    public func share() -> Observable<E> {

        -> Observable<E> {

        -> Observable<E> {

        -> Observable<E> {

        -> Observable<E> {

extension Observable {

    public static func create(subscribe: (AnyObserver<E>) -> Disposable) -> Observable<E> {

    public static func empty() -> Observable<E> {

    public static func never() -> Observable<E> {

    public static func just(element: E) -> Observable<E> {

    public static func just(element: E, scheduler: ImmediateSchedulerType) -> Observable<E> {

    public static func error(error: ErrorType) -> Observable<E> {

    public static func of(elements: E ..., scheduler: ImmediateSchedulerType? = nil) -> Observable<E> {

    public static func deferred(observableFactory: () throws -> Observable<E>)

        -> Observable<E> {

    public static func generate(initialState initialState: E, condition: E throws -> Bool, scheduler: ImmediateSchedulerType = CurrentThreadScheduler.instance, iterate: E throws -> E) -> Observable<E> {

    public static func repeatElement(element: E, scheduler: ImmediateSchedulerType = CurrentThreadScheduler.instance) -> Observable<E> {

    public static func using<R: Disposable>(resourceFactory: () throws -> R, observableFactory: R throws -> Observable<E>) -> Observable<E> {

    public static func using<R: Disposable>(resourceFactory: () throws -> R, observableFactory: R throws -> Observable<E>) -> Observable<E> {

extension Observable where Element : SignedIntegerType {

    public static func range(start start: E, count: E, scheduler: ImmediateSchedulerType = CurrentThreadScheduler.instance) -> Observable<E> {

    public func toObservable(scheduler: ImmediateSchedulerType? = nil) -> Observable<Generator.Element> {

    public func toObservable(scheduler: ImmediateSchedulerType? = nil) -> Observable<Generator.Element> {

        -> Observable<E> {

    public func combineLatest<R>(resultSelector: [Generator.Element.E] throws -> R) -> Observable<R> {

    public func zip<R>(resultSelector: [Generator.Element.E] throws -> R) -> Observable<R> {

    public func switchLatest() -> Observable<E.E> {

    public func concat<O: ObservableConvertibleType where O.E == E>(second: O) -> Observable<E> {

        -> Observable<Generator.Element.E> {

        -> Observable<Generator.Element.E> {

    public func concat() -> Observable<E.E> {

    public func merge() -> Observable<E.E> {

        -> Observable<E.E> {

    public func catchError(handler: (ErrorType) throws -> Observable<E>)

        -> Observable<E> {

        -> Observable<E> {

        return Catch(source: asObservable(), handler: { _ in Observable.just(element) })

        -> Observable<Generator.Element.E> {

        -> Observable<E> {

        -> Observable<E> {

        -> Observable<E> {

        -> Observable<Generator.Element.E> {

        return self.reduce(Observable.never()) { a, o in

    public func withLatestFrom<SecondO: ObservableConvertibleType, ResultType>(second: SecondO, resultSelector: (E, SecondO.E) throws -> ResultType) -> Observable<ResultType> {

    public func withLatestFrom<SecondO: ObservableConvertibleType>(second: SecondO) -> Observable<SecondO.E> {

        -> Observable<E> {

        -> Observable<E> {

        -> Observable<E> {

        -> Observable<E> {

        -> Observable<E> {

        -> Observable<E> {

        -> Observable<E> {

        -> Observable<E> {

        -> Observable<E> {

        -> Observable<E> {

    public func retry() -> Observable<E> {

        -> Observable<E> {

    public func retryWhen<TriggerObservable: ObservableType, Error: ErrorType>(notificationHandler: Observable<Error> -> TriggerObservable)

        -> Observable<E> {

    public func retryWhen<TriggerObservable: ObservableType>(notificationHandler: Observable<ErrorType> -> TriggerObservable)

        -> Observable<E> {

        -> Observable<A> {

        -> Observable<E> {

        -> Observable<E> {

        -> Observable<E> {

        -> Observable<E> {

            return Observable.empty()

        -> Observable<E> {

        -> Observable<E> {

    public func skipWhile(predicate: (E) throws -> Bool) -> Observable<E> {

    public func skipWhileWithIndex(predicate: (E, Int) throws -> Bool) -> Observable<E> {

        -> Observable<R> {

        -> Observable<R> {

        -> Observable<O.E> {

        -> Observable<O.E> {

        -> Observable<O.E> {

        -> Observable<O.E> {

        -> Observable<E> {

        -> Observable<E> {

        -> Observable<E> {

        -> Observable<E> {

        -> Observable<E> {

        -> Observable<E> {

extension Observable where Element : SignedIntegerType {

        -> Observable<E> {

extension Observable where Element: SignedIntegerType {

        -> Observable<E> {

        -> Observable<E> {

        -> Observable<E> {

        -> Observable<E> {

        -> Observable<E> {

        -> Observable<[E]> {

        -> Observable<Observable<E>> {

        -> Observable<Observable<E>> {

        -> Observable<E> {

            return Timeout(source: self.asObservable(), dueTime: dueTime, other: Observable.error(RxError.Timeout), scheduler: scheduler)

        -> Observable<E> {

    public func asObservable() -> Observable<E> {

    internal func composeMap<R>(selector: Element throws -> R) -> Observable<R> {

    func asObservable() -> Observable<E>

    public func asObservable() -> Observable<E> {

        return Observable.create(self.subscribe)

    let source: Observable<E>

    init(source: Observable<E>, scheduler: ImmediateSchedulerType) {

    let source: Observable<E>

    init(source: Observable<E>, scheduler: SerialDispatchQueueScheduler) {

class Producer<Element> : Observable<Element> {

    : Observable<Element>

    private let _source: Observable<SourceType>

    init(source: Observable<SourceType>, seed: AccumulateType, accumulator: AccumulatorType, mapResult: ResultSelectorType) {

    : Observable<Element>

    private let _handler: Observable<TriggerObservable.E>

    override func extract(observable: Observable<E>) -> SequenceGenerator? {

    override func subscribeToNext(source: Observable<E>) -> Disposable {

    private let _notificationHandler: Observable<Error> -> TriggerObservable

    init(sources: S, notificationHandler: Observable<Error> -> TriggerObservable) {

    private let _source: Observable<Element>

    private let _sampler: Observable<SampleType>

    init(source: Observable<Element>, sampler: Observable<SampleType>, onlyNew: Bool) {

    init(source: Observable<Element>, sampler: Observable<SampleType>, onlyNew: Bool) {

    private let _source: Observable<Element>

    init(source: Observable<Element>, seed: Accumulate, accumulator: Accumulator) {

    : Observable<Element>

    private let _source: Observable<Element>

    init(source: Observable<Element>) {

    : Observable<Element>

    private let _source: Observable<Element>

    init(source: Observable<Element>) {

    private let _source: Observable<Element>

    init(source: Observable<Element>, predicate: Predicate? = nil) {

    let source: Observable<Element>

    init(source: Observable<Element>, count: Int) {

    let source: Observable<Element>

    init(source: Observable<Element>, duration: RxTimeInterval, scheduler: SchedulerType) {

    private let _source: Observable<Element>

    private let _other: Observable<Other>

    init(source: Observable<Element>, other: Observable<Other>) {

    init(source: Observable<Element>, other: Observable<Other>) {

    private let _source: Observable<Element>

    init(source: Observable<Element>, predicate: Predicate) {

    init(source: Observable<Element>, predicate: PredicateWithIndex) {

    let source: Observable<Element>

    init(source: Observable<Element>, elements: [Element]) {

    func run(source: Observable<SourceType>) -> Disposable {

    private let _source: Observable<S>

    init(source: Observable<S>) {

    private let _source: Observable<SourceType>

    init(source: Observable<SourceType>, selector: Selector) {

    func extract(observable: Observable<E>) -> SequenceGenerator? {

        var next: Observable<E>? = nil

    func subscribeToNext(source: Observable<E>) -> Disposable {

    private let _source: Observable<Element>

    init(source: Observable<Element>, count: Int) {

    private let _source: Observable<Element>

    init(source: Observable<Element>, duration: TimeInterval, scheduler: SchedulerType) {

    private let _source: Observable<Element>

    init(source: Observable<Element>, count: Int) {

    private let _source: Observable<Element>

    private let _other: Observable<Other>

    init(source: Observable<Element>, other: Observable<Other>) {

    init(source: Observable<Element>, other: Observable<Other>) {

    private let _source: Observable<Element>

    init(source: Observable<Element>, predicate: Predicate) {

    init(source: Observable<Element>, predicate: PredicateWithIndex) {

    private let _source: Observable<Element>

    init(source: Observable<Element>, dueTime: RxTimeInterval, scheduler: SchedulerType) {

    private let _source: Observable<Element>

    private let _other: Observable<Element>

    init(source: Observable<Element>, dueTime: RxTimeInterval, other: Observable<Element>, scheduler: SchedulerType) {

    init(source: Observable<Element>, dueTime: RxTimeInterval, other: Observable<Element>, scheduler: SchedulerType) {

    let _source: Observable<SourceType>

    init(source: Observable<SourceType>) {

                Observable.error(error).subscribe(self),

    typealias ObservableFactory = ResourceType throws -> Observable<SourceType>

    public func asObservable() -> Observable<E> {

class WindowTimeCount<Element> : Producer<Observable<Element>> {

    private let _source: Observable<Element>

    init(source: Observable<Element>, timeSpan: RxTimeInterval, count: Int, scheduler: SchedulerType) {

    override func run<O : ObserverType where O.E == Observable<Element>>(observer: O) -> Disposable {

    private let _first: Observable<FirstType>

    private let _second: Observable<SecondType>

    init(first: Observable<FirstType>, second: Observable<SecondType>, resultSelector: ResultSelector) {

    init(first: Observable<FirstType>, second: Observable<SecondType>, resultSelector: ResultSelector) {

extension Observable {

        -> Observable<E> {

    let source1: Observable<E1>

    let source2: Observable<E2>

    init(source1: Observable<E1>, source2: Observable<E2>, resultSelector: ResultSelector) {

    init(source1: Observable<E1>, source2: Observable<E2>, resultSelector: ResultSelector) {

extension Observable {

        -> Observable<E> {

    let source1: Observable<E1>

    let source2: Observable<E2>

    let source3: Observable<E3>

    init(source1: Observable<E1>, source2: Observable<E2>, source3: Observable<E3>, resultSelector: ResultSelector) {

    init(source1: Observable<E1>, source2: Observable<E2>, source3: Observable<E3>, resultSelector: ResultSelector) {

    init(source1: Observable<E1>, source2: Observable<E2>, source3: Observable<E3>, resultSelector: ResultSelector) {

extension Observable {

        -> Observable<E> {

    let source1: Observable<E1>

    let source2: Observable<E2>

    let source3: Observable<E3>

    let source4: Observable<E4>

    init(source1: Observable<E1>, source2: Observable<E2>, source3: Observable<E3>, source4: Observable<E4>, resultSelector: ResultSelector) {

    init(source1: Observable<E1>, source2: Observable<E2>, source3: Observable<E3>, source4: Observable<E4>, resultSelector: ResultSelector) {

    init(source1: Observable<E1>, source2: Observable<E2>, source3: Observable<E3>, source4: Observable<E4>, resultSelector: ResultSelector) {

    init(source1: Observable<E1>, source2: Observable<E2>, source3: Observable<E3>, source4: Observable<E4>, resultSelector: ResultSelector) {

extension Observable {

        -> Observable<E> {

    let source1: Observable<E1>

    let source2: Observable<E2>

    let source3: Observable<E3>

    let source4: Observable<E4>

    let source5: Observable<E5>

    init(source1: Observable<E1>, source2: Observable<E2>, source3: Observable<E3>, source4: Observable<E4>, source5: Observable<E5>, resultSelector: ResultSelector) {

    init(source1: Observable<E1>, source2: Observable<E2>, source3: Observable<E3>, source4: Observable<E4>, source5: Observable<E5>, resultSelector: ResultSelector) {

    init(source1: Observable<E1>, source2: Observable<E2>, source3: Observable<E3>, source4: Observable<E4>, source5: Observable<E5>, resultSelector: ResultSelector) {

    init(source1: Observable<E1>, source2: Observable<E2>, source3: Observable<E3>, source4: Observable<E4>, source5: Observable<E5>, resultSelector: ResultSelector) {

    init(source1: Observable<E1>, source2: Observable<E2>, source3: Observable<E3>, source4: Observable<E4>, source5: Observable<E5>, resultSelector: ResultSelector) {

extension Observable {

        -> Observable<E> {

    let source1: Observable<E1>

    let source2: Observable<E2>

    let source3: Observable<E3>

    let source4: Observable<E4>

    let source5: Observable<E5>

    let source6: Observable<E6>

    init(source1: Observable<E1>, source2: Observable<E2>, source3: Observable<E3>, source4: Observable<E4>, source5: Observable<E5>, source6: Observable<E6>, resultSelector: ResultSelector) {

    init(source1: Observable<E1>, source2: Observable<E2>, source3: Observable<E3>, source4: Observable<E4>, source5: Observable<E5>, source6: Observable<E6>, resultSelector: ResultSelector) {

    init(source1: Observable<E1>, source2: Observable<E2>, source3: Observable<E3>, source4: Observable<E4>, source5: Observable<E5>, source6: Observable<E6>, resultSelector: ResultSelector) {

    init(source1: Observable<E1>, source2: Observable<E2>, source3: Observable<E3>, source4: Observable<E4>, source5: Observable<E5>, source6: Observable<E6>, resultSelector: ResultSelector) {

    init(source1: Observable<E1>, source2: Observable<E2>, source3: Observable<E3>, source4: Observable<E4>, source5: Observable<E5>, source6: Observable<E6>, resultSelector: ResultSelector) {

    init(source1: Observable<E1>, source2: Observable<E2>, source3: Observable<E3>, source4: Observable<E4>, source5: Observable<E5>, source6: Observable<E6>, resultSelector: ResultSelector) {

extension Observable {

        -> Observable<E> {

    let source1: Observable<E1>

    let source2: Observable<E2>

    let source3: Observable<E3>

    let source4: Observable<E4>

    let source5: Observable<E5>

    let source6: Observable<E6>

    let source7: Observable<E7>

    init(source1: Observable<E1>, source2: Observable<E2>, source3: Observable<E3>, source4: Observable<E4>, source5: Observable<E5>, source6: Observable<E6>, source7: Observable<E7>, resultSelector: ResultSelector) {

    init(source1: Observable<E1>, source2: Observable<E2>, source3: Observable<E3>, source4: Observable<E4>, source5: Observable<E5>, source6: Observable<E6>, source7: Observable<E7>, resultSelector: ResultSelector) {

    init(source1: Observable<E1>, source2: Observable<E2>, source3: Observable<E3>, source4: Observable<E4>, source5: Observable<E5>, source6: Observable<E6>, source7: Observable<E7>, resultSelector: ResultSelector) {

    init(source1: Observable<E1>, source2: Observable<E2>, source3: Observable<E3>, source4: Observable<E4>, source5: Observable<E5>, source6: Observable<E6>, source7: Observable<E7>, resultSelector: ResultSelector) {

    init(source1: Observable<E1>, source2: Observable<E2>, source3: Observable<E3>, source4: Observable<E4>, source5: Observable<E5>, source6: Observable<E6>, source7: Observable<E7>, resultSelector: ResultSelector) {

    init(source1: Observable<E1>, source2: Observable<E2>, source3: Observable<E3>, source4: Observable<E4>, source5: Observable<E5>, source6: Observable<E6>, source7: Observable<E7>, resultSelector: ResultSelector) {

    init(source1: Observable<E1>, source2: Observable<E2>, source3: Observable<E3>, source4: Observable<E4>, source5: Observable<E5>, source6: Observable<E6>, source7: Observable<E7>, resultSelector: ResultSelector) {

extension Observable {

        -> Observable<E> {

    let source1: Observable<E1>

    let source2: Observable<E2>

    let source3: Observable<E3>

    let source4: Observable<E4>

    let source5: Observable<E5>

    let source6: Observable<E6>

    let source7: Observable<E7>

    let source8: Observable<E8>

    init(source1: Observable<E1>, source2: Observable<E2>, source3: Observable<E3>, source4: Observable<E4>, source5: Observable<E5>, source6: Observable<E6>, source7: Observable<E7>, source8: Observable<E8>, resultSelector: ResultSelector) {

    init(source1: Observable<E1>, source2: Observable<E2>, source3: Observable<E3>, source4: Observable<E4>, source5: Observable<E5>, source6: Observable<E6>, source7: Observable<E7>, source8: Observable<E8>, resultSelector: ResultSelector) {

    init(source1: Observable<E1>, source2: Observable<E2>, source3: Observable<E3>, source4: Observable<E4>, source5: Observable<E5>, source6: Observable<E6>, source7: Observable<E7>, source8: Observable<E8>, resultSelector: ResultSelector) {

    init(source1: Observable<E1>, source2: Observable<E2>, source3: Observable<E3>, source4: Observable<E4>, source5: Observable<E5>, source6: Observable<E6>, source7: Observable<E7>, source8: Observable<E8>, resultSelector: ResultSelector) {

    init(source1: Observable<E1>, source2: Observable<E2>, source3: Observable<E3>, source4: Observable<E4>, source5: Observable<E5>, source6: Observable<E6>, source7: Observable<E7>, source8: Observable<E8>, resultSelector: ResultSelector) {

    init(source1: Observable<E1>, source2: Observable<E2>, source3: Observable<E3>, source4: Observable<E4>, source5: Observable<E5>, source6: Observable<E6>, source7: Observable<E7>, source8: Observable<E8>, resultSelector: ResultSelector) {

    init(source1: Observable<E1>, source2: Observable<E2>, source3: Observable<E3>, source4: Observable<E4>, source5: Observable<E5>, source6: Observable<E6>, source7: Observable<E7>, source8: Observable<E8>, resultSelector: ResultSelector) {

    init(source1: Observable<E1>, source2: Observable<E2>, source3: Observable<E3>, source4: Observable<E4>, source5: Observable<E5>, source6: Observable<E6>, source7: Observable<E7>, source8: Observable<E8>, resultSelector: ResultSelector) {

    public typealias E = Element

    internal func composeMap<R>(selector: Element throws -> R) -> Observable<R> {

    public func on(event: Event<E>) {

    func _synchronized_on(event: Event<E>) {

    func _synchronized_subscribe<O : ObserverType where O.E == E>(observer: O) -> Disposable {

        (source1: O1, _ source2: O2, resultSelector: (O1.E, O2.E) throws -> E)

            -> Observable<E> {

        (source1: O1, _ source2: O2, _ source3: O3, resultSelector: (O1.E, O2.E, O3.E) throws -> E)

            -> Observable<E> {

        (source1: O1, _ source2: O2, _ source3: O3, _ source4: O4, resultSelector: (O1.E, O2.E, O3.E, O4.E) throws -> E)

            -> Observable<E> {

        (source1: O1, _ source2: O2, _ source3: O3, _ source4: O4, _ source5: O5, resultSelector: (O1.E, O2.E, O3.E, O4.E, O5.E) throws -> E)

            -> Observable<E> {

        (source1: O1, _ source2: O2, _ source3: O3, _ source4: O4, _ source5: O5, _ source6: O6, resultSelector: (O1.E, O2.E, O3.E, O4.E, O5.E, O6.E) throws -> E)

            -> Observable<E> {

        (source1: O1, _ source2: O2, _ source3: O3, _ source4: O4, _ source5: O5, _ source6: O6, _ source7: O7, resultSelector: (O1.E, O2.E, O3.E, O4.E, O5.E, O6.E, O7.E) throws -> E)

            -> Observable<E> {

        (source1: O1, _ source2: O2, _ source3: O3, _ source4: O4, _ source5: O5, _ source6: O6, _ source7: O7, _ source8: O8, resultSelector: (O1.E, O2.E, O3.E, O4.E, O5.E, O6.E, O7.E, O8.E) throws -> E)

            -> Observable<E> {

    private let _resultSelector: S throws -> E

    init(initialState: S, condition: S throws -> Bool, iterate: S throws -> S, resultSelector: S throws -> E, scheduler: ImmediateSchedulerType) {

    override func run<O : ObserverType where O.E == E>(observer: O) -> Disposable {

    override func subscribe<O : ObserverType where O.E == E>(observer: O) -> Disposable {

    public static func create(subscribe: (AnyObserver<E>) -> Disposable) -> Observable<E> {

    public static func create(subscribe: (AnyObserver<E>) -> Disposable) -> Observable<E> {

    public static func empty() -> Observable<E> {

        return Empty<E>()

    public static func never() -> Observable<E> {

    public static func just(element: E) -> Observable<E> {

    public static func just(element: E) -> Observable<E> {

    public static func just(element: E, scheduler: ImmediateSchedulerType) -> Observable<E> {

    public static func just(element: E, scheduler: ImmediateSchedulerType) -> Observable<E> {

    public static func error(error: ErrorType) -> Observable<E> {

    public static func of(elements: E ..., scheduler: ImmediateSchedulerType? = nil) -> Observable<E> {

    public static func of(elements: E ..., scheduler: ImmediateSchedulerType? = nil) -> Observable<E> {

    public static func deferred(observableFactory: () throws -> Observable<E>)

        -> Observable<E> {

    public static func generate(initialState initialState: E, condition: E throws -> Bool, scheduler: ImmediateSchedulerType = CurrentThreadScheduler.instance, iterate: E throws -> E) -> Observable<E> {

    public static func generate(initialState initialState: E, condition: E throws -> Bool, scheduler: ImmediateSchedulerType = CurrentThreadScheduler.instance, iterate: E throws -> E) -> Observable<E> {

    public static func generate(initialState initialState: E, condition: E throws -> Bool, scheduler: ImmediateSchedulerType = CurrentThreadScheduler.instance, iterate: E throws -> E) -> Observable<E> {

    public static func generate(initialState initialState: E, condition: E throws -> Bool, scheduler: ImmediateSchedulerType = CurrentThreadScheduler.instance, iterate: E throws -> E) -> Observable<E> {

    public static func generate(initialState initialState: E, condition: E throws -> Bool, scheduler: ImmediateSchedulerType = CurrentThreadScheduler.instance, iterate: E throws -> E) -> Observable<E> {

    public static func repeatElement(element: E, scheduler: ImmediateSchedulerType = CurrentThreadScheduler.instance) -> Observable<E> {

    public static func repeatElement(element: E, scheduler: ImmediateSchedulerType = CurrentThreadScheduler.instance) -> Observable<E> {

    public static func using<R: Disposable>(resourceFactory: () throws -> R, observableFactory: R throws -> Observable<E>) -> Observable<E> {

    public static func using<R: Disposable>(resourceFactory: () throws -> R, observableFactory: R throws -> Observable<E>) -> Observable<E> {

    public static func range(start start: E, count: E, scheduler: ImmediateSchedulerType = CurrentThreadScheduler.instance) -> Observable<E> {

    public static func range(start start: E, count: E, scheduler: ImmediateSchedulerType = CurrentThreadScheduler.instance) -> Observable<E> {

    public static func range(start start: E, count: E, scheduler: ImmediateSchedulerType = CurrentThreadScheduler.instance) -> Observable<E> {

        return RangeProducer<E>(start: start, count: count, scheduler: scheduler)

        -> Observable<E> {

        -> Observable<E> {

    public func subscribe<O: ObserverType where O.E == E>(observer: O) -> Disposable {

    public func asObservable() -> Observable<E> {

    let source: Observable<E>

    init(source: Observable<E>, scheduler: ImmediateSchedulerType) {

    override func run<O : ObserverType where O.E == E>(observer: O) -> Disposable {

    let source: Observable<E>

    init(source: Observable<E>, scheduler: SerialDispatchQueueScheduler) {

    override func run<O : ObserverType where O.E == E>(observer: O) -> Disposable {

    func _synchronized_on(event: Event<E>) {

    func _synchronized_subscribe<O : ObserverType where O.E == E>(observer: O) -> Disposable {

    private let _start: E

    private let _count: E

    init(start: E, count: E, scheduler: ImmediateSchedulerType) {

    init(start: E, count: E, scheduler: ImmediateSchedulerType) {

    override func run<O : ObserverType where O.E == E>(observer: O) -> Disposable {

    public func on(event: Event<E>) {

    func _synchronized_on(event: Event<E>) {

    func _synchronized_subscribe<O : ObserverType where O.E == E>(observer: O) -> Disposable {

    override func replayBuffer(observer: AnyObserver<E>) {

    private let _elements: [E]

    init(elements: [E], scheduler: ImmediateSchedulerType?) {

    override func subscribe<O : ObserverType where O.E == E>(observer: O) -> Disposable {

    override func subscribe<O : ObserverType where O.E == E>(observer: O) -> Disposable {

    func _synchronized_subscribe<O : ObserverType where O.E == E>(observer: O) -> Disposable {

    func on(event: Event<E>) {

    func _synchronized_on(event: Event<E>) {

    override func subscribe<O : ObserverType where O.E == E>(observer: O) -> Disposable {

    func _synchronized_subscribe<O : ObserverType where O.E == E>(observer: O) -> Disposable {

    func on(event: Event<E>) {

    func _synchronized_on(event: Event<E>) {

    override func run<O : ObserverType where O.E == E>(observer: O) -> Disposable {

        (source1: O1, _ source2: O2, resultSelector: (O1.E, O2.E) throws -> E)

        -> Observable<E> {

        (source1: O1, _ source2: O2, _ source3: O3, resultSelector: (O1.E, O2.E, O3.E) throws -> E)

        -> Observable<E> {

        (source1: O1, _ source2: O2, _ source3: O3, _ source4: O4, resultSelector: (O1.E, O2.E, O3.E, O4.E) throws -> E)

        -> Observable<E> {

        (source1: O1, _ source2: O2, _ source3: O3, _ source4: O4, _ source5: O5, resultSelector: (O1.E, O2.E, O3.E, O4.E, O5.E) throws -> E)

        -> Observable<E> {

        (source1: O1, _ source2: O2, _ source3: O3, _ source4: O4, _ source5: O5, _ source6: O6, resultSelector: (O1.E, O2.E, O3.E, O4.E, O5.E, O6.E) throws -> E)

        -> Observable<E> {

        (source1: O1, _ source2: O2, _ source3: O3, _ source4: O4, _ source5: O5, _ source6: O6, _ source7: O7, resultSelector: (O1.E, O2.E, O3.E, O4.E, O5.E, O6.E, O7.E) throws -> E)

        -> Observable<E> {

        (source1: O1, _ source2: O2, _ source3: O3, _ source4: O4, _ source5: O5, _ source6: O6, _ source7: O7, _ source8: O8, resultSelector: (O1.E, O2.E, O3.E, O4.E, O5.E, O6.E, O7.E, O8.E) throws -> E)

        -> Observable<E> {

        subscription1.disposable = _parent._left.subscribe(sink1)

        subscription2.disposable = _parent._right.subscribe(sink2)

        return StableCompositeDisposable.create(_timerD, _parent._source.subscribe(self))

        d1.disposable = _parent._source.subscribe(self)

                _subscription.disposable = catchSequence.subscribe(observer)

        return source.subscribe(self)

         subscription1.disposable = _parent._source1.subscribe(observer1)

         subscription2.disposable = _parent._source2.subscribe(observer2)

         subscription1.disposable = _parent._source1.subscribe(observer1)

         subscription2.disposable = _parent._source2.subscribe(observer2)

         subscription3.disposable = _parent._source3.subscribe(observer3)

         subscription1.disposable = _parent._source1.subscribe(observer1)

         subscription2.disposable = _parent._source2.subscribe(observer2)

         subscription3.disposable = _parent._source3.subscribe(observer3)

         subscription4.disposable = _parent._source4.subscribe(observer4)

         subscription1.disposable = _parent._source1.subscribe(observer1)

         subscription2.disposable = _parent._source2.subscribe(observer2)

         subscription3.disposable = _parent._source3.subscribe(observer3)

         subscription4.disposable = _parent._source4.subscribe(observer4)

         subscription5.disposable = _parent._source5.subscribe(observer5)

         subscription1.disposable = _parent._source1.subscribe(observer1)

         subscription2.disposable = _parent._source2.subscribe(observer2)

         subscription3.disposable = _parent._source3.subscribe(observer3)

         subscription4.disposable = _parent._source4.subscribe(observer4)

         subscription5.disposable = _parent._source5.subscribe(observer5)

         subscription6.disposable = _parent._source6.subscribe(observer6)

         subscription1.disposable = _parent._source1.subscribe(observer1)

         subscription2.disposable = _parent._source2.subscribe(observer2)

         subscription3.disposable = _parent._source3.subscribe(observer3)

         subscription4.disposable = _parent._source4.subscribe(observer4)

         subscription5.disposable = _parent._source5.subscribe(observer5)

         subscription6.disposable = _parent._source6.subscribe(observer6)

         subscription7.disposable = _parent._source7.subscribe(observer7)

         subscription1.disposable = _parent._source1.subscribe(observer1)

         subscription2.disposable = _parent._source2.subscribe(observer2)

         subscription3.disposable = _parent._source3.subscribe(observer3)

         subscription4.disposable = _parent._source4.subscribe(observer4)

         subscription5.disposable = _parent._source5.subscribe(observer5)

         subscription6.disposable = _parent._source6.subscribe(observer6)

         subscription7.disposable = _parent._source7.subscribe(observer7)

         subscription8.disposable = _parent._source8.subscribe(observer8)

            _subscriptions[j].disposable = source.subscribe(AnyObserver { event in

        return source.subscribe(self)

            let disposable = _source.subscribe(_subject.asObserver())

        sink.disposable = _source.subscribe(sink)

            return self._source.subscribe(sink)

        sink.disposable = _source.subscribe(sink)

        sink.disposable = _source.subscribe(sink)

        sink.disposable = _source.subscribe(sink)

        sink.disposable = _source.subscribe(sink)

        sink.disposable = _source.subscribe(sink)

        let disposable = source.subscribe(self)

            let disposable = innerSource.asObservable().subscribe(observer)

            let subscription = source.subscribe(iter)

        let subscription = source.subscribe(self)

            let subscription = observable.subscribe(self)

        return self.asObservable().subscribe(observer)

        sink._subscription.disposable = source.subscribe(sink)

        sink.subscription.disposable = source.subscribe(sink)

        sink.disposable = _source.subscribe(sink)

        iter.disposable = source.subscribe(iter)

        let triggerSubscription = _handler.subscribe(_notifier.asObserver())

        _sourceSubscription.disposable = _parent._source.subscribe(self)

        let samplerSubscription = _parent._sampler.subscribe(SamplerSink(parent: self))

        sink.disposable = _source.subscribe(sink)

            connection.disposable = self._source.subscribe(self)

            connection.disposable = self._source.subscribe(self)

        sink.disposable = _source.subscribe(sink)

        sink.disposable = source.subscribe(sink)

        let disposeSubscription = parent.source.subscribe(self)

        let sourceSubscription = _parent._source.subscribe(self)

        let otherSubscription = _parent._other.subscribe(otherObserver)

            sink.disposable = _source.subscribe(sink)

            sink.disposable = _source.subscribe(sink)

        return source.subscribe(observer)

        let subscription = source.subscribe(self)

                let disposable = observable.subscribe(observer)

        sink.disposable = _source.subscribe(sink)

        let disposeSubscription = _parent._source.subscribe(self)

        sink.disposable = _source.subscribe(sink)

        let otherSubscription = _parent._other.subscribe(otherObserver)

        let sourceSubscription = _parent._source.subscribe(self)

            sink.disposable = _source.subscribe(sink)

            sink.disposable = _source.subscribe(sink)

        let subscription = _parent._source.subscribe(self)

        sink.disposable = _source.subscribe(sink)

                source.subscribe(self),

                Observable.error(error).subscribe(self),

        sndSubscription.disposable = _parent._second.subscribe(sndO)

        let fstSubscription = _parent._first.subscribe(self)

        subscription1.disposable = _parent.source1.subscribe(observer1)

        subscription2.disposable = _parent.source2.subscribe(observer2)

        subscription1.disposable = _parent.source1.subscribe(observer1)

        subscription2.disposable = _parent.source2.subscribe(observer2)

        subscription3.disposable = _parent.source3.subscribe(observer3)

        subscription1.disposable = _parent.source1.subscribe(observer1)

        subscription2.disposable = _parent.source2.subscribe(observer2)

        subscription3.disposable = _parent.source3.subscribe(observer3)

        subscription4.disposable = _parent.source4.subscribe(observer4)

        subscription1.disposable = _parent.source1.subscribe(observer1)

        subscription2.disposable = _parent.source2.subscribe(observer2)

        subscription3.disposable = _parent.source3.subscribe(observer3)

        subscription4.disposable = _parent.source4.subscribe(observer4)

        subscription5.disposable = _parent.source5.subscribe(observer5)

        subscription1.disposable = _parent.source1.subscribe(observer1)

        subscription2.disposable = _parent.source2.subscribe(observer2)

        subscription3.disposable = _parent.source3.subscribe(observer3)

        subscription4.disposable = _parent.source4.subscribe(observer4)

        subscription5.disposable = _parent.source5.subscribe(observer5)

        subscription6.disposable = _parent.source6.subscribe(observer6)

        subscription1.disposable = _parent.source1.subscribe(observer1)

        subscription2.disposable = _parent.source2.subscribe(observer2)

        subscription3.disposable = _parent.source3.subscribe(observer3)

        subscription4.disposable = _parent.source4.subscribe(observer4)

        subscription5.disposable = _parent.source5.subscribe(observer5)

        subscription6.disposable = _parent.source6.subscribe(observer6)

        subscription7.disposable = _parent.source7.subscribe(observer7)

        subscription1.disposable = _parent.source1.subscribe(observer1)

        subscription2.disposable = _parent.source2.subscribe(observer2)

        subscription3.disposable = _parent.source3.subscribe(observer3)

        subscription4.disposable = _parent.source4.subscribe(observer4)

        subscription5.disposable = _parent.source5.subscribe(observer5)

        subscription6.disposable = _parent.source6.subscribe(observer6)

        subscription7.disposable = _parent.source7.subscribe(observer7)

        subscription8.disposable = _parent.source8.subscribe(observer8)

            _subscriptions[j].disposable = source.subscribe(AnyObserver { event in

        forwardOn(.Next(AddRef(source: _subject, refCount: _refCountDisposable).asObservable()))

        forwardOn(.Next(AddRef(source: _subject, refCount: _refCountDisposable).asObservable()))

        return self.asObservable().composeMap(selector)