Address comments

Author: varkor

src/SUMMARY.md

@@ -66,7 +66,7 @@
         - [Match expressions](expressions/match-expr.md)
         - [Return expressions](expressions/return-expr.md)
         - [Await expressions](expressions/await-expr.md)
-        - [Underscore expression](expressions/underscore-expr.md)
+        - [Underscore expressions](expressions/underscore-expr.md)
 
 - [Patterns](patterns.md)
 

src/expressions/operator-expr.md

@@ -428,20 +428,15 @@ assert_eq!(values[1], 3);
 
 An *assignment expression* moves a value into a specified place.
 
-An assignment expression consists of a [mutable] [assignee expression], the
-*assignee operand*, followed by an equals sign (`=`) and a [value expression],
-the *assigned value operand*. In its most basic form, an assignee expression is
-a [place expression], and we discuss this case first. The more general case of
-destructuring assignment is discussed below, but this case always decomposes
-into sequential assignments to place expressions, which may be considered the
-more fundamental case.
+An assignment expression consists of a [mutable] [assignee expression], the *assignee operand*, followed by an equals sign (`=`) and a [value expression], the *assigned value operand*.
+In its most basic form, an assignee expression is a [place expression], and we discuss this case first.
+The more general case of destructuring assignment is discussed below, but this case always decomposes into sequential assignments to place expressions, which may be considered the more fundamental case.
 
 ### Basic assignments
 
-Evaluating assignment expressions begins by evaluating its operands. The
-assigned value operand is evaluated first, followed by the assignee expression.
-(For destructuring assignment, subexpressions of the assignee expression are
-evaluated left-to-right.)
+Evaluating assignment expressions begins by evaluating its operands.
+The assigned value operand is evaluated first, followed by the assignee expression.
+For destructuring assignment, subexpressions of the assignee expression are evaluated left-to-right.
 
 > **Note**: This is different than other expressions in that the right operand is evaluated before the left one.
 
@@ -460,29 +455,25 @@ x = y;
 
 ### Destructuring assignments
 
-Destructuring assignment is a counterpart to destructuring pattern matches for
-variable declaration, permitting assignment to complex values, such as tuples or
-structs. For instance, we may swap two mutable variables:
+Destructuring assignment is a counterpart to destructuring pattern matches for variable declaration, permitting assignment to complex values, such as tuples or structs.
+For instance, we may swap two mutable variables:
 
-```rust,ignore
+```rust
 let (mut a, mut b) = (0, 1);
 // Swap `a` and `b` using destructuring assignment.
 (b, a) = (a, b);
 ```
 
-In contrast to destructuring declarations using `let`, patterns may not appear
-on the left-hand side of an assignment due to syntactic ambiguities. Instead, a
-group of expressions that correspond to patterns are designated to be [assignee
-expressions][assignee expression], and permitted on the left-hand side of an
-assignment. Assignee expressions are then desugared to pattern matches followed
-by sequential assignment. The desugared patterns must be irrefutable: in
-particular, this means that only slice patterns whose length is known at
-compile-time, and the trivial slice `[..]`, are permitted for destructuring
-assignment.
+In contrast to destructuring declarations using `let`, patterns may not appear on the left-hand side of an assignment due to syntactic ambiguities.
+Instead, a group of expressions that correspond to patterns are designated to be [assignee expressions][assignee expression], and permitted on the left-hand side of an assignment.
+Assignee expressions are then desugared to pattern matches followed by sequential assignment.
+The desugared patterns must be irrefutable: in particular, this means that only slice patterns whose length is known at compile-time, and the trivial slice `[..]`, are permitted for destructuring assignment.
 
 The desugaring method is straightforward, and is illustrated best by example.
 
-```rust,ignore
+```rust
+# struct Struct { x: u32, y: u32 }
+# let (mut a, mut b) = (0, 0);
 (a, b) = (3, 4);
 
 [a, b] = [3, 4];
@@ -510,12 +501,9 @@ Struct { x: a, y: b } = Struct { x: 3, y: 4};
 }
 ```
 
-Identifiers are not forbidden from being used multiple times in a single
-assignee expression.
+Identifiers are not forbidden from being used multiple times in a single assignee expression.
 
-[Underscore expressions][_UnderscoreExpression_] and empty [range
-expressions][_RangeExpression_] may be used to ignore certain values, without
-binding them.
+[Underscore expressions][_UnderscoreExpression_] and empty [range expressions][_RangeExpression_] may be used to ignore certain values, without binding them.
 
 Note that default binding modes do not apply for the desugared expression.
 

src/expressions/underscore-expr.md

@@ -1,19 +1,17 @@
-# `_` expression
+# `_` expressions
 
 > **<sup>Syntax</sup>**\
 > _UnderscoreExpression_ :\
 > &nbsp;&nbsp; `_`
 
-The underscore expression, denoted with the symbol `_`, is used to signify a
-placeholder in a destructuring assignment. It may only appear in the left-hand
+Underscore expressions, denoted with the symbol `_`, are used to signify a
+placeholder in a destructuring assignment. They may only appear in the left-hand
 side of an assignment.
 
 An example of an `_` expression:
 
-```rust,ignore
+```rust
 let p = (1, 2);
 let mut a = 0;
 (_, a) = p;
 ```
-
-[_Expression_]: ../expressions.md