combineWithMostRecent

[samuelgruetter]

I'm looking for an operation which does the following:

Whenever Observable o1 emits an item, combine this item with the most recent item of Observable o2.

Illustration:

----A-------B------C----->  o1

--0----1-2----3-4-------->  o2

    |       |      |
    V       V      V

  (A,0)   (B,2)  (C,4)

I can't find a nice way of doing this.
Can anyone help me?
Or do we need to add a new operation to rx.Observable?

[jmhofer]

Actually, combineLatest together with distinctUntilChanged, with equality based on the tuple projection would work here I think. Maybe there's an easier way, but this is what first came to my mind...

[samuelgruetter]

But what if o1 emits two equal items in sequence?

[abersnaze]

If that is part of your problem we're discussing the distinct operator here. #395 (comment)

[jmhofer]

Maybe this is a Join use case? I found a description here.

[headinthebox]

Join is hardly ever used, and the semantics are subtle. and because of all the functions you need to pass pretty nasty if you don't have groupBy query comprehension syntax.

But implementing it would be a fun task for anyone that wants to dig down to the next level of detail.

Watch http://channel9.msdn.com/Series/Rx-Workshop/Rx-Workshop-7-Reactive-Coincidence first ...

On Sep 24, 2013, at 7:32 AM, Joachim Hofer notifications@github.com wrote:

Maybe this is a Join use case? I found a description here.

—
Reply to this email directly or view it on GitHub.

[jmhofer]

This means that maybe it's a good idea to add combineWithMostRecent (as described by @samuelgruetter) as an operator? - To me it sounds like a relatively frequent use case.

[zorba128]

I have similar problem - came up with:

public static <T, U, R> Observable<R> enrich(Observable<T> source, Observable<U> data, Func2<T, U, R> f) {
    return Observable.zip(source, data.sample(source), f);
}

but noticed sample() doesn't really sample input - it doesn't emit last value multiple times when no change occured between timer, causing zip operation to get out of sync.

Isn't that a bug (or at least serious documentation problem) with sample()?

marcin

[samuelgruetter]

I agree, that's inconsistent: sample(long, TimeUnit) emits the last value multiple times if the source observable didn't emit a new value between two ticks, but sample(Observable<U>) does not repeat it, and this line suggests it was done on purpose. But I think sample(Observable<U>) should be changed to match the behavior of sample(long, TimeUnit).

[benjchristensen]

How about this?

    Observable.combineLatest(a, b, { x, y -> [x, y] })
        .distinctUntilChanged({ tuple -> tuple[0]})
        .distinctUntilChanged({ tuple -> tuple[1]})
        .toBlockingObservable().forEach({ v-> println(v)})

[samuelgruetter]

Regarding issue1: How to get combineWithMostRecent/enrich behavior: What if the source Observable a emits two equal values in succession? We still want to see this in the resulting Observable, so we can't use an approach with distinctUntilChanged.

Regarding issue2: Is the behavior of sample(Observable<U>) correct? @benjchristensen what do you think?

[benjchristensen]

The sample operator was fixed in v0.18.2.

[samuelgruetter]

Note: The sample operator was indeed fixed, but not the way @zorba128 and me would have expected. sample(Observable<U>) and sample(long, TimeUnit) are now consistent and both do not emit the last value multiple times if it hasn't changed between two sampler ticks.

[I've reread this thread because this question was asked on stackoverflow].

[benjchristensen]

Would something like the following work:

observableA.combineWithMostRecentFrom(observableB)

This would different from combineLatest as it would not emit all permutations. It would only emit when A emits and take whatever the last from B was.

Then the A observable could be the "slow one" and we just grab whatever the last from B was.

[staltz]

Guys, guys, we need to solve this one. I've been using this "combineWithMostRecent" or "enrich" (I call it "combinePrev") many times in an Android project in production. It's very useful. Basically what we need is the asymmetric version of combineLatest. I used to have an implementation of it based on join, and I informed @mattpodwysocki that it would be good if we could do that in RxJS too, see Reactive-Extensions/RxJS#335 (comment).

My implementation of the operator with join is this:

 /**
   * Similar to combineLatest, except it joins the latestitems from the two source
   * observables only when the first observable emits an item.
   * 
   * first:  ------f----f-------------f--------------f----|>
   * second: ---s1----------s---s--s3-----s-s-s-s4--------|>
   * result: ------R1---R1------------R3-------------R4---|>
   * 
   * @param first
   *        The first source Observable
   * @param second
   *        The second source Observable
   * @param combineFunction
   *        the aggregation function used to combine the items emitted by the source
   *        Observables
   * @return an Observable that emits items that are the result of combining the items
   *         emitted by the source Observables by means of the given function
   */
  public static <TFirst, TSecond, R> Observable<R> combinePrev(
    final Observable<TFirst> first, 
    final Observable<TSecond> second, 
    final Func2<TFirst, TSecond, R> combineFunction) 
  {
    final Observable<TSecond> hotSecond = second.publish().refCount();
    return first.join(hotSecond, new Func1<TFirst, Observable<Object>>() {
      public Observable<Object> call(final TFirst it) {
        return Observable.<Object>empty();
      }
    }, new Func1<TSecond, Observable<TSecond>>() {
      public Observable<TSecond> call(final TSecond it) {
        return hotSecond;
      }
    }, combineFunction);
  }

But I just figured a much simpler implementation based only on map and switch, basically this:

A.map({a -> B.map({b -> [a, b]})}).switch()

See this StackOverflow answer I wrote.