A immutable asynchronous stream
Types that can be subscribed to:
Base:
Emitter<T>
Observable<T>: T* (Completion|Error)
- Base reactive class
Single<T>: T (Completion | Exception)
Completable: Completion | Exception
- effectively Single<Unit>
Maybe<T>: T? (Completion | Exception)
- effectively Single<Unit?>
Flowable:
- a backpressure-enabled base reactive class, new in RxJava 2.0
subscribe
to one of them causes event to flow through observer.
"transforms" a observable
-- map as in Array#map
map :: Observable T1 -> (T1 -> T2) -> Observable T2
-- flatMap or (map and then flatten)
flatMap :: Observable T1 -> (T1 -> Observable T2) -> Observable T2
-- filter as in Array#filter
filter :: Observable T1 -> (T1 -> bool) -> Observable T1
-- doOnNext: like Array#tap in ruby
doOnNext :: Observable T1 -> (T1 -> void) -> Observable T1
Observable<T> Observable.create(Observable.OnSubscript<T> onsubscribe)
Observable<T> Observable.just(T value)
Subscriber<T>
with onNext
/ onCompleted
/ onError
Action1<T>
that only responds to onNext
Observable::create
Observable::Just
<Observable>#subscribe(<Observer>)
I am still in a process to generalize different "value containers".
For a value type T
, we have:
T
itself
T[]
or Array<T>
Promise<T>
subsequent
promises retured by then/catchObservable<T>
:
Flowable<T>
have same form but different behaviorSingle<T>
Completable
is effectively Single<Void>