You signed in with another tab or window. Reload to refresh your session.You signed out in another tab or window. Reload to refresh your session.You switched accounts on another tab or window. Reload to refresh your session.Dismiss alert
<!-- TODO: The exception above isn't accurate, see https://github.com/rust-lang/reference/issues/569 -->
13
17
14
18
r[expr.if.intro]
15
-
An `if` expression is a conditional branch in program control.
16
-
The syntax of an `if` expression is a condition operand, followed by a consequent block, any number of `else if` conditions and blocks, and an optional trailing `else` block.
19
+
The syntax of an `if` expression is a sequence of one or more condition operands separated by `&&`,
20
+
followed by a consequent block, any number of `else if` conditions and blocks, and an optional trailing `else` block.
17
21
18
-
r[expr.if.condition-bool]
19
-
The condition operands must have the [boolean type].
22
+
r[expr.if.condition]
23
+
Condition operands must be either an [_Expression_] with a [boolean type] or a conditional `let` match.
20
24
21
25
r[expr.if.condition-true]
22
-
If a condition operand evaluates to `true`, the consequent block is executed and any subsequent `else if` or `else` block is skipped.
26
+
If all of the condition operands evaluate to `true` and all of the `let` patterns successfully match their [scrutinee]s,
27
+
the consequent block is executed and any subsequent `else if` or `else` block is skipped.
23
28
24
29
r[expr.if.else-if]
25
-
If a condition operand evaluates to `false`, the consequent block is skipped and any subsequent `else if` condition is evaluated.
30
+
If any condition operand evaluates to `false` or any `let` pattern does not match its scrutinee,
31
+
the consequent block is skipped and any subsequent `else if` condition is evaluated.
26
32
27
33
r[expr.if.else]
28
34
If all `if` and `else if` conditions evaluate to `false` then any `else` block is executed.
29
35
30
36
r[expr.if.result]
31
-
An if expression evaluates to the same value as the executed block, or `()` if no block is evaluated.
37
+
An `if` expression evaluates to the same value as the executed block, or `()` if no block is evaluated.
32
38
33
39
r[expr.if.type]
34
40
An `if` expression must have the same type in all situations.
An `if let` expression is semantically similar to an `if` expression but in place of a condition operand it expects the keyword `let` followed by a pattern, an `=` and a [scrutinee] operand.
66
-
67
-
r[expr.if.let.pattern]
68
-
If the value of the scrutinee matches the pattern, the corresponding block will execute.
65
+
`let` patterns in an `if` condition allow binding new variables into scope when the pattern matches successfully.
69
66
70
-
r[expr.if.let.else]
71
-
Otherwise, flow proceeds to the following `else` block if it exists.
72
-
73
-
r[expr.if.let.result]
74
-
Like `if` expressions, `if let` expressions have a value determined by the block that is evaluated.
67
+
The following examples illustrate bindings using `let` patterns:
75
68
76
69
```rust
77
70
letdish= ("Ham", "Eggs");
78
71
79
-
//this body will be skipped because the pattern is refuted
72
+
//This body will be skipped because the pattern is refuted.
80
73
iflet ("Bacon", b) =dish {
81
74
println!("Bacon is served with {}", b);
82
75
} else {
83
76
// This block is evaluated instead.
84
77
println!("No bacon will be served");
85
78
}
86
79
87
-
//this body will execute
80
+
//This body will execute.
88
81
iflet ("Ham", b) =dish {
89
82
println!("Ham is served with {}", b);
90
83
}
@@ -94,47 +87,9 @@ if let _ = 5 {
94
87
}
95
88
```
96
89
97
-
r[expr.if.let.else-if]
98
-
`if` and `if let` expressions can be intermixed:
99
-
100
-
```rust
101
-
letx=Some(3);
102
-
leta=ifletSome(1) =x {
103
-
1
104
-
} elseifx==Some(2) {
105
-
2
106
-
} elseifletSome(y) =x {
107
-
y
108
-
} else {
109
-
-1
110
-
};
111
-
assert_eq!(a, 3);
112
-
```
113
-
114
-
r[expr.if.let.desugaring]
115
-
An `if let` expression is equivalent to a [`match` expression] as follows:
116
-
117
-
<!-- ignore: expansion example -->
118
-
```rust,ignore
119
-
if let PATS = EXPR {
120
-
/* body */
121
-
} else {
122
-
/*else */
123
-
}
124
-
```
125
-
126
-
is equivalent to
127
-
128
-
<!-- ignore: expansion example -->
129
-
```rust,ignore
130
-
match EXPR {
131
-
PATS => { /* body */ },
132
-
_ => { /* else */ }, // () if there is no else
133
-
}
134
-
```
135
-
136
90
r[expr.if.let.or-pattern]
137
-
Multiple patterns may be specified with the `|` operator. This has the same semantics as with `|` in `match` expressions:
91
+
Multiple patterns may be specified with the `|` operator.
92
+
This has the same semantics as with `|` in [`match` expressions]:
138
93
139
94
```rust
140
95
enumE {
@@ -148,27 +103,70 @@ if let E::X(n) | E::Y(n) = v {
148
103
}
149
104
```
150
105
151
-
r[expr.if.let.lazy-bool]
152
-
The expression cannot be a [lazy boolean operator expression][expr.bool-logic].
153
-
Use of a lazy boolean operator is ambiguous with a planned feature change of the language (the implementation of if-let chains - see [eRFC 2947][_eRFCIfLetChain_]).
154
-
When lazy boolean operator expression is desired, this can be achieved by using parenthesis as below:
106
+
r[expr.if.chains]
107
+
## Chains of conditions
108
+
109
+
r[expr.if.chains.intro]
110
+
Multiple condition operands can be separated with `&&`.
111
+
112
+
r[expr.if.chains.order]
113
+
Similar to a `&&`[_LazyBooleanOperatorExpression_], each operand is evaluated from left-to-right until an operand evaluates as `false` or a `let` match fails,
114
+
in which case the subsequent operands are not evaluated.
115
+
116
+
r[expr.if.chains.bindings]
117
+
The bindings of each pattern are put into scope to be available for the next condition operand and the consequent block.
118
+
119
+
The following is an example of chaining multiple expressions, mixing `let` bindings and boolean expressions, and with expressions able to reference pattern bindings from previous expressions:
155
120
156
-
<!-- ignore: pseudo code -->
157
-
```rust,ignore
158
-
// Before...
159
-
if let PAT = EXPR && EXPR { .. }
121
+
```rust
122
+
fnsingle() {
123
+
letouter_opt=Some(Some(1i32));
124
+
125
+
ifletSome(inner_opt) =outer_opt
126
+
&&letSome(number) =inner_opt
127
+
&&number==1
128
+
{
129
+
println!("Peek a boo");
130
+
}
131
+
}
132
+
```
160
133
161
-
// After...
162
-
if let PAT = ( EXPR && EXPR ) { .. }
134
+
The above is equivalent to the following without using chains of conditions:
163
135
164
-
// Before...
165
-
if let PAT = EXPR || EXPR { .. }
136
+
```rust
137
+
fnnested() {
138
+
letouter_opt=Some(Some(1i32));
139
+
140
+
ifletSome(inner_opt) =outer_opt {
141
+
ifletSome(number) =inner_opt {
142
+
ifnumber==1 {
143
+
println!("Peek a boo");
144
+
}
145
+
}
146
+
}
147
+
}
148
+
```
149
+
150
+
r[expr.if.chains.or]
151
+
If any condition operand is a `let` pattern, then none of the condition operands can be a `||`[lazy boolean operator expression][_LazyBooleanOperatorExpression_] due to ambiguity and precedence with the `let` scrutinee.
152
+
If a `||` expression is needed, then parentheses can be used. For example:
0 commit comments