Все места, где можно использовать шаблоны
Шаблоны встречаются в ряде мест в Rust, и вы использовали их много раз, даже не осознавая этого! В этом разделе обсуждаются все места, где шаблоны допустимы.
Ветви match
Как обсуждалось в шестой главе, мы используем шаблоны в ветвях выражений match.
Формально выражения match определяются как ключевое слово match, значение для
сопоставления и одна или несколько ветвей match, состоящих из шаблона и
выражения для выполнения, если значение соответствует шаблону этой ветви, вот так:
match VALUE {
PATTERN => EXPRESSION,
PATTERN => EXPRESSION,
PATTERN => EXPRESSION,
}
Например, вот выражение match из листинга 6-5, которое сопоставляется со
значением Option<i32> в переменной x:
match x {
None => None,
Some(i) => Some(i + 1),
}
Шаблоны в этом выражении match — это None и Some(i) слева от каждой
стрелки.
Одно требование к выражениям match состоит в том, что они должны быть исчерпывающими в
том смысле, что все возможности для значения в выражении match должны
быть учтены. Один из способов убедиться, что вы охватили все возможности, —
иметь шаблон, охватывающий все остальные случаи, для последней ветви: например, имя переменной,
соответствующее любому значению, никогда не может потерпеть неудачу и, таким образом, охватывает все оставшиеся случаи.
Конкретный шаблон _ соответствует чему угодно, но он никогда не связывается с
переменной, поэтому он часто используется в последней ветви match. Шаблон _ может быть
полезен, когда вы хотите игнорировать любое значение, не указанное, например. Мы
рассмотрим шаблон _ более подробно в разделе «Игнорирование значений в
шаблоне» далее в этой главе.
Операторы let
До этой главы мы явно обсуждали использование шаблонов только с
match и if let, но на самом деле мы использовали шаблоны и в других местах,
включая операторы let. Например, рассмотрим это простое
присваивание переменной с помощью let:
#![allow(unused)]
fn main() {
let x = 5;
}
Каждый раз, когда вы использовали такой оператор let, вы использовали шаблоны,
хотя, возможно, и не осознавали этого! Более формально оператор let выглядит
так:
let PATTERN = EXPRESSION;
В операторах вроде let x = 5; с именем переменной на месте PATTERN
имя переменной — это просто особенно простая форма шаблона. Rust сравнивает
выражение с шаблоном и присваивает любые найденные имена. Так, в
примере let x = 5; x — это шаблон, означающий «связать то, что совпадает здесь, с
переменной x». Поскольку имя x — это весь шаблон, этот шаблон
фактически означает «связать всё с переменной x, каким бы ни было значение».
Чтобы яснее увидеть аспект сопоставления с образцом у let, рассмотрим листинг
19-1, который использует шаблон с let для деструктуризации кортежа.
fn main() {
let (x, y, z) = (1, 2, 3);
}
Здесь мы сопоставляем кортеж с шаблоном. Rust сравнивает значение (1, 2, 3)
с шаблоном (x, y, z) и видит, что значение соответствует шаблону — то есть
он видит, что количество элементов одинаково в обоих — поэтому Rust связывает 1 с
x, 2 с y и 3 с z. Вы можете думать об этом шаблоне кортежа как о вложении
трёх отдельных шаблонов переменных внутри него.
Если количество элементов в шаблоне не совпадает с количеством элементов в кортеже, общий тип не совпадёт, и мы получим ошибку компилятора. Например, листинг 19-2 показывает попытку деструктурировать кортеж с тремя элементами в две переменные, что не сработает.
fn main() {
let (x, y) = (1, 2, 3);
}
Попытка скомпилировать этот код приводит к этой ошибке типа:
$ cargo run
Compiling patterns v0.1.0 (file:///projects/patterns)
error[E0308]: mismatched types
--> src/main.rs:2:9
|
2 | let (x, y) = (1, 2, 3);
| ^^^^^^ --------- this expression has type `({integer}, {integer}, {integer})`
| |
| expected a tuple with 3 elements, found one with 2 elements
|
= note: expected tuple `({integer}, {integer}, {integer})`
found tuple `(_, _)`
For more information about this error, try `rustc --explain E0308`.
error: could not compile `patterns` (bin "patterns") due to 1 previous error
Чтобы исправить ошибку, мы могли бы проигнорировать одно или несколько значений в кортеже, используя
_ или .., как вы увидите в разделе «Игнорирование значений в
шаблоне». Если проблема
в том, что у нас слишком много переменных в шаблоне, решение состоит в том, чтобы привести
типы в соответствие, удалив переменные так, чтобы количество переменных равнялось
количеству элементов в кортеже.
Условные выражения if let
В шестой главе мы обсуждали, как использовать выражения if let в основном как более короткий
способ написать эквивалент match, который соответствует только одному случаю.
Опционально if let может иметь соответствующий else, содержащий код для выполнения, если
шаблон в if let не совпадает.
Листинг 19-3 показывает, что также возможно смешивать и сочетать if let, else if и else if let. Это даёт нам больше гибкости, чем
выражение match, в котором мы можем выразить только одно значение для сравнения с
шаблонами. Кроме того, Rust не требует, чтобы условия в серии if let, else if и else if let были связаны друг с другом.
Код в листинге 19-3 определяет, какой цвет сделать фон, на основе серии проверок нескольких условий. Для этого примера мы создали переменные с жёстко заданными значениями, которые реальная программа могла бы получить от пользовательского ввода.
fn main() {
let favorite_color: Option<&str> = None;
let is_tuesday = false;
let age: Result<u8, _> = "34".parse();
if let Some(color) = favorite_color {
println!("Using your favorite color, {color}, as the background");
} else if is_tuesday {
println!("Tuesday is green day!");
} else if let Ok(age) = age {
if age > 30 {
println!("Using purple as the background color");
} else {
println!("Using orange as the background color");
}
} else {
println!("Using blue as the background color");
}
}
if let, else if, else if let и elseЕсли пользователь указывает любимый цвет, этот цвет используется в качестве фона. Если любимый цвет не указан и сегодня вторник, цвет фона — зелёный. В противном случае, если пользователь указывает свой возраст в виде строки и мы можем разобрать его как число успешно, цвет — либо фиолетовый, либо оранжевый в зависимости от значения числа. Если ни одно из этих условий не применимо, цвет фона — синий.
Эта условная структура позволяет нам поддерживать сложные требования. С
жёстко заданными значениями, которые у нас здесь есть, этот пример выведет Using purple as the background color.
Вы можете видеть, что if let также может вводить новые переменные, которые затеняют существующие
переменные так же, как это могут делать ветви match: строка if let Ok(age) = age
вводит новую переменную age, которая содержит значение внутри варианта Ok,
затеняя существующую переменную age. Это означает, что нам нужно поместить условие if age > 30
внутри этого блока: мы не можем объединить эти два условия в if let Ok(age) = age && age > 30. Новая age, которую мы хотим сравнить с 30, не
действительна до тех пор, пока не начнётся новая область видимости с фигурной скобки.
Недостаток использования выражений if let состоит в том, что компилятор не проверяет
исчерпывающест��, тогда как с выражениями match он это делает. Если бы мы пропустили
последний блок else и, следовательно, не обработали некоторые случаи, компилятор
не предупредил бы нас о возможной логической ошибке.
Условные циклы while let
По конструкции похожий на if let, условный цикл while let позволяет
циклу while выполняться до тех пор, пока шаблон продолжает совпадать. В листинге
19-4 мы показываем цикл while let, который ожидает сообщения, отправленные между потоками,
но в этом случае проверяет Result вместо Option.
fn main() {
let (tx, rx) = std::sync::mpsc::channel();
std::thread::spawn(move || {
for val in [1, 2, 3] {
tx.send(val).unwrap();
}
});
while let Ok(value) = rx.recv() {
println!("{value}");
}
}
while let для печати значений до тех пор, пока rx.recv() возвращает OkЭтот пример печатает 1, 2, а затем 3. Метод recv берёт первое
сообщение из принимающей стороны канала и возвращает Ok(value). Когда
мы впервые увидели recv в шестнадцатой главе, мы разворачивали ошибку напрямую, или
мы взаимодействовали с ней как с итератором, используя цикл for. Как показывает листинг 19-4,
однако, мы также можем использовать while let, потому что метод recv возвращает Ok
каждый раз, когда приходит сообщение, пока существует отправитель, а затем выдаёт
Err, как только отправитель отключается.
Циклы for
В цикле for значение, которое непосредственно следует за ключевым словом for, является
шаблоном. Например, в for x in y x — это шаблон. Листинг 19-5
демонстрирует, как использовать шаблон в цикле for для деструктуризации, или разбора
на части, кортежа как части цикла for.
fn main() {
let v = vec!['a', 'b', 'c'];
for (index, value) in v.iter().enumerate() {
println!("{value} is at index {index}");
}
}
for для деструктуризации кортежаКод в листинге 19-5 выведет следующее:
$ cargo run
Compiling patterns v0.1.0 (file:///projects/patterns)
Finished `dev` profile [unoptimized + debuginfo] target(s) in 0.52s
Running `target/debug/patterns`
a is at index 0
b is at index 1
c is at index 2
Мы адаптируем итератор с помощью метода enumerate, чтобы он выдавал значение
и индекс для этого значения, помещённые в кортеж. Первое выдаваемое значение —
это кортеж (0, 'a'). Когда это значение сопоставляется с шаблоном (index, value), index будет 0, а value будет 'a', печатая первую строку
вывода.
Параметры функций
Параметры функций также могут быть шаблонами. Код в листинге 19-6, который
объявляет функцию с именем foo, принимающую один параметр с именем x типа
i32, к настоящему времени должен выглядеть знакомым.
fn foo(x: i32) {
// здесь код
}
fn main() {}
Часть x — это шаблон! Как мы делали с let, мы могли бы сопоставить кортеж в
аргументах функции с шаблоном. Листинг 19-7 разделяет значения в кортеже,
когда мы передаём его в функцию.
fn print_coordinates(&(x, y): &(i32, i32)) {
println!("Current location: ({x}, {y})");
}
fn main() {
let point = (3, 5);
print_coordinates(&point);
}
Этот код печатает Current location: (3, 5). Значения &(3, 5) соответствуют
шаблону &(x, y), поэтому x — это значение 3, а y — значение 5.
Мы также можем использовать шаблоны в списках параметров замыканий так же, как в списках параметров функций, потому что замыкания похожи на функции, как обсуждалось в тринадцатой главе.
На этом этапе вы видели несколько способов использования шаблонов, но шаблоны не работают одинаково во всех местах, где мы можем их использовать. В некоторых местах шаблоны должны быть неопровержимыми; в других обстоятельствах они могут быть опровержимыми. Мы обсудим эти две концепции далее.