Update links in nested directories.

Author: Alexis Hunt

src/expressions/array-expr.md

@@ -8,19 +8,16 @@
 > &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
-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.
+An _[array] 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.
 
 Alternatively there can be exactly two expressions inside the brackets,
 separated by a semi-colon. The expression after the `;` must be a have type
-`usize` and be a [constant expression](expressions.html#constant-expressions),
-such as a [literal](tokens.html#literals) or a [constant
-item](items/constant-items.html). `[a; b]` creates an array containing `b`
-copies of the value of `a`. If the expression after the semi-colon has a value
-greater than 1 then this requires that the type of `a` is
-[`Copy`](special-types-and-traits.html#copy).
+`usize` and be a [constant expression], such as a [literal] or a [constant
+item]. `[a; b]` creates an array containing `b` copies of the value of `a`. If
+the expression after the semi-colon has a value greater than 1 then this
+requires that the type of `a` is [`Copy`].
 
 ```rust
 [1, 2, 3, 4];
@@ -34,9 +31,8 @@ greater than 1 then this requires that the type of `a` is
 
 > **<sup>Syntax</sup>**\
 > _IndexExpression_ :\
-> &nbsp;&nbsp; [_Expression_] `[` [_Expression_] `]`
 
-[Array and slice](types.html#array-and-slice-types)-typed expressions can be
+[Array and slice]-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.
@@ -71,10 +67,15 @@ arr[10];                  // warning: index out of bounds
 ```
 
 The array index expression can be implemented for types other than arrays and slices
-by implementing the [Index] and [IndexMut] traits.
-
-[_Expression_]: expressions.html
-[memory location]: expressions.html#place-expressions-and-value-expressions
-[Index]: ../std/ops/trait.Index.html
-[IndexMut]: ../std/ops/trait.IndexMut.html
-[constant expression]: expressions.html#constant-expressions
+by implementing the [`Index`] and [`IndexMut`] traits.
+
+[_Expression_]: /expressions.html
+[memory location]: /expressions.html#place-expressions-and-value-expressions
+[`Index`]: ../../std/ops/trait.Index.html
+[`IndexMut`]: ../../std/ops/trait.IndexMut.html
+[constant expression]: ../expressions.html#constant-expressions
+[literal]: ../tokens.html#literals
+[Array and slice]: ../types.html#array-and-slice-types
+[constant item]: ../items/constant-items.htm
+[`Copy`]: ../special-types-and-traits.html#copy
+[array]: ../types.html#array-and-slice-types

src/expressions/block-expr.md

@@ -75,14 +75,14 @@ fn is_unix_platform() -> bool {
 }
 ```
 
-[_InnerAttribute_]: attributes.html
-[_Statement_]: statements.html
-[_Expression_]: expressions.html
-[expression]: expressions.html
-[statements]: statements.html
-[value expressions]: expressions.html#place-expressions-and-value-expressions
-[outer attributes]: attributes.html
-[inner attributes]: attributes.html
-[expression statement]: statements.html#expression-statements
-[`cfg`]: attributes.html#conditional-compilation
-[the lint check attributes]: attributes.html#lint-check-attributes
+[_InnerAttribute_]: ../attributes.html
+[_Statement_]: ../statements.html
+[_Expression_]: ../expressions.html
+[expression]: ../expressions.html
+[statements]: ../statements.html
+[value expressions]: ../expressions.html#place-expressions-and-value-expressions
+[outer attributes]: ../attributes.html
+[inner attributes]: ../attributes.html
+[expression statement]: ../statements.html#expression-statements
+[`cfg`]: ../attributes.html#conditional-compilation
+[the lint check attributes]: ../attributes.html#lint-check-attributes

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], 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
@@ -93,9 +93,9 @@ fn main() {
 
 Refer to [RFC 132] for further details and motivations.
 
-[`std::ops::Fn`]: ../std/ops/trait.Fn.html
-[`std::ops::FnMut`]: ../std/ops/trait.FnMut.html
-[`std::ops::FnOnce`]: ../std/ops/trait.FnOnce.html
+[`std::ops::Fn`]: ../../std/ops/trait.Fn.html
+[`std::ops::FnMut`]: ../../std/ops/trait.FnMut.html
+[`std::ops::FnOnce`]: ../../std/ops/trait.FnOnce.html
 [RFC 132]: https://github.com/rust-lang/rfcs/blob/master/text/0132-ufcs.md
-
-[_Expression_]: expressions.html
+[non-function types]: ../types.html#function-item-types
+[_Expression_]: ../expressions.html

src/expressions/closure-expr.md

@@ -25,22 +25,20 @@ 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),
-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
-should be moved or copied (depending on their type) from the environment. A
-closure can be forced to capture its environment by copying or moving values by
-prefixing it with the `move` keyword. This is often used to ensure that the
-closure's type is `'static`.
+[infers] how it captures each variable from its environment, 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 should be moved or copied
+(depending on their type) from the environment. A closure can be forced to
+capture its environment by copying or moving values by 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
-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.
-These traits allow functions to accept closures using generics, even though the
-exact types can't be named.
+The compiler will determine which of the [closure traits] the closure's type
+will implement by how it acts on its captured variables. The closure will also
+implement [`Send`] and/or [`Sync`] if all of its captured types do. These traits
+allow functions to accept closures using generics, even though the exact types
+can't be named.
 
 In this example, we define a function `ten_times` that takes a higher-order
 function argument, and we then call it with a closure expression as an argument,
@@ -61,10 +59,13 @@ let word = "konnichiwa".to_owned();
 ten_times(move |j| println!("{}, {}", word, j));
 ```
 
-[block]: expressions/block-expr.html
-[function definitions]: items/functions.html
-
-[_Expression_]: expressions.html
-[_BlockExpression_]: expressions/block-expr.html
-[_TypeNoBounds_]: types.html
-[_FunctionParameters_]: items/functions.html
+[block]: block-expr.html
+[function definitions]: ../items/functions.html
+[_Expression_]: ../expressions.html
+[_BlockExpression_]: block-expr.html
+[_TypeNoBounds_]: ../types.html
+[_FunctionParameters_]: ../items/functions.html
+[infers]: ../types.html#capture-modes
+[closure traits]: ../types.html#call-traits-and-coercions
+[`Send`]: ../special-types-and-traits.html#send
+[`Sync`]: ../special-types-and-traits.html#sync

src/expressions/field-expr.md

@@ -26,10 +26,10 @@ automatically dereferenced as many times as necessary to make the field access
 possible. In cases of ambiguity, we prefer fewer autoderefs to more.
 
 Finally, the fields of a struct or a reference to a struct are treated as
-separate entities when borrowing. If the struct does not implement
-[`Drop`](special-types-and-traits.html#drop) and is stored in a local variable,
-this also applies to moving out of each of its fields. This also does not apply
-if automatic dereferencing is done though user defined types.
+separate entities when borrowing. If the struct does not implement [`Drop`] and
+is stored in a local variable, this also applies to moving out of each of its
+fields. This also does not apply if automatic dereferencing is done though user
+defined types.
 
 ```rust
 struct A { f1: String, f2: String, f3: String }
@@ -45,10 +45,11 @@ let c: &String = &x.f2;         // Can borrow again
 let d: String = x.f3;           // Move out of x.f3
 ```
 
-[_Expression_]: expressions.html
-[IDENTIFIER]: identifiers.html
-[method call expression]: expressions/method-call-expr.html
-[struct]: items/structs.html
-[union]: items/unions.html
-[place expression]: expressions.html#place-expressions-and-value-expressions
-[mutable]: expressions.html#mutability
+[_Expression_]: ../expressions.html
+[IDENTIFIER]: ../identifiers.html
+[method call expression]: method-call-expr.html
+[struct]: ../items/structs.html
+[union]: ../items/unions.html
+[place expression]: ../expressions.html#place-expressions-and-value-expressions
+[mutable]: ../expressions.html#mutability
+[`Drop`]: ../special-types-and-traits.html#drop

src/expressions/grouped-expr.md

@@ -35,4 +35,4 @@ assert_eq!( a.f (), "The method f");
 assert_eq!((a.f)(), "The field f");
 ```
 
-[_Expression_]: expressions.html
+[_Expression_]: ../expressions.html

src/expressions/if-expr.md

@@ -92,5 +92,5 @@ let a = if let Some(1) = x {
 assert_eq!(a, 3);
 ```
 
-[_Expression_]: expressions.html
-[_BlockExpression_]: expressions/block-expr.html
+[_Expression_]: ../expressions.html
+[_BlockExpression_]: block-expr.html

src/expressions/literal-expr.md

@@ -12,22 +12,22 @@
 >    | [FLOAT_LITERAL]\
 >    | [BOOLEAN_LITERAL]
 
-A _literal expression_ consists of one of the [literal](tokens.html#literals)
-forms described earlier. It directly describes a number, character, string,
-or boolean value.
+A _literal expression_ consists of one of the [literal] forms described earlier.
+It directly describes a number, character, string, or boolean value.
 
 ```rust
 "hello";   // string type
 '5';       // character type
 5;         // integer type
 ```
 
-[CHAR_LITERAL]: tokens.html#character-literals
-[STRING_LITERAL]: tokens.html#string-literals
-[RAW_STRING_LITERAL]: tokens.html#raw-string-literals
-[BYTE_LITERAL]: tokens.html#byte-literals
-[BYTE_STRING_LITERAL]: tokens.html#byte-string-literals
-[RAW_BYTE_STRING_LITERAL]: tokens.html#raw-byte-string-literals
-[INTEGER_LITERAL]: tokens.html#integer-literals
-[FLOAT_LITERAL]: tokens.html#floating-point-literals
-[BOOLEAN_LITERAL]: tokens.html#boolean-literals
+[CHAR_LITERAL]: ../tokens.html#character-literals
+[STRING_LITERAL]: ../tokens.html#string-literals
+[RAW_STRING_LITERAL]: ../tokens.html#raw-string-literals
+[BYTE_LITERAL]: ../tokens.html#byte-literals
+[BYTE_STRING_LITERAL]: ../tokens.html#byte-string-literals
+[RAW_BYTE_STRING_LITERAL]: ../tokens.html#raw-byte-string-literals
+[INTEGER_LITERAL]: ../tokens.html#integer-literals
+[FLOAT_LITERAL]: ../tokens.html#floating-point-literals
+[BOOLEAN_LITERAL]: ../tokens.html#boolean-literals
+[literal]: ../tokens.html#literals

src/expressions/loop-expr.md

@@ -9,23 +9,17 @@
 >       | [_IteratorLoopExpression_]\
 >    )
 
-[_LoopLabel_]: #loop-labels
-[_InfiniteLoopExpression_]: #infinite-loops
-[_PredicateLoopExpression_]: #predicate-loops
-[_PredicatePatternLoopExpression_]: #predicate-pattern-loops
-[_IteratorLoopExpression_]: #iterator-loops
-
 Rust supports four loop expressions:
 
-*   A [`loop` expression](#infinite-loops) denotes an infinite loop.
-*   A [`while` expression](#predicate-loops) loops until a predicate is false.
-*   A [`while let` expression](#predicate-pattern-loops) tests a refutable pattern.
-*   A [`for` expression](#iterator-loops) extracts values from an iterator,
+*   A [`loop` expression] denotes an infinite loop.
+*   A [`while` expression] loops until a predicate is false.
+*   A [`while let` expression] tests a refutable pattern.
+*   A [`for` expression] extracts values from an iterator,
     looping until the iterator is empty.
 
-All four types of loop support [`break` expressions](#break-expressions),
-[`continue` expressions](#continue-expressions), and [labels](#loop-labels).
-Only `loop` supports [evaluation to non-trivial values](#break-and-loop-values).
+All four types of loop support [`break` expressions],
+[`continue` expressions], and [labels].
+Only `loop` supports [evaluation to non-trivial values][loop values].
 
 ## Infinite loops
 
@@ -37,8 +31,8 @@ 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
-associated [`break` expression(s)](#break-expressions) may terminate, and must
+has type [`!`]. 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).
 
 ## Predicate loops
@@ -129,8 +123,7 @@ a lifetime preceding the loop expression, as in `'foo: loop { break 'foo; }`,
 `'bar: while false {}`, `'humbug: for _ in 0..0 {}`.
 If a label is present, then labeled `break` and `continue` expressions nested
 within this loop may exit out of this loop or return control to its head.
-See [break expressions](#break-expressions) and [continue
-expressions](#continue-expressions).
+See [break expressions] and [continue expressions].
 
 ## `break` expressions
 
@@ -153,7 +146,7 @@ assert_eq!(last, 12);
 ```
 
 A `break` expression is normally associated with the innermost `loop`, `for` or
-`while` loop enclosing the `break` expression, but a [label](#loop-labels) can
+`while` loop enclosing the `break` expression, but a [label][labels] can
 be used to specify which enclosing loop is affected. Example:
 
 ```rust
@@ -165,7 +158,7 @@ be used to specify which enclosing loop is affected. Example:
 ```
 
 A `break` expression is only permitted in the body of a loop, and has one of
-the forms `break`, `break 'label` or ([see below](#break-and-loop-values))
+the forms `break`, `break 'label` or ([see below][loop values])
 `break EXPR` or `break 'label EXPR`.
 
 ## `continue` expressions
@@ -209,9 +202,21 @@ and the `loop` must have a type compatible with each `break` expression.
 `break` without an expression is considered identical to `break` with
 expression `()`.
 
-[IDENTIFIER]: identifiers.html
-
-[_Expression_]:      expressions.html
-[_BlockExpression_]: expressions/block-expr.html
-
-[LIFETIME_OR_LABEL]: tokens.html#lifetimes-and-loop-labels
+[IDENTIFIER]: ../identifiers.html
+[_Expression_]: ../expressions.html
+[_BlockExpression_]: block-expr.html
+[LIFETIME_OR_LABEL]: ../tokens.html#lifetimes-and-loop-labels
+[_LoopLabel_]: #loop-labels
+[_InfiniteLoopExpression_]: #infinite-loops
+[_PredicateLoopExpression_]: #predicate-loops
+[_PredicatePatternLoopExpression_]: #predicate-pattern-loops
+[_IteratorLoopExpression_]: #iterator-loops
+[`loop` expression]: #infinite-loops
+[`while` expression]: #predicate-loops
+[`while let` expression`]: #predicate-pattern-loops
+[`for` expression]: #iterator-loops
+[`break` expressions]: #break-expressions
+[`continue` expressions]: #continue-expressions
+[labels]: #loop-labels
+[loop values]: #break-and-loop-values
+[`!`]: ../types.html#never-type

src/expressions/match-expr.md

@@ -201,14 +201,14 @@ let message = match maybe_digit {
 Outer attributes are allowed on match arms. The only attributes that have
 meaning on match arms are [`cfg`], `cold`, and the [lint check attributes].
 
-[_Expression_]: expressions.html
-[_BlockExpression_]: expressions/block-expr.html#block-expressions
-[place expression]: expressions.html#place-expressions-and-value-expressions
-[value expression]: expressions.html#place-expressions-and-value-expressions
-[`char`]: types.html#textual-types
-[numeric types]: types.html#numeric-types
-[_InnerAttribute_]: attributes.html
-[_OuterAttribute_]: attributes.html
-[`cfg`]: attributes.html#conditional-compilation
-[lint check attributes]: attributes.html#lint-check-attributes
-[range]: expressions/range-expr.html
+[_Expression_]: ../expressions.html
+[_BlockExpression_]: block-expr.html#block-expressions
+[place expression]: ../expressions.html#place-expressions-and-value-expressions
+[value expression]: ../expressions.html#place-expressions-and-value-expressions
+[`char`]: ../types.html#textual-types
+[numeric types]: ../types.html#numeric-types
+[_InnerAttribute_]: ../attributes.html
+[_OuterAttribute_]: ../attributes.html
+[`cfg`]: ../attributes.html#conditional-compilation
+[lint check attributes]: ../attributes.html#lint-check-attributes
+[range]: range-expr.html