diff --git a/docs/Operator-Matrix.md b/docs/Operator-Matrix.md
index ded48d8509..832d64311d 100644
--- a/docs/Operator-Matrix.md
+++ b/docs/Operator-Matrix.md
@@ -1,240 +1,347 @@
-Operator | `Flowable` | `Observable` | `Maybe` | `Single` | `Completable` |
------|:---:|:---:|:---:|:---:|:---:|
-`all`||||||
-`amb`||||||
-`ambArray`||||||
-`ambWith`||||||
-`andThen`||||||
-`any`||||||
-`blockingAwait`||||||
-`blockingFirst`||||||
-`blockingForEach`||||||
-`blockingGet`||||||
-`blockingIterable`||||||
-`blockingLast`||||||
-`blockingLatest`||||||
-`blockingMostRecent`||||||
-`blockingNext`||||||
-`blockingSingle`||||||
-`blockingStream`||||||
-`blockingSubscribe`||||||
-`buffer`||||||
-`cache`||||||
-`cacheWithInitialCapacity`||||||
-`cast`||||||
-`collect`||||||
-`collectInto`||||||
-`combineLatest`||||||
-`combineLatestArray`||||||
-`combineLatestArrayDelayError`||||||
-`combineLatestDelayError`||||||
-`complete`||||||
-`compose`||||||
-`concat`||||||
-`concatArray`||||||
-`concatArrayDelayError`||||||
-`concatArrayEager`||||||
-`concatArrayEagerDelayError`||||||
-`concatDelayError`||||||
-`concatEager`||||||
-`concatMap`||||||
-`concatMapCompletable`||||||
-`concatMapCompletableDelayError`||||||
-`concatMapDelayError`||||||
-`concatMapEager`||||||
-`concatMapEagerDelayError`||||||
-`concatMapIterable`||||||
-`concatMapMaybe`||||||
-`concatMapMaybeDelayError`||||||
-`concatMapSingle`||||||
-`concatMapSingleDelayError`||||||
-`concatMapStream`||||||
-`concatWith`||||||
-`contains`||||||
-`count`||||||
-`create`||||||
-`debounce`||||||
-`defaultIfEmpty`||||||
-`defer`||||||
-`delay`||||||
-`delaySubscription`||||||
-`dematerialize`||||||
-`distinct`||||||
-`distinctUntilChanged`||||||
-`doAfterNext`||||||
-`doAfterSuccess`||||||
-`doAfterTerminate`||||||
-`doFinally`||||||
-`doOnCancel`||||||
-`doOnComplete`||||||
-`doOnDispose`||||||
-`doOnEach`||||||
-`doOnError`||||||
-`doOnEvent`||||||
-`doOnLifecycle`||||||
-`doOnNext`||||||
-`doOnRequest`||||||
-`doOnSubscribe`||||||
-`doOnSuccess`||||||
-`doOnTerminate`||||||
-`elementAt`||||||
-`elementAtOrError`||||||
-`empty`||||||
-`equals`||||||
-`error`||||||
-`filter`||||||
-`first`||||||
-`firstElement`||||||
-`firstOrError`||||||
-`firstOrErrorStage`||||||
-`firstStage`||||||
-`flatMap`||||||
-`flatMapCompletable`||||||
-`flatMapIterable`||||||
-`flatMapMaybe`||||||
-`flatMapObservable`||||||
-`flatMapPublisher`||||||
-`flatMapSingle`||||||
-`flatMapSingleElement`||||||
-`flatMapStream`||||||
-`flattenAsFlowable`||||||
-`flattenAsObservable`||||||
-`flattenStreamAsFlowable`||||||
-`flattenStreamAsObservable`||||||
-`forEach`||||||
-`forEachWhile`||||||
-`fromAction`||||||
-`fromArray`||||||
-`fromCallable`||||||
-`fromCompletable`||||||
-`fromCompletionStage`||||||
-`fromFuture`||||||
-`fromIterable`||||||
-`fromMaybe`||||||
-`fromObservable`||||||
-`fromOptional`||||||
-`fromPublisher`||||||
-`fromRunnable`||||||
-`fromSingle`||||||
-`fromStream`||||||
-`fromSupplier`||||||
-`generate`||||||
-`groupBy`||||||
-`groupJoin`||||||
-`hide`||||||
-`ignoreElement`||||||
-`ignoreElements`||||||
-`interval`||||||
-`intervalRange`||||||
-`isEmpty`||||||
-`join`||||||
-`just`||||||
-`last`||||||
-`lastElement`||||||
-`lastOrError`||||||
-`lastOrErrorStage`||||||
-`lastStage`||||||
-`lift`||||||
-`map`||||||
-`mapOptional`||||||
-`materialize`||||||
-`merge`||||||
-`mergeArray`||||||
-`mergeArrayDelayError`||||||
-`mergeDelayError`||||||
-`mergeWith`||||||
-`never`||||||
-`observeOn`||||||
-`ofType`||||||
-`onBackpressureBuffer`||||||
-`onBackpressureDrop`||||||
-`onBackpressureLatest`||||||
-`onErrorComplete`||||||
-`onErrorResumeNext`||||||
-`onErrorResumeWith`||||||
-`onErrorReturn`||||||
-`onErrorReturnItem`||||||
-`onTerminateDetach`||||||
-`parallel`||||||
-`publish`||||||
-`range`||||||
-`rangeLong`||||||
-`rebatchRequests`||||||
-`reduce`||||||
-`reduceWith`||||||
-`repeat`||||||
-`repeatUntil`||||||
-`repeatWhen`||||||
-`replay`||||||
-`retry`||||||
-`retryUntil`||||||
-`retryWhen`||||||
-`safeSubscribe`||||||
-`sample`||||||
-`scan`||||||
-`scanWith`||||||
-`sequenceEqual`||||||
-`serialize`||||||
-`share`||||||
-`single`||||||
-`singleElement`||||||
-`singleOrError`||||||
-`singleOrErrorStage`||||||
-`singleStage`||||||
-`skip`||||||
-`skipLast`||||||
-`skipUntil`||||||
-`skipWhile`||||||
-`sorted`||||||
-`startWith`||||||
-`startWithArray`||||||
-`startWithItem`||||||
-`startWithIterable`||||||
-`subscribe`||||||
-`subscribeOn`||||||
-`subscribeWith`||||||
-`switchIfEmpty`||||||
-`switchMap`||||||
-`switchMapCompletable`||||||
-`switchMapCompletableDelayError`||||||
-`switchMapDelayError`||||||
-`switchMapMaybe`||||||
-`switchMapMaybeDelayError`||||||
-`switchMapSingle`||||||
-`switchMapSingleDelayError`||||||
-`switchOnNext`||||||
-`switchOnNextDelayError`||||||
-`take`||||||
-`takeLast`||||||
-`takeUntil`||||||
-`takeWhile`||||||
-`test`||||||
-`throttleFirst`||||||
-`throttleLast`||||||
-`throttleLatest`||||||
-`throttleWithTimeout`||||||
-`timeInterval`||||||
-`timeout`||||||
-`timer`||||||
-`timestamp`||||||
-`to`||||||
-`toCompletionStage`||||||
-`toFlowable`||||||
-`toFuture`||||||
-`toList`||||||
-`toMap`||||||
-`toMaybe`||||||
-`toMultimap`||||||
-`toObservable`||||||
-`toSingle`||||||
-`toSingleDefault`||||||
-`toSortedList`||||||
-`unsafeCreate`||||||
-`unsubscribeOn`||||||
-`using`||||||
-`window`||||||
-`withLatestFrom`||||||
-`wrap`||||||
-`zip`||||||
-`zipArray`||||||
-`zipWith`||||||
+Operator |  |  |  |  |  |
+-----|---|---|---|---|---|
+`all`||| ([1](#notes-1))| ([1](#notes-1))| ([2](#notes-2))|
+`amb`||||||
+`ambArray`||||||
+`ambWith`||||||
+`andThen`| ([3](#notes-3))| ([3](#notes-3))| ([3](#notes-3))| ([3](#notes-3))||
+`any`||| ([1](#notes-1))| ([1](#notes-1))| ([2](#notes-2))|
+`blockingAwait`| ([4](#notes-4))| ([4](#notes-4))| ([5](#notes-5))| ([5](#notes-5))||
+`blockingFirst`||| ([6](#notes-6))| ([6](#notes-6))| ([7](#notes-7))|
+`blockingForEach`||| ([8](#notes-8))| ([8](#notes-8))| ([8](#notes-8))|
+`blockingGet`| ([4](#notes-4))| ([4](#notes-4))||| ([7](#notes-7))|
+`blockingIterable`||| ([6](#notes-6))| ([6](#notes-6))| ([7](#notes-7))|
+`blockingLast`||| ([6](#notes-6))| ([6](#notes-6))| ([7](#notes-7))|
+`blockingLatest`||| ([6](#notes-6))| ([6](#notes-6))| ([7](#notes-7))|
+`blockingMostRecent`||| ([6](#notes-6))| ([6](#notes-6))| ([7](#notes-7))|
+`blockingNext`||| ([6](#notes-6))| ([6](#notes-6))| ([7](#notes-7))|
+`blockingSingle`||| ([6](#notes-6))| ([6](#notes-6))| ([7](#notes-7))|
+`blockingStream`||| ([6](#notes-6))| ([6](#notes-6))| ([7](#notes-7))|
+`blockingSubscribe`||||||
+`buffer`||| ([9](#notes-9))| ([10](#notes-10))| ([11](#notes-11))|
+`cache`||||||
+`cacheWithInitialCapacity`||| ([12](#notes-12))| ([12](#notes-12))| ([12](#notes-12))|
+`cast`||||| ([2](#notes-2))|
+`collect`||| ([13](#notes-13))| ([14](#notes-14))| ([15](#notes-15))|
+`collectInto`||| ([13](#notes-13))| ([14](#notes-14))| ([15](#notes-15))|
+`combineLatest`||| ([16](#notes-16))| ([16](#notes-16))| ([17](#notes-17))|
+`combineLatestArray`||| ([18](#notes-18))| ([18](#notes-18))| ([19](#notes-19))|
+`combineLatestArrayDelayError`||| ([18](#notes-18))| ([18](#notes-18))| ([20](#notes-20))|
+`combineLatestDelayError`||| ([16](#notes-16))| ([16](#notes-16))| ([21](#notes-21))|
+`complete`| ([22](#notes-22))| ([22](#notes-22))| ([22](#notes-22))| ([23](#notes-23))||
+`compose`||||||
+`concat`||||||
+`concatArray`||||||
+`concatArrayDelayError`||||||
+`concatArrayEager`||||| ([24](#notes-24))|
+`concatArrayEagerDelayError`||||| ([25](#notes-25))|
+`concatDelayError`||||||
+`concatEager`||||| ([26](#notes-26))|
+`concatMap`||||| ([27](#notes-27))|
+`concatMapCompletable`||||| ([27](#notes-27))|
+`concatMapCompletableDelayError`||||| ([27](#notes-27))|
+`concatMapDelayError`||||||
+`concatMapEager`||||||
+`concatMapEagerDelayError`||||||
+`concatMapIterable`||| ([28](#notes-28))| ([28](#notes-28))| ([27](#notes-27))|
+`concatMapMaybe`||||| ([27](#notes-27))|
+`concatMapMaybeDelayError`||||| ([27](#notes-27))|
+`concatMapSingle`||||| ([27](#notes-27))|
+`concatMapSingleDelayError`||||| ([27](#notes-27))|
+`concatMapStream`||| ([29](#notes-29))| ([29](#notes-29))| ([27](#notes-27))|
+`concatWith`||||||
+`contains`||||| ([2](#notes-2))|
+`count`|||| ([30](#notes-30))| ([31](#notes-31))|
+`create`||||||
+`debounce`||| ([32](#notes-32))| ([32](#notes-32))| ([33](#notes-33))|
+`defaultIfEmpty`|||| ([23](#notes-23))| ([34](#notes-34))|
+`defer`||||||
+`delay`||||||
+`delaySubscription`||||||
+`dematerialize`||||| ([33](#notes-33))|
+`distinct`||| ([35](#notes-35))| ([35](#notes-35))| ([33](#notes-33))|
+`distinctUntilChanged`||| ([35](#notes-35))| ([35](#notes-35))| ([33](#notes-33))|
+`doAfterNext`||| ([36](#notes-36))| ([36](#notes-36))| ([2](#notes-2))|
+`doAfterSuccess`| ([37](#notes-37))| ([37](#notes-37))||| ([33](#notes-33))|
+`doAfterTerminate`||||||
+`doFinally`||||||
+`doOnCancel`|| ([38](#notes-38))| ([38](#notes-38))| ([38](#notes-38))| ([38](#notes-38))|
+`doOnComplete`|||| ([39](#notes-39))||
+`doOnDispose`| ([40](#notes-40))|||||
+`doOnEach`||| ([41](#notes-41))| ([41](#notes-41))| ([33](#notes-33))|
+`doOnError`||||||
+`doOnEvent`| ([42](#notes-42))| ([42](#notes-42))||||
+`doOnLifecycle`||||||
+`doOnNext`||| ([43](#notes-43))| ([43](#notes-43))| ([33](#notes-33))|
+`doOnRequest`|| ([44](#notes-44))| ([44](#notes-44))| ([44](#notes-44))| ([44](#notes-44))|
+`doOnSubscribe`||||||
+`doOnSuccess`| ([45](#notes-45))| ([45](#notes-45))||| ([33](#notes-33))|
+`doOnTerminate`||||||
+`elementAt`||| ([46](#notes-46))| ([47](#notes-47))| ([33](#notes-33))|
+`elementAtOrError`||| ([48](#notes-48))|||
+`empty`|||| ([23](#notes-23))| ([49](#notes-49))|
+`equals`||||||
+`error`||||||
+`filter`||||| ([33](#notes-33))|
+`first`||| ([50](#notes-50))| ([51](#notes-51))| ([34](#notes-34))|
+`firstElement`||| ([52](#notes-52))| ([53](#notes-53))| ([2](#notes-2))|
+`firstOrError`||| ([52](#notes-52))| ([53](#notes-53))| ([54](#notes-54))|
+`firstOrErrorStage`||| ([55](#notes-55))| ([55](#notes-55))| ([56](#notes-56))|
+`firstStage`||| ([55](#notes-55))| ([55](#notes-55))| ([55](#notes-55))|
+`flatMap`||||| ([27](#notes-27))|
+`flatMapCompletable`||||| ([27](#notes-27))|
+`flatMapIterable`||| ([28](#notes-28))| ([28](#notes-28))| ([27](#notes-27))|
+`flatMapMaybe`||||| ([27](#notes-27))|
+`flatMapObservable`| ([57](#notes-57))| ([58](#notes-58))||| ([27](#notes-27))|
+`flatMapPublisher`| ([58](#notes-58))| ([59](#notes-59))||| ([27](#notes-27))|
+`flatMapSingle`||||| ([27](#notes-27))|
+`flatMapSingleElement`| ([60](#notes-60))| ([60](#notes-60))|| ([58](#notes-58))| ([27](#notes-27))|
+`flatMapStream`||| ([29](#notes-29))| ([29](#notes-29))| ([27](#notes-27))|
+`flattenAsFlowable`| ([61](#notes-61))| ([61](#notes-61))||| ([27](#notes-27))|
+`flattenAsObservable`| ([61](#notes-61))| ([61](#notes-61))||| ([27](#notes-27))|
+`flattenStreamAsFlowable`| ([62](#notes-62))| ([62](#notes-62))||| ([27](#notes-27))|
+`flattenStreamAsObservable`| ([62](#notes-62))| ([62](#notes-62))||| ([27](#notes-27))|
+`forEach`||| ([63](#notes-63))| ([63](#notes-63))| ([63](#notes-63))|
+`forEachWhile`||| ([63](#notes-63))| ([63](#notes-63))| ([63](#notes-63))|
+`fromAction`||||||
+`fromArray`||| ([64](#notes-64))| ([65](#notes-65))| ([66](#notes-66))|
+`fromCallable`||||||
+`fromCompletable`|||| ([67](#notes-67))| ([68](#notes-68))|
+`fromCompletionStage`||||||
+`fromFuture`||||||
+`fromIterable`||| ([64](#notes-64))| ([65](#notes-65))| ([66](#notes-66))|
+`fromMaybe`||| ([68](#notes-68))|||
+`fromObservable`|| ([68](#notes-68))||||
+`fromOptional`|||| ([65](#notes-65))| ([66](#notes-66))|
+`fromPublisher`||||||
+`fromRunnable`||||||
+`fromSingle`||||||
+`fromStream`||| ([64](#notes-64))| ([65](#notes-65))| ([66](#notes-66))|
+`fromSupplier`||||||
+`generate`||| ([69](#notes-69))| ([69](#notes-69))| ([69](#notes-69))|
+`groupBy`||| ([70](#notes-70))| ([70](#notes-70))| ([71](#notes-71))|
+`groupJoin`||| ([70](#notes-70))| ([70](#notes-70))| ([72](#notes-72))|
+`hide`||||||
+`ignoreElement`| ([73](#notes-73))| ([73](#notes-73))||| ([2](#notes-2))|
+`ignoreElements`||| ([74](#notes-74))| ([74](#notes-74))| ([2](#notes-2))|
+`interval`||| ([75](#notes-75))| ([75](#notes-75))| ([75](#notes-75))|
+`intervalRange`||| ([75](#notes-75))| ([75](#notes-75))| ([75](#notes-75))|
+`isEmpty`|||| ([51](#notes-51))| ([2](#notes-2))|
+`join`||| ([76](#notes-76))| ([76](#notes-76))| ([72](#notes-72))|
+`just`||||||
+`last`||| ([50](#notes-50))| ([51](#notes-51))| ([34](#notes-34))|
+`lastElement`||| ([52](#notes-52))| ([53](#notes-53))| ([2](#notes-2))|
+`lastOrError`||| ([52](#notes-52))| ([53](#notes-53))| ([54](#notes-54))|
+`lastOrErrorStage`||| ([55](#notes-55))| ([55](#notes-55))| ([56](#notes-56))|
+`lastStage`||| ([55](#notes-55))| ([55](#notes-55))| ([55](#notes-55))|
+`lift`||||||
+`map`||||| ([27](#notes-27))|
+`mapOptional`||||| ([27](#notes-27))|
+`materialize`||||||
+`merge`||||||
+`mergeArray`||||||
+`mergeArrayDelayError`||||||
+`mergeDelayError`||||||
+`mergeWith`||||||
+`never`||||||
+`observeOn`||||||
+`ofType`||||| ([77](#notes-77))|
+`onBackpressureBuffer`|| ([44](#notes-44))| ([44](#notes-44))| ([44](#notes-44))| ([44](#notes-44))|
+`onBackpressureDrop`|| ([44](#notes-44))| ([44](#notes-44))| ([44](#notes-44))| ([44](#notes-44))|
+`onBackpressureLatest`|| ([44](#notes-44))| ([44](#notes-44))| ([44](#notes-44))| ([44](#notes-44))|
+`onErrorComplete`||||||
+`onErrorResumeNext`||||||
+`onErrorResumeWith`||||||
+`onErrorReturn`||||||
+`onErrorReturnItem`||||||
+`onTerminateDetach`||||||
+`parallel`|| ([78](#notes-78))| ([78](#notes-78))| ([78](#notes-78))| ([78](#notes-78))|
+`publish`||| ([79](#notes-79))| ([80](#notes-80))| ([81](#notes-81))|
+`range`||| ([82](#notes-82))| ([82](#notes-82))| ([66](#notes-66))|
+`rangeLong`||| ([82](#notes-82))| ([82](#notes-82))| ([66](#notes-66))|
+`rebatchRequests`|| ([44](#notes-44))| ([44](#notes-44))| ([44](#notes-44))| ([44](#notes-44))|
+`reduce`||| ([83](#notes-83))| ([83](#notes-83))| ([84](#notes-84))|
+`reduceWith`||| ([83](#notes-83))| ([83](#notes-83))| ([84](#notes-84))|
+`repeat`||||||
+`repeatUntil`||||||
+`repeatWhen`||||||
+`replay`||| ([79](#notes-79))| ([80](#notes-80))| ([81](#notes-81))|
+`retry`||||||
+`retryUntil`||||||
+`retryWhen`||||||
+`safeSubscribe`||||||
+`sample`||| ([52](#notes-52))| ([52](#notes-52))| ([33](#notes-33))|
+`scan`||| ([83](#notes-83))| ([83](#notes-83))| ([84](#notes-84))|
+`scanWith`||| ([83](#notes-83))| ([83](#notes-83))| ([84](#notes-84))|
+`sequenceEqual`||||||
+`serialize`||| ([85](#notes-85))| ([85](#notes-85))| ([85](#notes-85))|
+`share`||| ([79](#notes-79))| ([80](#notes-80))| ([81](#notes-81))|
+`single`||| ([50](#notes-50))| ([51](#notes-51))| ([34](#notes-34))|
+`singleElement`||| ([52](#notes-52))| ([53](#notes-53))| ([2](#notes-2))|
+`singleOrError`||| ([52](#notes-52))| ([53](#notes-53))| ([54](#notes-54))|
+`singleOrErrorStage`||| ([55](#notes-55))| ([55](#notes-55))| ([56](#notes-56))|
+`singleStage`||| ([55](#notes-55))| ([55](#notes-55))| ([55](#notes-55))|
+`skip`||| ([52](#notes-52))| ([52](#notes-52))| ([52](#notes-52))|
+`skipLast`||| ([52](#notes-52))| ([52](#notes-52))| ([52](#notes-52))|
+`skipUntil`||| ([86](#notes-86))| ([86](#notes-86))| ([86](#notes-86))|
+`skipWhile`||| ([87](#notes-87))| ([87](#notes-87))| ([2](#notes-2))|
+`sorted`||| ([70](#notes-70))| ([70](#notes-70))| ([70](#notes-70))|
+`startWith`||||||
+`startWithArray`||| ([88](#notes-88))| ([88](#notes-88))| ([88](#notes-88))|
+`startWithItem`||| ([89](#notes-89))| ([89](#notes-89))| ([89](#notes-89))|
+`startWithIterable`||| ([90](#notes-90))| ([90](#notes-90))| ([90](#notes-90))|
+`subscribe`||||||
+`subscribeOn`||||||
+`subscribeWith`||||||
+`switchIfEmpty`|||| ([23](#notes-23))| ([91](#notes-91))|
+`switchMap`||| ([92](#notes-92))| ([92](#notes-92))| ([27](#notes-27))|
+`switchMapCompletable`||| ([92](#notes-92))| ([92](#notes-92))| ([27](#notes-27))|
+`switchMapCompletableDelayError`||| ([92](#notes-92))| ([92](#notes-92))| ([27](#notes-27))|
+`switchMapDelayError`||| ([92](#notes-92))| ([92](#notes-92))| ([27](#notes-27))|
+`switchMapMaybe`||| ([92](#notes-92))| ([92](#notes-92))| ([27](#notes-27))|
+`switchMapMaybeDelayError`||| ([92](#notes-92))| ([92](#notes-92))| ([27](#notes-27))|
+`switchMapSingle`||| ([92](#notes-92))| ([92](#notes-92))| ([27](#notes-27))|
+`switchMapSingleDelayError`||| ([92](#notes-92))| ([92](#notes-92))| ([27](#notes-27))|
+`switchOnNext`||||||
+`switchOnNextDelayError`||||||
+`take`||| ([52](#notes-52))| ([52](#notes-52))| ([52](#notes-52))|
+`takeLast`||| ([52](#notes-52))| ([52](#notes-52))| ([52](#notes-52))|
+`takeUntil`||||||
+`takeWhile`||| ([87](#notes-87))| ([87](#notes-87))| ([2](#notes-2))|
+`test`||||||
+`throttleFirst`||| ([32](#notes-32))| ([32](#notes-32))| ([33](#notes-33))|
+`throttleLast`||| ([32](#notes-32))| ([32](#notes-32))| ([33](#notes-33))|
+`throttleLatest`||| ([32](#notes-32))| ([32](#notes-32))| ([33](#notes-33))|
+`throttleWithTimeout`||| ([32](#notes-32))| ([32](#notes-32))| ([33](#notes-33))|
+`timeInterval`||||||
+`timeout`||||||
+`timer`||||||
+`timestamp`||||| ([33](#notes-33))|
+`to`||||||
+`toCompletionStage`| ([93](#notes-93))| ([93](#notes-93))||||
+`toFlowable`||||||
+`toFuture`||||||
+`toList`||| ([13](#notes-13))| ([14](#notes-14))| ([15](#notes-15))|
+`toMap`||| ([13](#notes-13))| ([14](#notes-14))| ([15](#notes-15))|
+`toMaybe`| ([94](#notes-94))| ([94](#notes-94))| ([95](#notes-95))|||
+`toMultimap`||| ([13](#notes-13))| ([14](#notes-14))| ([15](#notes-15))|
+`toObservable`|| ([95](#notes-95))||||
+`toSingle`| ([96](#notes-96))| ([96](#notes-96))|| ([95](#notes-95))||
+`toSingleDefault`| ([97](#notes-97))| ([97](#notes-97))| ([98](#notes-98))| ([95](#notes-95))||
+`toSortedList`||| ([13](#notes-13))| ([14](#notes-14))| ([15](#notes-15))|
+`unsafeCreate`||||||
+`unsubscribeOn`||||||
+`using`||||||
+`window`||| ([99](#notes-99))| ([100](#notes-100))| ([101](#notes-101))|
+`withLatestFrom`||| ([16](#notes-16))| ([16](#notes-16))| ([17](#notes-17))|
+`wrap`| ([102](#notes-102))|||||
+`zip`||||| ([103](#notes-103))|
+`zipArray`||||| ([104](#notes-104))|
+`zipWith`||||| ([105](#notes-105))|
+
+#### Notes
+1 Use [`contains()`](#contains).
+2 Always empty.
+3 Use [`concatWith`](#concatWith).
+4 Use [`blockingFirst()`](#blockingFirst), [`blockingSingle()`](#blockingSingle) or [`blockingLast()`](#blockingLast).
+5 Use [`blockingGet()`](#blockingGet).
+6 At most one element to get. Use [`blockingGet()`](#blockingGet).
+7 No elements to get. Use [`blockingAwait()`](#blockingAwait).
+8 Use [`blockingSubscribe()`](#blockingSubscribe)
+9 Use [`map()`](#map) and [`switchIfEmpty()`](#switchIfEmpty) to transform into a list/collection.
+10 Use [`map()`](#map) to transform into a list/collection.
+11 Always empty. Use [`andThen()`](#andThen) to bring in a list/collection.
+12 At most one element to store. Use [`cache()`](#cache).
+13 At most one element to collect. Use [`map()`](#map) and [`switchIfEmpty()`](#switchIfEmpty) to transform into a list/collection.
+14 One element to collect. Use [`map()`](#map) to transform into a list/collection.
+15 Always empty. Use [`andThen()`](#andThen) to bring in a collection.
+16 At most one element per source. Use [`zip()`](#zip).
+17 Always empty. Use [`merge()`](#merge).
+18 At most one element per source. Use [`zipArray()`](#zipArray).
+19 Always empty. Use [`mergeArray()`](#mergeArray).
+20 Always empty. Use [`mergeArrayDelayError()`](#mergeArrayDelayError).
+21 Always empty. Use [`mergeDelayError()`](#mergeDelayError).
+22 Use [`empty()`](#empty).
+23 Never empty.
+24 No items to keep ordered. Use [`mergeArray()`](#mergeArray).
+25 No items to keep ordered. Use [`mergeArrayDelayError()`](#mergeArrayDelayError).
+26 No items to keep ordered. Use [`merge()`](#merge).
+27 Always empty thus no items to map.
+28 At most one item. Use [`flattenAsFlowable`](#flattenAsFlowable) or [`flattenAsObservable`](#flattenAsObservable).
+29 At most one item. Use [`flattenStreamAsFlowable`](#flattenStreamAsFlowable) or [`flattenStreamAsObservable`](#flattenStreamAsObservable).
+30 Never empty thus always 1.
+31 Always empty thus always 0.
+32 At most one item signaled so no subsequent items to work with.
+33 Always empty thus no items to work with.
+34 Always empty. Use [`andThen()`](#andThen) to chose the follow-up sequence.
+35 At most one item, always distinct.
+36 Different terminology. Use [`doAfterSuccess()`](#doAfterSuccess).
+37 Different terminology. Use [`doAfterNext()`](#doAfterNext).
+38 Different terminology. Use [`doOnDispose()`](#doOnDispose).
+39 Always succeeds or fails, there is no `onComplete` signal.
+40 Different terminology. Use [`doOnCancel()`](#doOnCancel).
+41 At most one item. Use [`doOnEvent()`](#doOnEvent).
+42 Use [`doOnEach()`](#doOnEach).
+43 Different terminology. Use [`doOnSuccess()`](#doOnSuccess).
+44 Backpressure related and not supported outside `Flowable`.
+45 Different terminology. Use [`doOnNext()`](#doOnNext).
+46 At most one item with index 0. Use [`defaultIfEmpty`](#defaultIfEmpty).
+47 Always one item with index 0.
+48 At most one item with index 0. Use [`toSingle`](#toSingle).
+49 Use [`complete()`](#complete).
+50 At most one item. Use [`defaultIfEmpty`](#defaultIfEmpty).
+51 Always one item.
+52 At most one item, would be no-op.
+53 Always one item, would be no-op.
+54 Always empty. Use [`andThen()`](#andThen) and [`error()`](#error).
+55 At most one item. Use [`toCompletionStage()`](#toCompletionStage).
+56 Always empty. Use [`andThen()`](#andThen), [`error()`](#error) and [`toCompletionStage()`](#toCompletionStage).
+57 Not supported. Use [`flatMap`](#flatMap) and [`toFlowable()`](#toFlowable).
+58 Use [`flatMap`](#flatMap).
+59 Not supported. Use [`flatMap`](#flatMap) and [`toObservable()`](#toFlowable).
+60 Use [`flatMapSingle`](#flatMapSingle).
+61 Use [`flatMapIterable()`](#flatMapIterable).
+62 Use [`flatMapStream()`](#flatMapStream).
+63 Use [`subscribe()`](#subscribe).
+64 At most one item. Use [`just()`](#just) or [`empty()`](#empty).
+65 Always one item. Use [`just()`](#just).
+66 Always empty. Use [`complete()`](#complete).
+67 Always error.
+68 Use [`wrap()`](#wrap).
+69 Use [`fromSupplier()`](#fromSupplier).
+70 At most one item.
+71 Always empty thus no items to group.
+72 Always empty thus no items to join.
+73 Use [`ignoreElements()`](#ignoreElements).
+74 Use [`ignoreElement()`](#ignoreElement).
+75 At most one item. Use [`timer()`](#timer).
+76 At most one item. Use [`zip()`](#zip)
+77 Always empty thus no items to filter.
+78 Needs backpressure thus not supported outside `Flowable`.
+79 Connectable sources not supported outside `Flowable` and `Observable`. Use a `MaybeSubject`.
+80 Connectable sources not supported outside `Flowable` and `Observable`. Use a `SingleSubject`.
+81 Connectable sources not supported outside `Flowable` and `Observable`. Use a `ConnectableSubject`.
+82 At most one item. Use [`just()`](#just).
+83 At most one item. Use [`map()`](#map).
+84 Always empty thus no items to reduce.
+85 At most one signal type.
+86 At most one item. Use [`takeUntil()`](#takeUntil).
+87 At most one item. Use [`filter()`](#filter).
+88 Use [`startWith()`](#startWith) and [`fromArray()`](#fromArray) of `Flowable` or `Observable`.
+89 Use [`startWith()`](#startWith) and [`just()`](#just) of another reactive type.
+90 Use [`startWith()`](#startWith) and [`fromIterable()`](#fromArray) of `Flowable` or `Observable`.
+91 Always empty. Use [`defaultIfEmpty()`](#defaultIfEmpty).
+92 At most one item. Use [`flatMap()`](#flatMap).
+93 Use [`firstStage`](#firstStage), [`lastStage`](#lastStage) or [`singleStage`](#singleStage).
+94 Use [`firstElement`](#firstElement), [`lastElement`](#lastElement) or [`singleElement`](#singleElement).
+95 Would be no-op.
+96 Use [`firstOrError`](#firstOrError), [`lastOrError`](#lastOrError) or [`singleOrError`](#singleOrError).
+97 Use [`first`](#first), [`last`](#last) or [`single`](#single).
+98 Use [`defaultIfEmpty()`](#defaultIfEmpty).
+99 Use [`map()`](#map) and [`switchIfEmpty()`](#switchIfEmpty) to transform into a nested source.
+100 Use [`map()`](#map) to transform into a nested source.
+101 Always empty. Use [`andThen()`](#andThen) to bring in a nested source.
+102 Use [`fromPublisher()`](#fromPublisher).
+103 Use [`merge()`](#merge).
+104 Use [`mergeArray()`](#mergeArray).
+105 Use [`mergeWith()`](#mergeWith).
diff --git a/src/test/java/io/reactivex/rxjava3/internal/util/OperatorMatrixGenerator.java b/src/test/java/io/reactivex/rxjava3/internal/util/OperatorMatrixGenerator.java
index 42ea23dd1d..1273a5b441 100644
--- a/src/test/java/io/reactivex/rxjava3/internal/util/OperatorMatrixGenerator.java
+++ b/src/test/java/io/reactivex/rxjava3/internal/util/OperatorMatrixGenerator.java
@@ -40,6 +40,10 @@ private OperatorMatrixGenerator() {
Flowable.class, Observable.class, Maybe.class, Single.class, Completable.class
};
+ static String header(String type) {
+ return "![" + type + "](https://raw.github.com/wiki/ReactiveX/RxJava/images/opmatrix-" + type.toLowerCase() + ".png)";
+ }
+
public static void main(String[] args) throws IOException {
Set operatorSet = new HashSet<>();
Map, Set> operatorMap = new HashMap<>();
@@ -64,18 +68,24 @@ public static void main(String[] args) throws IOException {
try (PrintWriter out = new PrintWriter(Files.newBufferedWriter(Paths.get("docs", "Operator-Matrix.md"), StandardOpenOption.CREATE, StandardOpenOption.TRUNCATE_EXISTING))) {
out.print("Operator |");
for (Class clazz : CLASSES) {
- out.print(" `");
- out.print(clazz.getSimpleName());
- out.print("` |");
+ out.print(" ");
+ out.print(header(clazz.getSimpleName()));
+ out.print(" |");
}
out.println();
out.print("-----|");
for (int i = 0; i < CLASSES.length; i++) {
- out.print(":---:|");
+ out.print("---|");
}
out.println();
+
+ Map notesMap = new HashMap<>();
+ List notesList = new ArrayList<>();
+
for (String operatorName : sortedOperators) {
- out.print("`");
+ out.print("`");
out.print(operatorName);
out.print("`|");
for (Class clazz : CLASSES) {
@@ -83,11 +93,376 @@ public static void main(String[] args) throws IOException {
out.print(PRESENT);
} else {
out.print(ABSENT);
+ String notes = findNotes(clazz.getSimpleName(), operatorName);
+ if (notes != null) {
+ Integer index = notesMap.get(notes);
+ if (index == null) {
+ index = notesMap.size() + 1;
+ notesMap.put(notes, index);
+ notesList.add(notes);
+ }
+ out.print(" ([");
+ out.print(index);
+ out.print("](#notes-");
+ out.print(index);
+ out.print("))");
+ }
}
out.print("|");
}
out.println();
}
+
+ if (!notesList.isEmpty()) {
+ out.println();
+ out.println("#### Notes");
+
+ for (int i = 0; i < notesList.size(); i++) {
+ out.print("");
+ out.print(i + 1);
+ out.print(" ");
+ out.print(notesList.get(i));
+ out.println("
");
+ }
+ }
+ }
+ }
+
+ static String findNotes(String clazzName, String operatorName) {
+ Map classNotes = NOTES_MAP.get(operatorName);
+ if (classNotes != null) {
+ return classNotes.get(clazzName.substring(0, 1));
+ }
+ switch (operatorName) {
+ case "empty": {
+ if ("Completable".equals(clazzName)) {
+ return "Use [`complete()`](#complete).";
+ }
+ if ("Single".equals(clazzName)) {
+ return "Never empty.";
+ }
+ break;
+ }
+ }
+ return null;
+ }
+
+ static final String[] NOTES = {
+ // Format
+ // FOMSC methodName note
+ " MS all Use [`contains()`](#contains).",
+ " C all Always empty.",
+ "FOMS andThen Use [`concatWith`](#concatWith).",
+ " MS any Use [`contains()`](#contains).",
+ " C any Always empty.",
+ "FO blockingAwait Use [`blockingFirst()`](#blockingFirst), [`blockingSingle()`](#blockingSingle) or [`blockingLast()`](#blockingLast).",
+ " MS blockingAwait Use [`blockingGet()`](#blockingGet).",
+ " MS blockingFirst At most one element to get. Use [`blockingGet()`](#blockingGet).",
+ " C blockingFirst No elements to get. Use [`blockingAwait()`](#blockingAwait).",
+ " MSC blockingForEach Use [`blockingSubscribe()`](#blockingSubscribe)",
+ "FO blockingGet Use [`blockingFirst()`](#blockingFirst), [`blockingSingle()`](#blockingSingle) or [`blockingLast()`](#blockingLast).",
+ " C blockingGet No elements to get. Use [`blockingAwait()`](#blockingAwait).",
+ " MS blockingIterable At most one element to get. Use [`blockingGet()`](#blockingGet).",
+ " C blockingIterable No elements to get. Use [`blockingAwait()`](#blockingAwait).",
+ " MS blockingLast At most one element to get. Use [`blockingGet()`](#blockingGet).",
+ " C blockingLast No elements to get. Use [`blockingAwait()`](#blockingAwait).",
+ " MS blockingLatest At most one element to get. Use [`blockingGet()`](#blockingGet).",
+ " C blockingLatest No elements to get. Use [`blockingAwait()`](#blockingAwait).",
+ " MS blockingMostRecent At most one element to get. Use [`blockingGet()`](#blockingGet).",
+ " C blockingMostRecent No elements to get. Use [`blockingAwait()`](#blockingAwait).",
+ " MS blockingNext At most one element to get. Use [`blockingGet()`](#blockingGet).",
+ " C blockingNext No elements to get. Use [`blockingAwait()`](#blockingAwait).",
+ " MS blockingSingle At most one element to get. Use [`blockingGet()`](#blockingGet).",
+ " C blockingSingle No elements to get. Use [`blockingAwait()`](#blockingAwait).",
+ " MS blockingStream At most one element to get. Use [`blockingGet()`](#blockingGet).",
+ " C blockingStream No elements to get. Use [`blockingAwait()`](#blockingAwait).",
+ " M buffer Use [`map()`](#map) and [`switchIfEmpty()`](#switchIfEmpty) to transform into a list/collection.",
+ " S buffer Use [`map()`](#map) to transform into a list/collection.",
+ " C buffer Always empty. Use [`andThen()`](#andThen) to bring in a list/collection.",
+ " MSC cacheWithInitialCapacity At most one element to store. Use [`cache()`](#cache).",
+ " C cast Always empty.",
+ " M collect At most one element to collect. Use [`map()`](#map) and [`switchIfEmpty()`](#switchIfEmpty) to transform into a list/collection.",
+ " S collect One element to collect. Use [`map()`](#map) to transform into a list/collection.",
+ " C collect Always empty. Use [`andThen()`](#andThen) to bring in a collection.",
+ " M collectInto At most one element to collect. Use [`map()`](#map) and [`switchIfEmpty()`](#switchIfEmpty) to transform into a list/collection.",
+ " S collectInto One element to collect. Use [`map()`](#map) to transform into a list/collection.",
+ " C collectInto Always empty. Use [`andThen()`](#andThen) to bring in a collection.",
+ " MS combineLatest At most one element per source. Use [`zip()`](#zip).",
+ " C combineLatest Always empty. Use [`merge()`](#merge).",
+ " MS combineLatestArray At most one element per source. Use [`zipArray()`](#zipArray).",
+ " C combineLatestArray Always empty. Use [`mergeArray()`](#mergeArray).",
+ " MS combineLatestDelayError At most one element per source. Use [`zip()`](#zip).",
+ " C combineLatestDelayError Always empty. Use [`mergeDelayError()`](#mergeDelayError).",
+ " MS combineLatestArrayDelayError At most one element per source. Use [`zipArray()`](#zipArray).",
+ " C combineLatestArrayDelayError Always empty. Use [`mergeArrayDelayError()`](#mergeArrayDelayError).",
+ "FOM complete Use [`empty()`](#empty).",
+ " S complete Never empty.",
+ " C concatArrayEager No items to keep ordered. Use [`mergeArray()`](#mergeArray).",
+ " C concatArrayEagerDelayError No items to keep ordered. Use [`mergeArrayDelayError()`](#mergeArrayDelayError).",
+ " C concatEager No items to keep ordered. Use [`merge()`](#merge).",
+ " C concatEagerDelayError No items to keep ordered. Use [`mergeDelayError()`](#mergeDelayError).",
+ " C concatMap Always empty thus no items to map.",
+ " C concatMapCompletable Always empty thus no items to map.",
+ " C concatMapCompletableDelayError Always empty thus no items to map.",
+ " C concatMapIterable Always empty thus no items to map.",
+ " C concatMapMaybe Always empty thus no items to map.",
+ " C concatMapMaybeDelayError Always empty thus no items to map.",
+ " C concatMapSingle Always empty thus no items to map.",
+ " C concatMapSingleDelayError Always empty thus no items to map.",
+ " C concatMapStream Always empty thus no items to map.",
+ " MS concatMapIterable At most one item. Use [`flattenAsFlowable`](#flattenAsFlowable) or [`flattenAsObservable`](#flattenAsObservable).",
+ " MS concatMapStream At most one item. Use [`flattenStreamAsFlowable`](#flattenStreamAsFlowable) or [`flattenStreamAsObservable`](#flattenStreamAsObservable).",
+ " C contains Always empty.",
+ " S count Never empty thus always 1.",
+ " C count Always empty thus always 0.",
+ " MS debounce At most one item signaled so no subsequent items to work with.",
+ " C debounce Always empty thus no items to work with.",
+ " S defaultIfEmpty Never empty.",
+ " C defaultIfEmpty Always empty. Use [`andThen()`](#andThen) to chose the follow-up sequence.",
+ " C dematerialize Always empty thus no items to work with.",
+ " MS distinct At most one item, always distinct.",
+ " C distinct Always empty thus no items to work with.",
+ " MS distinctUntilChanged At most one item, always distinct.",
+ " C distinctUntilChanged Always empty thus no items to work with.",
+ " MS doAfterNext Different terminology. Use [`doAfterSuccess()`](#doAfterSuccess).",
+ " C doAfterNext Always empty.",
+ "FO doAfterSuccess Different terminology. Use [`doAfterNext()`](#doAfterNext).",
+ " C doAfterSuccess Always empty thus no items to work with.",
+ " OMSC doOnCancel Different terminology. Use [`doOnDispose()`](#doOnDispose).",
+ " S doOnComplete Always succeeds or fails, there is no `onComplete` signal.",
+ "F doOnDispose Different terminology. Use [`doOnCancel()`](#doOnCancel).",
+ " MS doOnEach At most one item. Use [`doOnEvent()`](#doOnEvent).",
+ " C doOnEach Always empty thus no items to work with.",
+ "FO doOnEvent Use [`doOnEach()`](#doOnEach).",
+ " MS doOnNext Different terminology. Use [`doOnSuccess()`](#doOnSuccess).",
+ " C doOnNext Always empty thus no items to work with.",
+ " OMSC doOnRequest Backpressure related and not supported outside `Flowable`.",
+ "FO doOnSuccess Different terminology. Use [`doOnNext()`](#doOnNext).",
+ " C doOnSuccess Always empty thus no items to work with.",
+ " M elementAt At most one item with index 0. Use [`defaultIfEmpty`](#defaultIfEmpty).",
+ " S elementAt Always one item with index 0.",
+ " C elementAt Always empty thus no items to work with.",
+ " M elementAtOrError At most one item with index 0. Use [`toSingle`](#toSingle).",
+ " S empty Never empty.",
+ " C empty Use [`complete()`](#complete).",
+ " C filter Always empty thus no items to work with.",
+ " M first At most one item. Use [`defaultIfEmpty`](#defaultIfEmpty).",
+ " S first Always one item.",
+ " C first Always empty. Use [`andThen()`](#andThen) to chose the follow-up sequence.",
+ " M firstElement At most one item, would be no-op.",
+ " S firstElement Always one item, would be no-op.",
+ " C firstElement Always empty.",
+ " M firstOrError At most one item, would be no-op.",
+ " S firstOrError Always one item, would be no-op.",
+ " C firstOrError Always empty. Use [`andThen()`](#andThen) and [`error()`](#error).",
+ " MS firstOrErrorStage At most one item. Use [`toCompletionStage()`](#toCompletionStage).",
+ " C firstOrErrorStage Always empty. Use [`andThen()`](#andThen), [`error()`](#error) and [`toCompletionStage()`](#toCompletionStage).",
+ " MSC firstStage At most one item. Use [`toCompletionStage()`](#toCompletionStage).",
+ " C flatMap Always empty thus no items to map.",
+ " C flatMapCompletable Always empty thus no items to map.",
+ " C flatMapCompletableDelayError Always empty thus no items to map.",
+ " C flatMapIterable Always empty thus no items to map.",
+ " C flatMapMaybe Always empty thus no items to map.",
+ " C flatMapMaybeDelayError Always empty thus no items to map.",
+ " C flatMapSingle Always empty thus no items to map.",
+ " C flatMapSingleDelayError Always empty thus no items to map.",
+ " C flatMapStream Always empty thus no items to map.",
+ " MS flatMapIterable At most one item. Use [`flattenAsFlowable`](#flattenAsFlowable) or [`flattenAsObservable`](#flattenAsObservable).",
+ " MS flatMapStream At most one item. Use [`flattenStreamAsFlowable`](#flattenStreamAsFlowable) or [`flattenStreamAsObservable`](#flattenStreamAsObservable).",
+ "F flatMapObservable Not supported. Use [`flatMap`](#flatMap) and [`toFlowable()`](#toFlowable).",
+ " O flatMapObservable Use [`flatMap`](#flatMap).",
+ " C flatMapObservable Always empty thus no items to map.",
+ " O flatMapPublisher Not supported. Use [`flatMap`](#flatMap) and [`toObservable()`](#toFlowable).",
+ "F flatMapPublisher Use [`flatMap`](#flatMap).",
+ " C flatMapPublisher Always empty thus no items to map.",
+ "FO flatMapSingleElement Use [`flatMapSingle`](#flatMapSingle).",
+ " S flatMapSingleElement Use [`flatMap`](#flatMap).",
+ " C flatMapSingleElement Always empty thus no items to map.",
+ "FO flattenAsFlowable Use [`flatMapIterable()`](#flatMapIterable).",
+ " C flattenAsFlowable Always empty thus no items to map.",
+ "FO flattenAsObservable Use [`flatMapIterable()`](#flatMapIterable).",
+ " C flattenAsObservable Always empty thus no items to map.",
+ "FO flattenStreamAsFlowable Use [`flatMapStream()`](#flatMapStream).",
+ " C flattenStreamAsFlowable Always empty thus no items to map.",
+ "FO flattenStreamAsObservable Use [`flatMapStream()`](#flatMapStream).",
+ " C flattenStreamAsObservable Always empty thus no items to map.",
+ " MSC forEach Use [`subscribe()`](#subscribe).",
+ " MSC forEachWhile Use [`subscribe()`](#subscribe).",
+ " M fromArray At most one item. Use [`just()`](#just) or [`empty()`](#empty).",
+ " S fromArray Always one item. Use [`just()`](#just).",
+ " C fromArray Always empty. Use [`complete()`](#complete).",
+ " S fromCompletable Always error.",
+ " C fromCompletable Use [`wrap()`](#wrap).",
+ " M fromIterable At most one item. Use [`just()`](#just) or [`empty()`](#empty).",
+ " S fromIterable Always one item. Use [`just()`](#just).",
+ " C fromIterable Always empty. Use [`complete()`](#complete).",
+ " M fromMaybe Use [`wrap()`](#wrap).",
+ " O fromObservable Use [`wrap()`](#wrap).",
+ " S fromOptional Always one item. Use [`just()`](#just).",
+ " C fromOptional Always empty. Use [`complete()`](#complete).",
+ " M fromStream At most one item. Use [`just()`](#just) or [`empty()`](#empty).",
+ " S fromStream Always one item. Use [`just()`](#just).",
+ " C fromStream Always empty. Use [`complete()`](#complete).",
+ " MSC generate Use [`fromSupplier()`](#fromSupplier).",
+ " MS groupBy At most one item.",
+ " C groupBy Always empty thus no items to group.",
+ " MS groupJoin At most one item.",
+ " C groupJoin Always empty thus no items to join.",
+ "FO ignoreElement Use [`ignoreElements()`](#ignoreElements).",
+ " C ignoreElement Always empty.",
+ " MS ignoreElements Use [`ignoreElement()`](#ignoreElement).",
+ " C ignoreElements Always empty.",
+ " MSC interval At most one item. Use [`timer()`](#timer).",
+ " MSC intervalRange At most one item. Use [`timer()`](#timer).",
+ " S isEmpty Always one item.",
+ " C isEmpty Always empty.",
+ " MS join At most one item. Use [`zip()`](#zip)",
+ " C join Always empty thus no items to join.",
+ " M last At most one item. Use [`defaultIfEmpty`](#defaultIfEmpty).",
+ " S last Always one item.",
+ " C last Always empty. Use [`andThen()`](#andThen) to chose the follow-up sequence.",
+ " M lastElement At most one item, would be no-op.",
+ " S lastElement Always one item, would be no-op.",
+ " C lastElement Always empty.",
+ " M lastOrError At most one item, would be no-op.",
+ " S lastOrError Always one item, would be no-op.",
+ " C lastOrError Always empty. Use [`andThen()`](#andThen) and [`error()`](#error).",
+ " MS lastOrErrorStage At most one item. Use [`toCompletionStage()`](#toCompletionStage).",
+ " C lastOrErrorStage Always empty. Use [`andThen()`](#andThen), [`error()`](#error) and [`toCompletionStage()`](#toCompletionStage).",
+ " MSC lastStage At most one item. Use [`toCompletionStage()`](#toCompletionStage).",
+ " C map Always empty thus no items to map.",
+ " C mapOptional Always empty thus no items to map.",
+ " C ofType Always empty thus no items to filter.",
+ " OMSC onBackpressureBuffer Backpressure related and not supported outside `Flowable`.",
+ " OMSC onBackpressureDrop Backpressure related and not supported outside `Flowable`.",
+ " OMSC onBackpressureLatest Backpressure related and not supported outside `Flowable`.",
+ " OMSC parallel Needs backpressure thus not supported outside `Flowable`.",
+ " M publish Connectable sources not supported outside `Flowable` and `Observable`. Use a `MaybeSubject`.",
+ " S publish Connectable sources not supported outside `Flowable` and `Observable`. Use a `SingleSubject`.",
+ " C publish Connectable sources not supported outside `Flowable` and `Observable`. Use a `ConnectableSubject`.",
+ " MS range At most one item. Use [`just()`](#just).",
+ " C range Always empty. Use [`complete()`](#complete).",
+ " MS rangeLong At most one item. Use [`just()`](#just).",
+ " C rangeLong Always empty. Use [`complete()`](#complete).",
+ " OMSC rebatchRequests Backpressure related and not supported outside `Flowable`.",
+ " MS reduce At most one item. Use [`map()`](#map).",
+ " C reduce Always empty thus no items to reduce.",
+ " MS reduceWith At most one item. Use [`map()`](#map).",
+ " C reduceWith Always empty thus no items to reduce.",
+ " M replay Connectable sources not supported outside `Flowable` and `Observable`. Use a `MaybeSubject`.",
+ " S replay Connectable sources not supported outside `Flowable` and `Observable`. Use a `SingleSubject`.",
+ " C replay Connectable sources not supported outside `Flowable` and `Observable`. Use a `ConnectableSubject`.",
+ " MS sample At most one item, would be no-op.",
+ " C sample Always empty thus no items to work with.",
+ " MS scan At most one item. Use [`map()`](#map).",
+ " C scan Always empty thus no items to reduce.",
+ " MS scanWith At most one item. Use [`map()`](#map).",
+ " C scanWith Always empty thus no items to reduce.",
+ " MSC serialize At most one signal type.",
+ " M share Connectable sources not supported outside `Flowable` and `Observable`. Use a `MaybeSubject`.",
+ " S share Connectable sources not supported outside `Flowable` and `Observable`. Use a `SingleSubject`.",
+ " C share Connectable sources not supported outside `Flowable` and `Observable`. Use a `ConnectableSubject`.",
+ " M single At most one item. Use [`defaultIfEmpty`](#defaultIfEmpty).",
+ " S single Always one item.",
+ " C single Always empty. Use [`andThen()`](#andThen) to chose the follow-up sequence.",
+ " M singleElement At most one item, would be no-op.",
+ " S singleElement Always one item, would be no-op.",
+ " C singleElement Always empty.",
+ " M singleOrError At most one item, would be no-op.",
+ " S singleOrError Always one item, would be no-op.",
+ " C singleOrError Always empty. Use [`andThen()`](#andThen) and [`error()`](#error).",
+ " MS singleOrErrorStage At most one item. Use [`toCompletionStage()`](#toCompletionStage).",
+ " C singleOrErrorStage Always empty. Use [`andThen()`](#andThen), [`error()`](#error) and [`toCompletionStage()`](#toCompletionStage).",
+ " MSC singleStage At most one item. Use [`toCompletionStage()`](#toCompletionStage).",
+ " MSC skip At most one item, would be no-op.",
+ " MSC skipLast At most one item, would be no-op.",
+ " MS skipWhile At most one item. Use [`filter()`](#filter).",
+ " C skipWhile Always empty.",
+ " MSC skipUntil At most one item. Use [`takeUntil()`](#takeUntil).",
+ " MSC sorted At most one item.",
+ " MSC startWithArray Use [`startWith()`](#startWith) and [`fromArray()`](#fromArray) of `Flowable` or `Observable`.",
+ " MSC startWithItem Use [`startWith()`](#startWith) and [`just()`](#just) of another reactive type.",
+ " MSC startWithIterable Use [`startWith()`](#startWith) and [`fromIterable()`](#fromArray) of `Flowable` or `Observable`.",
+ " S switchIfEmpty Never empty.",
+ " C switchIfEmpty Always empty. Use [`defaultIfEmpty()`](#defaultIfEmpty).",
+ " MS switchMap At most one item. Use [`flatMap()`](#flatMap).",
+ " C switchMap Always empty thus no items to map.",
+ " MS switchMapDelayError At most one item. Use [`flatMap()`](#flatMap).",
+ " C switchMapDelayError Always empty thus no items to map.",
+ " MS switchMapCompletable At most one item. Use [`flatMap()`](#flatMap).",
+ " C switchMapCompletable Always empty thus no items to map.",
+ " MS switchMapCompletableDelayError At most one item. Use [`flatMap()`](#flatMap).",
+ " C switchMapCompletableDelayError Always empty thus no items to map.",
+ " MS switchMapMaybe At most one item. Use [`flatMap()`](#flatMap).",
+ " C switchMapMaybe Always empty thus no items to map.",
+ " MS switchMapMaybeDelayError At most one item. Use [`flatMap()`](#flatMap).",
+ " C switchMapMaybeDelayError Always empty thus no items to map.",
+ " MS switchMapSingle At most one item. Use [`flatMap()`](#flatMap).",
+ " C switchMapSingle Always empty thus no items to map.",
+ " MS switchMapSingleDelayError At most one item. Use [`flatMap()`](#flatMap).",
+ " C switchMapSingleDelayError Always empty thus no items to map.",
+ " MSC take At most one item, would be no-op.",
+ " MSC takeLast At most one item, would be no-op.",
+ " MS takeWhile At most one item. Use [`filter()`](#filter).",
+ " C takeWhile Always empty.",
+ " MS throttleFirst At most one item signaled so no subsequent items to work with.",
+ " C throttleFirst Always empty thus no items to work with.",
+ " MS throttleLast At most one item signaled so no subsequent items to work with.",
+ " C throttleLast Always empty thus no items to work with.",
+ " MS throttleLatest At most one item signaled so no subsequent items to work with.",
+ " C throttleLatest Always empty thus no items to work with.",
+ " MS throttleWithTimeout At most one item signaled so no subsequent items to work with.",
+ " C throttleWithTimeout Always empty thus no items to work with.",
+ " C timestamp Always empty thus no items to work with.",
+ "FO toCompletionStage Use [`firstStage`](#firstStage), [`lastStage`](#lastStage) or [`singleStage`](#singleStage).",
+ " M toList At most one element to collect. Use [`map()`](#map) and [`switchIfEmpty()`](#switchIfEmpty) to transform into a list/collection.",
+ " S toList One element to collect. Use [`map()`](#map) to transform into a list/collection.",
+ " C toList Always empty. Use [`andThen()`](#andThen) to bring in a collection.",
+ " M toMap At most one element to collect. Use [`map()`](#map) and [`switchIfEmpty()`](#switchIfEmpty) to transform into a list/collection.",
+ " S toMap One element to collect. Use [`map()`](#map) to transform into a list/collection.",
+ " C toMap Always empty. Use [`andThen()`](#andThen) to bring in a collection.",
+ " M toMultimap At most one element to collect. Use [`map()`](#map) and [`switchIfEmpty()`](#switchIfEmpty) to transform into a list/collection.",
+ " S toMultimap One element to collect. Use [`map()`](#map) to transform into a list/collection.",
+ " C toMultimap Always empty. Use [`andThen()`](#andThen) to bring in a collection.",
+ "FO toMaybe Use [`firstElement`](#firstElement), [`lastElement`](#lastElement) or [`singleElement`](#singleElement).",
+ " M toMaybe Would be no-op.",
+ " O toObservable Would be no-op.",
+ "FO toSingle Use [`firstOrError`](#firstOrError), [`lastOrError`](#lastOrError) or [`singleOrError`](#singleOrError).",
+ " S toSingle Would be no-op.",
+ "FO toSingleDefault Use [`first`](#first), [`last`](#last) or [`single`](#single).",
+ " M toSingleDefault Use [`defaultIfEmpty()`](#defaultIfEmpty).",
+ " S toSingleDefault Would be no-op.",
+ " M toSortedList At most one element to collect. Use [`map()`](#map) and [`switchIfEmpty()`](#switchIfEmpty) to transform into a list/collection.",
+ " S toSortedList One element to collect. Use [`map()`](#map) to transform into a list/collection.",
+ " C toSortedList Always empty. Use [`andThen()`](#andThen) to bring in a collection.",
+ " M window Use [`map()`](#map) and [`switchIfEmpty()`](#switchIfEmpty) to transform into a nested source.",
+ " S window Use [`map()`](#map) to transform into a nested source.",
+ " C window Always empty. Use [`andThen()`](#andThen) to bring in a nested source.",
+ " MS withLatestFrom At most one element per source. Use [`zip()`](#zip).",
+ " C withLatestFrom Always empty. Use [`merge()`](#merge).",
+ "F wrap Use [`fromPublisher()`](#fromPublisher).",
+ " C zip Use [`merge()`](#merge).",
+ " C zipArray Use [`mergeArray()`](#mergeArray).",
+ " C zipWith Use [`mergeWith()`](#mergeWith).",
+ };
+
+ static final Map> NOTES_MAP;
+ static {
+ NOTES_MAP = new HashMap<>();
+ for (String s : NOTES) {
+ char[] classes = s.substring(0, 5).trim().toCharArray();
+ int idx = s.indexOf(' ', 7);
+ String method = s.substring(6, idx);
+ String note = s.substring(idx).trim();
+
+ for (char c : classes) {
+ NOTES_MAP.computeIfAbsent(method, v -> new HashMap<>())
+ .put(String.valueOf(c), note);
+ }
}
}
}