all(Func1<? super T, Boolean>) |
forall(T => Boolean) |
amb(Observable<? extends T>, Observable<? extends T>)
amb(...)
amb(...)
amb(...)
amb(...)
amb(...)
amb(...)
amb(...) |
unnecessary because we can use o1 amb o2 instead or amb(List(o1, o2, o3, ...) |
amb(Iterable<? extends Observable<? extends T>>) |
amb(Observable[T]*) |
ambWith(Observable<? extends T>) |
amb(Observable[U]) |
asObservable() |
considered unnecessary in Scala land |
buffer(Int) |
tumblingBuffer(Int) |
buffer(Long, TimeUnit) |
tumblingBuffer(Duration) |
buffer(Func0<? extends Observable<? extends TClosing>>)
buffer(Observable<B>) |
tumblingBuffer(=> Observable[Any]) |
buffer(Long, Long, TimeUnit, Scheduler) |
slidingBuffer(Duration, Duration, Scheduler) |
buffer(Int, Int) |
slidingBuffer(Int, Int) |
buffer(Long, TimeUnit, Scheduler) |
tumblingBuffer(Duration, Scheduler) |
buffer(...) |
slidingBuffer(Observable[Opening])(Opening => Observable[Any]) |
buffer(Long, TimeUnit, Int, Scheduler) |
tumblingBuffer(Duration, Int, Scheduler) |
buffer(Observable<B>, Int) |
tumblingBuffer(Observable[Any], Int) |
buffer(Long, Long, TimeUnit) |
slidingBuffer(Duration, Duration) |
buffer(Long, TimeUnit, Int) |
tumblingBuffer(Duration, Int) |
cache(Int) |
cache(Int) |
cache() |
cache |
cast(Class<R>) |
RxJava needs this one because rx.Observable is invariant. Observable in RxScala is covariant and does not need this operator. |
collect(Func0<R>, Action2<R, ? super T>) |
TODO: See https://github.com/ReactiveX/RxScala/issues/63 |
combineLatest(...) |
combineLatest(Observable[U]) |
combineLatest(...)
combineLatest(...)
combineLatest(...)
combineLatest(...)
combineLatest(...)
combineLatest(...)
combineLatest(...) |
If C# doesn't need it, Scala doesn't need it either ;-) |
combineLatest(...) |
combineLatest(Seq[Observable[T]])(Seq[T] => R) |
compose(Transformer<? super T, ? extends R>) |
use extension methods instead |
concat(Observable<? extends Observable<? extends T>>) |
concat(<:<[Observable[T], Observable[Observable[U]]]) |
concat(Observable<? extends T>, Observable<? extends T>)
concat(...)
concat(...)
concat(...)
concat(...)
concat(...)
concat(...)
concat(...) |
unnecessary because we can use ++ instead or Observable(o1, o2, ...).concat |
concatEager(Iterable<? extends Observable<? extends T>>, Int) |
use iter.toObservable.concatEager(Int) |
concatEager(Observable<? extends Observable<? extends T>>, Int) |
concatEager(Int)(<:<[Observable[T], Observable[Observable[U]]]) |
concatEager(Observable<? extends T>, Observable<? extends T>)
concatEager(...)
concatEager(...)
concatEager(...)
concatEager(...)
concatEager(...)
concatEager(...)
concatEager(...) |
unnecessary because we can use concatEager instead or Observable(o1, o2, ...).concatEager |
concatEager(Iterable<? extends Observable<? extends T>>) |
use iter.toObservable.concatEager |
concatEager(Observable<? extends Observable<? extends T>>) |
concatEager(<:<[Observable[T], Observable[Observable[U]]]) |
concatMap(Func1<? super T, ? extends Observable<? extends R>>) |
concatMap(T => Observable[R]) |
concatMapEager(...) |
concatMapEager(Int, T => Observable[R]) |
concatMapEager(...) |
concatMapEager(T => Observable[R]) |
concatWith(Observable<? extends T>) |
use o1 ++ o2 |
contains(Any) |
contains(U) |
count() |
length |
countLong() |
countLong |
create(OnSubscribe<T>) |
apply(Subscriber[T] => Unit) |
debounce(Long, TimeUnit) |
debounce(Duration) |
debounce(Func1<? super T, ? extends Observable<U>>) |
debounce(T => Observable[Any]) |
debounce(Long, TimeUnit, Scheduler) |
debounce(Duration, Scheduler) |
defaultIfEmpty(T) |
orElse(=> U) |
defer(Func0<Observable<T>>) |
defer(=> Observable[T]) |
delay(Long, TimeUnit) |
delay(Duration) |
delay(...) |
delay(() => Observable[Any], T => Observable[Any]) |
delay(Long, TimeUnit, Scheduler) |
delay(Duration, Scheduler) |
delay(Func1<? super T, ? extends Observable<U>>) |
delay(T => Observable[Any]) |
delaySubscription(Long, TimeUnit, Scheduler) |
delaySubscription(Duration, Scheduler) |
delaySubscription(Func0<? extends Observable<U>>) |
delaySubscription(() => Observable[Any]) |
delaySubscription(Long, TimeUnit) |
delaySubscription(Duration) |
dematerialize() |
dematerialize(<:<[Observable[T], Observable[Notification[U]]]) |
distinct(Func1<? super T, ? extends U>) |
distinct(T => U) |
distinct() |
distinct |
distinctUntilChanged() |
distinctUntilChanged |
distinctUntilChanged(Func1<? super T, ? extends U>) |
distinctUntilChanged(T => U) |
doOnCompleted(Action0) |
doOnCompleted(=> Unit) |
doOnEach(Action1<Notification<? super T>>) |
use doOnEach(T => Unit, Throwable => Unit, () => Unit) |
doOnEach(Observer<? super T>) |
doOnEach(Observer[T]) |
doOnError(Action1<Throwable>) |
doOnError(Throwable => Unit) |
doOnNext(Action1<? super T>) |
doOnNext(T => Unit) |
doOnRequest(Action1<Long>) |
doOnRequest(Long => Unit) |
doOnSubscribe(Action0) |
doOnSubscribe(=> Unit) |
doOnTerminate(Action0) |
doOnTerminate(=> Unit) |
doOnUnsubscribe(Action0) |
doOnUnsubscribe(=> Unit) |
elementAt(Int) |
elementAt(Int) |
elementAtOrDefault(Int, T) |
elementAtOrDefault(Int, U) |
empty() |
empty |
error(Throwable) |
error(Throwable) |
exists(Func1<? super T, Boolean>) |
exists(T => Boolean) |
extend(Func1<? super OnSubscribe<T>, ? extends R>) |
use Scala implicit feature to extend Observable |
filter(Func1<? super T, Boolean>) |
filter(T => Boolean) |
finallyDo(Action0) |
finallyDo(=> Unit) |
first() |
first |
first(Func1<? super T, Boolean>) |
use .filter(condition).first |
firstOrDefault(T, Func1<? super T, Boolean>) |
use .filter(condition).firstOrElse(default) |
firstOrDefault(T) |
firstOrElse(=> U) |
flatMap(...) |
flatMap(T => Observable[R], Throwable => Observable[R], () => Observable[R]) |
flatMap(...) |
flatMap(Int, T => Observable[R], Throwable => Observable[R], () => Observable[R]) |
flatMap(...) |
flatMap(Int, T => Observable[R]) |
flatMap(...) |
flatMapWith(Int, T => Observable[U])((T, U) => R) |
flatMap(...) |
flatMapWith(T => Observable[U])((T, U) => R) |
flatMap(Func1<? super T, ? extends Observable<? extends R>>) |
flatMap(T => Observable[R]) |
flatMapIterable(...) |
flatMapIterable(T => Iterable[R]) |
flatMapIterable(...) |
flatMapIterableWith(T => Iterable[U])((T, U) => R) |
forEach(Action1<? super T>) |
foreach(T => Unit) |
forEach(Action1<? super T>, Action1<Throwable>, Action0) |
foreach(T => Unit, Throwable => Unit, () => Unit) |
forEach(Action1<? super T>, Action1<Throwable>) |
foreach(T => Unit, Throwable => Unit) |
from(Future<? extends T>)
from(Future<? extends T>, Long, TimeUnit)
from(Future<? extends T>, Scheduler) |
TODO: Decide how Scala Futures should relate to Observables. Should there be a common base interface for Future and Observable? And should Futures also have an unsubscribe method? |
from(T[])
from(Iterable<? extends T>) |
from(Iterable[T]) |
fromCallable(Callable<? extends T>) |
use Observable.defer(Observable.just(expensiveComputation)) |
groupBy(Func1<? super T, ? extends K>) |
groupBy(T => K) |
groupBy(...) |
groupBy(T => K, T => V) |
groupJoin(...) |
groupJoin(Observable[S])(T => Observable[Any], S => Observable[Any], (T, Observable[S]) => R) |
ignoreElements() |
use filter(_ => false) |
interval(Long, TimeUnit) |
interval(Duration) |
interval(Long, Long, TimeUnit) |
interval(Duration, Duration) |
interval(Long, Long, TimeUnit, Scheduler) |
interval(Duration, Duration, Scheduler) |
interval(Long, TimeUnit, Scheduler) |
interval(Duration, Scheduler) |
isEmpty() |
isEmpty |
join(...) |
join(Observable[S])(T => Observable[Any], S => Observable[Any], (T, S) => R) |
just(T)
just(T, T)
just(T, T, T)
just(T, T, T, T)
just(T, T, T, T, T)
just(T, T, T, T, T, T)
just(T, T, T, T, T, T, T)
just(T, T, T, T, T, T, T, T)
just(T, T, T, T, T, T, T, T, T)
just(T, T, T, T, T, T, T, T, T, T) |
use just(T*) |
last() |
last |
last(Func1<? super T, Boolean>) |
use filter(predicate).last |
lastOrDefault(T, Func1<? super T, Boolean>) |
use filter(predicate).lastOrElse(default) |
lastOrDefault(T) |
lastOrElse(=> U) |
lift(Operator<? extends R, ? super T>) |
lift(Subscriber[R] => Subscriber[T]) |
limit(Int) |
take(Int) |
map(Func1<? super T, ? extends R>) |
map(T => R) |
materialize() |
materialize |
merge(Array<Observable<? extends T>>, Int) |
use Observable.from(array).flatten(n) |
merge(Array<Observable<? extends T>>) |
use Observable.from(array).flatten |
merge(...)
merge(...)
merge(...)
merge(...)
merge(...)
merge(...)
merge(...) |
unnecessary because we can use Observable(o1, o2, ...).flatten instead |
merge(Observable<? extends Observable<? extends T>>) |
flatten(<:<[Observable[T], Observable[Observable[U]]]) |
merge(Observable<? extends T>, Observable<? extends T>) |
merge(Observable[U]) |
merge(Iterable<? extends Observable<? extends T>>) |
use Observable.from(iter).flatten |
merge(Observable<? extends Observable<? extends T>>, Int) |
flatten(Int)(<:<[Observable[T], Observable[Observable[U]]]) |
merge(Iterable<? extends Observable<? extends T>>, Int) |
use Observable.from(iter).flatten(n) |
mergeDelayError(Observable<? extends Observable<? extends T>>) |
flattenDelayError(<:<[Observable[T], Observable[Observable[U]]]) |
mergeDelayError(...) |
flattenDelayError(Int)(<:<[Observable[T], Observable[Observable[U]]]) |
mergeDelayError(...)
mergeDelayError(...)
mergeDelayError(...)
mergeDelayError(...)
mergeDelayError(...)
mergeDelayError(...)
mergeDelayError(...) |
unnecessary because we can use Observable(o1, o2, ...).flattenDelayError instead |
mergeDelayError(...) |
mergeDelayError(Observable[U]) |
mergeWith(Observable<? extends T>) |
merge(Observable[U]) |
nest() |
nest |
never() |
never |
observeOn(Scheduler) |
observeOn(Scheduler) |
ofType(Class<R>) |
use filter(_.isInstanceOf[Class]) |
onBackpressureBuffer(Long) |
onBackpressureBuffer(Long) |
onBackpressureBuffer(Long, Action0) |
onBackpressureBuffer(Long, => Unit) |
onBackpressureBuffer() |
onBackpressureBuffer |
onBackpressureDrop(Action1<? super T>) |
onBackpressureDrop(T => Unit) |
onBackpressureDrop() |
onBackpressureDrop |
onBackpressureLatest() |
onBackpressureLatest |
onErrorResumeNext(...)
onErrorResumeNext(Observable<? extends T>) |
onErrorResumeNext(Throwable => Observable[U]) |
onErrorReturn(Func1<Throwable, ? extends T>) |
onErrorReturn(Throwable => U) |
onExceptionResumeNext(Observable<? extends T>) |
onExceptionResumeNext(Observable[U]) |
publish() |
publish |
publish(Func1<? super Observable<T>, ? extends Observable<R>>) |
publish(Observable[T] => Observable[R]) |
range(Int, Int) |
The range method of the Java Observable takes start and count parameters, whereas the range method of the Scala Iterable takes start and end parameters, so adding any of these two would be confusing. Moreover, since scala.collection.immutable.Range is a subtype of Iterable, there are two nice ways of creating range Observables: (start to end).toObservable or Observable.from(start to end), and even more options are possible using until and by. |
range(Int, Int, Scheduler) |
use (start until end).toObservable.subscribeOn(scheduler) instead of range(start, count, scheduler) |
reduce(Func2<T, T, T>) |
reduce((U, U) => U) |
reduce(R, Func2<R, ? super T, R>) |
foldLeft(R)((R, T) => R) |
repeat() |
repeat |
repeat(Long) |
repeat(Long) |
repeat(Long, Scheduler) |
repeat(Long, Scheduler) |
repeat(Scheduler) |
repeat(Scheduler) |
repeatWhen(...) |
repeatWhen(Observable[Unit] => Observable[Any]) |
repeatWhen(...) |
repeatWhen(Observable[Unit] => Observable[Any], Scheduler) |
replay(...) |
replay(Observable[T] => Observable[R], Int, Duration, Scheduler) |
replay(...) |
replay(Observable[T] => Observable[R], Scheduler) |
replay(Long, TimeUnit, Scheduler) |
replay(Duration, Scheduler) |
replay(Scheduler) |
replay(Scheduler) |
replay(...) |
replay(Observable[T] => Observable[R], Int) |
replay(...) |
replay(Observable[T] => Observable[R], Duration) |
replay(Long, TimeUnit) |
replay(Duration) |
replay(Int, Long, TimeUnit) |
replay(Int, Duration) |
replay(...) |
replay(Observable[T] => Observable[R], Int, Duration) |
replay(Int, Long, TimeUnit, Scheduler) |
replay(Int, Duration, Scheduler) |
replay(Func1<? super Observable<T>, ? extends Observable<R>>) |
replay(Observable[T] => Observable[R]) |
replay(Int) |
replay(Int) |
replay(...) |
replay(Observable[T] => Observable[R], Int, Scheduler) |
replay(...) |
replay(Observable[T] => Observable[R], Duration, Scheduler) |
replay(Int, Scheduler) |
replay(Int, Scheduler) |
replay() |
replay |
retry(Long) |
retry(Long) |
retry() |
retry |
retry(Func2<Integer, Throwable, Boolean>) |
retry((Int, Throwable) => Boolean) |
retryWhen(...) |
retryWhen(Observable[Throwable] => Observable[Any]) |
retryWhen(...) |
retryWhen(Observable[Throwable] => Observable[Any], Scheduler) |
sample(Long, TimeUnit) |
sample(Duration) |
sample(Long, TimeUnit, Scheduler) |
sample(Duration, Scheduler) |
sample(Observable<U>) |
sample(Observable[Any]) |
scan(Func2<T, T, T>) |
considered unnecessary in Scala land |
scan(R, Func2<R, ? super T, R>) |
scan(R)((R, T) => R) |
sequenceEqual(Observable<? extends T>, Observable<? extends T>) |
sequenceEqual(Observable[U]) |
sequenceEqual(...) |
sequenceEqualWith(Observable[U])((U, U) => Boolean) |
serialize() |
serialize |
share() |
share |
single(Func1<? super T, Boolean>) |
use filter(predicate).single |
single() |
single |
singleOrDefault(T, Func1<? super T, Boolean>) |
use filter(predicate).singleOrElse(default) |
singleOrDefault(T) |
singleOrElse(=> U) |
skip(Long, TimeUnit, Scheduler) |
drop(Duration, Scheduler) |
skip(Int) |
drop(Int) |
skip(Long, TimeUnit) |
drop(Duration) |
skipLast(Long, TimeUnit, Scheduler) |
dropRight(Duration, Scheduler) |
skipLast(Long, TimeUnit) |
dropRight(Duration) |
skipLast(Int) |
dropRight(Int) |
skipUntil(Observable<U>) |
dropUntil(Observable[Any]) |
skipWhile(Func1<? super T, Boolean>) |
dropWhile(T => Boolean) |
startWith(Iterable<T>) |
use Observable.from(iterable) ++ o |
startWith(T, T)
startWith(T, T, T)
startWith(T, T, T, T)
startWith(T, T, T, T, T)
startWith(T, T, T, T, T, T)
startWith(T, T, T, T, T, T, T)
startWith(T, T, T, T, T, T, T, T)
startWith(T, T, T, T, T, T, T, T, T) |
use Observable.just(...) ++ o |
startWith(T) |
use item +: o |
startWith(Observable<T>) |
use ++ |
subscribe(Action1<? super T>, Action1<Throwable>) |
subscribe(T => Unit, Throwable => Unit) |
subscribe(Action1<? super T>, Action1<Throwable>, Action0) |
subscribe(T => Unit, Throwable => Unit, () => Unit) |
subscribe() |
subscribe() |
subscribe(Action1<? super T>) |
subscribe(T => Unit) |
subscribe(Subscriber<? super T>) |
subscribe(Subscriber[T]) |
subscribe(Observer<? super T>) |
subscribe(Observer[T]) |
subscribeOn(Scheduler) |
subscribeOn(Scheduler) |
switchIfEmpty(Observable<? extends T>) |
switchIfEmpty(Observable[U]) |
switchMap(Func1<? super T, ? extends Observable<? extends R>>) |
switchMap(T => Observable[R]) |
switchOnNext(Observable<? extends Observable<? extends T>>) |
switch(<:<[Observable[T], Observable[Observable[U]]]) |
take(Long, TimeUnit, Scheduler) |
take(Duration, Scheduler) |
take(Int) |
take(Int) |
take(Long, TimeUnit) |
take(Duration) |
takeFirst(Func1<? super T, Boolean>) |
use filter(condition).take(1) |
takeLast(Int, Long, TimeUnit) |
takeRight(Int, Duration) |
takeLast(Long, TimeUnit, Scheduler) |
takeRight(Duration, Scheduler) |
takeLast(Int, Long, TimeUnit, Scheduler) |
takeRight(Int, Duration, Scheduler) |
takeLast(Long, TimeUnit) |
takeRight(Duration) |
takeLast(Int) |
takeRight(Int) |
takeLastBuffer(Int)
takeLastBuffer(Int, Long, TimeUnit)
takeLastBuffer(Int, Long, TimeUnit, Scheduler)
takeLastBuffer(Long, TimeUnit)
takeLastBuffer(Long, TimeUnit, Scheduler) |
use takeRight(...).toSeq |
takeUntil(Func1<? super T, Boolean>) |
takeUntil(T => Boolean) |
takeUntil(Observable<? extends E>) |
takeUntil(Observable[Any]) |
takeWhile(Func1<? super T, Boolean>) |
takeWhile(T => Boolean) |
throttleFirst(Long, TimeUnit) |
throttleFirst(Duration) |
throttleFirst(Long, TimeUnit, Scheduler) |
throttleFirst(Duration, Scheduler) |
throttleLast(Long, TimeUnit) |
throttleLast(Duration) |
throttleLast(Long, TimeUnit, Scheduler) |
throttleLast(Duration, Scheduler) |
throttleWithTimeout(Long, TimeUnit, Scheduler) |
throttleWithTimeout(Duration, Scheduler) |
throttleWithTimeout(Long, TimeUnit) |
throttleWithTimeout(Duration) |
timeInterval() |
timeInterval |
timeInterval(Scheduler) |
timeInterval(Scheduler) |
timeout(...) |
timeout(T => Observable[Any], Observable[U]) |
timeout(...) |
timeout(() => Observable[Any], T => Observable[Any]) |
timeout(Func1<? super T, ? extends Observable<V>>) |
timeout(T => Observable[Any]) |
timeout(Long, TimeUnit, Observable<? extends T>) |
timeout(Duration, Observable[U]) |
timeout(Long, TimeUnit, Observable<? extends T>, Scheduler) |
timeout(Duration, Observable[U], Scheduler) |
timeout(Long, TimeUnit) |
timeout(Duration) |
timeout(...) |
timeout(() => Observable[Any], T => Observable[Any], Observable[U]) |
timeout(Long, TimeUnit, Scheduler) |
timeout(Duration, Scheduler) |
timer(Long, TimeUnit, Scheduler) |
timer(Duration, Scheduler) |
timer(Long, TimeUnit) |
timer(Duration) |
timestamp(Scheduler) |
timestamp(Scheduler) |
timestamp() |
timestamp |
toBlocking() |
toBlocking |
toList() |
toSeq |
toMap(...) |
toMap(T => K, T => V) |
toMap(Func1<? super T, ? extends K>) |
toMap(T => K) |
toMap(...) |
mapFactory is not necessary because Scala has CanBuildFrom |
toMultimap(...) |
toMultiMap in RxScala returns mutable.MultiMap. It's a Map[A, mutable.Set[B]]. You can override def makeSet: Set[B] to create a custom Set. |
toMultimap(Func1<? super T, ? extends K>) |
toMultiMap(T => K) |
toMultimap(...) |
toMultiMap(T => K, T => V, => M) |
toMultimap(...) |
toMultiMap(T => K, T => V) |
toSingle() |
TODO |
toSortedList(Func2<? super T, ? super T, Integer>)
toSortedList(Func2<? super T, ? super T, Integer>, Int) |
Sorting is already done in Scala's collection library, use .toSeq.map(_.sortWith(f)) |
toSortedList()
toSortedList(Int) |
Sorting is already done in Scala's collection library, use .toSeq.map(_.sorted) |
unsafeSubscribe(Subscriber<? super T>) |
unsafeSubscribe(Subscriber[T]) |
unsubscribeOn(Scheduler) |
unsubscribeOn(Scheduler) |
using(...)
using(...) |
using(=> Resource)(Resource => Observable[T], Resource => Unit, Boolean) |
window(Long, TimeUnit, Scheduler) |
tumbling(Duration, Scheduler) |
window(Func0<? extends Observable<? extends TClosing>>)
window(Observable<U>) |
tumbling(=> Observable[Any]) |
window(Int) |
tumbling(Int) |
window(Long, Long, TimeUnit) |
sliding(Duration, Duration) |
window(Int, Int) |
sliding(Int, Int) |
window(Long, Long, TimeUnit, Int, Scheduler) |
sliding(Duration, Duration, Int, Scheduler) |
window(Long, TimeUnit, Int, Scheduler) |
tumbling(Duration, Int, Scheduler) |
window(Long, Long, TimeUnit, Scheduler) |
sliding(Duration, Duration, Scheduler) |
window(...) |
sliding(Observable[Opening])(Opening => Observable[Any]) |
window(Long, TimeUnit) |
tumbling(Duration) |
window(Long, TimeUnit, Int) |
tumbling(Duration, Int) |
withLatestFrom(...) |
withLatestFrom(Observable[U])((T, U) => R) |
zip(...) |
use instance method zip and map |
zip(Iterable<? extends Observable<_>>, FuncN<? extends R>)
zip(Observable<? extends Observable<_>>, FuncN<? extends R>) |
use zip in companion object and map |
zip(...)
zip(...)
zip(...)
zip(...)
zip(...)
zip(...)
zip(...) |
considered unnecessary in Scala land |
zipWith(...) |
zipWith(Iterable[U])((T, U) => R) |
zipWith(...) |
zipWith(Observable[U])((T, U) => R) |
ReactiveX