如何解决数组中newtype带来的Rust运行时开销问题

Rust官方宣称newtype模式不存在运行时开销，但我遇到了不符合这个说法的场景，代码如下：

pub struct MyInt(i32);

pub fn f(xs: [i32; 3]) -> i32 {
    xs[0]
}

pub fn g() -> i32 {
    let xs = [MyInt(1), MyInt(2), MyInt(3)];
    let myxs = xs.map(|x| x.0);
    f(myxs)
}

由于API函数f接收[i32;3]类型数组，我必须把MyInt数组通过map转换为i32数组才能调用它，这会创建新数组，存在运行时开销。我是不是遗漏了什么？这属于newtype模式的误用吗？

编辑补充 #

看了评论后我意识到问题更多出在数组而非newtype本身，尝试了基于slice和vector的方案：

Slice版本（需unsafe）

pub struct MyInt(i32);

pub fn f(xs: &[i32]) -> i32 { xs[0] }

pub fn g() -> i32 {
    let xs = [MyInt(1), MyInt(2), MyInt(3)].as_slice();
    let myxs: &[i32] = unsafe { std::mem::transmute(xs) };
    f(myxs)
}

Vector版本（仍需创建新向量）

pub struct MyInt(i32);

pub fn f(xs: Vec<i32>) -> i32 { xs[0] }

pub fn g() -> i32 {
    let xs = vec![MyInt(1), MyInt(2), MyInt(3)];
    let myxs: Vec<i32> = xs.into_iter().map(|MyInt(x)| x).collect();
    f(myxs)
}

但数组版本必须用unsafe的transmute，vector版本还是要创建新向量，有没有更优的解决方法？

解决方法 #

1. 为Newtype数组实现AsRef<[i32]>（安全可控的零开销）

利用newtype与底层类型内存布局一致的特性，通过安全封装的unsafe代码实现无开销转换：

pub struct MyInt(i32);

impl AsRef<[i32]> for [MyInt; 3] {
    fn as_ref(&self) -> &[i32] {
        // 因MyInt仅包含i32，内存布局完全匹配，此unsafe操作安全
        unsafe { std::slice::from_raw_parts(self.as_ptr() as *const i32, self.len()) }
    }
}

pub fn f(xs: &[i32]) -> i32 { xs[0] }

pub fn g() -> i32 {
    let xs = [MyInt(1), MyInt(2), MyInt(3)];
    f(xs.as_ref()) // 直接转换，无运行时开销
}

2. 泛化API函数f（根源解决，优先选择）

如果有权限修改f的定义，直接通过泛型让它兼容newtype类型，彻底避免转换：

pub struct MyInt(i32);

// 方案A：支持所有可转为&[i32]的类型
pub fn f<T: AsRef<[i32]>>(xs: T) -> i32 {
    xs.as_ref()[0]
}

// 方案B：针对实现Deref到i32的类型
pub fn f<T>(xs: [T; 3]) -> i32
where
    T: std::ops::Deref<Target = i32>,
{
    *xs[0]
}

impl std::ops::Deref for MyInt {
    type Target = i32;
    fn deref(&self) -> &Self::Target {
        &self.0
    }
}

pub fn g() -> i32 {
    let xs = [MyInt(1), MyInt(2), MyInt(3)];
    f(xs) // 直接调用，无任何转换开销
}

3. Vector的零开销转换（unsafe但可控）

如果必须使用Vec<MyInt>转Vec<i32>，可利用Vec的内存布局特性直接转换，避免重新分配：

pub struct MyInt(i32);

pub fn f(xs: Vec<i32>) -> i32 { xs[0] }

pub fn g() -> i32 {
    let xs = vec![MyInt(1), MyInt(2), MyInt(3)];
    let myxs: Vec<i32> = unsafe {
        let ptr = xs.as_ptr() as *mut i32;
        let len = xs.len();
        let cap = xs.capacity();
        std::mem::forget(xs); // 阻止原Vec执行drop逻辑
        Vec::from_raw_parts(ptr, len, cap)
    };
    f(myxs)
}

注意：此方法仅在MyInt无自定义Drop实现、且与i32内存布局完全一致时安全。

关于newtype模式的说明 #

newtype本身确实是零开销的——单个MyInt实例和i32在内存中完全等价，无额外存储或计算开销。你遇到的问题是容器类型的批量转换限制，而非newtype本身的设计问题，因此不算误用，只需结合Rust类型系统的特性优化转换逻辑即可。

内容的提问来源于stack exchange，提问作者Yu-zh