如何在Rust中实现带维度的标量算术运算？

编译时维度检查（推荐方案） #

Rust虽无原生依赖类型，但可通过类型级编程模拟实现编译期维度校验，核心思路是用泛型参数编码单位指数：

• 定义零大小的基础单位标记类型，比如Meter、Kelvin
• 用泛型结构体Dimensioned<V, M, K>，其中V为数值类型，M、K分别代表米、开尔文的类型级指数（借助typenum库实现）
• 为Dimensioned实现std::ops下的运算符 trait：
  • 乘法/除法时，泛型指数做类型级加减，生成新维度的类型
  • 加法/减法时，强制要求两个操作数的泛型指数完全一致，否则直接编译报错

核心示例代码：

use std::ops::{Add, Mul, Div};
use typenum::{Integer, P1, P0, Neg};

// 基础单位标记类型（零大小，仅用于类型区分）
struct Meter;
struct Kelvin;

// 维度标量结构体
#[derive(Debug)]
struct Dimensioned<V, M, K> {
    value: V,
    _unit: (M, K), // 标记类型，无运行时开销
}

// 为数值类型实现meters()方法
trait MeterExt {
    fn meters(self) -> Dimensioned<Self, P1, P0>;
}

impl<V: Copy> MeterExt for V {
    fn meters(self) -> Dimensioned<Self, P1, P0> {
        Dimensioned {
            value: self,
            _unit: (P1, P0),
        }
    }
}

// 为数值类型实现kelvins()方法
trait KelvinExt {
    fn kelvins(self) -> Dimensioned<Self, P0, P1>;
}

impl<V: Copy> KelvinExt for V {
    fn kelvins(self) -> Dimensioned<Self, P0, P1> {
        Dimensioned {
            value: self,
            _unit: (P0, P1),
        }
    }
}

// 乘法实现：指数类型级相加
impl<V: Mul<Output = V>, M1, M2, K1, K2> Mul for Dimensioned<V, M1, K1>
where
    M1: Integer + std::ops::Add<M2>,
    K1: Integer + std::ops::Add<K2>,
{
    type Output = Dimensioned<V, <M1 as std::ops::Add<M2>>::Output, <K1 as std::ops::Add<K2>>::Output>;

    fn mul(self, rhs: Dimensioned<V, M2, K2>) -> Self::Output {
        Dimensioned {
            value: self.value * rhs.value,
            _unit: (M1::add(M1::default(), M2::default()), K1::add(K1::default(), K2::default())),
        }
    }
}

// 除法实现：指数类型级相减
impl<V: Div<Output = V>, M1, M2, K1, K2> Div for Dimensioned<V, M1, K1>
where
    M1: Integer + std::ops::Sub<M2>,
    K1: Integer + std::ops::Sub<K2>,
{
    type Output = Dimensioned<V, <M1 as std::ops::Sub<M2>>::Output, <K1 as std::ops::Sub<K2>>::Output>;

    fn div(self, rhs: Dimensioned<V, M2, K2>) -> Self::Output {
        Dimensioned {
            value: self.value / rhs.value,
            _unit: (M1::sub(M1::default(), M2::default()), K1::sub(K1::default(), K2::default())),
        }
    }
}

// 加法实现：仅维度完全相同时允许
impl<V: Add<Output = V>, M, K> Add for Dimensioned<V, M, K> {
    type Output = Dimensioned<V, M, K>;

    fn add(self, rhs: Dimensioned<V, M, K>) -> Self::Output {
        Dimensioned {
            value: self.value + rhs.value,
            _unit: self._unit,
        }
    }
}

fn main() {
    let length1 = 3.meters();
    let length2 = 4.meters();
    let area = length1 * length2;
    println!("{:?}", area); // 对应平方米维度

    let temperature = 243.kelvins();
    let dilation_rate = 3.2.meters() * 1.meters() * 1.meters() / 1.kelvins();
    // let non_sensical = temperature + dilation_rate; // 编译直接报错：类型不匹配
}

该方案完全符合你的语法期望，编译期拦截维度错误，无运行时开销，typenum是Rust类型级编程的常用工具，生态成熟。

运行时维度检查优化方案 #

若暂时不想用类型级编程，可优化运行时方案：

• 实现Add/Sub trait时，在方法内检查维度，不匹配时触发带清晰提示的panic
• 额外提供try_add/try_sub方法返回Result，兼顾原生语法和安全场景

示例代码片段：

#[derive(Debug, PartialEq, Clone)]
struct Unit {
    meter: i32,
    kelvin: i32,
}

#[derive(Debug, Clone)]
struct DimensionedScalar {
    value: f64,
    unit: Unit,
}

impl std::ops::Add for DimensionedScalar {
    type Output = Self;

    fn add(self, rhs: Self) -> Self::Output {
        assert_eq!(self.unit, rhs.unit, "维度不匹配：无法将 {:?} 与 {:?} 相加", self.unit, rhs.unit);
        DimensionedScalar {
            value: self.value + rhs.value,
            unit: self.unit,
        }
    }
}

impl DimensionedScalar {
    pub fn try_add(self, rhs: Self) -> Result<Self, &'static str> {
        if self.unit != rhs.unit {
            Err("维度不匹配，无法执行加法")
        } else {
            Ok(DimensionedScalar {
                value: self.value + rhs.value,
                unit: self.unit,
            })
        }
    }
}

这种方案实现简单，适合快速原型，但牺牲了编译期安全性。

折中方案：宏辅助编译时检查 #

若觉得类型级编程过于复杂，可通过宏封装维度校验逻辑，在编译期验证维度，但灵活性远不如泛型方案，语法糖也不如原生运算符自然，一般不推荐作为首选。

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