如何在Rust中将[Option<T>; N]转为Option<[T; N]>并保留编译期长度保证？

方法一：使用标准库 TryInto trait（Rust 1.64+） #

从Rust 1.64版本开始，数组的TryInto原生实现支持这种转换，全程无unwrap，编译期自动保证长度一致性：

fn main() {
    let valid_array: [Option<i32>; 3] = [Some(1), Some(2), Some(3)];
    let invalid_array: [Option<i32>; 3] = [Some(1), None, Some(3)];

    let result1: Option<[i32; 3]> = valid_array.try_into().ok();
    let result2: Option<[i32; 3]> = invalid_array.try_into().ok();

    assert_eq!(result1, Some([1, 2, 3]));
    assert_eq!(result2, None);
}

try_into()会尝试将[Option<T>; N]转为[T; N]，遇到None则返回Err，我们通过.ok()将其转为Option类型，全程安全且无运行时长度风险。

方法二：手动实现（兼容旧版Rust） #

如果你的Rust版本低于1.64，可以通过以下两种安全方式实现：

方式A：模式匹配（适合固定小长度数组） #

针对长度固定且较小的数组，直接用模式匹配，编译期即可确保长度一致：

fn option_array_to_array_option<T>(arr: [Option<T>; 3]) -> Option<[T; 3]> {
    match arr {
        [Some(a), Some(b), Some(c)] => Some([a, b, c]),
        _ => None,
    }
}

这种方式完全无unsafe操作，但仅适用于固定长度的场景，数组长度变更时需要修改代码。

方式B：泛型安全封装（支持任意长度） #

通过先检查所有元素状态，再用unsafe的unwrap_unchecked做零成本转换（逻辑上已确保所有元素为Some，因此操作安全）：

fn option_array_to_array_option<T, const N: usize>(arr: [Option<T>; N]) -> Option<[T; N]> {
    if arr.iter().all(|opt| opt.is_some()) {
        // 已确认所有元素都是Some，unwrap_unchecked操作安全
        let converted = unsafe { arr.map(|opt| opt.unwrap_unchecked()) };
        Some(converted)
    } else {
        None
    }
}

对外暴露的是完全安全的接口，编译期保留数组长度N的约束，无unwrap风险。

方法三：宏生成匹配代码（编译期全安全） #

如果需要对任意长度数组都做编译期检查，可以用宏自动生成对应长度的模式匹配代码：

macro_rules! unwrap_option_array {
    ($($elem:expr),* $(,)?) => {
        match [$($elem),*] {
            [$($std::option::Option::Some(inner)),*] => Some([$inner, *]),
            _ => None,
        }
    };
}

// 使用示例
fn main() {
    let arr = [Some(1), Some(2), Some(3)];
    let result = unwrap_option_array!(arr[0], arr[1], arr[2]);
    assert_eq!(result, Some([1, 2, 3]));
}

宏会根据传入的元素数量生成对应长度的匹配逻辑，全程编译期安全，无运行时开销。

内容的提问来源于stack exchange，提问作者Ari Fordsham