A modern programming language that makes developers happier.

kotlinlang

Question for y'all: Is there an operator similar to `combineLatest` but that emits _as soon as_ any of the combined streams have a value? Right now it appears that `combineLatest` will only emit once _all of the streams_ have a value, and will then emit each time one of the streams is updated.

Good question. I’ve been wondering this also

There's an interesting question of what the types of that would be. Since you can't have `null` values in a stream, you'd need to represent both values as an optional or something along those lines

For each of the observables, I wonder if you could have them emit Optional.None, then perform their operation where they eventually return Optional(value)

except as far as I can tell Kotlin doesn't have a real `Optional` type

We ended up making our own at my company. Optional.None and Optional.Some with easy functions to call them, optional(value).

```    private fun s() {
        Observable.combineLatest(
                Observable.just(optional(1), optional(2)).startWith(Optional.None),
                Observable.just(optional("a", optional("b"))).startWith(Optional.None),
                BiFunction { ints: Optional&lt;Int&gt;, strings: Optional&lt;String&gt; -&gt; 
                    TODO()
                }
        )```

Doesn’t seem to be any errors here. Just doesn’t look pretty. And there is also the useless 1st case where everything is Optional.None. Not sure you want a filter that is checking every time something is emitted

Yeah I'm building basically the same thing now but with `Pair`s that are really `Either`s...

I keep trying to present to my manager a proper use-case for Either. However, every time a sealed class seems to be the better option

I mean I think a sealed class of size two _is_ an either

which I guess makes it not an either but that's pedantic

and then map em to null in the combiner function