Split Types Chapter

This splits the types chapter into multiple subchapters.

I tried to avoid content changes, but I ended up with a few changes:
- Added overview links in `types.md`, and a separate discussion of type expressions.
- Split array and slice into separate chapters. Although there is some overlap between them, I feel like it was awkward explaining one and then the other. I also felt it conflated the two too much since slices can be used for more than arrays.
- Combined `Self` section with the one on the paths page.
- Added a basic redirector for external links.

Some pages may seem a little bare now, but I think each type page has potential to be expanded and improved in the future.

Author: ehuss

src/SUMMARY.md

@@ -67,6 +67,22 @@
 
 - [Type system](type-system.md)
     - [Types](types.md)
+        - [Boolean type](types/boolean.md)
+        - [Numeric types](types/numeric.md)
+        - [Textual types](types/textual.md)
+        - [Never type](types/never.md)
+        - [Tuple types](types/tuple.md)
+        - [Array types](types/array.md)
+        - [Slice types](types/slice.md)
+        - [Struct types](types/struct.md)
+        - [Enumerated types](types/enum.md)
+        - [Union types](types/union.md)
+        - [Function item types](types/function-item.md)
+        - [Closure types](types/closure.md)
+        - [Pointer types](types/pointer.md)
+        - [Function pointer types](types/function-pointer.md)
+        - [Trait object types](types/trait-object.md)
+        - [Impl trait type](types/impl-trait.md)
     - [Dynamically Sized Types](dynamically-sized-types.md)
     - [Type layout](type-layout.md)
     - [Interior mutability](interior-mutability.md)

src/const_eval.md

@@ -51,7 +51,7 @@ A _const context_ is one of the following:
   * [statics]
   * [enum discriminants]
 
-[array type length expressions]: types.html#array-and-slice-types
+[array type length expressions]: types/array.html
 [enum discriminants]: items/enumerations.html#custom-discriminant-values-for-field-less-enumerations
 [constants]: items/constant-items.html
 [statics]: items/static-items.html
@@ -68,7 +68,7 @@ A _const context_ is one of the following:
 [block expressions]:    expressions/block-expr.html
 [field]:                expressions/field-expr.html
 [array indexing]:       expressions/array-expr.html#array-and-slice-indexing-expressions
-[slice]:                types.html#array-and-slice-types
+[slice]:                types/slice.html
 [range expressions]:    expressions/range-expr.html
 [closure expressions]:  expressions/closure-expr.html
 [negation]:             expressions/operator-expr.html#negation-operators

src/crates-and-source-files.md

@@ -111,7 +111,7 @@ fn main() {
 [module]: items/modules.html
 [module path]: paths.html
 [attributes]: attributes.html
-[unit]: types.html#tuple-types
+[unit]: types/tuple.html
 [_InnerAttribute_]: attributes.html
 [_Item_]: items.html
 [_shebang_]: https://en.wikipedia.org/wiki/Shebang_(Unix)

src/destructors.md

@@ -82,12 +82,12 @@ variable or field from being dropped automatically.
 [Assignment]: expressions/operator-expr.html#assignment-expressions
 [`std::ops::Drop::drop`]: ../std/ops/trait.Drop.html
 [RFC 1857]: https://github.com/rust-lang/rfcs/blob/master/text/1857-stabilize-drop-order.md
-[struct]: types.html#struct-types
-[tuple]: types.html#tuple-types
-[enum variant]: types.html#enumerated-types
-[array]: types.html#array-and-slice-types
-[closure]: types.html#closure-types
-[Trait objects]: types.html#trait-objects
+[struct]: types/struct.html
+[tuple]: types/tuple.html
+[enum variant]: types/enum.html
+[array]: types/array.html
+[closure]: types/closure.html
+[Trait objects]: types/trait-object.html
 [`std::ptr::drop_in_place`]: ../std/ptr/fn.drop_in_place.html
 [`std::mem::forget`]: ../std/mem/fn.forget.html
 [`std::mem::ManuallyDrop`]: ../std/mem/struct.ManuallyDrop.html

src/dynamically-sized-types.md

@@ -24,9 +24,9 @@ Notably: [variables], function parameters, [const] and [static] items must be
 `Sized`.
 
 [sized]: special-types-and-traits.html#sized
-[Slices]: types.html#array-and-slice-types
-[trait objects]: types.html#trait-objects
-[Pointer types]: types.html#pointer-types
+[Slices]: types/slice.html
+[trait objects]: types/trait-object.html
+[Pointer types]: types/pointer.html
 [variables]: variables.html
 [const]: items/constant-items.html
 [static]: items/static-items.html

src/expressions.md

@@ -277,7 +277,7 @@ exist in `core::ops` and `core::cmp` with the same names.
 [let statement]:        statements.html#let-statements
 [Mutable `static` items]: items/static-items.html#mutable-statics
 [const contexts]:       const_eval.html
-[slice]:                types.html#array-and-slice-types
+[slice]:                types/slice.html
 [static variables]:     items/static-items.html
 [Temporary values]:     #temporary-lifetimes
 [Variables]:            variables.html

src/expressions/array-expr.md

@@ -8,7 +8,7 @@
 > &nbsp;&nbsp; | `[` [_Expression_] ( `,` [_Expression_] )<sup>\*</sup> `,`<sup>?</sup> `]`\
 > &nbsp;&nbsp; | `[` [_Expression_] `;` [_Expression_] `]`
 
-An _[array](types.html#array-and-slice-types) expression_ can be written by
+An _[array](types/array.html) expression_ can be written by
 enclosing zero or more comma-separated expressions of uniform type in square
 brackets. This produces and array containing each of these values in the
 order they are written.
@@ -36,7 +36,7 @@ greater than 1 then this requires that the type of `a` is
 > _IndexExpression_ :\
 > &nbsp;&nbsp; [_Expression_] `[` [_Expression_] `]`
 
-[Array and slice](types.html#array-and-slice-types)-typed expressions can be
+[Array](types/array.html) and [slice](types/slice.html)-typed expressions can be
 indexed by writing a square-bracket-enclosed expression of type `usize` (the
 index) after them. When the array is mutable, the resulting [memory location]
 can be assigned to.

src/expressions/call-expr.md

@@ -10,7 +10,7 @@
 A _call expression_ consists of an expression followed by a parenthesized
 expression-list. It invokes a function, providing zero or more input variables.
 If the function eventually returns, then the expression completes. For
-[non-function types](types.html#function-item-types), the expression f(...) uses
+[non-function types](types/function-item.html), the expression f(...) uses
 the method on one of the [`std::ops::Fn`], [`std::ops::FnMut`] or
 [`std::ops::FnOnce`] traits, which differ in whether they take the type by
 reference, mutable reference, or take ownership respectively. An automatic

src/expressions/closure-expr.md

@@ -25,7 +25,7 @@ functions, as an abbreviation for defining and capturing a separate function.
 
 Significantly, closure expressions _capture their environment_, which regular
 [function definitions] do not. Without the `move` keyword, the closure expression
-[infers how it captures each variable from its environment](types.html#capture-modes),
+[infers how it captures each variable from its environment](types/closure.html#capture-modes),
 preferring to capture by shared reference, effectively borrowing
 all outer variables mentioned inside the closure's body. If needed the compiler
 will infer that instead mutable references should be taken, or that the values
@@ -35,7 +35,7 @@ prefixing it with the `move` keyword. This is often used to ensure that the
 closure's type is `'static`.
 
 The compiler will determine which of the [closure
-traits](types.html#call-traits-and-coercions) the closure's type will implement by how it
+traits](types/closure.html#call-traits-and-coercions) the closure's type will implement by how it
 acts on its captured variables. The closure will also implement
 [`Send`](special-types-and-traits.html#send) and/or
 [`Sync`](special-types-and-traits.html#sync) if all of its captured types do.
@@ -67,5 +67,5 @@ ten_times(move |j| println!("{}, {}", word, j));
 
 [_Expression_]: expressions.html
 [_BlockExpression_]: expressions/block-expr.html
-[_TypeNoBounds_]: types.html
+[_TypeNoBounds_]: types.html#type-expressions
 [_FunctionParameters_]: items/functions.html

src/expressions/loop-expr.md

@@ -37,7 +37,7 @@ A `loop` expression repeats execution of its body continuously:
 `loop { println!("I live."); }`.
 
 A `loop` expression without an associated `break` expression is diverging and
-has type [`!`](types.html#never-type). A `loop` expression containing
+has type [`!`](types/never.html). A `loop` expression containing
 associated [`break` expression(s)](#break-expressions) may terminate, and must
 have type compatible with the value of the `break` expression(s).