如何为Rust泛型VecN结构体创建编译时常量轴向量？

我们有一个用于线性代数的简易向量结构体：

pub struct VecN<T, const N: usize>
{
    v: [T; N],
}

需求是创建编译时常量的标准轴向量，但最初的尝试因From和Default trait无法在编译期求值而失败：

impl<T> VecN<T, 3> where T: From<f32> + Default
{
    const AXES: [VecN<T, 3>; 3] = [VecN::new([T::from(1.0), T::default(), T::default()]),
                                   VecN::new([T::default(), T::from(1.0), T::default()]),
                                   VecN::new([T::default(), T::default(), T::from(1.0)])];
}

目前的临时方案是为每个类型单独实现，冗余性极强，即便用宏缓解也无法覆盖所有特殊类型。以下是几种更通用的实现方式：

1. 自定义编译期安全的数值 trait #

定义一个能在编译期提供单位值和零值的 trait，替代依赖运行时的From和Default：

pub trait ConstNum {
    const ONE: Self;
    const ZERO: Self;
}

// 为基础数值类型实现该 trait
impl ConstNum for f32 {
    const ONE: Self = 1.0;
    const ZERO: Self = 0.0;
}

impl ConstNum for f64 {
    const ONE: Self = 1.0;
    const ZERO: Self = 0.0;
}

impl ConstNum for i32 {
    const ONE: Self = 1;
    const ZERO: Self = 0;
}

// 可按需扩展到u32、i64等其他类型

基于这个 trait 实现通用的轴向量生成逻辑：

impl<T, const N: usize> VecN<T, N>
where
    T: ConstNum + Copy,
{
    // 编译期生成指定索引的轴向量
    const fn axis(index: usize) -> Self {
        let mut arr = [T::ZERO; N];
        let mut i = 0;
        // Rust 1.59+支持编译期while循环
        while i < N {
            arr[i] = if i == index { T::ONE } else { T::ZERO };
            i += 1;
        }
        VecN { v: arr }
    }
}

// 针对3维向量预定义轴向量数组
impl<T> VecN<T, 3>
where
    T: ConstNum + Copy,
{
    pub const AXES: [Self; 3] = [
        Self::axis(0),
        Self::axis(1),
        Self::axis(2),
    ];
}

只要为目标类型实现ConstNum，就能直接使用通用的AXES常量，无需重复编写初始化代码。

2. 用宏批量生成类型实现 #

如果不想自定义 trait，可以通过宏自动为指定类型生成轴向量常量，支持任意维度：

macro_rules! impl_axis_vectors {
    ($($ty:ty),*) => {
        $(
            impl<const N: usize> VecN<$ty, N> {
                // 编译期生成单个轴向量
                const fn axis(index: usize) -> Self {
                    let mut arr = [<$ty>::default(); N];
                    let mut i = 0;
                    while i < N {
                        arr[i] = if i == index { 1 as $ty } else { 0 as $ty };
                        i += 1;
                    }
                    VecN { v: arr }
                }
            }

            // 3维轴向量数组
            impl VecN<$ty, 3> {
                pub const AXES: [Self; 3] = [
                    Self::axis(0),
                    Self::axis(1),
                    Self::axis(2),
                ];
            }

            // 可按需添加2维、4维等其他维度的实现
            impl VecN<$ty, 2> {
                pub const AXES: [Self; 2] = [
                    Self::axis(0),
                    Self::axis(1),
                ];
            }
        )*
    };
}

// 为需要的类型批量生成实现
impl_axis_vectors!(f32, f64, i32, u32);

这个宏可以一次性为多个类型生成不同维度的轴向量常量，大幅减少重复代码，且能灵活添加新类型。

3. 利用 Rust 1.61+ 的 const trait 支持 #

从 Rust 1.61 开始，Default和部分From实现支持const fn。如果目标类型的Default和From<f32>是编译期安全的，可以调整最初的实现：

impl<T> VecN<T, 3>
where
    T: Default + From<f32>,
    // 约束Default和From<f32>的方法是const fn
    <T as Default>::Default: ~const,
    <T as From<f32>>::from: ~const fn(f32) -> T,
{
    pub const AXES: [VecN<T, 3>; 3] = [
        VecN { v: [T::from(1.0), T::default(), T::default()] },
        VecN { v: [T::default(), T::from(1.0), T::default()] },
        VecN { v: [T::default(), T::default(), T::from(1.0)] },
    ];
}

这种方式依赖类型本身的const trait实现，兼容性不如自定义trait方案，但对于f32、f64等标准库类型已经适用。

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