diff --git a/src/expressions/match-expr.md b/src/expressions/match-expr.md
index a5ccf6829..eb672fac6 100644
--- a/src/expressions/match-expr.md
+++ b/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;
diff --git a/src/expressions/operator-expr.md b/src/expressions/operator-expr.md
index 05468277d..65abf9cbe 100644
--- a/src/expressions/operator-expr.md
+++ b/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`.
 
diff --git a/src/special-types-and-traits.md b/src/special-types-and-traits.md
index 6d803a0aa..5cd095601 100644
--- a/src/special-types-and-traits.md
+++ b/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
diff --git a/src/type-coercions.md b/src/type-coercions.md
index c8719aee4..5b2fcb964 100644
--- a/src/type-coercions.md
+++ b/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
diff --git a/src/type-layout.md b/src/type-layout.md
index 82ee95e56..b0efe3ffc 100644
--- a/src/type-layout.md
+++ b/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,
diff --git a/src/types/trait-object.md b/src/types/trait-object.md
index eb31a1bbd..e909d1c1c 100644
--- a/src/types/trait-object.md
+++ b/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:
diff --git a/src/variables.md b/src/variables.md
index f6589e394..eaddee4b5 100644
--- a/src/variables.md
+++ b/src/variables.md
@@ -41,3 +41,5 @@ fn initialization_example() {
     // uninit_after_if; // err: use of possibly uninitialized `uninit_after_if`
 }
 ```
+
+[`if` expression]: expressions/if-expr.html#if-expressions