Typo fixes

src/expressions/match-expr.md

@@ -113,7 +113,7 @@ let message = match maybe_digit {
 ```
 
 > Note: Multiple matches using the `|` operator can cause the pattern guard and
-> and side effects it has to execute multiple times. For example:
+> the side effects it has to execute multiple times. For example:
 >
 > ```rust
 > # use std::cell::Cell;

src/expressions/operator-expr.md

@@ -93,7 +93,7 @@ Dereferencing a raw pointer requires `unsafe`.
 
 On non-pointer types `*x` is equivalent to `*std::ops::Deref::deref(&x)` in an
 [immutable place expression context](expressions.html#mutability) and
-`*std::ops::Deref::deref_mut(&mut x)` in a mutable place expression context.
+`*std::ops::DerefMut::deref_mut(&mut x)` in a mutable place expression context.
 
 ```rust
 let x = &7;
@@ -131,7 +131,7 @@ println!("{:?}", res);
 # assert!(res.is_err())
 ```
 
-When applied to values of the `Option<T>` type, it propagates `Nones`. If the
+When applied to values of the `Option<T>` type, it propagates `None`s. If the
 value is `None`, then it will return `None`. If applied to `Some(x)`, then it
 will unwrap the value to evaluate to `x`.
 

src/special-types-and-traits.md

@@ -110,7 +110,7 @@ according to the following rules:
   closure that captures a `T` by shared reference and a `U` by value implements
   any auto traits that both `&T` and `U` do.
 
-For generic types (counting the built-in types above as generic over `T`), if an
+For generic types (counting the built-in types above as generic over `T`), if a
 generic implementation is available, then the compiler does not automatically
 implement it for types that could use the implementation except that they do not
 meet the requisite trait bounds. For instance, the standard library implements

src/type-coercions.md

@@ -96,7 +96,7 @@ Coercion is allowed between the following types:
 * `T_1` to `T_3` where `T_1` coerces to `T_2` and `T_2` coerces to `T_3`
 (*transitive case*)
 
-    Note that this is not fully supported yet
+    Note that this is not fully supported yet.
 
 * `&mut T` to `&T`
 
@@ -158,9 +158,9 @@ cases where other coercions are not, as described above. They can still happen
 anywhere else a coercion can occur.
 
 Two traits, [`Unsize`] and [`CoerceUnsized`], are used
-to assist in this process and expose it for library use. The compiler following
-coercions are built-in and, if `T` can be coerced to `U` with one of the, then
-the compiler will provide an implementation of `Unsize<U>` for `T`:
+to assist in this process and expose it for library use. The following
+coercions are built-ins and, if `T` can be coerced to `U` with one of them, then
+an implementation of `Unsize<U>` for `T` will be provided:
 
 * `[T; n]` to `[T]`.
 
@@ -182,5 +182,5 @@ unsized coercion to `Foo<U>`.
 > has been stabilized, the traits themselves are not yet stable and therefore
 > can't be used directly in stable Rust.
 
-[Unsize]: ../std/marker/trait.Unsize.html
-[CoerceUnsized]: ../std/ops/trait.CoerceUnsized.html
+[`Unsize`]: ../std/marker/trait.Unsize.html
+[`CoerceUnsized`]: ../std/ops/trait.CoerceUnsized.html

src/type-layout.md

@@ -205,7 +205,7 @@ The union will have a size of the maximum size of all of its fields rounded to
 its alignment, and an alignment of the maximum alignment of all of its fields.
 These maximums may come from different fields.
 
-```
+```rust
 #[repr(C)]
 union Union {
     f1: u16,

src/types/trait-object.md

@@ -17,7 +17,7 @@ of the base trait.
 Trait objects are written as the optional keyword `dyn` followed by a set of
 trait bounds, but with the following restrictions on the trait bounds. All
 traits except the first trait must be auto traits, there may not be more than
-one lifetime, and opt-out bounds (e.g. `?sized`) are not allowed. Furthermore,
+one lifetime, and opt-out bounds (e.g. `?Sized`) are not allowed. Furthermore,
 paths to traits may be parenthesized.
 
 For example, given a trait `Trait`, the following are all trait objects: