一、源码
这段代码定义了一个泛型结构体 Var，用于封装数值类型并提供各种运算操作。
/*
* 变量结构体 Var
* 该结构体泛型参数 T 需满足 Numeric 约束
*/
use core::ops::{Neg, Add, Sub, Mul, Div, AddAssign, SubAssign, MulAssign};
use crate::constant::Integer;
/// 定义 Numeric trait，约束 T 必须实现基本数值运算
/// 包括：
/// - 一元负号运算 (Neg)
/// - 加减乘除运算 (Add, Sub, Mul, Div)
/// - 复合赋值运算 (AddAssign, SubAssign)
/// - 从i32转换 (From<i32>)
/// - 复制语义 (Copy, Clone)
/// - 默认值 (Default)
/// - 静态生命周期 ('static)
pub trait Numeric:
Neg<Output = Self> +
Add<Output = Self> +
Sub<Output = Self> +
Mul<Output = Self> +
Div<Output = Self> +
AddAssign +
SubAssign +
From<i32> +
Copy +
Clone +
Default +
Sized +
'static
{}
// 为基本类型实现 Numeric trait
impl Numeric for i64 {} // i64 类型实现 Numeric
impl Numeric for f64 {} // f64 类型实现 Numeric
/// 定义 Scalar trait，用于物理量取值
/// 在 Numeric 基础上增加了 MulAssign 约束
pub trait Scalar:
Neg<Output = Self> +
Add<Output = Self> +
Sub<Output = Self> +
Mul<Output = Self> +
Div<Output = Self> +
AddAssign +
SubAssign +
MulAssign +
From<i32> +
Copy +
Clone +
Default +
Sized +
'static
{}
// 为 Var 类型实现 Scalar trait
impl Scalar for Var<i64> {} // Var<i64> 实现 Scalar
impl Scalar for Var<f64> {} // Var<f64> 实现 Scalar
/// 变量结构体，封装一个泛型值 T
/// T 需要满足 Numeric 约束
#[derive(Debug, Clone, Copy, PartialEq, Default)]
pub struct Var<T: Numeric>(pub T);
// 运算符重载实现
// =============================================
/// 实现 Var 的取反运算
/// 用法: -V
impl<T: Numeric> Neg for Var<T> {
type Output = Self;
fn neg(self) -> Self::Output {
Var(-self.0) // 对内部值取反后包装为新 Var
}
}
/// 实现 Var 与 Var 的加法运算
/// 用法: V + V
impl<T: Numeric> Add for Var<T> {
type Output = Self;
fn add(self, b: Self) -> Self::Output {
Var(self.0 + b.0) // 内部值相加后包装为新 Var
}
}
/// 实现 Var 与 Var 的减法运算
/// 用法: V - V
impl<T: Numeric> Sub for Var<T> {
type Output = Self;
fn sub(self, b: Self) -> Self::Output {
Var(self.0 - b.0) // 内部值相减后包装为新 Var
}
}
/// 实现 Var 与 Var 的乘法运算
/// 用法: V * V
impl<T: Numeric> Mul<Var<T>> for Var<T> {
type Output = Self;
fn mul(self, b: Self) -> Self::Output {
Var(self.0 * b.0) // 内部值相乘后包装为新 Var
}
}
/// 实现 Var 与 Var 的除法运算
/// 用法：V / V
impl<T: Numeric> Div<Var<T>> for Var<T> {
type Output = Self;
fn div(self, b: Self) -> Self::Output {
Var(self.0 / b.0) // 内部值相除后包装为新 Var
}
}
/// 实现 Var 的加法赋值运算
/// 用法: V += V
impl<T: Numeric> AddAssign for Var<T> {
fn add_assign(&mut self, rhs: Self) {
self.0 += rhs.0; // 直接转发到底层类型的 += 运算
}
}
/// 实现 Var 的减法赋值运算
/// 用法: V -= V
impl<T: Numeric> SubAssign for Var<T> {
fn sub_assign(&mut self, rhs: Self) {
self.0 -= rhs.0; // 直接转发到底层类型的 -= 运算
}
}
// 与常量运算实现
// =============================================
/// 实现 Var 与常量的乘法运算
/// 用法: V * C
impl<T: Numeric, C:Integer + Mul<Var<T>>> Mul<C> for Var<T> {
type Output = <C as Mul<Var<T>>>::Output;
fn mul(self, c: C) -> Self::Output {
c * self // 交换乘法顺序，调用常量的 * 运算符
}
}
/// 实现 Var 与常量的加法运算
/// 用法: V + C
impl<T: Numeric, C: Integer + Add<Var<T>>> Add<C> for Var<T> {
type Output = <C as Add<Var<T>>>::Output;
fn add(self, c:C) -> Self::Output {
c + self // 交换加法顺序，调用常量的 + 运算符
}
}
/// 实现 Var 与常量的减法运算
/// 用法: V - C
impl<T: Numeric, C: Integer + Neg> Sub<C> for Var<T>
where
<C as Neg>::Output: Add<Var<T>>,
{
type Output = < C::Output as Add<Var<T>> >::Output;
fn sub(self, c: C) -> Self::Output {
-c+self // 转换为 -c + V 的形式
}
}
// 类型转换实现
// =============================================
/// 实现从 i32 到 Var<i64> 的转换
impl From<i32> for Var<i64> {
fn from(value: i32) -> Self {
Var(value as i64) // 将 i32 转换为 i64 后包装
}
}
/// 实现从 i32 到 Var<f64> 的转换
impl From<i32> for Var<f64> {
fn from(value: i32) -> Self {
Var(value as f64) // 将 i32 转换为 f64 后包装
}
}
/// 实现从 i64 到 Var<i64> 的转换
impl From<i64> for Var<i64> {
fn from(value: i64) -> Self {
Var(value) // 直接包装 i64 值
}
}
/// 实现从 f64 到 Var<f64> 的转换
impl From<f64> for Var<f64> {
fn from(value: f64) -> Self {
Var(value) // 直接包装 f64 值
}
}
/// 实现 Var 的乘法赋值运算
/// 用法: V *= V
impl<T: Numeric + MulAssign> MulAssign for Var<T> {
fn mul_assign(&mut self, rhs: Self) {
self.0 *= rhs.0; // 直接转发到底层类型的 *= 运算
}
}
/// 实现 Var 与底层类型的乘法赋值运算
/// 用法: V *= T
impl<T: Numeric + MulAssign> MulAssign<T> for Var<T> {
fn mul_assign(&mut self, rhs: T) {
self.0 *= rhs; // 直接使用底层类型的 *= 运算
}
}
二、Trait 定义
Numeric Trait
pub trait Numeric:
Neg<Output = Self> + // 支持取反运算
Add<Output = Self> + // 支持加法
Sub<Output = Self> + // 支持减法
Mul<Output = Self> + // 支持乘法
Div<Output = Self> + // 支持除法
AddAssign + // 支持 += 操作
SubAssign + // 支持 -= 操作
From<i32> + // 可以从i32转换
Copy + // 可复制语义
Clone + // 可克隆
Default + // 有默认值
Sized + // 编译时大小已知
'static // 静态生命周期
{}
这个 trait 定义了数值类型需要满足的基本操作，为 i64 和 f64 实现了这个 trait。
Scalar Trait
pub trait Scalar:
// 包含 Numeric 的所有功能，并增加 MulAssign
// ...
{}
这个 trait 用于物理量取值，为 Var 和 Var 实现了这个 trait。
三、Var 结构体
#[derive(Debug, Clone, Copy, PartialEq, Default)]
pub struct Var<T: Numeric>(pub T);
这是一个泛型结构体，封装了一个数值类型 T，要求 T 必须实现 Numeric trait。它派生了一些常用 trait：
-
Debug: 支持调试打印
-
Clone, Copy: 可克隆和复制
-
PartialEq: 支持相等比较
-
Default: 有默认值
四、运算符重载
为 Var 实现了各种运算符：
一元运算
- 取反 (-v): 通过实现 Neg trait
二元运算 (Var 与 Var)
-
加法 (v1 + v2): 实现 Add
-
减法 (v1 - v2): 实现 Sub
-
乘法 (v1 * v2): 实现 Mul
-
除法 (v1 / v2): 实现 Div
复合赋值运算
-
+=: 实现 AddAssign
-
-=: 实现 SubAssign
-
*=: 实现 MulAssign (对 Var 和底层类型 T 都实现了)
与常量的运算
-
v * c: 实现 Var 与常量 C 的乘法
-
v + c: 实现 Var 与常量 C 的加法
-
v - c: 实现 Var 与常量 C 的减法 (通过转换为 -c + v)
五、类型转换
实现了多种 From trait，支持从不同数值类型创建 Var:
-
从 i32 创建 Var 或 Var
-
从 i64 创建 Var
-
从 f64 创建 Var
六、设计目的
这个 Var 结构体的主要目的是：
-
封装基本数值类型，为其添加额外的语义或功能
-
通过 trait 约束确保类型安全
-
提供丰富的运算符重载，使使用更直观
-
支持与常量的交互操作
这种设计常见于需要增强基本类型功能的场景，比如物理量计算、单位系统或代数运算库中。
