1.x: Observable.ignoreElementsThen #3443

davidmoten · 2015-10-14T05:42:10Z

As discussed in #3113.

I also considered on a consistency basis calling it ignoreElementsWith but I don't think it carries the same clarity of meaning like startWith or concatWith. "ignore" and "then" seems to be a more natural combination in English to capture the sequential nature.

akarnokd · 2015-10-14T08:13:45Z

src/test/java/rx/internal/operators/OperatorIgnoreElementsTest.java

+                    .toList().toBlocking().single());
+        assertTrue(firstCompleted.get());
+    }
+


I'd also add a test to see if the source ignored emits an error and the other is not even subscribed. I'd do this in case one decides to write an operator directly for this use case instead of using concat.

akarnokd · 2015-10-14T08:22:26Z

Looks good but it may be confusing to users when they encounter this and concatEmptyWith() or mergeEmptyWith(), or even a backport of the Completable class.

davidmoten · 2015-10-14T23:17:09Z

Looks good but it may be confusing to users when they encounter this and concatEmptyWith() or mergeEmptyWith(), or even a backport of the Completable class.

Those operators are a little bit different and even though ignoreElementsThen can be expressed as .ignoreElements().concatEmptyWith() I think we get enough questions from user land about this issue to warrant first class support (an explicit method).

In terms of using Completable I'm assuming that ignoreElements could be modified to return a Completable and that Completable would have a concatWith operator that did the same as concatEmptyWith. That would be nice though it might be a problem for API backwards compatibility in v1.

davidmoten · 2015-10-14T23:24:12Z

Extra test has been added, thanks @akarnokd

stealthcode · 2015-11-10T20:37:58Z

This operates very similarly to #3430 concatEmptyWith. To my knowledge the functional difference between the two is that ignoreElementsThen will drop all onNexted data while concatEmptyWith will blow up if onNext is called. It seems to me that we have the following choices:

Merge both functionality but rename one to better align the API (i.e. rename ignoreElementsThen to concatEmptyWithUnchecked and create a mergeEmptyWithUnchecked).
Merge this pull request and get the unchecked functionality (auto-drop onNexted values).
Merge New operators: concatEmptyWith and mergeEmptyWith #3430 and get the checked functionality (trigger an onError when onNext is called).

@abersnaze @akarnokd preferences? I vote for option 3 above.

davidmoten · 2015-11-10T21:24:26Z

I think one thing that should drive this decision is how often the functionality of ignoreElementsThen is requested on question and answer sites. It is such a frequent use case that I think it deserves first class support.

akarnokd · 2015-11-10T21:38:50Z

Tough. I don't have any use case that would require throwing an error if the first source happens to be non-empty and even if were so, I'd use doOnNext( crash ). I'd go for option 2 and seriously think about a shorter method name.

stealthcode · 2015-11-10T21:45:03Z

How about andThen?

akarnokd · 2015-11-10T21:54:07Z

Sounds good to me.

davidmoten · 2015-11-11T00:33:27Z

Unfortunately andThen doesn't carry the meaning of ignoring the emissions of the source and could be confused with concatWith.

abersnaze · 2015-11-11T00:40:29Z

I vote for number 3 with the option to drop/onError when onNext is called.

davidmoten · 2015-11-11T03:34:14Z

I prefer #1 without a rename of ignoreElementsThen (haven't seen a better name yet)

stealthcode · 2015-12-04T23:58:24Z

So far we have 3 totally different proposals and no consensus.

Proposed by @akarnokd - Merge this pull request with a shorter name.
Proposed by @abersnaze - Change the operator in New operators: concatEmptyWith and mergeEmptyWith #3430 to have an overload to drop the values or onError. If we pick option 2 then would we merge this pull request? Would the functionality would be subsumed?
Proposed by @davidmoten - Rename the operator in New operators: concatEmptyWith and mergeEmptyWith #3430 to something that better aligns with ignoreElementsThen and merging them both.

Option 2 above gives us both behaviors with a unified name. I vote for a variation of 2...

Rename ignoreElementsThen to andThen. Also the semantics of the concat used internally should eagerly subscribe (to prevent issues with refcounted subscribers).

public Observable<R> andThen(Observable<R> doNext);
public Observable<R> andThen(Values doForValues, Observable<R> doNext);
public enum Values { Ignore, Error }

example callsite...

return inputs.publish(is -> 
    doSomeWork(Values.Ignore, is).andThen(is).retryWhen(this::tryRetry)
);

Thoughts? I'd like to close the books on these 2 PRs.

stealthcode · 2015-12-05T00:04:19Z

Or instead of an overload I'd be okay with adding a .none() that enforced no onNext values.

davidmoten · 2015-12-05T04:05:19Z

As mentioned above andThen suffers from this:

Unfortunately andThen doesn't carry the meaning of ignoring the emissions of the source and could be confused with concatWith.

stealthcode · 2015-12-05T22:48:13Z

The method name sounds fine to me. I'm thinking about the API of a
Completable which makes sense that it's logically one step of completable
work and then the next.

On Fri, Dec 4, 2015, 20:05 Dave Moten [email protected] wrote:

As mentioned above andThen suffers from this:

Unfortunately andThen doesn't carry the meaning of ignoring the emissions
of the source and could be confused with concatWith.

—
Reply to this email directly or view it on GitHub
#3443 (comment).

davidmoten · 2015-12-06T23:53:27Z

I'm sounding a bit repetitive but nothing about 'andThen' suggests that it
suppresses the onNext emissions of the first Observable. That's an issue
for readability and discoverability.

On Sun, 6 Dec 2015 09:48 Aaron Tull [email protected] wrote:

The method name sounds fine to me. I'm thinking about the API of a
Completable which makes sense that it's logically one step of completable
work and then the next.

On Fri, Dec 4, 2015, 20:05 Dave Moten [email protected] wrote:

As mentioned above andThen suffers from this:

Unfortunately andThen doesn't carry the meaning of ignoring the emissions
of the source and could be confused with concatWith.

—
Reply to this email directly or view it on GitHub
#3443 (comment).

—
Reply to this email directly or view it on GitHub
#3443 (comment).

stealthcode · 2015-12-07T23:05:01Z

@davidmoten I'm really not concerned with the name that much. I think that it's fairly clear.

What I'd really like to see happen is this...

Merge the Completable PR 1.x: Completable class to support valueless event composition + tests #3444.
Add an instance method to Observable public Completable none() that ignores all values onNexted and returns a Completable.
Add an instance method in Completable public Observable<T> concat(Observable<T>)

The usage of this would look like this.

public Observable<T> writeData(Observable<T> inputs) {
    return inputs.publish(i -> {}
        Completable work = database.insert(i).doOnNext(this::logQuery).none();
        return results.concat(i);
    });
}

This reduces a.ignoreElements().castAs(R.class).concatWith(b) to a.none().concat(b) and it's composable. I believe that @akarnokd recommended a similar approach in #3430

Now that #3444 is merged we could add these 2 methods.

davidmoten · 2015-12-08T01:10:35Z

That sounds ok

On Tue, 8 Dec 2015 10:05 Aaron Tull [email protected] wrote:

@davidmoten https://github.com/davidmoten I'm really not concerned with
the name that much. I think that it's fairly clear.

What I'd really like to see happen is this...

Merge the Completable PR 1.x: Completable class to support valueless event composition + tests #3444
1.x: Completable class to support valueless event composition + tests #3444.

Add a method Observable.none() that ignores all values onNexted and
returns a Completable.

Add an instance method in Completable public Observable
concat(Observable)

The usage of this would look like this.

public Observable writeData(Observable inputs) {
return inputs.publish(i -> {}
Completable work = database.insert(i).doOnNext(this::logQuery).none();
return results.concat(i);
});
}

This reduces a.ignoreElements().castAs(R.class).concatWith(b) to
a.none().concat(b) and it's composable. I believe that @akarnokd
https://github.com/akarnokd recommended a similar approach in #3430
#3430

Now that #3444 #3444 is merged
we could add these 2 methods.

—
Reply to this email directly or view it on GitHub
#3443 (comment).

stealthcode · 2015-12-08T02:08:43Z

Great. I like this better as well. @abersnaze @akarnokd - do you guys agree with this approach?

abersnaze · 2015-12-09T01:02:09Z

I don't particularly like none() maybe toCompletable() to match toSingle() otherwise a solid plan.

stealthcode · 2015-12-09T03:24:15Z

Next step would be to implement Completable#merge(Observable<T>)... but I'm not convinced on naming just a thought.

stealthcode · 2015-12-09T20:47:21Z

I opened a PR adding Observable<T> andThen(Observable<T>) to Completable #3570. Please comment. I'm open to different method name options.

stealthcode · 2015-12-10T19:39:36Z

@NiteshKant is this an acceptable resolution to your PR #3430? Can that PR be closed?

stealthcode · 2015-12-11T22:44:23Z

Since Completable now has an option to append an Observable I think this PR can be closed. Please comment if it needs to be reopened.

add Observable.ignoreElementsThen

1b96954

akarnokd added Enhancement Feature-Request labels Oct 14, 2015

akarnokd reviewed Oct 14, 2015
View reviewed changes

JakeWharton mentioned this pull request Oct 14, 2015

How can I use OperatorConcat<T>? #3446

Closed

add extra test for ignoreElementsThen

5ffb36e

fougere-mike mentioned this pull request Oct 22, 2015

Scheduler Synchronization? #3464

Closed

akarnokd changed the title ~~Observable.ignoreElementsThen~~ 1.x: Observable.ignoreElementsThen Nov 12, 2015

DavidMGross mentioned this pull request Dec 2, 2015

Document the new Completable Observable-like variant ReactiveX/reactivex.github.io#164

Open

stealthcode mentioned this pull request Dec 9, 2015

Implemented Observable#toCompletable #3567

Merged

stealthcode closed this Dec 11, 2015

Provide feedback

Saved searches

Use saved searches to filter your results more quickly

1.x: Observable.ignoreElementsThen #3443

1.x: Observable.ignoreElementsThen #3443

davidmoten commented Oct 14, 2015

akarnokd Oct 14, 2015

akarnokd commented Oct 14, 2015

davidmoten commented Oct 14, 2015

davidmoten commented Oct 14, 2015

stealthcode commented Nov 10, 2015

davidmoten commented Nov 10, 2015

akarnokd commented Nov 10, 2015

stealthcode commented Nov 10, 2015

akarnokd commented Nov 10, 2015

davidmoten commented Nov 11, 2015

abersnaze commented Nov 11, 2015

davidmoten commented Nov 11, 2015

stealthcode commented Dec 4, 2015

stealthcode commented Dec 5, 2015

davidmoten commented Dec 5, 2015

stealthcode commented Dec 5, 2015

davidmoten commented Dec 6, 2015

stealthcode commented Dec 7, 2015

davidmoten commented Dec 8, 2015

stealthcode commented Dec 8, 2015

abersnaze commented Dec 9, 2015

stealthcode commented Dec 9, 2015

stealthcode commented Dec 9, 2015

stealthcode commented Dec 10, 2015

stealthcode commented Dec 11, 2015

1.x: Observable.ignoreElementsThen #3443

1.x: Observable.ignoreElementsThen #3443

Conversation

davidmoten commented Oct 14, 2015

akarnokd Oct 14, 2015

Choose a reason for hiding this comment

akarnokd commented Oct 14, 2015

davidmoten commented Oct 14, 2015

davidmoten commented Oct 14, 2015

stealthcode commented Nov 10, 2015

davidmoten commented Nov 10, 2015

akarnokd commented Nov 10, 2015

stealthcode commented Nov 10, 2015

akarnokd commented Nov 10, 2015

davidmoten commented Nov 11, 2015

abersnaze commented Nov 11, 2015

davidmoten commented Nov 11, 2015

stealthcode commented Dec 4, 2015

stealthcode commented Dec 5, 2015

davidmoten commented Dec 5, 2015

stealthcode commented Dec 5, 2015

davidmoten commented Dec 6, 2015

stealthcode commented Dec 7, 2015

davidmoten commented Dec 8, 2015

stealthcode commented Dec 8, 2015

abersnaze commented Dec 9, 2015

stealthcode commented Dec 9, 2015

stealthcode commented Dec 9, 2015

stealthcode commented Dec 10, 2015

stealthcode commented Dec 11, 2015