Word wrapping

Author: matthewjasper

src/types.md

@@ -9,15 +9,17 @@ limited capabilities.
 
 ## Primitive types
 
-Some types are defined by the language, rather than as part of the standard library,
-these are called _primitive types_. Some of these are induvidual types:
+Some types are defined by the language, rather than as part of the standard
+library, these are called _primitive types_. Some of these are induvidual
+types:
 
 * The boolean type `bool` with values `true` and `false`.
 * The [machine types] (integer and floating-point).
 * The [machine-dependent integer types].
 * The [textual types] `char` and `str`.
 
-There are also some primitive constructs for generic types built in to the language:
+There are also some primitive constructs for generic types built in to the
+language:
 
 * [Tuples]
 * [Arrays]
@@ -45,27 +47,27 @@ There are also some primitive constructs for generic types built in to the langu
 The machine types are the following:
 
 * The unsigned word types `u8`, `u16`, `u32` and `u64`, with values drawn from
-  the integer intervals [0, 2^8 - 1], [0, 2^16 - 1], [0, 2^32 - 1] and
-  [0, 2^64 - 1] respectively.
+  the integer intervals [0, 2^8 - 1], [0, 2^16 - 1], [0, 2^32 - 1] and [0, 2^64
+  - 1] respectively.
 
 * The signed two's complement word types `i8`, `i16`, `i32` and `i64`, with
-  values drawn from the integer intervals [-(2^(7)), 2^7 - 1],
-  [-(2^(15)), 2^15 - 1], [-(2^(31)), 2^31 - 1], [-(2^(63)), 2^63 - 1]
-  respectively.
+  values drawn from the integer intervals [-(2^(7)), 2^7 - 1], [-(2^(15)), 2^15
+  - 1], [-(2^(31)), 2^31 - 1], [-(2^(63)), 2^63 - 1] respectively.
 
 * The IEEE 754-2008 `binary32` and `binary64` floating-point types: `f32` and
   `f64`, respectively.
 
 ### Machine-dependent integer types
 
-The `usize` type is an unsigned integer type with the same number of bits as the
-platform's pointer type. It can represent every memory address in the process.
+The `usize` type is an unsigned integer type with the same number of bits as
+the platform's pointer type. It can represent every memory address in the
+process.
 
 The `isize` type is a signed integer type with the same number of bits as the
 platform's pointer type. The theoretical upper bound on object and array size
-is the maximum `isize` value. This ensures that `isize` can be used to calculate
-differences between pointers into an object or array and can address every byte
-within an object along with one byte past the end.
+is the maximum `isize` value. This ensures that `isize` can be used to
+calculate differences between pointers into an object or array and can address
+every byte within an object along with one byte past the end.
 
 ## Textual types
 
@@ -79,8 +81,8 @@ string.
 
 A value of type `str` is a Unicode string, represented as an array of 8-bit
 unsigned bytes holding a sequence of UTF-8 code points. Since `str` is a
-[dynamically sized type], it is not a _first-class_ type, but can only be instantiated
-through a pointer type, such as `&str`.
+[dynamically sized type], it is not a _first-class_ type, but can only be
+instantiated through a pointer type, such as `&str`.
 
 ## Tuple types
 
@@ -91,8 +93,8 @@ Tuple types and values are denoted by listing the types or values of their
 elements, respectively, in a parenthesized, comma-separated list.
 
 Because tuple elements don't have a name, they can only be accessed by
-pattern-matching or by using `N` directly as a field to access the
-`N`th element.
+pattern-matching or by using `N` directly as a field to access the `N`th
+element.
 
 An example of a tuple type and its use:
 
@@ -160,25 +162,24 @@ expression](expressions.html#struct-expressions).
 
 The memory layout of a `struct` is undefined by default to allow for compiler
 optimizations like field reordering, but it can be fixed with the
-`#[repr(...)]` attribute. In either case, fields may be given in any order in
-a corresponding struct *expression*; the resulting `struct` value will always
+`#[repr(...)]` attribute. In either case, fields may be given in any order in a
+corresponding struct *expression*; the resulting `struct` value will always
 have the same memory layout.
 
 The fields of a `struct` may be qualified by [visibility
-modifiers](visibility-and-privacy.html), to allow access to data in a
-struct outside a module.
+modifiers](visibility-and-privacy.html), to allow access to data in a struct
+outside a module.
 
 A _tuple struct_ type is just like a struct type, except that the fields are
 anonymous.
 
-A _unit-like struct_ type is like a struct type, except that it has no
-fields. The one value constructed by the associated [struct
-expression](expressions.html#struct-expressions) is the only value that inhabits such a
-type.
+A _unit-like struct_ type is like a struct type, except that it has no fields.
+The one value constructed by the associated [struct
+expression](expressions.html#struct-expressions) is the only value that
+inhabits such a type.
 
-[^structtype]: `struct` types are analogous to `struct` types in C,
-    the *record* types of the ML family,
-    or the *struct* types of the Lisp family.
+[^structtype]: `struct` types are analogous to `struct` types in C, the
+    *record* types of the ML family, or the *struct* types of the Lisp family.
 
 ## Enumerated types
 
@@ -203,8 +204,8 @@ named reference to an [`enum` item](items.html#enumerations).
 
 ## Union types
 
-A *union type* is a nominal, heterogeneous C-like union, denoted by the name
-of a [`union` item](items.html#unions).
+A *union type* is a nominal, heterogeneous C-like union, denoted by the name of
+a [`union` item](items.html#unions).
 
 A union contains the value of any one of its fields. Since the accessing the
 wrong field can cause unexpected or undefined behaviour, it requires `unsafe`,
@@ -221,13 +222,14 @@ recursive. That is, each `enum` variant or `struct` or `union` field may refer,
 directly or indirectly, to the enclosing `enum` or `struct` type itself. Such
 recursion has restrictions:
 
-* Recursive types must include a nominal type in the recursion
-  (not mere [type definitions](../grammar.html#type-definitions),
-   or other structural types such as [arrays](#array-and-slice-types) or [tuples](#tuple-types)).
-* The size of a recursive type must be finite;
-  in other words the recursive fields of the type must be [pointer types](#pointer-types).
-* Recursive type definitions can cross module boundaries, but not module *visibility* boundaries,
-  or crate boundaries (in order to simplify the module system and type checker).
+* Recursive types must include a nominal type in the recursion (not mere [type
+  definitions](../grammar.html#type-definitions), or other structural types
+  such as [arrays](#array-and-slice-types) or [tuples](#tuple-types)).
+* The size of a recursive type must be finite; in other words the recursive
+  fields of the type must be [pointer types](#pointer-types).
+* Recursive type definitions can cross module boundaries, but not module
+  *visibility* boundaries, or crate boundaries (in order to simplify the module
+  system and type checker).
 
 An example of a *recursive* type and its use:
 
@@ -243,8 +245,8 @@ let a: List<i32> = List::Cons(7, Box::new(List::Cons(13, Box::new(List::Nil))));
 ## Pointer types
 
 All pointers in Rust are explicit first-class values. They can be copied,
-stored into data structs, and returned from functions. There are two
-varieties of pointer in Rust:
+stored into data structs, and returned from functions. There are two varieties
+of pointer in Rust:
 
 ### Shared references (`&`)
 
@@ -261,10 +263,9 @@ keep it alive during the scope of the reference itself.
 
 ### Mutable references (`&mut`)
 
-These also point to memory owned by some other value. A mutable reference
-type is written `&mut type` or `&'a mut type`. A mutable reference (that
-hasn't been borrowed) is the only way to access the value it points to, so
-is not `Copy`.
+These also point to memory owned by some other value. A mutable reference type
+is written `&mut type` or `&'a mut type`. A mutable reference (that hasn't been
+borrowed) is the only way to access the value it points to, so is not `Copy`.
 
 ### Raw pointers (`*const` and `*mut`)
 
@@ -283,8 +284,8 @@ types](#dynamically-sized-types) they also have their addition data compared.
 
 ### Smart Pointers
 
-The standard library contains additional 'smart pointer' types beyond references
-and raw pointers.
+The standard library contains additional 'smart pointer' types beyond
+references and raw pointers.
 
 ## Function item types
 
@@ -297,8 +298,8 @@ need to contain an actual function pointer, and no indirection is needed when
 the function is called.
 
 There is currently no syntax that directly refers to a function item type, but
-the compiler will display the type as something like `fn() {foo::<u32>}` in error
-messages.
+the compiler will display the type as something like `fn() {foo::<u32>}` in
+error messages.
 
 Because the function item type explicitly identifies the function, the item
 types of different functions - different items, or the same item with different
@@ -310,11 +311,11 @@ let x = &mut foo::<i32>;
 *x = foo::<u32>; //~ ERROR mismatched types
 ```
 
-However, there is a [coercion] from function items to [function pointers](#function-pointer-types)
-with the same signature, which is triggered not only when a function item
-is used when a function pointer is directly expected, but also when different
-function item types with the same signature meet in different arms of the same
-`if` or `match`:
+However, there is a [coercion] from function items to [function
+pointers](#function-pointer-types) with the same signature, which is triggered
+not only when a function item is used when a function pointer is directly
+expected, but also when different function item types with the same signature
+meet in different arms of the same `if` or `match`:
 
 [coercion]: type-coercions.html
 
@@ -363,29 +364,26 @@ x = bo(5,7);
 A [closure expression](expressions.html#closure-expressions) produces a closure
 value with a unique, anonymous type that cannot be written out.
 
-Depending on the requirements of the closure, its type implements one or
-more of the closure traits:
+Depending on the requirements of the closure, its type implements one or more
+of the closure traits:
 
-* `FnOnce`
-  : The closure can be called once. A closure called as `FnOnce`
-    can move out values from its environment.
+* `FnOnce` : The closure can be called once. A closure called as `FnOnce` can
+  move out values from its environment.
 
-* `FnMut`
-  : The closure can be called multiple times as mutable. A closure called as
-    `FnMut` can mutate values from its environment. `FnMut` inherits from
-    `FnOnce` (i.e. anything implementing `FnMut` also implements `FnOnce`).
+* `FnMut` : The closure can be called multiple times as mutable. A closure
+  called as `FnMut` can mutate values from its environment. `FnMut` inherits
+  from `FnOnce` (i.e. anything implementing `FnMut` also implements `FnOnce`).
 
-* `Fn`
-  : The closure can be called multiple times through a shared reference. A
-    closure called as `Fn` can neither move out from nor mutate captured
-    variables, but read-only access to such values is allowed. Using `move` to
-    capture variables by value is allowed so long as they aren't mutated or
-    moved in the body of the closure. `Fn` inherits from `FnMut`, which itself
-    inherits from `FnOnce`.
+* `Fn` : The closure can be called multiple times through a shared reference. A
+  closure called as `Fn` can neither move out from nor mutate captured
+  variables, but read-only access to such values is allowed. Using `move` to
+  capture variables by value is allowed so long as they aren't mutated or moved
+  in the body of the closure. `Fn` inherits from `FnMut`, which itself inherits
+  from `FnOnce`.
 
-Closures that don't use anything from their environment ("non capturing closures")
-can be coerced to function pointers (`fn`) with the matching signature.
-To adopt the example from the section above:
+Closures that don't use anything from their environment ("non capturing
+closures") can be coerced to function pointers (`fn`) with the matching
+signature. To adopt the example from the section above:
 
 ```rust
 let add = |x, y| x + y;
@@ -414,7 +412,8 @@ function pointer is loaded from the trait object vtable and invoked indirectly.
 The actual implementation for each vtable entry can vary on an object-by-object
 basis.
 
-Note that for a trait object types only exist for _object-safe_ traits ([RFC 255]):
+Note that for a trait object types only exist for _object-safe_ traits ([RFC
+255]):
 
 [RFC 255]: https://github.com/rust-lang/rfcs/blob/master/text/0255-object-safety.md
 
@@ -457,8 +456,8 @@ 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. The assumed lifetime of
-references held by a trait object is called its _default object lifetime bound_.
-These were defined in [RFC 599] and amended in [RFC 1156].
+references held by a trait object is called its _default object lifetime
+bound_. These were defined in [RFC 599] and amended in [RFC 1156].
 
 [RFC 599]: https://github.com/rust-lang/rfcs/blob/master/text/0599-default-object-bound.md
 [RFC 1156]: https://github.com/rust-lang/rfcs/blob/master/text/1156-adjust-default-object-bounds.md
@@ -480,8 +479,9 @@ Box<Foo + 'static>
 ```
 
 The `+ 'static` and `+ 'a` refer to the default bounds of those kinds of trait
-objects, and also to how you can directly override them. Note that the innermost
-object sets the bound, so `&'a Box<Foo>` is still `&'a Box<Foo + 'static>`.
+objects, and also to how you can directly override them. Note that the
+innermost object sets the bound, so `&'a Box<Foo>` is still `&'a Box<Foo +
+'static>`.
 
 For traits that have lifetime parameters of their own, the default bound is
 based on that lifetime parameter:
@@ -508,7 +508,8 @@ trait [`Sized`]. A type with a size that is known only at run-time is called a
 _dynamically sized type_ (_DST_) or unsized type. [Slices] and [trait objects]
 are two of the most DSTs. Such types can only be used in certain cases:
 
-* [Pointer types] to DSTs are sized but have twice the size of pointers to sized types
+* [Pointer types] to DSTs are sized but have twice the size of pointers to
+  sized types
     * Pointers to slices also store the number of elements of the slice.
     * Pointers to trait objects also store a pointer to a vtable.
 * Traits may be implemented for DSTs
@@ -560,14 +561,15 @@ fn to_vec<A: Clone>(xs: &[A]) -> Vec<A> {
 }
 ```
 
-Here, `first` has type `A`, referring to `to_vec`'s `A` type parameter; and `rest`
-has type `Vec<A>`, a vector with element type `A`.
+Here, `first` has type `A`, referring to `to_vec`'s `A` type parameter; and
+`rest` has type `Vec<A>`, a vector with element type `A`.
 
 ## Self types
 
-The special type `Self` has a meaning within traits and impls. In a trait definition, it refers
-to an implicit type parameter representing the "implementing" type. In an impl,
-it is an alias for the implementing type. For example, in:
+The special type `Self` has a meaning within traits and impls. In a trait
+definition, it refers to an implicit type parameter representing the
+"implementing" type. In an impl, it is an alias for the implementing type. For
+example, in:
 
 ```rust
 pub trait From<T> {
@@ -581,8 +583,8 @@ impl From<i32> for String {
 }
 ```
 
-The notation `Self` in the impl refers to the implementing type: `String`. In another
-example:
+The notation `Self` in the impl refers to the implementing type: `String`. In
+another example:
 
 ```rust
 trait Printable {