explain scrutinee in glossary.

Author: Centril

src/expressions/loop-expr.md

@@ -70,9 +70,11 @@ while i < 10 {
 > &nbsp;&nbsp; `while` `let` [_Pattern_] `=` [_Expression_]<sub>except struct expression</sub>
 >              [_BlockExpression_]
 
+[scrutinee]: glossary.html#scrutinee
+
 A `while let` loop is semantically similar to a `while` loop but in place of a
 condition expression it expects the keyword `let` followed by a refutable
-pattern, an `=`, a scrutinee expression and a block expression. If the value of
+pattern, an `=`, a [scrutinee] expression and a block expression. If the value of
 the expression on the right hand side of the `=` matches the pattern, the loop
 body block executes then control returns to the pattern matching statement.
 Otherwise, the while expression completes.

src/expressions/match-expr.md

@@ -23,9 +23,11 @@
 > _MatchArmGuard_ :\
 >    `if` [_Expression_]
 
+[scrutinee]: glossary.html#scrutinee
+
 A *`match` expression* branches on a pattern. The exact form of matching that
 occurs depends on the [pattern]. A `match`
-expression has a *scrutinee expression*, which is the value to compare to the
+expression has a *[scrutinee] expression*, which is the value to compare to the
 patterns. The scrutinee expression and the patterns must have the same type.
 
 A `match` behaves differently depending on whether or not the scrutinee

src/expressions/struct-expr.md

@@ -71,8 +71,10 @@ let base = Point3d {x: 1, y: 2, z: 3};
 Point3d {y: 0, z: 10, .. base};
 ```
 
+[scrutinee]: glossary.html#scrutinee
+
 Struct expressions with curly braces can't be used directly in a [loop] or [if]
-expression's head, or in the scrutinee of a [if let] or [match] expression.
+expression's head, or in the [scrutinee] of an [if let] or [match] expression.
 However, struct expressions can be in used in these situations if they are
 within another expression, for example inside [parentheses].
 

src/glossary.md

@@ -80,6 +80,12 @@ Types that can be referred to by a path directly. Specifically [enums],
 Prelude, or The Rust Prelude, is a small collection of items - mostly traits - that are
 imported into every module of every crate. The traits in the prelude are pervasive.
 
+### Scrutinee
+
+A scrutinee is the expression that is matched on in `match` expressions and
+similar pattern matching constructs. For example, in `match x { A => 1, B => 2 }`,
+the expression `x` is the scrutinee.
+
 ### Size
 
 The size of a value has two definitions.

src/patterns.md

@@ -67,9 +67,11 @@ Patterns are used in:
 
 ## Destructuring
 
+[scrutinee]: glossary.html#scrutinee
+
 Patterns can be used to *destructure* [structs], [enums], and [tuples].
 Destructuring breaks up a value into its component pieces. The syntax used is
-almost the same as when creating such values. In a pattern whose scrutinee
+almost the same as when creating such values. In a pattern whose [scrutinee]
 expression has a `struct`, `enum` or `tuple` type, a placeholder (`_`) stands
 in for a *single* data field, whereas a wildcard `..` stands in for *all* the
 remaining fields of a particular variant. When destructuring a data structure