Как преобразовать Option в Result в Rust без использования макросов?

Использование метода ok_or и ok_or_else

Да, в стандартной библиотеке Rust есть встроенные методы для преобразования Option в Result. Это методы ok_or и ok_or_else, которые определены в трейте Option. Они позволяют преобразовать Option<T> в Result<T, E>, предоставляя значение ошибки на случай, если Option равен None.

Метод ok_or

Преобразует Option<T> в Result<T, E>, принимая значение ошибки по значению. Подходит, когда ошибка — это простой клонируемый тип или статическая строка.

fn find_user(id: u32) -> Result<User, String> {
    let users = get_users();
    users.iter()
        .find(|u| u.id == id)
        .cloned()  // или .map(|u| u.clone()), если не реализован Copy
        .ok_or("User not found".to_string())
}

Метод ok_or_else

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

fn find_user(id: u32) -> Result<User, String> {
    let users = get_users();
    users.iter()
        .find(|u| u.id == id)
        .cloned()
        .ok_or_else(|| format!("User with id {} not found", id))
}

Работа с пользовательскими типами ошибок

Если вы используете кастомный тип ошибки (например, через крейт thiserror), это тоже работает:

#[derive(thiserror::Error, Debug)]
pub enum MyError {
    #[error("User not found: {0}")]
    NotFound(u32),
}

fn find_user(id: u32) -> Result<User, MyError> {
    let users = get_users();
    users.iter()
        .find(|u| u.id == id)
        .cloned()
        .ok_or(MyError::NotFound(id))
}

Комбинирование с ? оператором

Особенно мощно эти методы работают в связке с оператором ?:

fn process_user(id: u32) -> Result<User, MyError> {
    let user = find_user(id)?;  // если None, ошибка пробрасывается наверх
    // ... дальнейшая обработка
    Ok(user)
}

Использование Option::transpose

Если у вас есть Option<Result<T, E>>, вы можете использовать transpose() для преобразования в Result<Option<T>, E>:

fn find_user_optional(id: u32) -> Option<Result<User, String>> {
    // ... какой-то код
}

let result: Result<Option<User>, String> = find_user_optional(id).transpose();

Почему это идиоматично?

• Читаемость: цепочка методов читается как "найди, склонируй, верни Ok или Err".
• Производительность: ok_or_else не вычисляет ошибку, если значение есть.
• Гибкость: работает с любыми типами ошибок.
• Нет макросов: чистый код без магических макросов.

В вашем примере замена match на .cloned().ok_or(...) делает код короче и выразительнее. Также обратите внимание на .cloned() — он заменяет явный user.clone() внутри Some.

Дополнительные полезные методы: Option::ok_or (уже видели), Result::ok (обратное преобразование), Result::err (получить ошибку из Result).

use anyhow::{Context, Result};

fn find_user(id: u32) -> Result<User> {
    let users = get_users();
    users.iter()
        .find(|u| u.id == id)
        .cloned()
        .context(format!("User {} not found", id))
}

users.iter()
    .find(|u| u.id == id)
    .cloned()
    .with_context(|| format!("User {} not found", id))