Опровержимость: может ли шаблон не совпасть
Шаблоны бывают двух форм: опровержимые и неопровержимые. Шаблоны, которые совпадут
для любого возможного переданного значения, неопровержимы. Примером может быть x в
операторе let x = 5;, потому что x совпадает с чем угодно и, следовательно, не может не
совпасть. Шаблоны, которые могут не совпасть для некоторого возможного значения,
опровержимы. Примером может быть Some(x) в выражении if let Some(x) = a_value, потому что если значение в переменной a_value равно None, а не
Some, шаблон Some(x) не совпадёт.
Параметры функций, операторы let и циклы for могут принимать только
неопровержимые шаблоны, потому что программа не может сделать ничего осмысленного, когда
значения не совпадают. Выражения if let и while let и
оператор let...else принимают опровержимые и неопровержимые шаблоны, но
компилятор предупреждает против неопровержимых шаблонов, потому что по определению они
предназначены для обработки возможной неудачи: функциональность условия заключается в
его способности действовать по-разному в зависимости от успеха или неудачи.
В целом, вам не нужно беспокоиться о различии между опровержимыми и неопровержимыми шаблонами; однако вам нужно быть знакомым с концепцией опровержимости, чтобы вы могли отреагировать, когда увидите её в сообщении об ошибке. В этих случаях вам нужно будет изменить либо шаблон, либо конструкцию, которую вы используете с шаблоном, в зависимости от предполагаемого поведения кода.
Давайте посмотрим на пример того, что происходит, когда мы пытаемся использовать опровержимый шаблон
там, где Rust требует неопровержимый шаблон, и наоборот. Листинг 19-8 показывает
оператор let, но для шаблона мы указали Some(x), опровержимый
шаблон. Как и следовало ожидать, этот код не скомпилируется.
fn main() {
let some_option_value: Option<i32> = None;
let Some(x) = some_option_value;
}
letЕсли some_option_value было бы значением None, оно не совпало бы с шаблоном
Some(x), что означает, что шаблон опровержим. Однако оператор let может
принимать только неопровержимый шаблон, потому что нет ничего допустимого, что код может
сделать со значением None. Во время компиляции Rust пожалуется, что мы пытались
использовать опровержимый шаблон там, где требуется неопровержимый:
$ cargo run
Compiling patterns v0.1.0 (file:///projects/patterns)
error[E0005]: refutable pattern in local binding
--> src/main.rs:3:9
|
3 | let Some(x) = some_option_value;
| ^^^^^^^ pattern `None` not covered
|
= note: `let` bindings require an "irrefutable pattern", like a `struct` or an `enum` with only one variant
= note: for more information, visit https://doc.rust-lang.org/book/ch19-02-refutability.html
= note: the matched value is of type `Option<i32>`
help: you might want to use `let...else` to handle the variant that isn't matched
|
3 | let Some(x) = some_option_value else { todo!() };
| ++++++++++++++++
For more information about this error, try `rustc --explain E0005`.
error: could not compile `patterns` (bin "patterns") due to 1 previous error
Поскольку мы не покрыли (и не могли покрыть!) каждое допустимое значение с помощью
шаблона Some(x), Rust справедливо выдаёт ошибку компилятора.
Если у нас есть опровержимый шаблон там, где нужен неопровержимый, мы можем
исправить это, изменив код, использующий шаблон: вместо использования let мы
можем использовать let...else. Тогда, если шаблон не совпадёт, код в фигурных
скобках обработает значение. Листинг 19-9 показывает, как исправить код в
листинге 19-8.
fn main() {
let some_option_value: Option<i32> = None;
let Some(x) = some_option_value else {
return;
};
}
let...else и блока с опровержимыми шаблонами вместо letМы дали коду выход! Этот код совершенно корректен, хотя это означает, что мы
не можем использовать неопровержимый шаблон без получения предупреждения. Если мы дадим
let...else шаблон, который всегда совпадает, например x, как показано в листинге
19-10, компилятор выдаст предупреждение.
fn main() {
let x = 5 else {
return;
};
}
let...elseRust жалуется, что не имеет смысла использовать let...else с
неопровержимым шаблоном, потому что else никогда не будет достигнут:
$ cargo run
Compiling patterns v0.1.0 (file:///projects/patterns)
warning: unreachable `else` clause
--> src/main.rs:2:15
|
2 | let x = 5 else {
| --------- ^^^^
| |
| assigning to binding pattern will always succeed
|
= note: this pattern always matches, so the else clause is unreachable
= note: `#[warn(irrefutable_let_patterns)]` on by default
warning: `patterns` (bin "patterns") generated 1 warning
Finished `dev` profile [unoptimized + debuginfo] target(s) in 0.39s
Running `target/debug/patterns`
По этой причине ветви match должны использовать опровержимые шаблоны, за
исключением последней ветви, которая должна совпадать с любыми оставшимися значениями с помощью неопровержимого шаблона. Rust
позволяет нам использовать неопровержимый шаблон в match только с одной ветвью, но
этот синтаксис не особенно полезен и мог бы быть заменён более простым
оператором let.
Теперь, когда вы знаете, где использовать шаблоны, и разницу между опровержимыми и неопровержимыми шаблонами, давайте рассмотрим весь синтаксис, который мы можем использовать для создания шаблонов.