Merge pull request #283 from tbroadley/fix-typos

Fix typos

Author: matthewjasper

src/destructors.md

@@ -2,11 +2,11 @@
 
 When an [initialized] [variable] in Rust goes out of scope or a [temporary]
 is no longer needed its _destructor_ is run. [Assignment] also runs the
-destructor of its left-hand operand, unless it's an unitialized variable. If a
+destructor of its left-hand operand, unless it's an uninitialized variable. If a
 [struct] variable has been partially initialized, only its initialized fields
 are dropped.
 
-The destrutor of a type consists of
+The destructor of a type consists of
 
 1. Calling its [`std::ops::Drop::drop`] method, if it has one.
 2. Recursively running the destructor of all of its fields.

src/dynamically-sized-types.md

@@ -14,7 +14,7 @@ types">DSTs</abbr>. Such types can only be used in certain cases:
   type arguments when a bound of `?Sized`. By default any type parameter
   has a `Sized` bound.
 * Traits may be implemented for <abbr title="dynamically sized
-  types">DSTs</abbr>. Unlike type parameters`Self: ?Sized` by default in trait
+  types">DSTs</abbr>. Unlike type parameters `Self: ?Sized` by default in trait
   definitions.
 * Structs may contain a <abbr title="dynamically sized type">DST</abbr> as the
   last field, this makes the struct itself a

src/expressions/operator-expr.md

@@ -109,14 +109,14 @@ assert_eq!(*y, 11);
 > _ErrorPropagationExpression_ :  
 >    [_Expression_] `?`  
 
-The question mark operator (`?`) unwraps valid values or returns errornous
+The question mark operator (`?`) unwraps valid values or returns erroneous
 values, propagating them to the calling function. It is a unary postfix
 operator that can only be applied to the types `Result<T, E>` and `Option<T>`.
 
 When applied to values of the `Result<T, E>` type, it propagates errors. If 
 the value is `Err(e)`, then it will return `Err(From::from(e))` from the
 enclosing function or closure. If applied to `Ok(x)`, then it will unwrap the
-value to evaulate to `x`.
+value to evaluate to `x`.
 
 ```rust
 # use std::num::ParseIntError;
@@ -393,7 +393,7 @@ An _assignment expression_ consists of a [place expression] followed by an
 equals sign (`=`) and a [value expression].
 
 Evaluating an assignment expression [drops](destructors.html) the left-hand
-operand, unless it's an unitialized local variable or field of a local variable,
+operand, unless it's an uninitialized local variable or field of a local variable,
 and [either copies or moves](expressions.html#moved-and-copied-types) its
 right-hand operand to its left-hand operand. The left-hand operand must be a
 place expression: using a value expression results in a compiler error, rather

src/items/associated-items.md

@@ -33,7 +33,7 @@ The identifier if the name of the function. The generics, parameter list,
 return type, and where clause of the associated function must be the same as the
 associated function declarations's.
 
-An *associated function definiton* defines a function associated with another
+An *associated function definition* defines a function associated with another
 type. It is written the same as a [function item].
 
 An example of a common associated function is a `new` function that returns

src/items/implementations.md

@@ -54,7 +54,7 @@ The implementing type implements the implemented trait.
 
 A trait implementation must define all non-default associated items declared
 by the implemented trait, may redefine default associated items defined by the 
-implemented trait trait, and cannot define any other items.
+implemented trait, and cannot define any other items.
 
 The path to the associated items is `<` followed by a path to the implementing
 type followed by `as` followed by a path to the trait followed by `>` as a path
@@ -95,7 +95,7 @@ impl Shape for Circle {
 ### Trait Implementation Coherence
 
 A trait implementation is consider incoherent if either the orphan check fails
-or there are overlapping implementation instaces. 
+or there are overlapping implementation instances. 
 
 Two trait implementations overlap when there is a non-empty intersection of the
 traits the implementation is for, the implementations can be instantiated with

src/keywords.md

@@ -8,7 +8,7 @@ Rust divides keywords into three categories:
 
 ## Strict keywords
 
-These keywords can only be used in their correct contexts. They cannnot
+These keywords can only be used in their correct contexts. They cannot
 be used as the names of:
 
 * [Items]

src/macros.md

@@ -4,7 +4,7 @@ A number of minor features of Rust are not central enough to have their own
 syntax, and yet are not implementable as functions. Instead, they are given
 names, and invoked through a consistent syntax: `some_extension!(...)`.
 
-Thre are two ways to define new macros:
+There are two ways to define new macros:
 
 * [Macros by Example] define new syntax in a higher-level, declarative way.
 * [Procedural Macros] can be used to implement custom derive.

src/type-layout.md

@@ -66,7 +66,7 @@ reference does not change the layout.
 
 Pointers to sized types have the same size and alignment as `usize`.
 
-Pointers to unsized types are sized. The size and alignemnt is guaranteed to be
+Pointers to unsized types are sized. The size and alignment is guaranteed to be
 at least equal to the size and alignment of a pointer.
 
 > Note: Though you should not rely on this, all pointers to <abbr
@@ -88,7 +88,7 @@ Slices have the same layout as the section of the array they slice.
 
 ## Tuple Layout
 
-Tuples do not have any guarantes about their layout.
+Tuples do not have any guarantees about their layout.
 
 The exception to this is the unit tuple (`()`) which is guaranteed as a
 zero-sized type to have a size of 0 and an alignment of 1.
@@ -170,7 +170,7 @@ is now. Then increase the current offset by the size of the field.
 Finally, the size of the struct is the current offset rounded up to the nearest
 multiple of the struct's alignment.
 
-Here is this algorithm described in psudeocode.
+Here is this algorithm described in pseudocode.
 
 ```rust,ignore
 struct.alignment = struct.fields().map(|field| field.alignment).max();
@@ -238,7 +238,7 @@ the default `enum` size and alignment for the target platform's C ABI.
 > mostly a `typedef` plus some named constants; in other words, an object of an
 > `enum` type can hold any integer value. For example, this is often used for
 > bitflags in `C`. In contrast, Rust’s C-like enumerations can only legally hold
-> the discrimnant values, everything else is undefined behaviour. Therefore,
+> the discriminant values, everything else is undefined behaviour. Therefore,
 > using a C-like enumeration in FFI to model a C `enum` is often wrong.
 
 It is an error for [zero-variant enumerations] to have the `C` representation.

src/types.md

@@ -585,7 +585,7 @@ type signature of `print`, and the cast expression in `main`.
 Since a trait object can contain references, the lifetimes of those references
 need to be expressed as part of the trait object. This lifetime is written as
 `Trait + 'a`. There are [defaults] that allow this lifetime to usually be
-infered with a sensible choice.
+inferred with a sensible choice.
 
 [defaults]: lifetime-elision.html#default-trait-object-lifetimes