Update 2. Reducing a sequence.md

Author: Tiltman

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

@@ -6,7 +6,7 @@ Most of the operators here will be familiar to anyone who has worked with Java's
 
 ### Marble diagrams
 
-This is an appropriate time to introduce to concept of marble diagrams. It is a popular way of explaining the operators in Rx, because of their intuitive and graphical nature. They are present a lot in the documetation of RxJava and it only makes sense that we take advantage of their explanatory nature. The format is mostly self-explanatory: time flows left to right, shapes represent values, a slash is a onCompletion, an X is an error. The operator is applied to the top sequence and the result is the sequence below.
+This is an appropriate time to introduce to concept of marble diagrams. It is a popular way of explaining the operators in Rx, because of their intuitive and graphical nature. They are present a lot in the documentation of RxJava and it only makes sense that we take advantage of their explanatory nature. The format is mostly self-explanatory: time flows left to right, shapes represent values, a slash is a onCompletion, an X is an error. The operator is applied to the top sequence and the result is the sequence below.
 
 ![](https://raw.github.com/wiki/ReactiveX/RxJava/images/rx-operators/legend.png)
 
@@ -111,7 +111,7 @@ Third
 Completed
 ```
 
-"Fourth" and "Fifth" were filtered out because their is is 'F' and that has already appeared in "First".
+"Fourth" and "Fifth" were filtered out because their first character is 'F' and that has already appeared in "First".
 
 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.
 
@@ -182,7 +182,7 @@ Completed
 
 ## ignoreElements
 
-`ignoreElements` will ignore every value, but lets though `onCompleted` and `onError`.
+`ignoreElements` will ignore every value, but lets pass through `onCompleted` and `onError`.
 
 ```java
 Observable<Integer> values = Observable.range(0, 10);
@@ -232,7 +232,7 @@ Subscription first2 = values
 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 that we will soon see.
+Users of Java 8 streams should 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. 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.
 
@@ -310,7 +310,7 @@ Completed
 
 ## skipWhile and takeWhile
 
-`take` and `skip` work with predefined indices. If you want to "discover" the cutoff point as the values come, `takeWhile` and `shipWhile` will use a predicate instead. `takeWhile` takes items while a predicate function returns `true`
+`take` and `skip` work with predefined indices. If you want to "discover" the cutoff point as the values come, `takeWhile` and `skipWhile` will use a predicate instead. `takeWhile` takes items while a predicate function returns `true`
 
 ```java
 Observable<T> 	takeWhile(Func1<? super T,java.lang.Boolean> predicate)
@@ -414,7 +414,7 @@ Completed
 
 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. Values are ignored until the signal comes to start letting values through.
+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 pass through.
 
 ```java
 Observable<Long> values = Observable.interval(100,TimeUnit.MILLISECONDS);