Update 4. Aggregation.md

Tiltman · Tiltman · commit 876065863a81 · 2015-07-21T13:44:23.000+02:00
diff --git a/Part 2 - Sequence Basics/4. Aggregation.md b/Part 2 - Sequence Basics/4. Aggregation.md
@@ -103,15 +103,15 @@ Single1: 5
 Single1: Completed
 ```
 
-Like in with previous methods, you can have a default value with `singleOrDefault`
+Like in the previous methods, you can have a default value with `singleOrDefault`
 
 ## Custom aggregators
 
 The methods we saw on this chapter so far don't seem that different from the ones in previous chapters. We will now see two very powerful methods that will greatly expand what we can do with an observable. Many of the methods we've seen so far can be implemented using those.
 
 ### reduce
 
-You may have heard of `reduce` from MapReduce. Alternatively, you might have met it under the names "aggregate", "accumulate" or "fold". The general idea is that you produce a single value out of many by combining them two at a time. It its most basic overload, all you need is a function that combines two values into one.
+You may have heard of `reduce` from [MapReduce] (https://en.wikipedia.org/wiki/MapReduce). Alternatively, you might have met it under the names "aggregate", "accumulate" or "fold". The general idea is that you produce a single value out of many by combining them two at a time. In its most basic overload, all you need is a function that combines two values into one.
 
 ```java
 public final Observable<T> reduce(Func2<T,T,T> accumulator)
@@ -279,7 +279,7 @@ values
 [10, 11, 12, 13, 14]
 ```
 
-Usually, you won't have to collect values manually. Rxjava offers a variety of operators for collecting your sequence into a container. Those aggregators return an observable that will emit the corresponding collection when it is ready, just like what we did here. We will see such aggregators next.
+Usually, you won't have to collect values manually. RxJava offers a variety of operators for collecting your sequence into a container. Those aggregators return an observable that will emit the corresponding collection when it is ready, just like what we did here. We will see such aggregators next.
 
 #### toList
 
@@ -314,7 +314,7 @@ values
 	.toSortedList((i1,i2) -> i2 - i1)
 	.subscribe(v -> System.out.println(v));
 ```
-[Output]((/tests/java/itrx/chapter2/aggregation/ToCollectionExample.java) 
+[Output](/tests/java/itrx/chapter2/aggregation/ToCollectionExample.java) 
 ```
 [14, 13, 12, 11, 10]
 ```
@@ -533,7 +533,7 @@ Nested observables may be confusing at first, but they are a powerful construct
  * Partitions of Data
     * You may partition data from a single source so that it can easily be filtered and shared to many sources. Partitioning data may also be useful for aggregates as we have seen. This is commonly done with the `groupBy` operator. 
  * Online Game servers
-    * Consider a sequence of servers. New values represent a server coming online. The value itself is a sequence of latency values allowing the consumer to see real time information of quantity and quality of servers available. If a server went down then the inner sequence can signify that by completing. 
+    * Consider a sequence of servers. New values represent a server coming online. The value itself is a sequence of latency values allowing the consumer to see real time information of quantity and quality of servers available. If a server went down then the inner sequence can signal that by completing. 
  * Financial data streams
     * New markets or instruments may open and close during the day. These would then stream price information and could complete when the market closes. 
  * Chat Room
@@ -543,7 +543,7 @@ Nested observables may be confusing at first, but they are a powerful construct
  
 ### nest
 
-When dealing with nested observables, the `nest` operator becomes useful. It allows you to turn a non-nested observable into a nested observable. `nest` takes a source observable and returns an observable that will the source observable and then terminate.
+When dealing with nested observables, the `nest` operator becomes useful. It allows you to turn a non-nested observable into a nested observable. `nest` takes a source observable and returns an observable that will be the source observable and then terminate.
 
 ![](https://raw.github.com/wiki/ReactiveX/RxJava/images/rx-operators/nest.png)
 
