I want to implement the following functions in the most re-active way. I need these for implementing the bijections for automatic conversion between the said types.
def convertScalaRXObservableToTwitterFuture[A](a: Observable[A]): TwitterFuture[A] = ???
def convertScalaRXObservableToTwitterFutureList[A](a: Observable[A]): TwitterFuture[List[A]] = ???
I came across this article on a related subject but I can't get it working.
Unfortunately the claim in that article is not correct and there can't be a true bijection between Observable
and anything like Future
. The thing is that Observable
is more powerful abstraction that can represent things that can't be represented by Future
. For example, Observable
might actually represent an infinite sequence. For example see Observable.interval
. Obviously there is no way to represent something like this with a Future
. The Observable.toList
call used in that article explicitly mentions that:
Returns a
Single
that emits a single item, a list composed of all the items emitted by the finite sourceObservableSource
.
and later it says:
Sources that are infinite and never complete will never emit anything through this operator and an infinite source may lead to a fatal OutOfMemoryError.
Even if you limit yourself to only finite Observable
s, still Future
can't fully express semantics of Observable
. Consider Observable.intervalRange
that generates a limited range one by one over some time period. With Observable
the first event comes after initialDelay
and then you get event each period
. With Future
you can get only one event and it must be only when the sequence is fully generated so Observable
is completed. It means that by transforming Observable[A]
into Future[List[A]]
you immediately break the main benefit of Observable
- reactivity: you can't process events one by one, you have to process them all in a single bunch.
To sum up the claim at the first paragraph of the article:
convert between the two, without loosing asynchronous and event-driven nature of them.
is false because conversion Observable[A]
-> Future[List[A]]
exactly looses the "event-driven nature" of Observable
and there is no way to work this around.
P.S. Actually the fact that Future
is less powerful than Observable
should not be a big surprise. If it was not, why anybody would create Observable
in the first place?