Конструкция потока управления match
В Rust есть чрезвычайно мощный конструкт управления потоком, называемый match, который позволяет сравнивать значение с рядом шаблонов и затем выполнять код в зависимости от того, какой шаблон совпал. Шаблоны могут состоять из литеральных значений, имён переменных, подстановочных знаков и многого другого; глава 19 охватывает все различные виды шаблонов и то, что они делают. Сила match происходит от выразительности шаблонов и того факта, что компилятор подтверждает, что все возможные случаи обработаны.
Думайте о выражении match как о машине для сортировки монет: монеты скользят по дорожке с отверстиями разного размера, и каждая монета проваливается в первое отверстие, в которое она помещается. Точно так же значения проходят через каждый шаблон в match, и в первом шаблоне, которому значение «подходит», значение попадает в связанный блок кода для использования во время выполнения.
Кстати о монетах, давайте используем их в качестве примера с match! Мы можем написать функцию, которая принимает неизвестную американскую монету и, подобно машине для подсчёта, определяет, какая это монета, и возвращает её стоимость в центах, как показано в листинге 6-3.
enum Coin {
Penny,
Nickel,
Dime,
Quarter,
}
fn value_in_cents(coin: Coin) -> u8 {
match coin {
Coin::Penny => 1,
Coin::Nickel => 5,
Coin::Dime => 10,
Coin::Quarter => 25,
}
}
fn main() {}
match, которое имеет варианты перечисления в качестве своих шаблоновДавайте разберём match в функции value_in_cents. Сначала мы указываем ключевое слово match, за которым следует выражение, в данном случае значение coin. Это очень похоже на условное выражение, используемое с if, но есть большое различие: с if условие должно вычисляться в логическое значение, но здесь оно может быть любого типа. Тип coin в этом примере — это перечисление Coin, которое мы определили в первой строке.
Далее идут ветви match. Ветвь состоит из двух частей: шаблона и некоторого кода. Первая ветвь здесь имеет шаблон, который является значением Coin::Penny, а затем оператор =>, который разделяет шаблон и код для выполнения. Код в этом случае — это просто значение 1. Каждая ветвь отделена от следующей запятой.
Когда выполняется выражение match, оно сравнивает результирующее значение с шаблоном каждой ветви по порядку. Если шаблон совпадает со значением, выполняется код, связанный с этим шаблоном. Если этот шаблон не совпадает со значением, выполнение продолжается со следующей ветвью, во многом как в машине для сортировки монет. У нас может быть столько ветвей, сколько нужно: в листинге 6-3 наш match имеет четыре ветви.
Код, связанный с каждой ветвью, является выражением, и результирующее значение выражения в совпавшей ветви — это значение, которое возвращается для всего выражения match.
Обычно мы не используем фигурные скобки, если код ветви match короткий, как в листинге 6-3, где каждая ветвь просто возвращает значение. Если вы хотите выполнить несколько строк кода в ветви match, вы должны использовать фигурные скобки, и тогда запятая после ветви необязательна. Например, следующий код печатает «Lucky penny!» каждый раз, когда метод вызывается с Coin::Penny, но всё равно возвращает последнее значение блока, 1:
enum Coin {
Penny,
Nickel,
Dime,
Quarter,
}
fn value_in_cents(coin: Coin) -> u8 {
match coin {
Coin::Penny => {
println!("Lucky penny!");
1
}
Coin::Nickel => 5,
Coin::Dime => 10,
Coin::Quarter => 25,
}
}
fn main() {}
Шаблоны, которые связываются со значениями
Ещё одна полезная особенность ветвей match заключается в том, что они могут связываться с частями значений, которые соответствуют шаблону. Именно так мы можем извлекать значения из вариантов перечисления.
В качестве примера давайте изменим один из наших вариантов перечисления, чтобы он содержал данные внутри себя. С 1999 по 2008 год США чеканили кварталы с разными рисунками для каждого из 50 штатов на одной стороне. Никакие другие монеты не получали рисунки штатов, поэтому только кварталы имеют это дополнительное значение. Мы можем добавить эту информацию в наше enum, изменив вариант Quarter, чтобы он включал значение UsState, хранящееся внутри него, что мы и сделали в листинге 6-4.
#[derive(Debug)] // чтобы мы могли исследовать состояние через минуту
enum UsState {
Alabama,
Alaska,
// --snip--
}
enum Coin {
Penny,
Nickel,
Dime,
Quarter(UsState),
}
fn main() {}
Coin, в котором вариант Quarter также содержит значение UsStateДавайте представим, что друг пытается собрать все 50 кварталов штатов. Пока мы сортируем нашу мелочь по типу монеты, мы также будем называть название штата, связанного с каждым кварталом, чтобы, если это тот, которого нет у нашего друга, он мог добавить его в свою коллекцию.
В выражении match для этого кода мы добавляем переменную, называемую state, к шаблону, который соответствует значениям варианта Coin::Quarter. Когда совпадает Coin::Quarter, переменная state будет связана со значением состояния этого квартала. Затем мы можем использовать state в коде для этой ветви, вот так:
#[derive(Debug)]
enum UsState {
Alabama,
Alaska,
// --snip--
}
enum Coin {
Penny,
Nickel,
Dime,
Quarter(UsState),
}
fn value_in_cents(coin: Coin) -> u8 {
match coin {
Coin::Penny => 1,
Coin::Nickel => 5,
Coin::Dime => 10,
Coin::Quarter(state) => {
println!("State quarter from {state:?}!");
25
}
}
}
fn main() {
value_in_cents(Coin::Quarter(UsState::Alaska));
}
Если бы мы вызвали value_in_cents(Coin::Quarter(UsState::Alaska)), coin было бы Coin::Quarter(UsState::Alaska). Когда мы сравниваем это значение с каждой из ветвей match, ни одна из них не совпадает, пока мы не достигнем Coin::Quarter(state). В этот момент привязка для state будет значением UsState::Alaska. Затем мы можем использовать эту привязку в выражении println!, таким образом получая внутреннее значение состояния из варианта перечисления Coin для Quarter.
Шаблон Option<T> в match
В предыдущем разделе мы хотели получить внутреннее значение T из случая Some при использовании Option<T>; мы также можем обрабатывать Option<T> с помощью match, как мы делали с перечислением Coin! Вместо сравнения монет мы будем сравнивать варианты Option<T>, но способ работы выражения match остаётся прежним.
Допустим, мы хотим написать функцию, которая принимает Option<i32> и, если внутри есть значение, добавляет 1 к этому значению. Если внутри нет значения, функция должна вернуть значение None и не пытаться выполнять никаких операций.
Эту функцию очень легко написать благодаря match, и она будет выглядеть как в листинге 6-5.
fn main() {
fn plus_one(x: Option<i32>) -> Option<i32> {
match x {
None => None,
Some(i) => Some(i + 1),
}
}
let five = Some(5);
let six = plus_one(five);
let none = plus_one(None);
}
match для Option<i32>Давайте более подробно рассмотрим первое выполнение plus_one. Когда мы вызываем plus_one(five), переменная x в теле plus_one будет иметь значение Some(5). Затем мы сравниваем это с каждой ветвью match:
fn main() {
fn plus_one(x: Option<i32>) -> Option<i32> {
match x {
None => None,
Some(i) => Some(i + 1),
}
}
let five = Some(5);
let six = plus_one(five);
let none = plus_one(None);
}
Значение Some(5) не соответствует шаблону None, поэтому мы переходим к следующей ветви:
fn main() {
fn plus_one(x: Option<i32>) -> Option<i32> {
match x {
None => None,
Some(i) => Some(i + 1),
}
}
let five = Some(5);
let six = plus_one(five);
let none = plus_one(None);
}
Соответствует ли Some(5) шаблону Some(i)? Да! У нас одинаковый вариант. i связывается со значением, содержащимся в Some, поэтому i принимает значение 5. Затем выполняется код в ветви match, поэтому мы добавляем 1 к значению i и создаём новое значение Some с нашей суммой 6 внутри.
Теперь давайте рассмотрим второй вызов plus_one в листинге 6-5, где x равно None. Мы входим в match и сравниваем с первой ветвью:
fn main() {
fn plus_one(x: Option<i32>) -> Option<i32> {
match x {
None => None,
Some(i) => Some(i + 1),
}
}
let five = Some(5);
let six = plus_one(five);
let none = plus_one(None);
}
Она совпадает! Нет значения, к которому можно добавить, поэтому программа останавливается и возвращает значение None справа от =>. Поскольку первая ветвь совпала, другие ветви не сравниваются.
Объединение match и перечислений полезно во многих ситуациях. Вы будете видеть этот паттерн очень часто в коде на Rust: match по перечислению, привязка переменной к данным внутри, а затем выполнение кода на основе этого. Сначала это немного сложно, но как только вы привыкнете, вы захотите, чтобы это было во всех языках. Это неизменно фаворит пользователей.
Сопоставления исчерпывающие
Есть ещё один аспект match, который нам нужно обсудить: шаблоны ветвей должны охватывать все возможности. Рассмотрим эту версию нашей функции plus_one, которая содержит ошибку и не скомпилируется:
fn main() {
fn plus_one(x: Option<i32>) -> Option<i32> {
match x {
Some(i) => Some(i + 1),
}
}
let five = Some(5);
let six = plus_one(five);
let none = plus_one(None);
}
Мы не обработали случай None, поэтому этот код вызовет ошибку. К счастью, это ошибка, которую Rust умеет ловить. Если мы попытаемся скомпилировать этот код, мы получим такую ошибку:
$ cargo run
Compiling enums v0.1.0 (file:///projects/enums)
error[E0004]: non-exhaustive patterns: `None` not covered
--> src/main.rs:3:15
|
3 | match x {
| ^ pattern `None` not covered
|
note: `Option<i32>` defined here
--> /rustc/2d8144b7880597b6e6d3dfd63a9a9efae3f533d3/library/core/src/option.rs:597:0
::: /rustc/2d8144b7880597b6e6d3dfd63a9a9efae3f533d3/library/core/src/option.rs:601:4
|
= note: not covered
= note: the matched value is of type `Option<i32>`
help: ensure that all possible cases are being handled by adding a match arm with a wildcard pattern or an explicit pattern as shown
|
4 ~ Some(i) => Some(i + 1),
5 ~ None => todo!(),
|
For more information about this error, try `rustc --explain E0004`.
error: could not compile `enums` (bin "enums") due to 1 previous error
Rust знает, что мы не покрыли все возможные случаи, и даже знает, какой шаблон мы забыли! Сопоставления в Rust исчерпывающие: мы должны исчерпать все последние возможности, чтобы код был действительным. Особенно в случае Option<T>, когда Rust предотвращает наше забывание явно обработать случай None, он защищает нас от предположения, что у нас есть значение, когда у нас может быть null, делая тем самым ошибку на миллиард долларов, обсуждавшуюся ранее, невозможной.
Универсальные шаблоны и заполнитель _
Используя перечисления, мы также можем выполнять специальные действия для нескольких конкретных значений, но для всех других значений выполнять одно действие по умолчанию. Представьте, что мы реализуем игру, где, если вы выбрасываете 3 на кубике, ваш игрок не двигается, а вместо этого получает модную новую шляпу. Если вы выбрасываете 7, ваш игрок теряет модную шляпу. Для всех других значений ваш игрок перемещается на это количество клеток на игровом поле. Вот match, который реализует эту логику, с жёстко закодированным результатом броска кубика, а не случайным значением, и всей остальной логикой, представленной функциями без тел, потому что их фактическая реализация выходит за рамки этого примера:
fn main() {
let dice_roll = 9;
match dice_roll {
3 => add_fancy_hat(),
7 => remove_fancy_hat(),
other => move_player(other),
}
fn add_fancy_hat() {}
fn remove_fancy_hat() {}
fn move_player(num_spaces: u8) {}
}
Для первых двух ветвей шаблоны — это литеральные значения 3 и 7. Для последней ветви, которая покрывает все другие возможные значения, шаблон — это переменная, которую мы решили назвать other. Код, который выполняется для ветви other, использует переменную, передавая её в функцию move_player.
Этот код компилируется, хотя мы не перечислили все возможные значения, которые может иметь u8, потому что последний шаблон будет соответствовать всем значениям, не указанным конкретно. Этот универсальный шаблон удовлетворяет требованию, что match должен быть исчерпывающим. Обратите внимание, что мы должны поместить универсальную ветвь последней, потому что шаблоны оцениваются по порядку. Если бы мы поместили универсальную ветвь раньше, другие ветви никогда бы не выполнились, поэтому Rust предупредит нас, если мы добавим ветви после универсальной!
В Rust также есть шаблон, который мы можем использовать, когда хотим универсальный шаблон, но не хотим использовать значение в универсальном шаблоне: _ — это специальный шаблон, который соответствует любому значению и не связывается с этим значением. Это говорит Rust, что мы не собираемся использовать значение, поэтому Rust не будет предупреждать нас о неиспользуемой переменной.
Давайте изменим правила игры: теперь, если вы выбрасываете что-либо, кроме 3 или 7, вы должны бросать снова. Нам больше не нужно использовать универсальное значение, поэтому мы можем изменить наш код, чтобы использовать _ вместо переменной с именем other:
fn main() {
let dice_roll = 9;
match dice_roll {
3 => add_fancy_hat(),
7 => remove_fancy_hat(),
_ => reroll(),
}
fn add_fancy_hat() {}
fn remove_fancy_hat() {}
fn reroll() {}
}
Этот пример также удовлетворяет требованию исчерпывающего охвата, потому что мы явно игнорируем все другие значения в последней ветви; мы ничего не забыли.
Наконец, давайте изменим правила игры ещё раз, чтобы в ваш ход ничего не происходило, если вы выбрасываете что-либо, кроме 3 или 7. Мы можем выразить это, используя единичное значение (тип пустого кортежа, который мы упоминали в разделе «Тип кортеж») в качестве кода, который идёт с ветвью _:
fn main() {
let dice_roll = 9;
match dice_roll {
3 => add_fancy_hat(),
7 => remove_fancy_hat(),
_ => (),
}
fn add_fancy_hat() {}
fn remove_fancy_hat() {}
}
Здесь мы говорим Rust явно, что мы не собираемся использовать никакое другое значение, которое не соответствует шаблону в более ранней ветви, и мы не хотим выполнять никакой код в этом случае.
В главе 19 мы рассмотрим больше о шаблонах и сопоставлении. Сейчас мы перейдём к синтаксису if let, который может быть полезен в ситуациях, когда выражение match немного многословно.