2.2 Reworked chapter

Author: Froussios

Part 2 - Sequence Basics/2. Reducing a sequence.md

@@ -1,8 +1,8 @@
 # Reducing a sequence
 
-The examples we've seen so far where all very small. Nothing should stop you from using Rx on a huge stream of realtime data, but what good would Rx be if it dumped the whole data onto you, and let you handle it like you would otherwise? Here we will explore operators that will filter out irrelevant data, or reduce the data to the single value that you want.
+The examples we've seen so far were all very small. Nothing should stop you from using Rx on a huge stream of realtime data, but what good would Rx be if it dumped the whole bulk of the data onto you, and force you handle it like you would otherwise? Here we will explore operators that can filter out irrelevant data, or reduce the data to the single value that you want.
 
-As usual, most of the operators here will be familiar to anyone that has worked with Java's `Stream`s, or functional programming in general. All the operators here return a new observable and do _not_ affect the original observable. This principle is present throughout Rx. Transformations of observables create a new observable every time and leave the original unaffected. Subscribers to the original observable should notice no change, but we will see in later chapters that guaranteeing this may require caution from the developer as well.
+Most of the operators here will be familiar to anyone who has worked with Java's `Stream`s or functional programming in general. All the operators here return a new observable and do _not_ affect the original observable. This principle is present throughout Rx. Transformations of observables create a new observable every time and leave the original unaffected. Subscribers to the original observable should notice no change, but we will see in later chapters that guaranteeing this may require caution from the developer as well.
 
 ### Marble diagrams
 
@@ -12,15 +12,15 @@ This is an appropriate time to introduce to concept of marble diagrams. It is a
 
 ## Filter
 
-`filter` takes a predicate function that takes an emitted value and returns a boolean decision on if it should be kept.
+`filter` takes a predicate function that makes a boolean decision for each value emitted. If the decision is `false`, the item is omitted from the filtered sequence.
 
 ```java
 public final Observable<T> filter(Func1<? super T,java.lang.Boolean> predicate)
 ```
 
 ![](https://raw.github.com/wiki/ReactiveX/RxJava/images/rx-operators/filter.png)
 
-Now we will create a sequence of numbers and filter out all the even ones, keeping the odd.
+We will use `filter` to create a sequence of numbers and filter out all the even ones, keeping only odd values.
 
 ```java
 Observable<Integer> values = Observable.range(0,10);
@@ -107,7 +107,7 @@ Subscription subscription = values
 
 "Fourth" and "Fifth" were filtered out because their is is 'F' and that has already appeared in "First".
 
-An experienced programmed already knows that this operator houses a set that keeps every unique value that passes through the observable and checks every new value against it. While Rx operators neatly hide these things, you should still be aware the an Rx operator can have significant cost and consider what kind of an observable it is used on.
+An experienced programmer already knows that this operator maintains a set internally with every unique value that passes through the observable and checks every new value against it. While Rx operators neatly hide these things, you should still be aware that an Rx operator can have a significant cost and consider what you are using it on.
 
 A variant of `distinct` is `distinctUntilChanged`. The difference is that only consecutive non-distinct values are filtered out.
 
@@ -201,7 +201,7 @@ Completed
 
 ## skip and take
 
-The next group of methods serve to cut the sequence at an indexed point, and either take the first half or take the second. `take` takes the first n elements and `skip` skips them. Note that neither function considers it an error if there are too few items in the sequence.
+The next group of methods serve to cut the sequence at a specific point based on the item's index, and either take the first part or the second part. `take` takes the first n elements, while `skip` skips them. Note that neither function considers it an error if there are fewer items in the sequence than the specified index.
 
 ```java
 Observable<T> 	take(int num)
@@ -228,9 +228,9 @@ Output
 Completed
 ```
 
-Users of Java 8 streams will be know the `take` operator as `limit`. The `limit` operator exists in Rx too, for symmetry purposes. It is an alias of `take`, but it lacks the richer overloads.
+Users of Java 8 streams will be know the `take` operator as `limit`. The `limit` operator exists in Rx too, for symmetry purposes. It is an alias of `take`, but it lacks the richer overloads that we will soon see.
 
-`take` completes as soon as the n-th item is available and does not care what the source emits after that.
+`take` completes as soon as the n-th item is available. If an error occurs, the error will be forwarded, but not if it occurs after the cutting point. `take` doesn't care what happens in the observable after the n-th item.
 
 ```java
 Observable<Integer> values = Observable.create(o -> {
@@ -253,7 +253,7 @@ Output
 Completed
 ```
 
-`skip` is the other half of `take`.
+`skip` returns the other half of a `take`.
 
 ```java
 Observable<T> 	skip(int num)
@@ -334,7 +334,7 @@ Output
 Completed
 ```
 
-As you would expect, `skipWhile` return the other half of the observable
+As you would expect, `skipWhile` returns the other half of the sequence
 
 ```java
 Observable<Long> values = Observable.interval(100, TimeUnit.MILLISECONDS);
@@ -358,7 +358,7 @@ Output
 
 ## skipLast and takeLast
 
-`skipLast` and `takeLast` work just like `take` and `skip`, with the difference that the cutoff points are measured from the end.
+`skipLast` and `takeLast` work just like `take` and `skip`, with the difference that the point of reference is from the end.
 
 ```java
 Observable<Integer> values = Observable.range(0,5);
@@ -379,14 +379,14 @@ Subscription subscription = values
 Completed
 ```
 
-By now you are in position to understand how `takeLast` is related to `skipLast`. There are overloads for both indices and time.
+By now you should be able to guess how `takeLast` is related to `skipLast`. There are overloads for both indices and time.
 
 
 ## takeUntil and skipUntil
 
-There are also methods `takeUntil` and `skipUntil`. `takeUntil` works exactly like `takeWhile` except that it takes items while the predictate is false. The same is true of `skipUntil`. 
+There are also two methods named `takeUntil` and `skipUntil`. `takeUntil` works exactly like `takeWhile` except that it takes items while the predictate is false. The same is true of `skipUntil`.
 
-Along with that, `takeUntil` and `skipUntil` have a very interesting overload. The cutoff point is defined as the moment when _another_ observable emits an item. Note that this can be any item as the actual value is dismissed.
+Along with that, `takeUntil` and `skipUntil` each have a very interesting overload. The cutoff point is defined as the moment when _another_ observable emits an item.
 
 ```java
 public final <E> Observable<T> takeUntil(Observable<? extends E> other)
@@ -414,9 +414,9 @@ Output
 Completed
 ```
 
-As you remember, `timer` here will wait 250ms and emit one event. This signals the `takeUntil` to stop.
+As you may remember, `timer` here will wait 250ms and emit one event. This signals `takeUntil` to stop the sequence. Note that the signal can be of any type, since the actual value is not used.
 
-Once again `skipUntil` works by the same rules and returns the other half of the observable.
+Once again `skipUntil` works by the same rules and returns the other half of the observable. Values are ignored until the signal comes to start letting values through.
 
 ```java
 Observable<Long> values = Observable.interval(100,TimeUnit.MILLISECONDS);