fun <First : Any, Second : Any, Third : Any, Res : Any> combine(first: Flowable<First>, second: Flowable<Second>, third: Flowable<Third>, combFunc: (First, Second, Third) -> Res): Flowable<Res>

fun <First : Any, Second : Any, Third : Any, Res : Any> combine(first: Observable<First>, second: Observable<Second>, third: Observable<Third>, combFunc: (First, Second, Third) -> Res): Observable<Res>

fun <First : Any, Second : Any, Third : Any, Fourth : Any, Res : Any> combine(first: Flowable<First>, second: Flowable<Second>, third: Flowable<Third>, fourth: Flowable<Fourth>, combFunc: (First, Second, Third, Fourth) -> Res): Flowable<Res>

fun <First : Any, Second : Any, Third : Any, Fourth : Any, Res : Any> combine(first: Observable<First>, second: Observable<Second>, third: Observable<Third>, fourth: Observable<Fourth>, combFunc: (First, Second, Third, Fourth) -> Res): Observable<Res>

fun <First : Any, Second : Any, Third : Any, Fourth : Any, Fifth : Any, Res : Any> combine(first: Flowable<First>, second: Flowable<Second>, third: Flowable<Third>, fourth: Flowable<Fourth>, fifth: Flowable<Fifth>, combFunc: (First, Second, Third, Fourth, Fifth) -> Res): Flowable<Res>

fun <First : Any, Second : Any, Third : Any, Fourth : Any, Fifth : Any, Res : Any> combine(first: Observable<First>, second: Observable<Second>, third: Observable<Third>, fourth: Observable<Fourth>, fifth: Observable<Fifth>, combFunc: (First, Second, Third, Fourth, Fifth) -> Res): Observable<Res>

fun <First : Any, Second : Any, Third : Any, Fourth : Any, Fifth : Any, Sixth : Any, Res : Any> combine(first: Flowable<First>, second: Flowable<Second>, third: Flowable<Third>, fourth: Flowable<Fourth>, fifth: Flowable<Fifth>, six: Flowable<Sixth>, combFunc: (First, Second, Third, Fourth, Fifth, Sixth) -> Res): Flowable<Res>

fun <First : Any, Second : Any, Third : Any, Fourth : Any, Fifth : Any, Sixth : Any, Res : Any> combine(first: Observable<First>, second: Observable<Second>, third: Observable<Third>, fourth: Observable<Fourth>, fifth: Observable<Fifth>, six: Observable<Sixth>, combFunc: (First, Second, Third, Fourth, Fifth, Sixth) -> Res): Observable<Res>

fun <First : Any, Second : Any, Third : Any, Fourth : Any, Fifth : Any, Sixth : Any, Seventh : Any, Res : Any> combine(first: Flowable<First>, second: Flowable<Second>, third: Flowable<Third>, fourth: Flowable<Fourth>, fifth: Flowable<Fifth>, six: Flowable<Sixth>, seventh: Flowable<Seventh>, combFunc: (First, Second, Third, Fourth, Fifth, Sixth, Seventh) -> Res): Flowable<Res>

fun <First : Any, Second : Any, Third : Any, Fourth : Any, Fifth : Any, Sixth : Any, Seventh : Any, Res : Any> combine(first: Observable<First>, second: Observable<Second>, third: Observable<Third>, fourth: Observable<Fourth>, fifth: Observable<Fifth>, six: Observable<Sixth>, seventh: Observable<Seventh>, combFunc: (First, Second, Third, Fourth, Fifth, Sixth, Seventh) -> Res): Observable<Res>

fun <First : Any, Second : Any, Third : Any, Fourth : Any, Fifth : Any, Sixth : Any, Seventh : Any, Eighth : Any, Res : Any> combine(first: Flowable<First>, second: Flowable<Second>, third: Flowable<Third>, fourth: Flowable<Fourth>, fifth: Flowable<Fifth>, six: Flowable<Sixth>, seventh: Flowable<Seventh>, eighth: Flowable<Eighth>, combFun: (First, Second, Third, Fourth, Fifth, Sixth, Seventh, Eighth) -> Res): Flowable<Res>

fun <First : Any, Second : Any, Third : Any, Fourth : Any, Fifth : Any, Sixth : Any, Seventh : Any, Eighth : Any, Res : Any> combine(first: Observable<First>, second: Observable<Second>, third: Observable<Third>, fourth: Observable<Fourth>, fifth: Observable<Fifth>, six: Observable<Sixth>, seventh: Observable<Seventh>, eighth: Observable<Eighth>, combFun: (First, Second, Third, Fourth, Fifth, Sixth, Seventh, Eighth) -> Res): Observable<Res>

fun <First : Any, Second : Any, Third : Any, Fourth : Any, Fifth : Any, Sixth : Any, Seventh : Any, Eighth : Any, Ninth : Any, Res : Any> combine(first: Flowable<First>, second: Flowable<Second>, third: Flowable<Third>, fourth: Flowable<Fourth>, fifth: Flowable<Fifth>, six: Flowable<Sixth>, seventh: Flowable<Seventh>, eighth: Flowable<Eighth>, ninth: Flowable<Ninth>, combFun: (First, Second, Third, Fourth, Fifth, Sixth, Seventh, Eighth, Ninth) -> Res): Flowable<Res>

fun <First : Any, Second : Any, Third : Any, Fourth : Any, Fifth : Any, Sixth : Any, Seventh : Any, Eighth : Any, Ninth : Any, Res : Any> combine(first: Observable<First>, second: Observable<Second>, third: Observable<Third>, fourth: Observable<Fourth>, fifth: Observable<Fifth>, six: Observable<Sixth>, seventh: Observable<Seventh>, eighth: Observable<Eighth>, ninth: Observable<Ninth>, combFun: (First, Second, Third, Fourth, Fifth, Sixth, Seventh, Eighth, Ninth) -> Res): Observable<Res>

fun <First : Any, Second : Any, Res : Any> combine(first: Flowable<First>, second: Flowable<Second>, combFunc: (First, Second) -> Res): Flowable<Res>

fun <First : Any, Second : Any, Res : Any> combine(first: Observable<First>, second: Observable<Second>, combFunc: (First, Second) -> Res): Observable<Res>

COMBINE

completable

fun completable(block: (CompletableEmitter) -> Unit): Completable

completableOf

fun completableOf(action: () -> Unit): Completable

CompletableSubject

fun CompletableSubject(): CompletableSubject

defer

fun <T : Any> Observable<T>.defer(): Observable<T>

fun <T : Any> Single<T>.defer(): Single<T>

deferredCompletable

fun deferredCompletable(block: () -> Completable): Completable

deferredFlowable

fun <T : Any> deferredFlowable(block: () -> Flowable<T>): Flowable<T>

deferredMaybe

fun <T : Any> deferredMaybe(block: () -> Maybe<T>): Maybe<T>

deferredObservable

fun <T : Any> deferredObservable(block: () -> Observable<T>): Observable<T>

deferredSingle

fun <T : Any> deferredSingle(block: () -> Single<T>): Single<T>

emitErrorOnComplete

fun <T : Any> Completable.emitErrorOnComplete(error: Throwable): Single<T>

Creates a Single that will subscribe to this and always call onError after this completes, regardless of onComplete or onError.

emitFinally

fun <T : Any> Completable.emitFinally(item: T): Single<T>

Creates a Single that will subscribe to this and always call onSuccess after this completes, regardless of onComplete or onError.

emitOnComplete

fun <T : Any> Completable.emitOnComplete(item: T, alternateError: Throwable? = null): Single<T>

Creates a Single that will subscribe to this and emit after this completes.

emptyFlowable

fun <T : Any> emptyFlowable(): Flowable<T>

emptyMaybe

fun <T : Any> emptyMaybe(): Maybe<T>

emptyObservable

fun <T : Any> emptyObservable(): Observable<T>

filterNotifications

inline fun <T : Any> Observable<T>.filterNotifications(crossinline predicate: (Notification<T>) -> Boolean): Observable<T>

Function to peek emissions and possibly filter them out based on a given predicate.

flatMapIf

fun <T : Any> Single<T>.flatMapIf(predicate: Boolean, mapper: (T) -> Single<T>): Single<T>

Chains a flapMap to this if predicate is true, applying mapper to the item emitted by the source Single.

flowable

fun <T : Any> flowable(backPressureStrategy: BackpressureStrategy = BackpressureStrategy.LATEST, block: (FlowableEmitter<T>) -> Unit): Flowable<T>

flowableFrom

fun <T : Any> flowableFrom(block: () -> T): Flowable<T>

flowableOf

fun <T : Any> flowableOf(item: T): Flowable<T>

fun <T : Any> flowableOf(vararg items: T): Flowable<T>

@JvmName(name = "flowableOfArray")

fun <T : Any> flowableOf(items: Array<T>): Flowable<T>

fun flowableOf(items: BooleanArray): Flowable<Boolean>

fun flowableOf(items: ByteArray): Flowable<Byte>

fun flowableOf(items: CharArray): Flowable<Char>

fun flowableOf(items: DoubleArray): Flowable<Double>

fun flowableOf(items: FloatArray): Flowable<Float>

fun flowableOf(items: IntArray): Flowable<Int>

fun flowableOf(items: LongArray): Flowable<Long>

fun flowableOf(items: ShortArray): Flowable<Short>

fun <T : Any> flowableOf(items: Iterable<T>): Flowable<T>

ifCompletes

fun Completable.ifCompletes(chainableCompletableInvocation: () -> Completable): Completable

Creates a Completable that will subscribe to this and once onComplete is called then subscribe will be called on chainableCompletableInvocation. The new completable will emit the values emitted by chainableCompletableInvocation.

ifNotDisposed

inline fun CompletableEmitter.ifNotDisposed(body: CompletableEmitter.() -> Unit)

inline fun <T : Any> MaybeEmitter<T>.ifNotDisposed(body: MaybeEmitter<T>.() -> Unit)

inline fun <T : Any> ObservableEmitter<T>.ifNotDisposed(body: ObservableEmitter<T>.() -> Unit)

inline fun <T : Any> SingleEmitter<T>.ifNotDisposed(body: SingleEmitter<T>.() -> Unit)

Checks if this is already disposed before invoking body.

intervalRequest

inline fun <T : Any> Flowable<T>.intervalRequest(duration: Long): Flowable<T>

inline fun <T : Any> Observable<T>.intervalRequest(duration: Long): Observable<T>

joinToString

fun <T : Any> Observable<T>.joinToString(separator: String? = null, prefix: String? = null, postfix: String? = null): Single<String>

makeDBCall

fun Completable?.makeDBCall(compositeDisposable: CompositeDisposable, onThrow: (error: Throwable) -> Unit = { _ -> }, onComplete: () -> Unit = {})

makeDBCallCompletable

fun CompositeDisposable.makeDBCallCompletable(onComplete: () -> Unit = {}, onThrow: (error: Throwable) -> Unit = { _ -> }, function: () -> Completable?)

mapSelf

fun <T : Any, R : Any> Flowable<T>.mapSelf(mapper: T.() -> R): @NonNull Flowable<R>

fun <T, R : Any> Maybe<T>.mapSelf(mapper: T.() -> R): @NonNull Maybe<R>

fun <T : Any, R : Any> Observable<T>.mapSelf(mapper: T.() -> R): @NonNull Observable<R>

mapToList

fun <T, R> Flowable<List<T>>.mapToList(mapper: (T) -> R): Flowable<List<R>>

fun <T, R> Observable<List<T>>.mapToList(mapper: (T) -> R): Observable<List<R>>

fun <T : Any, R : Any> Single<List<T>>.mapToList(mapper: (T) -> R): Single<List<R>>

maybe

fun <T : Any> maybe(block: (MaybeEmitter<T>) -> Unit): Maybe<T>

maybeFrom

fun <T> maybeFrom(block: () -> T): Maybe<T & Any>

maybeOf

fun <T : Any> maybeOf(item: T?): Maybe<T>

MaybeSubject

fun <T> MaybeSubject(): MaybeSubject<T>

observable

fun <T : Any> observable(block: (ObservableEmitter<T>) -> Unit): Observable<T>

observableFrom

fun <T : Any> observableFrom(block: () -> T): Observable<T>

observableOf

fun <T : Any> observableOf(item: T): Observable<T>

fun <T : Any> observableOf(vararg items: T): Observable<T>

@JvmName(name = "observableOfArray")

fun <T : Any> observableOf(items: Array<T>): Observable<T>

fun observableOf(items: BooleanArray): Observable<Boolean>

fun observableOf(items: ByteArray): Observable<Byte>

fun observableOf(items: CharArray): Observable<Char>

fun observableOf(items: DoubleArray): Observable<Double>

fun observableOf(items: FloatArray): Observable<Float>

fun observableOf(items: IntArray): Observable<Int>

fun observableOf(items: LongArray): Observable<Long>

fun observableOf(items: ShortArray): Observable<Short>

fun <T : Any> observableOf(items: Iterable<T>): Observable<T>

PublishSubject

fun <T> PublishSubject(): PublishSubject<T>

ReplaySubject

fun <T> ReplaySubject(): ReplaySubject<T>

runSafeOnIO

fun Completable.runSafeOnIO(subscribeOn: Scheduler = newThreadScheduler): Completable

fun <T : Any> Flowable<T>.runSafeOnIO(subscribeOn: Scheduler = newThreadScheduler): Flowable<T>

fun <T : Any> Maybe<T>.runSafeOnIO(subscribeOn: Scheduler = newThreadScheduler): Maybe<T>

fun <T : Any> Observable<T>.runSafeOnIO(subscribeOn: Scheduler = newThreadScheduler): Observable<T>

fun <T : Any> Single<T>.runSafeOnIO(subscribeOn: Scheduler = newThreadScheduler): Single<T>

runSafeOnMain

fun Completable.runSafeOnMain(subscribeOn: Scheduler = newThreadScheduler): Completable

fun <T : Any> Flowable<T>.runSafeOnMain(subscribeOn: Scheduler = newThreadScheduler): Flowable<T>

fun <T : Any> Maybe<T>.runSafeOnMain(subscribeOn: Scheduler = newThreadScheduler): Maybe<T>

fun <T : Any> Single<T>.runSafeOnMain(subscribeOn: Scheduler = newThreadScheduler): Single<T>

fun <T : Any> Observable<T>.runSafeOnMain(subscribeOn: Scheduler = newThreadScheduler): Observable<T>

observe on main thread subscribe on new thread unsubsidised on error and on complete and removes the need to handle it afterwards

rxTimer

fun rxTimer(oldTimer: Disposable?, time: Long, unit: TimeUnit = TimeUnit.MILLISECONDS, thread: Scheduler = Schedulers.computation(), observerThread: Scheduler = mainThreadScheduler, action: (Long) -> Unit): Disposable?

safe

fun <T : Any> Flowable<T>?.safe(factory: () -> T? = null): Flowable<T>

fun <T : Any> Maybe<T>?.safe(factory: () -> T? = null): Maybe<T>

fun <T : Any> Observable<T>?.safe(factory: () -> T? = null): Observable<T>

safeDispose

fun Disposable?.safeDispose()

Safely dispose = if not null and not already disposed

single

fun <T : Any> single(block: (SingleEmitter<T>) -> Unit): Single<T>

singleFrom

fun <T : Any> singleFrom(block: () -> T): Single<T>

singleOf

fun <T : Any> singleOf(item: T): Single<T>

SingleSubject

fun <T> SingleSubject(): SingleSubject<T>

subscribeIgnoringResult

fun Completable.subscribeIgnoringResult()

Calls subscribe on this, with an empty function for both onComplete and onError.

fun <T : Any> Observable<T>.subscribeIgnoringResult()

Calls subscribe on this, with an empty function for onNext and onError

fun <T : Any> Single<T>.subscribeIgnoringResult()

Calls subscribe on this, with an empty function for both onSuccess and onError.

subscribeSafely

fun <T : Any> Observable<T>?.subscribeSafely(): @NonNull Disposable?

fun <T : Any> Observable<T>?.subscribeSafely(consumer: Consumer<T>): @NonNull Disposable?

toBitmap

fun ByteArray.toBitmap(): Single<Bitmap>

toByteArray

fun Bitmap.toByteArray(compressFormat: Bitmap.CompressFormat, quality: Int): Single<ByteArray>?

toCompletable

fun () -> Throwable.toCompletable(): Completable

fun Throwable.toCompletable(): Completable

toFlowable

fun <T : Any> T.toFlowable(): Flowable<T>

fun <T : Any> () -> Throwable.toFlowable(): Flowable<T>

fun <T : Any> Throwable.toFlowable(): Flowable<T>

toFlowableBuffer

fun <T : Any> Maybe<T>.toFlowableBuffer(): Flowable<T>

fun <T : Any> Observable<T>.toFlowableBuffer(): Flowable<T>

fun <T : Any> Single<T>.toFlowableBuffer(): Flowable<T>

toFlowableDrop

fun <T : Any> Maybe<T>.toFlowableDrop(): Flowable<T>

fun <T : Any> Observable<T>.toFlowableDrop(): Flowable<T>

fun <T : Any> Single<T>.toFlowableDrop(): Flowable<T>

toFlowableError

fun <T : Any> Maybe<T>.toFlowableError(): Flowable<T>

fun <T : Any> Observable<T>.toFlowableError(): Flowable<T>

fun <T : Any> Single<T>.toFlowableError(): Flowable<T>

toFlowableLatest

fun <T : Any> Maybe<T>.toFlowableLatest(): Flowable<T>

fun <T : Any> Observable<T>.toFlowableLatest(): Flowable<T>

fun <T : Any> Single<T>.toFlowableLatest(): Flowable<T>

toFlowableMissing

fun <T : Any> Maybe<T>.toFlowableMissing(): Flowable<T>

fun <T : Any> Observable<T>.toFlowableMissing(): Flowable<T>

fun <T : Any> Single<T>.toFlowableMissing(): Flowable<T>

toMaybe

fun <T : Any> T?.toMaybe(): Maybe<T>

fun <T : Any> Callable<T>.toMaybe(): Maybe<T>

fun <T : Any> Future<T>.toMaybe(): Maybe<T>

fun <T : Any> () -> T.toMaybe(): Maybe<T>

@JvmName(name = "toMaybeFromThrowable")

fun <T : Any> () -> Throwable.toMaybe(): Maybe<T>

fun <T : Any> Throwable.toMaybe(): Maybe<T>

toObservable

fun <T : Any> T.toObservable(): Observable<T>

fun <T : Any> () -> Throwable.toObservable(): Observable<T>

fun <T : Any> Throwable.toObservable(): Observable<T>

toSingle

fun <T : Any> T.toSingle(): Single<T>

fun <T : Any> Callable<T>.toSingle(): Single<T>

fun <T : Any> Future<T>.toSingle(): Single<T>

fun <T : Any> () -> T.toSingle(): Single<T>

@JvmName(name = "toSingleFromThrowable")

fun <T : Any> () -> Throwable.toSingle(): Single<T>

fun <T : Any> Throwable.toSingle(): Single<T>

fun <T : Any> Completable.toSingle(item: () -> T): @NonNull Single<T>

UnicastSubject

fun <T> UnicastSubject(): UnicastSubject<T>

unsubscribe

fun Disposable?.unsubscribe()

withIndex

fun <T : Any> Observable<T>.withIndex(): Observable<IndexedValue<T>>

zip

fun <First : Any, Second : Any> zip(first: Flowable<First>, second: Flowable<Second>): Flowable<Pair<First, Second>>

fun <First : Any, Second : Any> zip(first: Observable<First>, second: Observable<Second>): Observable<Pair<First, Second>>

fun <First : Any, Second : Any, Third : Any> zip(first: Flowable<First>, second: Flowable<Second>, third: Flowable<Third>): Flowable<Triple<First, Second, Third>>

fun <First : Any, Second : Any, Res : Any> zip(first: Flowable<First>, second: Flowable<Second>, zipFun: (First, Second) -> Res): Flowable<Res>

fun <First : Any, Second : Any, Third : Any> zip(first: Observable<First>, second: Observable<Second>, third: Observable<Third>): Observable<Triple<First, Second, Third>>

fun <First : Any, Second : Any, Res : Any> zip(first: Observable<First>, second: Observable<Second>, zipFun: (First, Second) -> Res): Observable<Res>

fun <First : Any, Second : Any, Third : Any, Res : Any> zip(first: Flowable<First>, second: Flowable<Second>, third: Flowable<Third>, zipFun: (First, Second, Third) -> Res): Flowable<Res>

fun <First : Any, Second : Any, Third : Any, Res : Any> zip(first: Observable<First>, second: Observable<Second>, third: Observable<Third>, zipFun: (First, Second, Third) -> Res): Observable<Res>

fun <First : Any, Second : Any, Third : Any, Fourth : Any, Res : Any> zip(first: Flowable<First>, second: Flowable<Second>, third: Flowable<Third>, fourth: Flowable<Fourth>, zipFun: (First, Second, Third, Fourth) -> Res): Flowable<Res>

fun <First : Any, Second : Any, Third : Any, Fourth : Any, Res : Any> zip(first: Observable<First>, second: Observable<Second>, third: Observable<Third>, fourth: Observable<Fourth>, zipFun: (First, Second, Third, Fourth) -> Res): Observable<Res>

fun <First : Any, Second : Any, Third : Any, Fourth : Any, Fifth : Any, Res : Any> zip(first: Flowable<First>, second: Flowable<Second>, third: Flowable<Third>, fourth: Flowable<Fourth>, fifth: Flowable<Fifth>, zipFun: (First, Second, Third, Fourth, Fifth) -> Res): Flowable<Res>

fun <First : Any, Second : Any, Third : Any, Fourth : Any, Fifth : Any, Res : Any> zip(first: Observable<First>, second: Observable<Second>, third: Observable<Third>, fourth: Observable<Fourth>, fifth: Observable<Fifth>, zipFun: (First, Second, Third, Fourth, Fifth) -> Res): Observable<Res>

fun <First : Any, Second : Any, Third : Any, Fourth : Any, Fifth : Any, Sixth : Any, Res : Any> zip(first: Flowable<First>, second: Flowable<Second>, third: Flowable<Third>, fourth: Flowable<Fourth>, fifth: Flowable<Fifth>, sixth: Flowable<Sixth>, zipFun: (First, Second, Third, Fourth, Fifth, Sixth) -> Res): Flowable<Res>

fun <First : Any, Second : Any, Third : Any, Fourth : Any, Fifth : Any, Sixth : Any, Res : Any> zip(first: Observable<First>, second: Observable<Second>, third: Observable<Third>, fourth: Observable<Fourth>, fifth: Observable<Fifth>, sixth: Observable<Sixth>, zipFun: (First, Second, Third, Fourth, Fifth, Sixth) -> Res): Observable<Res>

fun <First : Any, Second : Any, Third : Any, Fourth : Any, Fifth : Any, Sixth : Any, Seventh : Any, Res : Any> zip(first: Flowable<First>, second: Flowable<Second>, third: Flowable<Third>, fourth: Flowable<Fourth>, fifth: Flowable<Fifth>, sixth: Flowable<Sixth>, seventh: Flowable<Seventh>, zipFun: (First, Second, Third, Fourth, Fifth, Sixth, Seventh) -> Res): Flowable<Res>

fun <First : Any, Second : Any, Third : Any, Fourth : Any, Fifth : Any, Sixth : Any, Seventh : Any, Res : Any> zip(first: Observable<First>, second: Observable<Second>, third: Observable<Third>, fourth: Observable<Fourth>, fifth: Observable<Fifth>, sixth: Observable<Sixth>, seventh: Observable<Seventh>, zipFun: (First, Second, Third, Fourth, Fifth, Sixth, Seventh) -> Res): Observable<Res>

fun <First : Any, Second : Any, Third : Any, Fourth : Any, Fifth : Any, Sixth : Any, Seventh : Any, Eight : Any, Res : Any> zip(first: Flowable<First>, second: Flowable<Second>, third: Flowable<Third>, fourth: Flowable<Fourth>, fifth: Flowable<Fifth>, sixth: Flowable<Sixth>, seventh: Flowable<Seventh>, eight: Flowable<Eight>, zipFun: (First, Second, Third, Fourth, Fifth, Sixth, Seventh, Eight) -> Res): Flowable<Res>

fun <First : Any, Second : Any, Third : Any, Fourth : Any, Fifth : Any, Sixth : Any, Seventh : Any, Eight : Any, Res : Any> zip(first: Observable<First>, second: Observable<Second>, third: Observable<Third>, fourth: Observable<Fourth>, fifth: Observable<Fifth>, sixth: Observable<Sixth>, seventh: Observable<Seventh>, eight: Observable<Eight>, zipFun: (First, Second, Third, Fourth, Fifth, Sixth, Seventh, Eight) -> Res): Observable<Res>

fun <First : Any, Second : Any, Third : Any, Fourth : Any, Fifth : Any, Sixth : Any, Seventh : Any, Eight : Any, Ninth : Any, Res : Any> zip(first: Flowable<First>, second: Flowable<Second>, third: Flowable<Third>, fourth: Flowable<Fourth>, fifth: Flowable<Fifth>, sixth: Flowable<Sixth>, seventh: Flowable<Seventh>, eight: Flowable<Eight>, ninth: Flowable<Ninth>, zipFun: (First, Second, Third, Fourth, Fifth, Sixth, Seventh, Eight, Ninth) -> Res): Flowable<Res>

fun <First : Any, Second : Any, Third : Any, Fourth : Any, Fifth : Any, Sixth : Any, Seventh : Any, Eight : Any, Ninth : Any, Res : Any> zip(first: Observable<First>, second: Observable<Second>, third: Observable<Third>, fourth: Observable<Fourth>, fifth: Observable<Fifth>, sixth: Observable<Sixth>, seventh: Observable<Seventh>, eight: Observable<Eight>, ninth: Observable<Ninth>, zipFun: (First, Second, Third, Fourth, Fifth, Sixth, Seventh, Eight, Ninth) -> Res): Observable<Res>

zipWith

fun <First : Any, Second : Any> Flowable<First>.zipWith(second: Flowable<Second>): Flowable<Pair<First, Second>>

fun <First : Any, Second : Any> Observable<First>.zipWith(second: Observable<Second>): Observable<Pair<First, Second>>

fun <First : Any, Second : Any, Res : Any> Flowable<First>.zipWith(second: Flowable<Second>, zipFun: (First, Second) -> Res): Flowable<Res>

fun <First : Any, Second : Any, Res : Any> Observable<First>.zipWith(second: Observable<Second>, zipFun: (First, Second) -> Res): Observable<Res>