如何在Rust稳定版中实现类似std::array::try_from_fn的功能？

当然可以在稳定版中实现这个功能，下面提供几种不同的实现方案，适配不同的需求场景：

方案一：基于Vec的简单实现（易读性优先） #

这个实现利用Vec预先分配内存，逻辑简单易懂，适合大多数日常场景：

pub fn try_from_fn<T, E, const N: usize>(mut f: impl FnMut(usize) -> Result<T, E>) -> Result<[T; N], E> {
    let mut elements = Vec::with_capacity(N);
    for idx in 0..N {
        elements.push(f(idx)?);
    }
    // 因预先分配了N的容量且循环执行N次，此处unwrap绝对安全
    Ok(elements.try_into().unwrap())
}

使用示例 #

fn main() -> Result<(), &'static str> {
    // 创建长度为5的数组，索引为2时返回错误
    let result: Result<[u32; 5], _> = try_from_fn(|idx| {
        if idx == 2 {
            Err("错误：索引2触发异常")
        } else {
            Ok(idx as u32 + 1)
        }
    });

    match result {
        Ok(arr) => println!("创建成功：{:?}", arr),
        Err(msg) => println!("创建失败：{}", msg),
    }

    Ok(())
}

方案二：基于MaybeUninit的高效实现（性能优先） #

这个版本更接近标准库try_from_fn的底层实现，避免了Vec的额外分配，性能最优，同时封装了unsafe逻辑保证安全：

use std::mem::{self, MaybeUninit};
use std::ptr;

pub fn try_from_fn<T, E, const N: usize>(mut f: impl FnMut(usize) -> Result<T, E>) -> Result<[T; N], E> {
    // 初始化未初始化的数组容器
    let mut arr: [MaybeUninit<T>; N] = MaybeUninit::uninit_array();
    let mut initialized_count = 0;

    // 尝试初始化所有元素
    let init_result = (|| {
        for idx in 0..N {
            let value = f(idx)?;
            arr[idx].write(value);
            initialized_count += 1;
        }
        Ok(())
    })();

    match init_result {
        Ok(()) => {
            // 所有元素初始化完成，安全转换为[T; N]
            Ok(unsafe { mem::transmute_copy(&arr) })
        }
        Err(e) => {
            // 清理已初始化的元素，避免内存泄漏
            for idx in 0..initialized_count {
                unsafe { ptr::drop_in_place(arr[idx].as_mut_ptr()); }
            }
            Err(e)
        }
    }
}

扩展：基于迭代器的可失败数组创建 #

如果需要从产生Result的迭代器创建数组，也可以实现对应的工具函数：

pub fn try_from_iter<T, E, const N: usize>(iter: impl IntoIterator<Item = Result<T, E>>) -> Result<[T; N], E> {
    let mut elements = Vec::with_capacity(N);
    for res in iter {
        elements.push(res?);
        if elements.len() > N {
            return Err("迭代器产生的元素数量超过数组长度".into());
        }
    }
    if elements.len() < N {
        return Err("迭代器产生的元素数量不足数组长度".into());
    }
    Ok(elements.try_into().unwrap())
}

使用示例 #

fn main() -> Result<(), String> {
    let iter = (0..5).map(|idx| {
        if idx == 3 {
            Err("索引3触发错误".to_string())
        } else {
            Ok(idx * 2)
        }
    });

    let result: Result<[i32; 5], _> = try_from_iter(iter);
    // 处理结果...
    Ok(())
}

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