Замыкания
Замыкания в Rust — это анонимные функции, которые можно сохранить в переменной или передать в качестве аргументов другим функциям. Можно создать замыкание в одном месте, а затем вызвать его в другом месте, чтобы вычислить его в другом контексте. В отличие от функций, замыкания могут захватывать значения из области видимости, в которой они определены. Мы продемонстрируем, как эти возможности замыканий позволяют повторно использовать код и настраивать поведение.
Захват окружения
Сначала рассмотрим, как можно использовать замыкания для захвата значений из окружения, в котором они определены, для последующего использования. Вот сценарий: время от времени наша компания по производству футболок дарит эксклюзивную футболку ограниченного выпуска кому-то из нашего списка рассылки в качестве рекламной акции. Люди из списка рассылки могут по желанию добавить свой любимый цвет в свой профиль. Если выбранный для бесплатной футболки человек указал свой любимый цвет, он получает футболку этого цвета. Если человек не указал любимый цвет, он получает тот цвет, которого у компании сейчас больше всего.
Есть много способов реализовать это. В этом примере мы собираемся использовать
перечисление ShirtColor с вариантами Red и Blue (для простоты ограничив
количество доступных цветов). Запасы компании мы представляем с помощью
структуры Inventory с полем shirts, которое
содержит Vec<ShirtColor>, представляющий цвета футболок, имеющихся на складе.
Метод giveaway, определённый для Inventory, получает необязательное предпочтение
цвета футболки победителя розыгрыша и возвращает цвет футболки, который
получит человек. Эта установка показана в листинге 13-1.
#[derive(Debug, PartialEq, Copy, Clone)]
enum ShirtColor {
Red,
Blue,
}
struct Inventory {
shirts: Vec<ShirtColor>,
}
impl Inventory {
fn giveaway(&self, user_preference: Option<ShirtColor>) -> ShirtColor {
user_preference.unwrap_or_else(|| self.most_stocked())
}
fn most_stocked(&self) -> ShirtColor {
let mut num_red = 0;
let mut num_blue = 0;
for color in &self.shirts {
match color {
ShirtColor::Red => num_red += 1,
ShirtColor::Blue => num_blue += 1,
}
}
if num_red > num_blue {
ShirtColor::Red
} else {
ShirtColor::Blue
}
}
}
fn main() {
let store = Inventory {
shirts: vec![ShirtColor::Blue, ShirtColor::Red, ShirtColor::Blue],
};
let user_pref1 = Some(ShirtColor::Red);
let giveaway1 = store.giveaway(user_pref1);
println!(
"The user with preference {:?} gets {:?}",
user_pref1, giveaway1
);
let user_pref2 = None;
let giveaway2 = store.giveaway(user_pref2);
println!(
"The user with preference {:?} gets {:?}",
user_pref2, giveaway2
);
}
Определённый в main магазин store имеет две синие футболки и одну красную, оставшиеся
для раздачи в рамках этой акции ограниченного выпуска. Мы вызываем метод giveaway
для пользователя с предпочтением красной футболки и для пользователя без каких-либо предпочтений.
Опять же, этот код можно было бы реализовать многими способами, и здесь, чтобы сосредоточиться на
замыканиях, мы придерживались концепций, которые уже были изучены, за исключением тела
метода giveaway, в котором используется замыкание. В методе giveaway мы получаем
предпочтение пользователя как параметр типа Option<ShirtColor> и вызываем метод
unwrap_or_else для user_preference. Метод unwrap_or_else для
Option<T> определён в стандартной библиотеке.
Он принимает один аргумент: замыкание без аргументов, которое возвращает значение T
(тот же тип, что хранится в варианте Some у Option<T>, в данном случае
ShirtColor). Если Option<T> — это вариант Some, unwrap_or_else
возвращает значение изнутри Some. Если Option<T> — это вариант None,
unwrap_or_else вызывает замыкание и возвращает значение, возвращённое
замыканием.
Мы указываем выражение замыкания || self.most_stocked() в качестве аргумента для
unwrap_or_else. Это замыкание, которое само не принимает параметров (если бы у
замыкания были параметры, они появились бы между двумя вертикальными чертами). Тело
замыкания вызывает self.most_stocked(). Мы определяем замыкание
здесь, а реализация unwrap_or_else вычислит замыкание
позже, если результат понадобится.
Выполнение этого кода выводит следующее:
$ cargo run
Compiling shirt-company v0.1.0 (file:///projects/shirt-company)
Finished `dev` profile [unoptimized + debuginfo] target(s) in 0.27s
Running `target/debug/shirt-company`
The user with preference Some(Red) gets Red
The user with preference None gets Blue
Один интересный аспект здесь заключается в том, что мы передали замыкание, которое вызывает
self.most_stocked() для текущего экземпляра Inventory. Стандартной библиотеке
не нужно было ничего знать о типах Inventory или ShirtColor, которые мы
определили, или о логике, которую мы хотим использовать в этом сценарии. Замыкание захватывает
неизменяемую ссылку на экземпляр Inventory self и передаёт его вместе с
кодом, который мы указываем, методу unwrap_or_else. Функции, с другой стороны,
не могут захватывать своё окружение таким образом.
Вывод и аннотирование типов замыканий
Между функциями и замыканиями есть и другие различия. Замыкания обычно
не требуют аннотировать типы параметров или возвращаемого значения
так, как это делают функции fn. Аннотации типов обязательны для функций, потому что
типы являются частью явного интерфейса, предоставляемого пользователям. Жёсткое
определение этого интерфейса важно для того, чтобы все соглашались с тем, какие типы
значений использует и возвращает функция. Замыкания, с другой стороны, не используются
в таком открытом интерфейсе: они хранятся в переменных и
используются без именования и предоставления пользователям нашей библиотеки.
Замыкания, как правило, короткие и актуальны только в узком контексте, а не в каком-либо произвольном сценарии. В этих ограниченных контекстах компилятор может вывести типы параметров и возвращаемый тип, подобно тому, как он способен вывести типы большинства переменных (есть редкие случаи, когда компилятору тоже нужны аннотации типов замыканий).
Как и с переменными, можно добавить аннотации типов, если нужно повысить явность и ясность ценой большей многословности, чем строго необходимо. Аннотирование типов для замыкания выглядело бы как определение, показанное в листинге 13-2. В этом примере мы определяем замыкание и сохраняем его в переменной, а не определяем замыкание в том месте, где передаём его как аргумент, как мы делали в листинге 13-1.
use std::thread;
use std::time::Duration;
fn generate_workout(intensity: u32, random_number: u32) {
let expensive_closure = |num: u32| -> u32 {
println!("calculating slowly...");
thread::sleep(Duration::from_secs(2));
num
};
if intensity < 25 {
println!("Today, do {} pushups!", expensive_closure(intensity));
println!("Next, do {} situps!", expensive_closure(intensity));
} else {
if random_number == 3 {
println!("Take a break today! Remember to stay hydrated!");
} else {
println!(
"Today, run for {} minutes!",
expensive_closure(intensity)
);
}
}
}
fn main() {
let simulated_user_specified_value = 10;
let simulated_random_number = 7;
generate_workout(simulated_user_specified_value, simulated_random_number);
}
С добавленными аннотациями типов синтаксис замыканий выглядит более похожим на синтаксис функций. Здесь мы определяем функцию, которая добавляет 1 к своему параметру, и замыкание с тем же поведением для сравнения. Мы добавили несколько пробелов, чтобы выровнять соответствующие части. Это иллюстрирует, насколько синтаксис замыканий похож на синтаксис функций, за исключением использования вертикальных черт и объёма синтаксиса, который является необязательным:
fn add_one_v1 (x: u32) -> u32 { x + 1 }
let add_one_v2 = |x: u32| -> u32 { x + 1 };
let add_one_v3 = |x| { x + 1 };
let add_one_v4 = |x| x + 1 ;
Первая строка показывает определение функции, а вторая строка показывает полностью
аннотированное определение замыкания. В третьей строке мы удаляем аннотации типов
из определения замыкания. В четвёртой строке мы удаляем скобки, которые
необязательны, потому что тело замыкания состоит только из одного выражения. Все это
допустимые определения, которые при вызове дадут одинаковое поведение. Строки
add_one_v3 и add_one_v4 требуют, чтобы замыкания были вычислены, чтобы
можно было скомпилировать, потому что типы будут выведены из их использования. Это
похоже на то, что let v = Vec::new(); требует либо аннотаций типов, либо значений
некоторого типа, вставленных в Vec, чтобы Rust мог вывести тип.
Для определений замыканий компилятор выведет один конкретный тип для каждого из
их параметров и для их возвращаемого значения. Например, листинг 13-3 показывает
определение короткого замыкания, которое просто возвращает значение, полученное в качестве
параметра. Это замыкание не очень полезно, кроме как для целей этого
примера. Обратите внимание, что мы не добавили никаких аннотаций типов в определение.
Поскольку аннотаций типов нет, мы можем вызывать замыкание с любым типом,
что мы и сделали здесь с String в первый раз. Если затем попытаться вызвать
example_closure с целым числом, мы получим ошибку.
fn main() {
let example_closure = |x| x;
let s = example_closure(String::from("hello"));
let n = example_closure(5);
}
Компилятор выдаёт нам эту ошибку:
$ cargo run
Compiling closure-example v0.1.0 (file:///projects/closure-example)
error[E0308]: mismatched types
--> src/main.rs:5:29
|
5 | let n = example_closure(5);
| --------------- ^ expected `String`, found integer
| |
| arguments to this function are incorrect
|
note: expected because the closure was earlier called with an argument of type `String`
--> src/main.rs:4:29
|
4 | let s = example_closure(String::from("hello"));
| --------------- ^^^^^^^^^^^^^^^^^^^^^ expected because this argument is of type `String`
| |
| in this closure call
note: closure parameter defined here
--> src/main.rs:2:28
|
2 | let example_closure = |x| x;
| ^
help: try using a conversion method
|
5 | let n = example_closure(5.to_string());
| ++++++++++++
For more information about this error, try `rustc --explain E0308`.
error: could not compile `closure-example` (bin "closure-example") due to 1 previous error
Когда мы впервые вызываем example_closure со значением String, компилятор
выводит тип x и возвращаемый тип замыкания как String. Затем эти
типы фиксируются в замыкании в example_closure, и мы получаем ошибку
типов, когда в следующий раз пытаемся использовать другой тип с тем же замыканием.
Захват ссылок или перемещение владения
Замыкания могут захватывать значения из своего окружения тремя способами, которые непосредственно соответствуют трём способам, которыми функция может принимать параметр: заимствование неизменяемо, заимствование изменяемо и принятие владения. Замыкание решит, какой из них использовать, исходя из того, что тело функции делает с захваченными значениями.
В листинге 13-4 мы определяем замыкание, которое захватывает неизменяемую ссылку на
вектор с именем list, потому что ему нужна только неизменяемая ссылка, чтобы напечатать
значение.
fn main() {
let list = vec![1, 2, 3];
println!("Before defining closure: {list:?}");
let only_borrows = || println!("From closure: {list:?}");
println!("Before calling closure: {list:?}");
only_borrows();
println!("After calling closure: {list:?}");
}
Этот пример также иллюстрирует, что переменная может связываться с определением замыкания, и мы можем позже вызвать замыкание, используя имя переменной и круглые скобки, как если бы имя переменной было именем функции.
Поскольку у нас может быть несколько неизменяемых ссылок на list одновременно,
list по-прежнему доступен из кода до определения замыкания, после
определения замыкания, но до вызова замыкания, и после того, как замыкание
вызвано. Этот код компилируется, выполняется и печатает:
$ cargo run
Compiling closure-example v0.1.0 (file:///projects/closure-example)
Finished `dev` profile [unoptimized + debuginfo] target(s) in 0.43s
Running `target/debug/closure-example`
Before defining closure: [1, 2, 3]
Before calling closure: [1, 2, 3]
From closure: [1, 2, 3]
After calling closure: [1, 2, 3]
Далее, в листинге 13-5, мы меняем тело замыкания так, чтобы оно добавляло элемент в
вектор list. Теперь замыкание захватывает изменяемую ссылку.
fn main() {
let mut list = vec![1, 2, 3];
println!("Before defining closure: {list:?}");
let mut borrows_mutably = || list.push(7);
borrows_mutably();
println!("After calling closure: {list:?}");
}
Этот код компилируется, выполняется и печатает:
$ cargo run
Compiling closure-example v0.1.0 (file:///projects/closure-example)
Finished `dev` profile [unoptimized + debuginfo] target(s) in 0.43s
Running `target/debug/closure-example`
Before defining closure: [1, 2, 3]
After calling closure: [1, 2, 3, 7]
Обратите внимание, что между определением и вызовом
замыкания borrows_mutably больше нет println!: когда borrows_mutably определяется, оно захватывает
изменяемую ссылку на list. Мы не используем замыкание снова после того, как замыкание
вызвано, поэтому изменяемое заимствование заканчивается. Между определением замыкания и
вызовом замыкания неизменяемое заимствование для печати не допускается, потому что при
изменяемом заимствовании никакие другие заимствования не разрешены. Попробуйте добавить println!
туда, чтобы увидеть, какое сообщение об ошибке вы получите!
Если нужно заставить замыкание принять владение значениями, которые оно использует в
окружении, даже если тело замыкания строго не требует
владения, можно использовать ключевое слово move перед списком параметров.
Этот приём в основном полезен при передаче замыкания в новый поток, чтобы переместить
данные так, чтобы они принадлежали новому потоку. Мы подробно обсудим потоки и то, зачем
их использовать, в главе 16, когда будем говорить о
конкурентности, но пока кратко рассмотрим порождение нового потока с использованием
замыкания, которому нужно ключевое слово move. Листинг 13-6 показывает листинг 13-4, изменённый
так, чтобы печатать вектор в новом потоке, а не в основном потоке.
use std::thread;
fn main() {
let list = vec![1, 2, 3];
println!("Before defining closure: {list:?}");
thread::spawn(move || println!("From thread: {list:?}"))
.join()
.unwrap();
}
move, чтобы заставить замыкание для потока принять владение listМы порождаем новый поток, передавая потоку замыкание для запуска в качестве аргумента. Тело
замыкания печатает список. В листинге 13-4 замыкание захватывало list
только через неизменяемую ссылку, потому что это минимальный уровень доступа
к list, необходимый для его печати. В этом примере, хотя тело замыкания
по-прежнему требует только неизменяемую ссылку, нам нужно указать, что list должен
быть перемещён в замыкание, поместив ключевое слово move в начале
определения замыкания. Если бы основной поток выполнил больше операций перед вызовом
join для нового потока, новый поток мог бы завершиться раньше остальной части
основного потока, или основной поток мог бы завершиться первым. Если бы основной поток
сохранял владение list, но завершился до нового потока и удалил
list, неизменяемая ссылка в потоке стала бы недействительной. Поэтому
компилятор требует, чтобы list был перемещён в замыкание, передаваемое новому потоку,
чтобы ссылка оставалась действительной. Попробуйте удалить ключевое слово move или использовать
list в основном потоке после определения замыкания, чтобы увидеть, какие ошибки
компилятора вы получите!
Перемещение захваченных значений из замыканий
После того как замыкание захватило ссылку или владение значением из окружения, в котором определено замыкание (что влияет на то, что, если что-то, перемещается в замыкание), код в теле замыкания определяет, что происходит со ссылками или значениями, когда замыкание вычисляется позже (что влияет на то, что, если что-то, перемещается из замыкания).
Тело замыкания может делать любое из следующего: перемещать захваченное значение из замыкания, изменять захваченное значение, не перемещать и не изменять значение или вообще ничего не захватывать из окружения.
Способ, которым замыкание захватывает и обрабатывает значения из окружения, влияет на
то, какие трейты реализует замыкание, а трейты — это то, как функции и структуры
могут указывать, какие виды замыканий они могут использовать. Замыкания автоматически
реализуют один, два или все три из этих трейтов Fn, аддитивным образом,
в зависимости от того, как тело замыкания обрабатывает значения:
FnOnceприменяется к замыканиям, которые могут быть вызваны один раз. Все замыкания реализуют как минимум этот трейт, потому что все замыкания могут быть вызваны. Замыкание, которое перемещает захваченные значения из своего тела, будет реализовывать толькоFnOnceи ни один из других трейтовFn, потому что оно может быть вызвано только один раз.FnMutприменяется к замыканиям, которые не перемещают захваченные значения из своего тела, но могут изменять захваченные значения. Такие замыкания могут быть вызваны более одного раза.Fnприменяется к замыканиям, которые не перемещают захваченные значения из своего тела и не изменяют захваченные значения, а также к замыканиям, которые ничего не захватывают из своего окружения. Такие замыкания могут быть вызваны более одного раза без изменения своего окружения, что важно в случаях, например, при вызове замыкания несколько раз одновременно.
Давайте посмотрим на определение метода unwrap_or_else для Option<T>, который
мы использовали в листинге 13-1:
impl<T> Option<T> {
pub fn unwrap_or_else<F>(self, f: F) -> T
where
F: FnOnce() -> T
{
match self {
Some(x) => x,
None => f(),
}
}
}
Напомним, что T — это обобщённый тип, представляющий тип значения в
варианте Some у Option. Этот тип T также является возвращаемым типом
функции unwrap_or_else: код, который вызывает unwrap_or_else для
Option<String>, например, получит String.
Далее, обратите внимание, что функция unwrap_or_else имеет дополнительный обобщённый параметр
типа F. Тип F — это тип параметра с именем f, который является
замыканием, которое мы предоставляем при вызове unwrap_or_else.
Ограничение трейта, указанное для обобщённого типа F, — это FnOnce() -> T, что
означает, что F должен иметь возможность быть вызванным один раз, не принимать аргументов и возвращать T.
Использование FnOnce в ограничении трейта выражает ограничение, что
unwrap_or_else не будет вызывать f более одного раза. В теле
unwrap_or_else мы видим, что если Option — это Some, f не будет
вызван. Если Option — это None, f будет вызван один раз. Поскольку все
замыкания реализуют FnOnce, unwrap_or_else принимает замыкания всех трёх видов
и настолько гибок, насколько это возможно.
Примечание: если то, что мы хотим сделать, не требует захвата значения из
окружения, мы можем использовать имя функции вместо замыкания там, где
нужно что-то, реализующее один из трейтов Fn. Например, для значения
Option<Vec<T>> мы могли бы вызвать unwrap_or_else(Vec::new), чтобы получить
новый пустой вектор, если значение — None. Компилятор автоматически
реализует тот из трейтов Fn, который применим к определению функции.
Теперь давайте посмотрим на метод стандартной библиотеки sort_by_key, определённый для срезов,
чтобы увидеть, чем он отличается от unwrap_or_else и почему sort_by_key использует
FnMut вместо FnOnce в ограничении трейта. Замыкание получает один аргумент
в виде ссылки на текущий элемент в рассматриваемом срезе
и возвращает значение типа K, которое можно упорядочить. Эта функция полезна
когда нужно отсортировать срез по определённому атрибуту каждого элемента. В
листинге 13-7 у нас есть список экземпляров Rectangle, и мы используем sort_by_key,
чтобы упорядочить их по атрибуту width от меньшего к большему.
#[derive(Debug)]
struct Rectangle {
width: u32,
height: u32,
}
fn main() {
let mut list = [
Rectangle { width: 10, height: 1 },
Rectangle { width: 3, height: 5 },
Rectangle { width: 7, height: 12 },
];
list.sort_by_key(|r| r.width);
println!("{list:#?}");
}
sort_by_key для упорядочивания прямоугольников по ширинеЭтот код печатает:
$ cargo run
Compiling rectangles v0.1.0 (file:///projects/rectangles)
Finished `dev` profile [unoptimized + debuginfo] target(s) in 0.41s
Running `target/debug/rectangles`
[
Rectangle {
width: 3,
height: 5,
},
Rectangle {
width: 7,
height: 12,
},
Rectangle {
width: 10,
height: 1,
},
]
Причина, по которой sort_by_key определён так, что принимает замыкание FnMut, заключается в том, что он вызывает
замыкание несколько раз: по одному разу для каждого элемента в срезе. Замыкание |r| r.width
ничего не захватывает, не изменяет и не перемещает из своего окружения, поэтому
оно соответствует требованиям ограничения трейта.
Напротив, листинг 13-8 показывает пример замыкания, которое реализует только
трейт FnOnce, потому что оно перемещает значение из окружения. Компилятор
не позволит нам использовать это замыкание с sort_by_key.
#[derive(Debug)]
struct Rectangle {
width: u32,
height: u32,
}
fn main() {
let mut list = [
Rectangle { width: 10, height: 1 },
Rectangle { width: 3, height: 5 },
Rectangle { width: 7, height: 12 },
];
let mut sort_operations = vec![];
let value = String::from("closure called");
list.sort_by_key(|r| {
sort_operations.push(value);
r.width
});
println!("{list:#?}");
}
FnOnce с sort_by_keyЭто надуманный, запутанный способ (который не работает) попытаться подсчитать количество
раз, которое sort_by_key вызывает замыкание при сортировке list. Этот код
пытается выполнить подсчёт, помещая value — String из окружения замыкания — в
вектор sort_operations. Замыкание захватывает value, а
затем перемещает value из замыкания, передавая владение value
вектору sort_operations. Это замыкание может быть вызвано один раз; попытка вызвать
его второй раз не сработала бы, потому что value больше не было бы в
окружении, чтобы снова поместить его в sort_operations! Поэтому это замыкание
реализует только FnOnce. Когда мы пытаемся скомпилировать этот код, мы получаем эту ошибку,
что value не может быть перемещено из замыкания, потому что замыкание должно
реализовывать FnMut:
$ cargo run
Compiling rectangles v0.1.0 (file:///projects/rectangles)
error[E0507]: cannot move out of `value`, a captured variable in an `FnMut` closure
--> src/main.rs:18:30
|
15 | let value = String::from("closure called");
| ----- ------------------------------ move occurs because `value` has type `String`, which does not implement the `Copy` trait
| |
| captured outer variable
16 |
17 | list.sort_by_key(|r| {
| --- captured by this `FnMut` closure
18 | sort_operations.push(value);
| ^^^^^ `value` is moved here
|
help: `Fn` and `FnMut` closures require captured values to be able to be consumed multiple times, but `FnOnce` closures may consume them only once
--> /rustc/2d8144b7880597b6e6d3dfd63a9a9efae3f533d3/library/alloc/src/slice.rs:249:11
help: consider cloning the value if the performance cost is acceptable
|
18 | sort_operations.push(value.clone());
| ++++++++
For more information about this error, try `rustc --explain E0507`.
error: could not compile `rectangles` (bin "rectangles") due to 1 previous error
Ошибка указывает на строку в теле замыкания, которая перемещает value из
окружения. Чтобы исправить это, нужно изменить тело замыкания так, чтобы оно не
перемещало значения из окружения. Хранение счётчика в окружении и
увеличение его значения в теле замыкания — более простой способ
подсчитать количество раз, которое замыкание вызывается. Замыкание в листинге 13-9
работает с sort_by_key, потому что оно захватывает только изменяемую ссылку на
счётчик num_sort_operations и поэтому может быть вызвано более одного раза.
#[derive(Debug)]
struct Rectangle {
width: u32,
height: u32,
}
fn main() {
let mut list = [
Rectangle { width: 10, height: 1 },
Rectangle { width: 3, height: 5 },
Rectangle { width: 7, height: 12 },
];
let mut num_sort_operations = 0;
list.sort_by_key(|r| {
num_sort_operations += 1;
r.width
});
println!("{list:#?}, sorted in {num_sort_operations} operations");
}
FnMut с sort_by_key разрешено.Трейты Fn важны при определении или использовании функций или типов, которые
используют замыкания. В следующем разделе мы обсудим итераторы. Многие
методы итераторов принимают аргументы-замыкания, так что имейте в виду эти детали замыканий,
продолжая изучение!