Rust中newtype模式类型的数组处理与类型转换的惯用方法

针对你遇到的两个痛点，Rust里有几种惯用处理方式：

1. 简化批量创建Height实例的代码 #

方式一：为Vec<f32>实现TryInto<Vec<Height>> #

通过实现TryInto trait，可以直接将普通f32数组/向量转换为Result<Vec<Height>, _>，避免重复调用try_from：

impl TryInto<Vec<Height>> for Vec<f32> {
    type Error = &'static str;

    fn try_into(self) -> Result<Vec<Height>, Self::Error> {
        self.into_iter()
            .map(Height::try_from)
            .collect()
    }
}

使用示例：

// 直接从f32向量转换，自动批量验证
let heights = vec![3., 2.].try_into().unwrap();

方式二：实现FromIterator支持迭代器收集 #

如果需要从任意f32迭代器创建Vec<Height>，可以为Result<Vec<Height>, _>实现FromIterator：

impl FromIterator<f32> for Result<Vec<Height>, &'static str> {
    fn from_iter<I: IntoIterator<Item = f32>>(iter: I) -> Self {
        iter.into_iter()
            .map(Height::try_from)
            .collect()
    }
}

使用示例：

// 从数组迭代器收集，批量验证后得到Result
let heights = [3., 2.].into_iter().collect::<Result<Vec<Height>, _>>().unwrap();

方式三：自定义宏快速创建 #

如果场景固定且信任输入值，可以写一个宏简化调用：

macro_rules! heights {
    ($($val:expr),* $(,)?) => {
        vec![$(Height::try_from($val).unwrap()),*]
    };
}

// 需要错误处理的版本
macro_rules! try_heights {
    ($($val:expr),* $(,)?) => {
        Ok(vec![$(Height::try_from($val)?),*])
    };
}

使用示例：

let heights = heights![3., 2.];
// 带错误处理的版本
let heights = try_heights![3., 2.].unwrap();

2. 简化向&[f32]的转换 #

方式一：实现AsRef<[f32]> trait #

利用Rust的内存布局保证（newtype结构体的内存布局与内部类型一致），可以安全地将&[Height]转换为&[f32]：

impl AsRef<[f32]> for [Height] {
    fn as_ref(&self) -> &[f32] {
        unsafe {
            std::slice::from_raw_parts(
                self.as_ptr() as *const f32,
                self.len()
            )
        }
    }
}

// 为Vec<Height>也实现AsRef<[f32]>，方便直接调用
impl AsRef<[f32]> for Vec<Height> {
    fn as_ref(&self) -> &[f32] {
        (&**self).as_ref()
    }
}

使用示例：

fn accept_f32_slice(slice: &[f32]) {
    // 处理逻辑
}

let heights = vec![3., 2.].try_into().unwrap();
// 直接传递转换后的slice
accept_f32_slice(heights.as_ref());

方式二：实现Deref trait（谨慎使用） #

如果希望Height能隐式解引用为f32，可以实现Deref，但这会降低封装性，仅适合不需要严格限制f32访问的场景：

use std::ops::Deref;

impl Deref for Height {
    type Target = f32;

    fn deref(&self) -> &Self::Target {
        &self.0
    }
}

此时可以通过迭代器转换为&[&f32]，再用std::slice::from_refs转成&[f32]：

let heights = vec![Height(3.), Height(2.)];
let f32_slice = std::slice::from_refs(&heights);
accept_f32_slice(f32_slice);

额外优化：完善错误信息 #

你当前的try_from错误信息不准确（比如负值或超过3.时也返回"value was infinite"），建议优化为更具体的错误：

enum HeightError {
    Infinite,
    Negative,
    ExceedsMax(f32),
}

impl std::fmt::Display for HeightError {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        match self {
            HeightError::Infinite => write!(f, "value is infinite"),
            HeightError::Negative => write!(f, "value is negative"),
            HeightError::ExceedsMax(max) => write!(f, "value exceeds maximum of {}", max),
        }
    }
}

impl std::error::Error for HeightError {}

impl TryFrom<f32> for Height {
    type Error = HeightError;

    fn try_from(value: f32) -> Result<Self, Self::Error> {
        if value.is_infinite() {
            Err(HeightError::Infinite)
        } else if value.is_sign_negative() {
            Err(HeightError::Negative)
        } else if value > 3. {
            Err(HeightError::ExceedsMax(3.))
        } else {
            Ok(Height(value))
        }
    }
}

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