Update 4. Combining sequences.md

Author: Tiltman

Part 3 - Taming the sequence/4. Combining sequences.md

@@ -1,6 +1,6 @@
 # Combining sequences
 
-So far, we've seen most of the methods that allow us to create a sequence and transform it into what we want. However, most applications will have more than one sources of input. We need a way a of combining sequences. We've already seen a few sequences that use more than one observable. In this chapter, we will see the most important operators that use multiple sequences to produce one.
+So far, we've seen most of the methods that allow us to create a sequence and transform it into what we want. However, most applications will have more than one source of input. We need a way a of combining sequences. We've already seen a few sequences that use more than one observable. In this chapter, we will see the most important operators that use multiple sequences to produce one.
 
 ## Concatenation
 
@@ -27,7 +27,7 @@ public static final <T> Observable<T> concat(Observable<? extends T> t1,
 ```
 ![](https://raw.github.com/wiki/ReactiveX/RxJava/images/rx-operators/concat.png)
 
-Concatenating two (or more) given observables is very straight forward.
+Concatenating two (or more) given observables is straightforward.
 
 ```java
 Observable<Integer> seq1 = Observable.range(0, 3);
@@ -46,7 +46,7 @@ Observable.concat(seq1, seq2)
 12
 ```
 
-If the number of sequences to be combined is dynamic, you can provide an observable that emits the sequences to be concatenated. In this example, we will use our familiar `groupBy` to create a sequence that emits words that start with the same letter together.
+If the number of sequences to be combined is dynamic, you can provide an observable that emits the sequences to be concatenated. In this example, we will use our familiar `groupBy` to create a sequence that emits words starting with the same letter together.
 
 ```java
 Observable<String> words = Observable.just(
@@ -106,7 +106,7 @@ public final Observable<T> repeat()
 public final Observable<T> repeat(long count)
 ```
 
-It application is very simple
+Its application is very simple
 
 ```java
 Observable<Integer> words = Observable.range(0,2);
@@ -320,7 +320,7 @@ Second
 First
 ```
 
-The difference between `concat` and `merge` is that `merge` does not wait for the current observable to terminate before moving to the next. `merge` subscribes to every observable available to it and emits items as they come. It that way, `merge` is similar to the flattening part of `flatMap`.
+The difference between `concat` and `merge` is that `merge` does not wait for the current observable to terminate before moving to the next. `merge` subscribes to every observable available to it and emits items as they come. In that way, `merge` is similar to the flattening part of `flatMap`.
 
 Like other combinators that are static methods, `merge` has an alternative that allows you to merge sequences one by one in a chain. The operator is called `mergeWith` and the behaviour is the same. The following example has the same result as the one above.
 
@@ -444,7 +444,7 @@ Observable.switchOnNext(
 2
 ```
 
-This example may be a bit confusing. What we've done is create an observable that creates a new observable every 100ms. Every created observable emits it's number in the sequence every 30ms. After 100ms, each of those observables has had enough time to emit its number 3 times. Then a new observable is created, which causes them to be replaced by the new one.
+This example may be a bit confusing. What we've done is creating an observable that creates a new observable every 100ms. Every created observable emits its number in the sequence every 30ms. After 100ms, each of those observables has had enough time to emit its number 3 times. Then a new observable is created, which causes them to be replaced by the new one.
 
 #### switchMap
 
@@ -661,7 +661,7 @@ Right emits
 3 - 2
 ```
 
-As we can see, ``combineLatest` first it waits for every sequence to have a value. After that, every value emitted by either observable results in a combined value being emitted.
+As we can see, `combineLatest` first it waits for every sequence to have a value. After that, every value emitted by either observable results in a combined value being emitted.
 
 Just like every combinator we've seen in this chapter, there are overloads that allow to combine more than two sequences.