Update rust reference info about closures

src/attributes/limits.md

@@ -15,10 +15,10 @@ syntax to specify the recursion depth.
 #![recursion_limit = "4"]
 
 macro_rules! a {
-    () => { a!(1) };
-    (1) => { a!(2) };
-    (2) => { a!(3) };
-    (3) => { a!(4) };
+    () => { a!(1); };
+    (1) => { a!(2); };
+    (2) => { a!(3); };
+    (3) => { a!(4); };
     (4) => { };
 }
 

src/destructors.md

@@ -1,7 +1,7 @@
 # Destructors
 
 When an [initialized] [variable] or [temporary] goes out of
-[scope](#drop-scopes) its *destructor* is run, or it is *dropped*. [Assignment]
+[scope](#drop-scopes), its *destructor* is run, or it is *dropped*. [Assignment]
 also runs the destructor of its left-hand operand, if it's initialized. If a
 variable has been partially initialized, only its initialized fields are
 dropped.
@@ -154,7 +154,7 @@ temporary variable that holds the result of that expression when used in a
 [place context], unless it is [promoted].
 
 Apart from lifetime extension, the temporary scope of an expression is the
-smallest scope that contains the expression and is for one of the following:
+smallest scope that contains the expression and is one of the following:
 
 * The entire function body.
 * A statement.
@@ -246,7 +246,8 @@ loop {
 ### Constant promotion
 
 Promotion of a value expression to a `'static` slot occurs when the expression
-could be written in a constant, borrowed, and dereferencing that borrow where
+could be written in a constant and borrowed, and that borrow could be dereferenced
+where
 the expression was originally written, without changing the runtime behavior.
 That is, the promoted expression can be evaluated at compile-time and the
 resulting value does not contain [interior mutability] or [destructors] (these

src/dynamically-sized-types.md

@@ -18,7 +18,7 @@ types">DSTs</abbr>. Such types can only be used in certain cases:
   types">DSTs</abbr>.
   Unlike with generic type parameters, `Self: ?Sized` is the 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
+  last field; this makes the struct itself a
   <abbr title="dynamically sized type">DST</abbr>.
 
 > **Note**: [variables], function parameters, [const] items, and [static] items must be

src/expressions.md

@@ -179,11 +179,11 @@ move the value. Only the following place expressions may be moved out of:
 * [Variables] which are not currently borrowed.
 * [Temporary values](#temporaries).
 * [Fields][field] of a place expression which can be moved out of and
-  doesn't implement [`Drop`].
+  don't implement [`Drop`].
 * The result of [dereferencing][deref] an expression with type [`Box<T>`] and
   that can also be moved out of.
 
-When moving out of a place expression that evaluates to a local variable, the
+After moving out of a place expression that evaluates to a local variable, the
 location is deinitialized and cannot be read from again until it is
 reinitialized. In all other cases, trying to use a place expression in a value
 expression context is an error.
@@ -206,7 +206,7 @@ The following expressions can be mutable place expression contexts:
 * Dereference of a variable, or field of a variable, with type `&mut T`. Note:
   This is an exception to the requirement of the next rule.
 * Dereferences of a type that implements `DerefMut`: this then requires that
-  the value being dereferenced is evaluated is a mutable place expression context.
+  the value being dereferenced is evaluated in a mutable place expression context.
 * [Array indexing] of a type that implements `IndexMut`: this
   then evaluates the value being indexed, but not the index, in mutable place
   expression context.

src/expressions/array-expr.md

@@ -21,7 +21,7 @@ The syntax for the second form is two expressions separated by a semicolon (`;`)
 The expression before the `;` is called the *repeat operand*.
 The expression after the `;` is called the *length operand*.
 It must have type `usize` and be a [constant expression], such as a [literal] or a [constant item].
-An array expression of this form creates an array with the length of the value of the legnth operand with each element a copy of the repeat operand.
+An array expression of this form creates an array with the length of the value of the length operand with each element being a copy of the repeat operand.
 That is, `[a; b]` creates an array containing `b` copies of the value of `a`.
 If the length operand has a value greater than 1 then this requires that the type of the repeat operand is [`Copy`] or that it must be a [path] to a constant item.
 

src/expressions/loop-expr.md

@@ -148,7 +148,7 @@ for n in 1..11 {
 assert_eq!(sum, 55);
 ```
 
-A for loop is equivalent to the following block expression.
+A `for` loop is equivalent to a `loop` expression containing a [`match` expression] as follows:
 
 <!-- ignore: expansion example -->
 ```rust,ignore

src/expressions/method-call-expr.md

@@ -71,7 +71,7 @@ These cases require a [disambiguating function call syntax] for method and funct
 ***Warning:*** For [trait objects], if there is an inherent method of the same name as a trait method, it will give a compiler error when trying to call the method in a method call expression.
 Instead, you can call the method using [disambiguating function call syntax], in which case it calls the trait method, not the inherent method.
 There is no way to call the inherent method.
-Just don't define inherent methods on trait objects with the same name a trait method and you'll be fine.
+Just don't define inherent methods on trait objects with the same name as a trait method and you'll be fine.
 
 </div>
 

src/glossary.md

@@ -125,7 +125,7 @@ implementation.
 
 A variable is initialized if it has been assigned a value and hasn't since been
 moved from. All other memory locations are assumed to be uninitialized. Only
-unsafe Rust can create such a memory without initializing it.
+unsafe Rust can create a memory location without initializing it.
 
 ### Local trait
 

src/identifiers.md

@@ -2,8 +2,8 @@
 
 > **<sup>Lexer:<sup>**\
 > IDENTIFIER_OR_KEYWORD :\
-> &nbsp;&nbsp; &nbsp;&nbsp; XID_start XID_continue<sup>\*</sup>\
-> &nbsp;&nbsp; | `_` XID_continue<sup>+</sup>
+> &nbsp;&nbsp; &nbsp;&nbsp; XID_Start XID_Continue<sup>\*</sup>\
+> &nbsp;&nbsp; | `_` XID_Continue<sup>+</sup>
 >
 > RAW_IDENTIFIER : `r#` IDENTIFIER_OR_KEYWORD <sub>*Except `crate`, `self`, `super`, `Self`*</sub>
 >
@@ -12,29 +12,59 @@
 > IDENTIFIER :\
 > NON_KEYWORD_IDENTIFIER | RAW_IDENTIFIER
 
-An identifier is any nonempty Unicode string of the following form:
+<!-- When updating the version, update the UAX links, too. -->
+Identifiers follow the specification in [Unicode Standard Annex #31][UAX31] for Unicode version 13.0, with the additions described below. Some examples of identifiers:
 
-Either
+* `foo`
+* `_identifier`
+* `r#true`
+* `Москва`
+* `東京`
 
-* The first character has property [`XID_start`].
-* The remaining characters have property [`XID_continue`].
+The profile used from UAX #31 is:
 
-Or
+* Start := [`XID_Start`], plus the underscore character (U+005F)
+* Continue := [`XID_Continue`]
+* Medial := empty
 
-* The first character is `_`.
-* The identifier is more than one character. `_` alone is not an identifier.
-* The remaining characters have property [`XID_continue`].
+> **Note**: Identifiers starting with an underscore are typically used to indicate an identifier that is intentionally unused, and will silence the unused warning in `rustc`.
 
-> **Note**: [`XID_start`] and [`XID_continue`] as character properties cover the
-> character ranges used to form the more familiar C and Java language-family
-> identifiers.
+Identifiers may not be a [strict] or [reserved] keyword without the `r#` prefix described below in [raw identifiers](#raw-identifiers).
+
+Zero width non-joiner (ZWNJ U+200C) and zero width joiner (ZWJ U+200D) characters are not allowed in identifiers.
+
+Identifiers are restricted to the ASCII subset of [`XID_Start`] and [`XID_Continue`] in the following situations:
+
+* [`extern crate`] declarations
+* External crate names referenced in a [path]
+* [Module] names loaded from the filesystem without a [`path` attribute]
+* [`no_mangle`] attributed items
+* Item names in [external blocks]
+
+## Normalization
+
+Identifiers are normalized using Normalization Form C (NFC) as defined in [Unicode Standard Annex #15][UAX15]. Two identifiers are equal if their NFC forms are equal.
+
+[Procedural][proc-macro] and [declarative][mbe] macros receive normalized identifiers in their input.
+
+## Raw identifiers
 
 A raw identifier is like a normal identifier, but prefixed by `r#`. (Note that
 the `r#` prefix is not included as part of the actual identifier.)
 Unlike a normal identifier, a raw identifier may be any strict or reserved
 keyword except the ones listed above for `RAW_IDENTIFIER`.
 
-[strict]: keywords.md#strict-keywords
+[`extern crate`]: items/extern-crates.md
+[`no_mangle`]: abi.md#the-no_mangle-attribute
+[`path` attribute]: items/modules.md#the-path-attribute
+[`XID_Continue`]: http://unicode.org/cldr/utility/list-unicodeset.jsp?a=%5B%3AXID_Continue%3A%5D&abb=on&g=&i=
+[`XID_Start`]:  http://unicode.org/cldr/utility/list-unicodeset.jsp?a=%5B%3AXID_Start%3A%5D&abb=on&g=&i=
+[external blocks]: items/external-blocks.md
+[mbe]: macros-by-example.md
+[module]: items/modules.md
+[path]: paths.md
+[proc-macro]: procedural-macros.md
 [reserved]: keywords.md#reserved-keywords
-[`XID_start`]:  http://unicode.org/cldr/utility/list-unicodeset.jsp?a=%5B%3AXID_Start%3A%5D&abb=on&g=&i=
-[`XID_continue`]: http://unicode.org/cldr/utility/list-unicodeset.jsp?a=%5B%3AXID_Continue%3A%5D&abb=on&g=&i=
+[strict]: keywords.md#strict-keywords
+[UAX15]: https://www.unicode.org/reports/tr15/tr15-50.html
+[UAX31]: https://www.unicode.org/reports/tr31/tr31-33.html

src/items/extern-crates.md

@@ -64,7 +64,7 @@ by using an underscore with the form `extern crate foo as _`. This may be
 useful for crates that only need to be linked, but are never referenced, and
 will avoid being reported as unused.
 
-The [`macro_use` attribute] works as usual and import the macro names
+The [`macro_use` attribute] works as usual and imports the macro names
 into the [`macro_use` prelude].
 
 ## The `no_link` attribute

src/items/external-blocks.md

@@ -17,7 +17,7 @@ External blocks provide _declarations_ of items that are not _defined_ in the
 current crate and are the basis of Rust's foreign function interface. These are
 akin to unchecked imports.
 
-Two kind of item _declarations_ are allowed in external blocks: [functions] and
+Two kinds of item _declarations_ are allowed in external blocks: [functions] and
 [statics]. Calling functions or accessing statics that are declared in external
 blocks is only allowed in an `unsafe` context.
 

src/items/functions.md

@@ -74,7 +74,7 @@ If the first parameter is a _SelfParam_, this indicates that the function is a
 function] in a [trait] or [implementation].
 
 A parameter with the `...` token indicates a [variadic function], and may only
-be used as the last parameter of a [external block] function. The variadic
+be used as the last parameter of an [external block] function. The variadic
 parameter may have an optional identifier, such as `args: ...`.
 
 ## Function body

src/items/generics.md

@@ -37,7 +37,7 @@ Generic parameters are in scope within the item definition where they are
 declared. They are not in scope for items declared within the body of a
 function as described in [item declarations].
 
-[References], [raw pointers], [arrays], [slices][arrays], [tuples], and
+[References], [raw pointers], [arrays], [slices], [tuples], and
 [function pointers] have lifetime or type parameters as well, but are not
 referred to with path syntax.
 
@@ -274,6 +274,7 @@ struct Foo<#[my_flexible_clone(unbounded)] H> {
 
 [array repeat expression]: ../expressions/array-expr.md
 [arrays]: ../types/array.md
+[slices]: ../types/slice.md
 [associated const]: associated-items.md#associated-constants
 [associated type]: associated-items.md#associated-types
 [block]: ../expressions/block-expr.md

src/items/implementations.md

@@ -87,8 +87,8 @@ fn main() {
 ## Trait Implementations
 
 A _trait implementation_ is defined like an inherent implementation except that
-the optional generic type declarations is followed by a [trait] followed
-by the keyword `for`. Followed by a path to a nominal type.
+the optional generic type declarations are followed by a [trait], followed
+by the keyword `for`, followed by a path to a nominal type.
 
 <!-- To understand this, you have to back-reference to the previous section. :( -->
 
@@ -265,7 +265,7 @@ impl<'a> HasAssocType for Struct {
 
 Implementations may contain outer [attributes] before the `impl` keyword and
 inner [attributes] inside the brackets that contain the associated items. Inner
-attributes must come before any associated items. That attributes that have
+attributes must come before any associated items. The attributes that have
 meaning here are [`cfg`], [`deprecated`], [`doc`], and [the lint check
 attributes].
 

src/items/modules.md

@@ -65,7 +65,7 @@ contents in a file named `mod.rs` within that directory. The above example can
 alternately be expressed with `crate::util`'s contents in a file named
 `util/mod.rs`. It is not allowed to have both `util.rs` and `util/mod.rs`.
 
-> **Note**: Previous to `rustc` 1.30, using `mod.rs` files was the way to load
+> **Note**: Prior to `rustc` 1.30, using `mod.rs` files was the way to load
 > a module with nested children. It is encouraged to use the new naming
 > convention as it is more consistent, and avoids having many files named
 > `mod.rs` within a project.

src/lifetime-elision.md

@@ -103,7 +103,7 @@ If neither of those rules apply, then the bounds on the trait are used:
 // For the following trait...
 trait Foo { }
 
-// These two are the same as Box<T> has no lifetime bound on T
+// These two are the same because Box<T> has no lifetime bound on T
 type T1 = Box<dyn Foo>;
 type T2 = Box<dyn Foo + 'static>;
 

src/names/preludes.md

@@ -3,7 +3,7 @@
 A *prelude* is a collection of names that are automatically brought into scope
 of every module in a crate.
 
-These prelude names are not part of the module itself, they are implicitly
+These prelude names are not part of the module itself: they are implicitly
 queried during [name resolution]. For example, even though something like
 [`Box`] is in scope in every module, you cannot refer to it as `self::Box`
 because it is not a member of the current module.

src/patterns.md

@@ -13,7 +13,6 @@
 >    | [_IdentifierPattern_]\
 >    | [_WildcardPattern_]\
 >    | [_RestPattern_]\
->    | [_ObsoleteRangePattern_]\
 >    | [_ReferencePattern_]\
 >    | [_StructPattern_]\
 >    | [_TupleStructPattern_]\
@@ -384,6 +383,9 @@ match slice {
     // `end` is a slice of everything but the first element, which must be "a".
     ["a", end @ ..] => println!("ends with: {:?}", end),
 
+    // 'whole' is the entire slice and `last` is the final element
+    whole @ [.., last] => println!("the last element of {:?} is {}", whole, last),
+
     rest => println!("{:?}", rest),
 }
 
@@ -404,7 +406,15 @@ match tuple {
 
 > **<sup>Syntax</sup>**\
 > _RangePattern_ :\
-> &nbsp;&nbsp; _RangePatternBound_ `..=` _RangePatternBound_
+> &nbsp;&nbsp; &nbsp;&nbsp; _InclusiveRangePattern_\
+> &nbsp;&nbsp; | _HalfOpenRangePattern_\
+> &nbsp;&nbsp; | _ObsoleteRangePattern_
+>
+> _InclusiveRangePattern_ :\
+> &nbsp;&nbsp; &nbsp;&nbsp; _RangePatternBound_ `..=` _RangePatternBound_
+>
+> _HalfOpenRangePattern_ :\
+> &nbsp;&nbsp; | _RangePatternBound_ `..`
 >
 > _ObsoleteRangePattern_ :\
 > &nbsp;&nbsp; _RangePatternBound_ `...` _RangePatternBound_
@@ -417,11 +427,20 @@ match tuple {
 > &nbsp;&nbsp; | [_PathInExpression_]\
 > &nbsp;&nbsp; | [_QualifiedPathInExpression_]
 
-Range patterns match values that are within the closed range defined by its lower and
-upper bounds. For example, a pattern `'m'..='p'` will match only the values `'m'`, `'n'`,
-`'o'`, and `'p'`. The bounds can be literals or paths that point to constant values.
+Range patterns match values within the range defined by their bounds. A range pattern may be
+closed or half-open. A range pattern is closed if it has both a lower and an upper bound, and
+it matches all the values between and including both of its bounds. A range pattern that is
+half-open is written with a lower bound but not an upper bound, and matches any value equal to
+or greater than the specified lower bound.
+
+For example, a pattern `'m'..='p'` will match only the values `'m'`, `'n'`, `'o'`, and `'p'`. For an integer the
+pattern `1..` will match 9, or 9001, or 9007199254740991 (if it is of an appropriate size), but
+not 0, and not negative numbers for signed integers. The bounds can be literals or paths that point
+to constant values.
 
-A pattern a `..=` b must always have a &le; b. It is an error to have a range pattern
+A half-open range pattern in the style `a..` cannot be used to match within the context of a slice.
+
+A pattern `a..=b` must always have a &le; b. It is an error to have a range pattern
 `10..=0`, for example.
 
 The `...` syntax is kept for backwards compatibility.
@@ -453,6 +472,12 @@ println!("{}", match ph {
     _ => unreachable!(),
 });
 
+# let uint: u32 = 5;
+match uint {
+    0 => "zero!",
+    1.. => "positive number!",
+};
+
 // using paths to constants:
 # const TROPOSPHERE_MIN : u8 = 6;
 # const TROPOSPHERE_MAX : u8 = 20;
@@ -733,6 +758,10 @@ is irrefutable. When matching a slice, it is irrefutable only in the form with
 a single `..` [rest pattern](#rest-patterns) or [identifier
 pattern](#identifier-patterns) with the `..` rest pattern as a subpattern.
 
+Within a slice, a half-open range pattern like `a..` must be enclosed in parentheses,
+as in `(a..)`, to clarify it is intended to match a single value.
+A future version of Rust may give the non-parenthesized version an alternate meaning.
+
 ## Path patterns
 
 > **<sup>Syntax</sup>**\

src/tokens.md

@@ -585,7 +585,7 @@ usages and meanings are defined in the linked pages.
 | `@`    | At          | [Subpattern binding]
 | `_`    | Underscore  | [Wildcard patterns], [Inferred types], Unnamed items in [constants], [extern crates], and [use declarations]
 | `.`    | Dot         | [Field access][field], [Tuple index]
-| `..`   | DotDot      | [Range][range], [Struct expressions], [Patterns]
+| `..`   | DotDot      | [Range][range], [Struct expressions], [Patterns], [Range Patterns][rangepat]
 | `...`  | DotDotDot   | [Variadic functions][extern], [Range patterns]
 | `..=`  | DotDotEq    | [Inclusive Range][range], [Range patterns]
 | `,`    | Comma       | Various separators
@@ -646,6 +646,7 @@ them are referred to as "token trees" in [macros].  The three types of brackets
 [patterns]: patterns.md
 [question]: expressions/operator-expr.md#the-question-mark-operator
 [range]: expressions/range-expr.md
+[rangepat]: patterns.md#range-patterns
 [raw pointers]: types/pointer.md#raw-pointers-const-and-mut
 [references]: types/pointer.md
 [sized]: trait-bounds.md#sized