如何在Rust中创建通用N维向量？现有实现遇阻求最优解

问题背景 #

想要在Rust中实现通用N维向量，尝试用类似C++模板的写法但编译失败，代码如下：

struct Vec<N,T> where N: u32{
    dim: N,
    data: T
}
pub type Vec2<T> = Vec<2,T>;
pub type Vec3<T> = Vec<3,T>; 

编译报错：

error[E0404]: expected trait, found builtin type `u32`
 --> main.rs:1:26
  |
1 | struct Vec<N,T> where N: u32{
  |                          ^^^ not a trait
error[E0747]: constant provided when a type was expected
 --> main.rs:5:24
  |
5 | pub type Vec2<T> = Vec<2,T>;
  |   

不想直接用数组别名（如pub type Vec2<T> = [T;2]），因为需要为每个维度编写重复方法（如vec2_add、vec3_cross），希望用单一add、dot、cross方法适配所有维度。

通用实现方案 #

Rust泛型仅支持类型作为参数，无法直接传入数值，需要用类型级常量实现维度的编译期约束，推荐结合typenum和generic-array库实现通用逻辑。

1. 添加依赖 #

在Cargo.toml中加入：

[dependencies]
typenum = "1.17.0"
generic-array = "0.14.7"

2. 定义通用向量结构体 #

用GenericArray存储编译期固定长度的数组，结合typenum的类型级数字标记维度：

use generic_array::GenericArray;
use typenum::Unsigned;

#[derive(Debug, Clone, Copy)]
struct VecN<N, T>
where
    N: Unsigned,
    T: Copy + Clone + Default,
{
    data: GenericArray<T, N>,
}

// 定义常用维度的类型别名
pub type Vec2<T> = VecN<typenum::U2, T>;
pub type Vec3<T> = VecN<typenum::U3, T>;

3. 实现通用加法 #

为VecN实现std::ops::Add，让所有维度的向量都能直接用+运算符：

use std::ops::Add;

impl<N, T> Add for VecN<N, T>
where
    N: Unsigned,
    T: Copy + Clone + Default + Add<Output = T>,
{
    type Output = Self;

    fn add(self, rhs: Self) -> Self::Output {
        let data = self.data.iter()
            .zip(rhs.data.iter())
            .map(|(a, b)| *a + *b)
            .collect::<GenericArray<T, N>>();
        VecN { data }
    }
}

4. 实现通用点积 #

定义trait Dot并为所有维度的VecN实现：

pub trait Dot<T> {
    fn dot(&self, rhs: &Self) -> T;
}

impl<N, T> Dot<T> for VecN<N, T>
where
    N: Unsigned,
    T: Copy + Clone + Default + Add<Output = T> + std::ops::Mul<Output = T>,
{
    fn dot(&self, rhs: &Self) -> T {
        self.data.iter()
            .zip(rhs.data.iter())
            .map(|(a, b)| *a * *b)
            .fold(T::default(), |acc, val| acc + val)
    }
}

5. 适配3维专属叉积 #

叉积仅对3维向量有意义，直接为Vec3<T>实现专属方法：

impl<T> Vec3<T>
where
    T: Copy + Clone + Default + std::ops::Sub<Output = T> + std::ops::Mul<Output = T>,
{
    pub fn cross(&self, rhs: &Self) -> Self {
        let x = self.data[1] * rhs.data[2] - self.data[2] * rhs.data[1];
        let y = self.data[2] * rhs.data[0] - self.data[0] * rhs.data[2];
        let z = self.data[0] * rhs.data[1] - self.data[1] * rhs.data[0];
        Vec3 {
            data: GenericArray::from([x, y, z]),
        }
    }
}

6. 使用示例 #

fn main() {
    let v2a = Vec2 { data: GenericArray::from([1, 2]) };
    let v2b = Vec2 { data: GenericArray::from([3, 4]) };
    println!("Vec2 加法结果: {:?}", v2a + v2b);
    println!("Vec2 点积结果: {}", v2a.dot(&v2b));

    let v3a = Vec3 { data: GenericArray::from([1, 2, 3]) };
    let v3b = Vec3 { data: GenericArray::from([4, 5, 6]) };
    println!("Vec3 加法结果: {:?}", v3a + v3b);
    println!("Vec3 点积结果: {}", v3a.dot(&v3b));
    println!("Vec3 叉积结果: {:?}", v3a.cross(&v3b));
}

核心逻辑说明 #

• 用typenum将数值转换为类型（如U2代表维度2），适配Rust泛型仅接受类型参数的规则
• GenericArray兼顾数组的性能和泛型传递的灵活性，确保编译期维度检查
• 通过trait约束实现通用方法，针对特定维度（如3维）实现专属逻辑，避免重复代码

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