Skip to content
New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

Sign up for GitHub

By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.

Already on GitHub? Sign in to your account

Fix javadoc for Observable.reduce() and Observable.reduceWith() #5406

Merged
merged 8 commits into from
Jun 11, 2017
Merged

Fix javadoc for Observable.reduce() and Observable.reduceWith() #5406

Show file tree
Hide file tree
Changes from all commits
Commits
Show all changes
8 commits
Select commit Hold shift + click to select a range
2db6748
fix javadoc sample code for Observable.reduce() to compile
devisnik Jun 11, 2017
7af41ac
update javadoc for Observable.reduceWith()
devisnik Jun 11, 2017
18cb093
fix javadoc sample code for Flowable.reduce() to compile
devisnik Jun 11, 2017
3b07ff6
update javadoc for Flowable.reduceWith()
devisnik Jun 11, 2017
13ac31e
remove one more word to be similar to Observable.reduce()
devisnik Jun 11, 2017
7c24e34
fix Publisher.defer() to Flowable.defer()
devisnik Jun 11, 2017
2d445bc
add example using reduceWith() to Observable.reduce() and Flowable.re…
devisnik Jun 11, 2017
6757548
add @see reduceWith() to reduce()
devisnik Jun 11, 2017
File filter

Filter by extension

Filter by extension
Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
34 changes: 13 additions & 21 deletions src/main/java/io/reactivex/Flowable.java
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -10723,18 +10723,22 @@ public final Maybe<T> reduce(BiFunction<T, T, T> reducer) {
* "compress," or "inject" in other programming contexts. Groovy, for instance, has an {@code inject} method
* that does a similar operation on lists.
* <p>
* Note that the {@code initialValue} is shared among all subscribers to the resulting Publisher
* Note that the {@code seed} is shared among all subscribers to the resulting Publisher
* and may cause problems if it is mutable. To make sure each subscriber gets its own value, defer
* the application of this operator via {@link #defer(Callable)}:
* <pre><code>
* Publisher&lt;T> source = ...
* Publisher.defer(() -> source.reduce(new ArrayList&lt;>(), (list, item) -> list.add(item)));
* Single.defer(() -> source.reduce(new ArrayList&lt;>(), (list, item) -> list.add(item)));
*
* // alternatively, by using compose to stay fluent
*
* source.compose(o ->
* Publisher.defer(() -> o.reduce(new ArrayList&lt;>(), (list, item) -> list.add(item)))
* );
* Flowable.defer(() -> o.reduce(new ArrayList&lt;>(), (list, item) -> list.add(item)).toFlowable())
* ).firstOrError();
*
* // or, by using reduceWith instead of reduce
*
* source.reduceWith(() -> new ArrayList&lt;>(), (list, item) -> list.add(item)));
* </code></pre>
* <dl>
* <dt><b>Backpressure:</b></dt>
Expand All @@ -10754,6 +10758,7 @@ public final Maybe<T> reduce(BiFunction<T, T, T> reducer) {
* items emitted by the source Publisher
* @see <a href="http://reactivex.io/documentation/operators/reduce.html">ReactiveX operators documentation: Reduce</a>
* @see <a href="http://en.wikipedia.org/wiki/Fold_(higher-order_function)">Wikipedia: Fold (higher-order function)</a>
* @see #reduceWith(Callable, BiFunction)
*/
@CheckReturnValue
@BackpressureSupport(BackpressureKind.UNBOUNDED_IN)
Expand All @@ -10766,29 +10771,16 @@ public final <R> Single<R> reduce(R seed, BiFunction<R, ? super T, R> reducer) {

/**
* Returns a Flowable that applies a specified accumulator function to the first item emitted by a source
* Publisher and a specified seed value, then feeds the result of that function along with the second item
* emitted by a Publisher into the same function, and so on until all items have been emitted by the
* source Publisher, emitting the final result from the final call to your function as its sole item.
* Publisher and a seed value derived from calling a specified seedSupplier, then feeds the result
* of that function along with the second item emitted by a Publisher into the same function, and so on until
* all items have been emitted by the source Publisher, emitting the final result from the final call to your
* function as its sole item.
* <p>
* <img width="640" height="325" src="https://raw.github.com/wiki/ReactiveX/RxJava/images/rx-operators/reduceSeed.png" alt="">
* <p>
* This technique, which is called "reduce" here, is sometimes called "aggregate," "fold," "accumulate,"
* "compress," or "inject" in other programming contexts. Groovy, for instance, has an {@code inject} method
* that does a similar operation on lists.
* <p>
* Note that the {@code initialValue} is shared among all subscribers to the resulting Publisher
* and may cause problems if it is mutable. To make sure each subscriber gets its own value, defer
* the application of this operator via {@link #defer(Callable)}:
* <pre><code>
* Publisher&lt;T> source = ...
* Publisher.defer(() -> source.reduce(new ArrayList&lt;>(), (list, item) -> list.add(item)));
*
* // alternatively, by using compose to stay fluent
*
* source.compose(o ->
* Publisher.defer(() -> o.reduce(new ArrayList&lt;>(), (list, item) -> list.add(item)))
* );
* </code></pre>
* <dl>
* <dt><b>Backpressure:</b></dt>
* <dd>The operator honors backpressure of its downstream consumer and consumes the
Expand Down
34 changes: 13 additions & 21 deletions src/main/java/io/reactivex/Observable.java
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -8922,18 +8922,22 @@ public final Maybe<T> reduce(BiFunction<T, T, T> reducer) {
* "compress," or "inject" in other programming contexts. Groovy, for instance, has an {@code inject} method
* that does a similar operation on lists.
* <p>
* Note that the {@code initialValue} is shared among all subscribers to the resulting ObservableSource
* Note that the {@code seed} is shared among all subscribers to the resulting ObservableSource
* and may cause problems if it is mutable. To make sure each subscriber gets its own value, defer
* the application of this operator via {@link #defer(Callable)}:
* <pre><code>
* ObservableSource&lt;T> source = ...
* Observable.defer(() -> source.reduce(new ArrayList&lt;>(), (list, item) -> list.add(item)));
* Single.defer(() -> source.reduce(new ArrayList&lt;>(), (list, item) -> list.add(item)));
*
* // alternatively, by using compose to stay fluent
*
* source.compose(o ->
* Observable.defer(() -> o.reduce(new ArrayList&lt;>(), (list, item) -> list.add(item)))
* );
* Observable.defer(() -> o.reduce(new ArrayList&lt;>(), (list, item) -> list.add(item)).toObservable())
* ).firstOrError();
*
* // or, by using reduceWith instead of reduce
*
* source.reduceWith(() -> new ArrayList&lt;>(), (list, item) -> list.add(item)));
* </code></pre>
* <dl>
* <dt><b>Scheduler:</b></dt>
Expand All @@ -8950,6 +8954,7 @@ public final Maybe<T> reduce(BiFunction<T, T, T> reducer) {
* items emitted by the source ObservableSource
* @see <a href="http://reactivex.io/documentation/operators/reduce.html">ReactiveX operators documentation: Reduce</a>
* @see <a href="http://en.wikipedia.org/wiki/Fold_(higher-order_function)">Wikipedia: Fold (higher-order function)</a>
* @see #reduceWith(Callable, BiFunction)
*/
@CheckReturnValue
@SchedulerSupport(SchedulerSupport.NONE)
Expand All @@ -8961,29 +8966,16 @@ public final <R> Single<R> reduce(R seed, BiFunction<R, ? super T, R> reducer) {

/**
* Returns a Single that applies a specified accumulator function to the first item emitted by a source
* ObservableSource and a specified seed value, then feeds the result of that function along with the second item
* emitted by an ObservableSource into the same function, and so on until all items have been emitted by the
* source ObservableSource, emitting the final result from the final call to your function as its sole item.
* ObservableSource and a seed value derived from calling a specified seedSupplier, then feeds the result
* of that function along with the second item emitted by an ObservableSource into the same function,
* and so on until all items have been emitted by the source ObservableSource, emitting the final result
* from the final call to your function as its sole item.
* <p>
* <img width="640" height="325" src="https://raw.github.com/wiki/ReactiveX/RxJava/images/rx-operators/reduceSeed.2.png" alt="">
* <p>
* This technique, which is called "reduce" here, is sometimes called "aggregate," "fold," "accumulate,"
* "compress," or "inject" in other programming contexts. Groovy, for instance, has an {@code inject} method
* that does a similar operation on lists.
* <p>
* Note that the {@code initialValue} is shared among all subscribers to the resulting ObservableSource
* and may cause problems if it is mutable. To make sure each subscriber gets its own value, defer
* the application of this operator via {@link #defer(Callable)}:
* <pre><code>
* ObservableSource&lt;T> source = ...
* Observable.defer(() -> source.reduce(new ArrayList&lt;>(), (list, item) -> list.add(item)));
*
* // alternatively, by using compose to stay fluent
*
* source.compose(o ->
* Observable.defer(() -> o.reduce(new ArrayList&lt;>(), (list, item) -> list.add(item)))
* );
* </code></pre>
* <dl>
* <dt><b>Scheduler:</b></dt>
* <dd>{@code reduceWith} does not operate by default on a particular {@link Scheduler}.</dd>
Expand Down