and at least optional makes it explicit that null can be emitted

@thomasnield Can you give an example? I haven't come across such need yet (but I don't argue there may be some 😃)

I have an example of it. I am working on an app that is designed to work with some video recording hardware but it doesn’t require it to function. There is a chain of network calls to make to get the data needed to connect to the hardware that could fail at various points. I can cleanly model the whole operation as

Observable<Optional<DvrService>>

this allows me to keep retrying to connect to the device if the empty optional was caused by network flake rather than non existent hardware registrations.

But your network calls can be done using Maybe, I guess?

Which also allows you to easily retry

actually in my case we are still using rx1 due to some external downstream issues 😞

Ok, that’s a different case 😉 You could even use

null

in that case 😄

yea could just trying not to do anything new like that since the 1->2 migration is imminent

You'll like 2.0 😉

The only thing not to like is it's dual nature - Observable vs Flowable 😃

it was for good reasons. but yea one more thing to get backwards 👍

@damirb has left the channel

given two observables of a type that extends

Event

, how would I merge them into a single stream/observable of it's common super type

Event

?

there is a

cast

operator you can call on each of them and then use

merge

do I really have to cast? 😕 I thought there'd be a more elegant alternative

maybe I can use kotlins syntax for covariance and somehow come up with a

mergeCast

extension function

that is probably the right thing to do

at the least the extension will make your calling code more readable

@tschuchort I don’t think I understand your question. If you have two classes that extend from a common base, then even simple

Observable.merge()

casts them to the parent type

I have, but it doesn't seem to work

The following works for me:

@User uploaded a file: Untitled

hmm, that's exactly how I do it 😕

It has to work 🙂 It’s not even related to RX IMO, but to the way generics work

Yes, you can also be explicit and put

Observable.merge<TYPE>()

but it should work without it

Is there some java interop at play here maybe messing with type inference on generics?

all in kotlin works fine for me as well

@gregd @damien5314 In user interfaces, it is not uncommon to have no value selected for a control at all (e.g. a

ComboBox<String>

that doesn't have a selection yet). It is valid to emit that null value as an

Optional<String>

which indicates a state that nothing is selected

I implemented this distinction in RxJavaFX. https://github.com/ReactiveX/RxJavaFX/blob/2.x/src/main/java/io/reactivex/rxjavafx/observables/JavaFxObservable.java#L76:L89

Why can’t it simply return an empty String? For example RxBinding for Android works this way