fixed match guard syntax

Author: Kivooeo

src/expressions/match-expr.md

@@ -20,8 +20,14 @@ MatchArm ->
     OuterAttribute* Pattern MatchArmGuard?
 
 MatchArmGuard ->
-      `if` Expression
-    | `if` Expression `&&` LetChain
+    `if` MatchConditions
+
+MatchConditions ->
+    MatchCondition ( `&&` MatchCondition )*
+
+MatchCondition ->
+      OuterAttribute* `let` Pattern `=` Scrutinee
+    | Expression
 ```
 <!-- TODO: The exception above isn't accurate, see https://github.com/rust-lang/reference/issues/569 -->
 
@@ -165,7 +171,7 @@ match expression {
     ...
 }
 ```
-Here, `guard_expr` is evaluated and matched against `subpattern`. If the `if let` expression in the guard matches successfully and the arm’s body is executed. Otherwise, pattern matching continues to the next arm.
+Here, `guard_expr` is evaluated and matched against `subpattern`. If the `if let` expression in the guard matches successfully, the arm's body is executed. Otherwise, pattern matching continues to the next arm.
 
 r[expr.match.if.let.guard.behavior]
 When the pattern matches successfully, the `if let` expression in the guard is evaluated:
@@ -209,7 +215,7 @@ match opt {
 r[expr.match.if.let.guard.borrowing]
 Before a guard (including an `if let` guard) is evaluated:
   1. Pattern bindings are performed first
-      Variables from the outer match pattern (e.g., `x` in `Some(x)`) are bound and initialized. These bindings may involve moving, copying, or borrowing values from   the scrutinee.
+      Variables from the outer match pattern (e.g., `x` in `Some(x)`) are bound and initialized. These bindings may involve moving, copying, or borrowing values from the scrutinee.
       ```rust,ignore
       match Some(String::from("hello")) {
           Some(s) if /* guard */ => { /* s is moved here */ }
@@ -221,12 +227,13 @@ Before a guard (including an `if let` guard) is evaluated:
       * Moves from the scrutinee in the guard are subject to standard Rust ownership rules. Avoid moving what's needed later; already moved parts from the main pattern can be used.
       * Variables successfully bound within the if let guard are in scope within the corresponding match arm body. Their scope extends to the arm after the guard condition is met.
       ```rust,ignore
-      let val = Some(vec![1, 2, 3]);
+        fn take<T>(value: T) -> Option<T> { Some(value) }
 
-      let result = match val {
-          Some(v) if let Some(_) = take(v) => "ok", // ERROR: cannot move out of `v`
-          _ => "nope",
-      };
+        let val = Some(vec![1, 2, 3]);
+        let result = match val {
+            Some(v) if let Some(_) = take(v) => "ok", // ERROR: cannot move out of `v`
+            _ => "nope",
+        };
       ```
       In the above example, `v` is already bound in the outer pattern, and the guard attempts to move it --- this is not allowed. You can fix it by cloning or borrowing:
       ```rust,ignore