Операторы let-else и пропагации ошибок в Rust

Введение

#

Написание выразительного кода требует лаконичных инструментов управления потоком выполнения. В Rust для борьбы с глубокой вложенностью кода (так называемым «callback hell» или «лестницей скобок») используются мощные операторы:

• Оператор ? — для быстрой передачи ошибок и отсутствия значений наверх по стеку вызовов.
• Конструкция let-else — для безопасного развертывания опровержимых шаблонов с гарантированным расходящимся выходом в случае неудачи.

Давайте изучим работу этих операторов на интерактивных примерах кода:

 1fn find_number(option: Option<i32>) -> Option<i32> {
 2    // Оператор ? возвращает значение внутри Some(x), либо делает досрочный возврат None
 3    let num = option?;
 4    Some(num * 2)
 5}
 6
 7fn parse_and_double(s: &str) -> Result<i32, std::num::ParseIntError> {
 8    // Оператор ? возвращает i32, либо немедленно пробрасывает ошибку Err вверх
 9    let val = s.parse::<i32>()?;
10    Ok(val * 2)
11}
12
13fn main() {
14    let result_opt = find_number(Some(21));
15    let none_opt = find_number(None);
16
17    let result_res = parse_and_double("10");
18    let err_res = parse_and_double("abc");
19
20    println!("opt success: {:?}, opt none: {:?}", result_opt, none_opt);
21    println!("res success: {:?}, res err: {:?}", result_res, err_res);
22}

 1fn handle_event(event: Option<String>) {
 2    // let-else извлекает значение из Some, либо выполняет расходящийся блок else
 3    let Some(name) = event else {
 4        println!("Событие не содержит имени, завершаем функцию.");
 5        return; // Обязательный расходящийся выход
 6    };
 7
 8    println!("Обработка события: {}", name);
 9}
10
11fn main() {
12    handle_event(Some("Click".to_string()));
13    handle_event(None);
14
15    // Пример let-else в цикле с continue
16    for i in 0..5 {
17        let opt = if i % 2 == 0 { Some(i) } else { None };
18        
19        let Some(val) = opt else {
20            continue; // Пропускаем нечетные числа
21        };
22        println!("Четное число: {}", val);
23    }
24}

Оператор ? (Error & Option Propagation)

#

Оператор ? используется для быстрой пропагации (передачи наверх) ошибок или отсутствующих значений. Он разворачивает успешный результат, а в случае неудачи — осуществляет немедленный досрочный возврат из текущей функции.

1. Работа с типом Option

#

Если результатом выражения является Some(r), оператор ? извлекает и возвращает r. Если результат None, происходит досрочный выход из функции с возвратом None.

// Эквивалентные конструкции:
fn foo() -> Option<u32> {
    let value = bar()?; // Использование оператора ?
    Some(value)
}

// Что происходит под капотом:
let value = match bar() {
    Some(r) => r,
    None => return None,
};

2. Работа с типом Result

#

Если результатом является Ok(r), возвращается r. Если Err(err), происходит досрочный возврат из функции значения Err(err.into()) (с автоматическим приведением типов ошибок через типаж From/Into).

// Эквивалентные конструкции:
fn foo() -> Result<u32, Error> {
    let value = bar()?; // Использование оператора ?
    Ok(value)
}

// Что происходит под капотом:
let value = match bar() {
    Ok(r) => r,
    Err(err) => return Err(err.into()),
};

Конструкция let - else (Diverging let)

#

Синтаксис let-else позволяет связать переменную по шаблону в случае успеха, либо выполнить расходящийся (diverging) блок кода в случае неудачи.

• Синтаксис: let pattern = expression else { ... };. Обратите внимание на обязательное наличие точки с запятой ; после закрывающей фигурной скобки.
• Критическое правило блока else: Блок else обязан быть расходящимся (diverging), то есть он не имеет права возвращать управление в текущую область видимости обычным путем. Он обязан завершаться операторами:
  • return (выход из функции)
  • break (выход из цикла)
  • continue (переход на следующую итерацию цикла)
  • panic!() (завершение потока с ошибкой)

Различие шаблонов

#

Обычный let работает только с неопровержимыми (irrefutable) шаблонами, которые всегда совпадают (например, кортежи, ссылки или простые переменные). Для опровержимых (refutable) шаблонов, таких как Some(x), необходим let-else или if let.

// Примеры неопровержимых шаблонов для классического let:
let a = 1 + 2;
let (a, b) = some_tuple;

// Использование let-else для опровержимых шаблонов:
let Some(x) = some_option else { return; };
let Some(x) = some_option else { break; };
let Some(x) = some_option else { continue; };
let Some(x) = some_option else { panic!(); };

Практический пример обработки потока событий в цикле

#

Использование let-else значительно уменьшает уровень вложенности кода по сравнению с match или if let:

loop {
    // Если get_event() вернул Err, прерываем цикл
    let Ok(event) = get_event() else {
        break;
    };
    
    // Если event равен None, переходим к следующей итерации
    let Some(event) = event else {
        continue;
    };
    
    // Переменная event гарантированно развернута и валидна в этой точке
    handle_event(event);
}

Проверь свои знания!

#

Пройдите короткий интерактивный тест, чтобы закрепить понимание let-else и ?.