Краткий ответ

transpose меняет порядок вложенности Option и Result, не меняя смысл ни одного состояния. Преобразование Option<Result<T, E>> в Result<Option<T>, E> позволяет единообразно обработать ошибку через Result: отсутствие значения становится успешным Ok(None), успешное значение — Ok(Some(value)), а ошибка сохраняется как Err(error).

Исторический контекст

В Rust составные перечисления позволяют точно описывать независимые исходы операции. Например, значение может быть необязательным, а если оно присутствует — его обработка может завершиться ошибкой.

Без специального преобразования вызывающий код получает вложенный тип Option<Result<T, E>> и вынужден отдельно разбирать оба уровня. transpose поддерживает композицию таких операций и позволяет использовать обычную цепочку обработки ошибок через Result.

Постановка проблемы

Представим необязательный параметр конфигурации: отсутствие параметра допустимо, но переданное значение должно корректно преобразовываться. Тогда возможны три состояния:

параметр отсутствует;
параметр присутствует и успешно разобран;
параметр присутствует, но содержит ошибку.

Если оставить тип Option<Result<T, E>>, код выше по стеку должен сначала обработать Option, а затем вложенный Result. Это увеличивает количество ветвлений и затрудняет применение оператора ?, который естественно работает с внешним Result.

Подробное решение

transpose выполняет строгое преобразование состояний:

None превращается в Ok(None);
Some(Ok(value)) превращается в Ok(Some(value));
Some(Err(error)) превращается в Err(error).

Метод не подавляет ошибку, не создает значение по умолчанию и не выполняет дополнительную бизнес-логику. Он только меняет структуру типа, сохраняя информацию о результате.

use std::num::ParseIntError;

fn optional_port(text: Option<&str>) -> Result<Option<u16>, ParseIntError> {
    text.map(str::parse::<u16>).transpose()
}

fn main() {
    println!("{:?}", optional_port(Some("8080")));
    println!("{:?}", optional_port(None));
    println!("{:?}", optional_port(Some("http")));
}

Результаты будут соответственно Ok(Some(8080)), Ok(None) и Err(...). После преобразования вызывающий код может применить ?: ошибка распространится вверх, а отсутствие необязательного значения останется штатным успешным исходом.

Обратное преобразование также поддерживается: Result<Option<T>, E> можно превратить в Option<Result<T, E>>. При этом Err(error) становится Some(Err(error)), потому что ошибка является присутствующим результатом, тогда как Ok(None) становится None.

Ручной match дает полный контроль и иногда лучше подходит для сложной логики. Однако для простого изменения вложенности transpose короче, явно выражает намерение и уменьшает риск случайно потерять ошибку; методы вроде filter или flatten здесь не являются заменой, поскольку могут изменить или скрыть семантику исходных состояний.

Ситуация из практики

В HTTP-сервисе параметр тайм-аута может отсутствовать, но при наличии должен быть целым числом в допустимом диапазоне. Первоначальный вариант возвращал Option<Result<u64, ParseIntError>>, из-за чего слой конфигурации отдельно разбирал наличие строки и результат парсинга.

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

Выбран вариант с transpose: после парсинга результат преобразуется в Result<Option<u64>, ParseIntError>. Отсутствующий параметр считается успешным отсутствием настройки, ошибка парсинга передается наверх и логируется как ошибка конфигурации, а корректное значение используется сервисом без дополнительных уровней сопоставления.

Что кандидаты часто упускают

Теряется ли ошибка при преобразовании Option<Result<T, E>> через transpose?

Нет. Состояние Some(Err(error)) превращается в Err(error), поэтому ошибка остается доступной вызывающему коду. Теряется только внешняя оболочка Some, потому что после преобразования ошибка уже представлена внешним Result.

Почему transpose не эквивалентен flatten?

flatten устраняет один уровень вложенности у однотипных контейнеров, например Option<Option<T>> превращает в Option<T>. В случае Option<Result<T, E>> контейнеры разные, поэтому требуется не просто убрать уровень, а сопоставить состояния None, Ok и Err с новой структурой; именно это делает transpose.

Что произойдет, если применить ? до вызова transpose?

Оператор ? не может напрямую извлечь Result из Option<Result<T, E>>, потому что внешний тип — Option, а не Result. Сначала нужно выбрать семантику отсутствия значения и преобразовать вложенность, например через transpose; после этого функция с возвращаемым типом Result<Option<T>, E> сможет использовать ? для распространения ошибки.