Added additional corrections.

Co-authored-by: SethTisue <seth@tisue.net>

Author: kazanzhy

_glossary/index.md

@@ -44,7 +44,7 @@ You can assign an object to a variable. Afterwards, the variable will refer to t
 Extra constructors defined inside the curly braces of the class definition, which look like method definitions named `this`, but with no result type.
 
 * #### block
-One or more expressions and declarations surrounded by curly braces. When the block evaluates, all of its expressions and declarations are processed in order, and then the block returns the value of the last expression as its own value. Blocks are commonly used as the bodies of functions, [for expressions](#for-expression), `while` loops, and any other place where you want to group a number of statements together. More formally, a block is an encapsulation construct for which you can only see side effects and a result value. The curly braces in which you define a class or object do not, therefore, form a block, because fields and methods (which are defined inside those curly braces) are visible from the out-side. Such curly braces form a template.
+One or more expressions and declarations surrounded by curly braces. When the block evaluates, all of its expressions and declarations are processed in order, and then the block returns the value of the last expression as its own value. Blocks are commonly used as the bodies of functions, [for expressions](#for-expression), `while` loops, and any other place where you want to group a number of statements together. More formally, a block is an encapsulation construct for which you can only see side effects and a result value. The curly braces in which you define a class or object do not, therefore, form a block, because fields and methods (which are defined inside those curly braces) are visible from the outside. Such curly braces form a template.
 
 * #### bound variable
 A bound variable of an expression is a variable that’s both used and defined inside the expression. For instance, in the function literal expression `(x: Int) => (x, y)`, both variables `x` and `y` are used, but only `x` is bound, because it is defined in the expression as an `Int` and the sole argument to the function described by the expression.
@@ -299,7 +299,7 @@ A _self type_ of a trait is the assumed type of `this`, the receiver, to be used
 XML data is semi-structured. It is more structured than a flat binary file or text file, but it does not have the full structure of a programming language’s data structures.
 
 * #### serialization
-You can _serialize_ an object into a byte stream which can then be saved to file or transmitted over the network. You can later _deserialize_ the byte stream, even on different computer, and obtain an object that is the same as the original serialized object.
+You can _serialize_ an object into a byte stream which can then be saved to a file or transmitted over the network. You can later _deserialize_ the byte stream, even on different computer, and obtain an object that is the same as the original serialized object.
 
 * #### shadow
 A new declaration of a local variable _shadows_ one of the same name in an enclosing scope.

_overviews/collections/iterators.md

@@ -26,7 +26,7 @@ As always, for-expressions can be used as an alternate syntax for expressions in
 
     for (elem <- it) println(elem)
 
-There's an important difference between the foreach method on iterators and the same method on traversable collections: When called on an iterator, `foreach` will leave the iterator at its end when it is done. So calling `next` again on the same iterator will fail with a `NoSuchElementException`. By contrast, when called on a collection, `foreach` leaves the number of elements in the collection unchanged (unless the passed function adds to remove elements, but this is discouraged, because it may lead to surprising results).
+There's an important difference between the foreach method on iterators and the same method on traversable collections: When called on an iterator, `foreach` will leave the iterator at its end when it is done. So calling `next` again on the same iterator will fail with a `NoSuchElementException`. By contrast, when called on a collection, `foreach` leaves the number of elements in the collection unchanged (unless the passed function adds or removes elements, but this is discouraged, because it may lead to surprising results).
 
 The other operations that Iterator has in common with `Traversable` have the same property. For instance, iterators provide a `map` method, which returns a new iterator:
 

_overviews/collections/migrating-from-scala-27.md

@@ -38,7 +38,7 @@ Generally, the old functionality of Scala 2.7 collections has been left in place
 
 There are two parts of the old libraries which have been replaced wholesale, and for which deprecation warnings were not feasible.
 
-1. The previous `scala.collection.jcl` package is gone. This package tried to mimic some Java collection library design in Scala, but in doing so broke many symmetries. Most people who wanted Java collections bypassed `jcl` and used `java.util` directly. Scala 2.8 offers automatic conversion mechanisms between both collection libraries in the [JavaConversions]({{ site.baseurl }}/overviews/collections/conversions-between-java-and-scala-collections.html) object which replaces the `jcl` package.
+1. The previous `scala.collection.jcl` package is gone. This package tried to mimic aspects of the Java collection library design in Scala, but in doing so broke many symmetries. Most people who wanted Java collections bypassed `jcl` and used `java.util` directly. Scala 2.8 offers automatic conversion mechanisms between both collection libraries in the [JavaConversions]({{ site.baseurl }}/overviews/collections/conversions-between-java-and-scala-collections.html) object which replaces the `jcl` package.
 2. Projections have been generalized and cleaned up and are now available as views. It seems that projections were used rarely, so not much code should be affected by this change.
 
 So, if your code uses either `jcl` or projections there might be some minor rewriting to do.

_overviews/collections/strings.md

@@ -26,4 +26,4 @@ Like arrays, strings are not directly sequences, but they can be converted to th
     scala> val s: Seq[Char] = str
     s: Seq[Char] = WrappedString(h, e, l, l, o)
 
-These operations are supported by two implicit conversions. The first, low-priority conversion maps a `String` to a `WrappedString`, which is a subclass of `immutable.IndexedSeq`, This conversion got applied in the last line above where a string got converted into a Seq. the other, high-priority conversion maps a string to a `StringOps` object, which adds all methods on immutable sequences to string. This conversion was implicitly inserted in the method calls of `reverse`, `map`, `drop`, and `slice` in the example above.
+These operations are supported by two implicit conversions. The first, low-priority conversion maps a `String` to a `WrappedString`, which is a subclass of `immutable.IndexedSeq`, This conversion got applied in the last line above where a string got converted into a Seq. the other, high-priority conversion maps a string to a `StringOps` object, which adds all methods on immutable sequences to strings. This conversion was implicitly inserted in the method calls of `reverse`, `map`, `drop`, and `slice` in the example above.

_overviews/collections/trait-traversable.md

@@ -25,7 +25,7 @@ The `foreach` method is meant to traverse all elements of the collection, and ap
 * **Conversions** `toArray`, `toList`, `toIterable`, `toSeq`, `toIndexedSeq`, `toStream`, `toSet`, `toMap`, which turn a `Traversable` collection into something more specific. All these conversions return their receiver argument unchanged if the run-time type of the collection already matches the demanded collection type. For instance, applying `toList` to a list will yield the list itself.
 * **Copying operations** `copyToBuffer` and `copyToArray`. As their names imply, these copy collection elements to a buffer or array, respectively.
 * **Size info** operations `isEmpty`, `nonEmpty`, `size`, and `hasDefiniteSize`: Traversable collections can be finite or infinite. An example of an infinite traversable collection is the stream of natural numbers `Stream.from(0)`. The method `hasDefiniteSize` indicates whether a collection is possibly infinite. If `hasDefiniteSize` returns true, the collection is certainly finite. If it returns false, the collection has not been fully elaborated yet, so it might be infinite or finite.
-* **Element retrieval** operations `head`, `last`, `headOption`, `lastOption`, and `find`. These select the first or last element of a collection, or else the first element matching a condition. Note, however, that not all collections have a well-defined meaning of what "first" and "last" means. For instance, a hash set might store elements according to their hash keys, which might change from run to run. In that case, the "first" element of a hash set could also be different for every run of a program. A collection is _ordered_ if it always yields its elements in the same order. Most collections are ordered, but some (_e.g._ hash sets) are not-- dropping the ordering gives a little of extra efficiency. Ordering is often essential to give reproducible tests and to help in debugging. That's why Scala collections give ordered alternatives for all collection types. For instance, the ordered alternative for `HashSet` is `LinkedHashSet`.
+* **Element retrieval** operations `head`, `last`, `headOption`, `lastOption`, and `find`. These select the first or last element of a collection, or else the first element matching a condition. Note, however, that not all collections have a well-defined meaning of what "first" and "last" means. For instance, a hash set might store elements according to their hash keys, which might change from run to run. In that case, the "first" element of a hash set could also be different for every run of a program. A collection is _ordered_ if it always yields its elements in the same order. Most collections are ordered, but some (_e.g._ hash sets) are not-- dropping the ordering gives a little extra efficiency. Ordering is often essential to give reproducible tests and to help in debugging. That's why Scala collections give ordered alternatives for all collection types. For instance, the ordered alternative for `HashSet` is `LinkedHashSet`.
 * **Sub-collection retrieval operations** `tail`, `init`, `slice`, `take`, `drop`, `takeWhile`, `dropWhile`, `filter`, `filterNot`, `withFilter`. These all return some sub-collection identified by an index range or some predicate.
 * **Subdivision operations** `splitAt`, `span`, `partition`, `groupBy`, which split the elements of this collection into several sub-collections.
 * **Element tests** `exists`, `forall`, `count` which test collection elements with a given predicate.

_overviews/contributors/index.md

@@ -370,7 +370,7 @@ or for publishing the resulting documentation to a web server.
 Finally, a simple solution for publishing the documentation online consists in using the
 [GitHub Pages](https://pages.github.com/) service, which is automatically available for each GitHub
 repository. The [sbt-ghpages](https://github.com/sbt/sbt-ghpages) plugin can automatically upload
-a sbt-site to GitHub Pages.
+an sbt-site to GitHub Pages.
 
 ### Create the Documentation Site
 

_overviews/core/architecture-of-scala-collections.md

@@ -217,7 +217,7 @@ maps the key/value pair to an integer, namely its value component. In
 that case, we cannot form a `Map` from the results, but we can still
 form an `Iterable`, a supertrait of `Map`.
 
-You might ask why not restrict `map` so that it can always return the
+You might ask why, not restrict `map` so that it can always return the
 same kind of collection? For instance, on bit sets `map` could accept
 only `Int`-to-`Int` functions and on `Map`s it could only accept
 pair-to-pair functions. Not only are such restrictions undesirable

_overviews/core/custom-collections.md

@@ -337,7 +337,7 @@ That is it. The final [`Capped` class](#final-version-of-capped-class):
   `knownSize` operation is also overridden because the size is always
   known.
 
-Its implementation requires a little of protocol. In essence, you
+Its implementation requires a little bit of protocol. In essence, you
 have to inherit from the `Ops` template trait in addition to just
 inheriting from a collection type, override the `iterableFactory`
 member to return a more specific factory, and finally implement abstract

_overviews/reflection/symbols-trees-types.md

@@ -298,7 +298,7 @@ with different type arguments.
     scala> getType(List(1,2,3)) =:= getType(List(9,8,7))
     res2: Boolean = true
 
-Also, important to note is that `=:=` should _always_ be used to compare types
+Also important to note is that `=:=` should _always_ be used to compare types
 for equality. That is, never use `==`, as it can't check for type equality in
 the presence of type aliases, whereas `=:=` can: