fixed few reviews

Author: Kivooeo

src/expressions/match-expr.md

@@ -9,16 +9,36 @@ MatchExpression ->
         MatchArms?
     `}`
 
-Scrutinee -> Expression _except [StructExpression]_
+Scrutinee ->
+    Expression _except_ [StructExpression]
 
 MatchArms ->
     ( MatchArm `=>` ( ExpressionWithoutBlock `,` | ExpressionWithBlock `,`? ) )*
     MatchArm `=>` Expression `,`?
 
-MatchArm -> OuterAttribute* Pattern MatchArmGuard?
-
-MatchArmGuard -> `if` Expression
-               | `if` `let` Pattern Expression
+MatchArm ->
+    OuterAttribute* Pattern MatchArmGuard?
+
+MatchArmGuard ->
+      `if` Expression
+    | `if` LetChain
+
+LetChain ->
+    LetChainCondition ( `&&` LetChainCondition )*
+
+LetChainCondition ->
+      Expression _except_ [ExcludedConditions]
+    | OuterAttribute* `let` Pattern `=` Expression _except_ [ExcludedConditions]
+
+ExcludedConditions ->
+    IfExpression
+  | MatchExpression
+  | WhileExpression
+  | ForExpression
+  | LoopExpression
+  | AsyncExpression
+  | TryExpression
+  | AwaitExpression
 ```
 <!-- TODO: The exception above isn't accurate, see https://github.com/rust-lang/reference/issues/569 -->
 
@@ -153,7 +173,7 @@ Moreover, by holding a shared reference while evaluating the guard, mutation ins
 
 r[expr.match.if.let.guard]
 ## If Let Guards
-Match arms can include `if let` guards to allow conditional pattern matching within the guard clause. This feature is currently unstable and requires the attribute. It is tracked in issue [#51114](https://github.com/rust-lang/rust/issues/51114).
+Match arms can include `if let` guards to allow conditional pattern matching within the guard clause.
 
 r[expr.match.if.let.guard.syntax]
 ```rust,ignore
@@ -162,11 +182,11 @@ match expression {
     ...
 }
 ```
-Here, `guard_expr` is evaluated and matched against `subpattern`. If the match succeeds, the guard evaluates to `true` and the arm is selected. 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 and 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:
-  * If the inner pattern (`subpattern`) matches the result of `guard_expr`, the guard evaluates to `true`.
+  * The guard proceeds if the inner pattern (`subpattern`) matches the result of `guard_expr`.
   * Otherwise, the next arm is tested.
 
 ```rust,ignore
@@ -176,7 +196,6 @@ let msg = match value {
     Some(x) if let Some(y) = Some(x - 1) => format!("Matched inner value: {}", y),
     _ => "No match".to_string(),
 };
-
 ```
 
 r[expr.match.if.let.guard.scope]
@@ -225,14 +244,13 @@ Before a guard (including an `if let` guard) is evaluated:
           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
       Some(v) if let Some(_) = take(v.clone()) => "ok",
       ```
 > [!NOTE]
-> Unlike regular if guards, `if let` guards execute only once per match arm, even if the pattern uses the `|` operator to match multiple patterns. This avoids repeated evaluation and potential side effects.
+> Multiple matches using the `|` operator can cause the pattern guard and the side effects it has to execute multiple times. For example:
 > ```rust,ignore
 > use std::cell::Cell;
 >
@@ -241,7 +259,7 @@ Before a guard (including an `if let` guard) is evaluated:
 >     1 | _ if let Some(_) = { i.set(i.get() + 1); Some(1) } => {}
 >     _ => {}
 > }
-> assert_eq!(i.get(), 1); // Guard not executed twice
+> assert_eq!(i.get(), 2); // Guard is executed twice
 > ```
 
 r[expr.match.attributes]