2.3 Reworked chapter

Author: Froussios

Part 2 - Sequence Basics/3. Inspection.md

@@ -1,10 +1,10 @@
 # Inspection
 
-We've just finished seeing ways to filter out data that we don't care about. Sometimes what we want is information about the sequence rather than its values. We will now introduce a few methods that revolve around reasoning about the sequence.
+In the previous chapter we just saw ways to filter out data that we don't care about. Sometimes what we want is information about the sequence rather than the values themselves. We will now introduce some methods that allow us to reason about a sequence.
 
 ## all
 
-The `all` methods establishes that every value emitted by an observable meets a criterion. Here's the signature and an example:
+The `all` method establishes that every value emitted by an observable meets a criterion. Here's the signature and an example:
 
 ```java
 public final Observable<java.lang.Boolean> all(Func1<? super T,java.lang.Boolean> predicate)
@@ -35,13 +35,13 @@ true
 Completed
 ```
 
-An interesting fact about this method is that it returns an observable with a single value, rather than the boolean value directly. This is because it is unknown how long it will take to establish whether the result should be true or false. Another interesting fact is that it returns its result and completes as soon as it can know. As soon as an item fails the predicate, `false` will be emitted. A value of `true` on the other hand cannot be emitted until the source sequence has completed. We can see that in the next example
+An interesting fact about this method is that it returns an observable with a single value, rather than the boolean value directly. This is because it is unknown how long it will take to establish whether the result should be true or false. Even though it completes as soon as it can know, that may take as long the source sequence itself. As soon as an item fails the predicate, `false` will be emitted. A value of `true` on the other hand cannot be emitted until the source sequence has completed and _all_ of the items are checked. Returning the decision inside an observable is a convenient way of making the operation non-blocking. We can see `all` failing as soon as possible in the next example:
 
 ```java
 Observable<Long> values = Observable.interval(150, TimeUnit.MILLISECONDS).take(5);
 
 Subscription subscription = values
-	.all(i -> i<3)
+	.all(i -> i<3) // Will fail eventually
 	.subscribe(
 	    v -> System.out.println("All: " + v),
 	    e -> System.out.println("All: Error: " + e),
@@ -67,8 +67,6 @@ All: Completed
 Completed
 ```
 
-There is an Rx operator that appears in other implementations but not in RxJava, called `any`. You can easily get the same behaviour by negating the predicate of the `all` operator.
-
 If the source observable emits an error, then `all` becomes irrelavant and the error passes through, terminating the sequence.
 
 ```java
@@ -92,7 +90,7 @@ Output
 Error: java.lang.Exception
 ```
 
-If, however, the predicate fails, then `false` is emitted and the sequence terminates. Even if the source observable fails after that, the event is ignored. Remember that it is Rx's contract that nothing is emitted after a termination of an observable.
+If, however, the predicate fails, then `false` is emitted and the sequence terminates. Even if the source observable fails after that, the event is ignored, as required by the Rx contract (no events after a termination event).
 
 ```java
 Observable<Integer> values = Observable.create(o -> {
@@ -174,11 +172,11 @@ false
 Completed
 ```
 
-Once again, falsehood is established as soon as the first value is emitted. True will only be returned once the source observable has terminated.
+Falsehood is established as soon as the first value is emitted. True will can be returned once the source observable has terminated.
 
 ## contains
 
-The method `contains` establishes if a particular element is emitter by an observable. `contains` will use the `Object.equals` function to establish the equality. Just like previous operators, it emits its decision as soon as it can be established and immediately completes.
+The method `contains` establishes if a particular element is emitted by an observable. `contains` will use the `Object.equals` method to establish the equality. Just like previous operators, it emits its decision as soon as it can be established and immediately completes.
 
 ![](https://raw.github.com/wiki/ReactiveX/RxJava/images/rx-operators/contains.png)
 
@@ -200,7 +198,7 @@ true
 Completed
 ```
 
-If we had used `contains(4)` where we used `contains(4L)`, nothing would be printed. That's because `4` and `4L` are not equal in Java. Our code would wait for the observable to complete to return false, only the observable we used is infinite.
+If we had used `contains(4)` where we used `contains(4L)`, nothing would be printed. That's because `4` and `4L` are not equal in Java. Our code would wait for the observable to complete before returning false, but the observable we used is infinite.
 
 ## defaultIfEmpty
 
@@ -209,10 +207,9 @@ If an empty sequence would cause you problems, rather than checking with `isEmpt
 ![](https://raw.github.com/wiki/ReactiveX/RxJava/images/rx-operators/defaultIfEmpty.png)
 
 ```java
-Observable<Integer> values = Observable.range(0,10);
+Observable<Integer> values = Observable.empty();
 
 Subscription subscription = values
-    .take(0)
 	.defaultIfEmpty(2)
 	.subscribe(
 	    v -> System.out.println(v),
@@ -227,9 +224,7 @@ Output
 Completed
 ```
 
-Here we emptied an observable with `take(0)`. We could have used `Observable.empty`.
-
-The value is emitted only if no other values appeared and only on successful completion. If the source is not empty, the result is just the source observable. In the case of the error, the default value will _not_ be emitted before the error.
+The default value is emitted only if no other values appeared and only on successful completion. If the source is not empty, the result is just the source observable. In the case of the error, the default value will _not_ be emitted before the error.
 
 ```java
 Observable<Integer> values = Observable.error(new Exception());
@@ -250,7 +245,7 @@ Error: java.lang.Exception
 
 ## elementAt
 
-You can select exactly one element our of an observable using the `elementAt` method
+You can select exactly one element out of an observable using the `elementAt` method
 
 ![](https://raw.github.com/wiki/ReactiveX/RxJava/images/rx-operators/elementAt.png)
 
@@ -294,7 +289,7 @@ Completed
 
 ## sequenceEqual
 
-The last method establishes that two sequences are equal by comparing the value at the same indices. Both the size of the sequences and the values must be equal. The function will either use `Object.equals` or the function that you supply to compare values.
+The last operator for this chapter establishes that two sequences are equal by comparing the values at the same index. Both the size of the sequences and the values must be equal. The function will either use `Object.equals` or the function that you supply to compare values.
 
 ```java
 Observable<String> strings = Observable.just("1", "2", "3");
@@ -315,7 +310,7 @@ true
 Completed
 ```
 
-If we had used the overload that was commented out (i.e the standard `Object.equals`), the result would be `false`.
+If swap the operator for the one that is commented out (i.e the one that uses the the standard `Object.equals`), the result would be `false`.
 
 Failing is not part of the comparison. As soon as either sequence fails, the resulting observable forwards the error.