Rust中如何以惯用方式拆分元组的Result/Option为Result/Option元组

在处理Result<(T, U), E>或Option<(T, U)>这类包裹元组的类型时，将其拆分为独立的Result<T, E>和Result<U, E>（或对应的Option类型）是常见需求，以下是几种更惯用的实现方式：

1. 自定义辅助函数（推荐方案） #

你自己实现的split函数本身就非常符合Rust惯用风格，还可以通过trait扩展让调用更简洁自然：

针对Result的扩展 #

trait SplitResultTuple {
    type T;
    type U;
    type E;
    fn split(self) -> (Result<Self::T, Self::E>, Result<Self::U, Self::E>);
}

impl<T, U, E: Clone> SplitResultTuple for Result<(T, U), E> {
    type T = T;
    type U = U;
    type E = E;
    
    fn split(self) -> (Result<T, E>, Result<U, E>) {
        match self {
            Ok((a, b)) => (Ok(a), Ok(b)),
            Err(e) => (Err(e.clone()), Err(e)),
        }
    }
}

// 调用示例
let pair: Result<_, String> = Ok((10, "x"));
let (a, b) = pair.split();

针对Option的扩展 #

Option的拆分更简单，不需要克隆错误的逻辑：

trait SplitOptionTuple {
    type T;
    type U;
    fn split(self) -> (Option<Self::T>, Option<Self::U>);
}

impl<T, U> SplitOptionTuple for Option<(T, U)> {
    type T = T;
    type U = U;
    
    fn split(self) -> (Option<T>, Option<U>) {
        match self {
            Some((a, b)) => (Some(a), Some(b)),
            None => (None, None),
        }
    }
}

2. 用as_ref/as_mut避免克隆（引用场景） #

如果只需要获取元组元素的引用、无需转移所有权，可以用as_ref避免克隆错误或值：

let pair: Result<(i32, &str), String> = Ok((10, "x"));
let a = pair.as_ref().map(|(a, _)| a);
let b = pair.as_ref().map(|(_, b)| b);
// 此时a为Result<&i32, &String>，b同理

需要可变引用时，替换为as_mut即可：

let mut pair: Result<(i32, String), String> = Ok((10, "x".to_string()));
let a = pair.as_mut().map(|(a, _)| a);
let b = pair.as_mut().map(|(_, b)| b);

3. 泛型元组的支持 #

Rust标准库确实没有提供任意长度元组的拆分方法，如果需要支持三元及以上的元组，要么针对常用元组长度分别实现辅助函数，比如三元组的拆分：

fn split_result_triple<T, U, V, E: Clone>(x: Result<(T, U, V), E>) -> (Result<T, E>, Result<U, E>, Result<V, E>) {
    match x {
        Ok((a, b, c)) => (Ok(a), Ok(b), Ok(c)),
        Err(e) => (Err(e.clone()), Err(e.clone()), Err(e)),
    }
}

要么借助第三方crate来实现，但如果不想引入额外依赖，针对常用元组长度手动实现是更务实的选择。

内容的提问来源于stack exchange，提问作者Michał Trybus