Rust泛型2D向量适配数值类型的标准库实现方案问询

在学习Rust泛型实现时，我构建了一个表示2D向量的泛型结构体：

pub struct Vector<T> {
  x: T,
  y: T,
}

随后为其实现了new、zero、unit方法，并指定约束T: Default + From<u8>：

impl<T: Default + From<u8>> Vector<T> {
  pub fn new(x: T, y: T) -> Self {
    Self { x, y }
  }

  pub fn zero() -> Self {
    Self { x: T::default(), y: T::default() }
  }

  pub fn unit() -> Self {
    Self { x: T::from(1), y: T::from(1) }
  }
}

使用u8类型时代码正常运行，但切换为i8类型后出现编译错误：trait bound i8: From<u8> was not satisfied。

我希望仅通过标准库解决该问题，不引入num crate的FromPrimitive trait。尝试为i8实现From<u8> trait：

impl From<u8> for i8 {
    fn from(value: u8) -> Self {
        value as Self
    }
}

但触发错误E0117：仅当前 crate 定义的 trait 可用于原生类型实现。用宏实现也得到同样错误。目前仅能通过创建新类型解决，请问是否有其他方案？

方案一：替换为From<i8>约束 #

标准库为i8、u8、i32等绝大多数数值类型都实现了From<i8>（1i8在所有这些类型的有效范围内），只需将impl块的约束从From<u8>改为From<i8>即可：

impl<T: Default + From<i8>> Vector<T> {
  pub fn new(x: T, y: T) -> Self {
    Self { x, y }
  }

  pub fn zero() -> Self {
    Self { x: T::default(), y: T::default() }
  }

  pub fn unit() -> Self {
    Self { x: T::from(1i8), y: T::from(1i8) }
  }
}

这样i8、u8等类型都能满足约束，正常调用unit方法。

方案二：自定义One trait #

如果需要更灵活的扩展能力，可以自定义一个用于生成“1”值的trait，然后为需要的原生类型实现它：

// 自定义trait，定义生成1的方法
pub trait One {
    fn one() -> Self;
}

// 为常用数值类型实现One
impl One for u8 {
    fn one() -> Self { 1 }
}

impl One for i8 {
    fn one() -> Self { 1 }
}

impl One for i32 {
    fn one() -> Self { 1 }
}

impl One for f32 {
    fn one() -> Self { 1.0 }
}

// 修改Vector的实现约束
impl<T: Default + One> Vector<T> {
  pub fn new(x: T, y: T) -> Self {
    Self { x, y }
  }

  pub fn zero() -> Self {
    Self { x: T::default(), y: T::default() }
  }

  pub fn unit() -> Self {
    Self { x: T::one(), y: T::one() }
  }
}

这种方式完全基于标准库，且可以根据需求轻松扩展到其他类型（比如浮点数）。

方案三：使用Into trait约束 #

通过约束i8: Into<T>，让1i8可以转换为目标类型T，同样能实现需求：

impl<T: Default> Vector<T>
where
    i8: Into<T>,
{
  pub fn new(x: T, y: T) -> Self {
    Self { x, y }
  }

  pub fn zero() -> Self {
    Self { x: T::default(), y: T::default() }
  }

  pub fn unit() -> Self {
    Self { x: 1i8.into(), y: 1i8.into() }
  }
}

该方案的约束更精准，仅要求i8能转换为T，适合仅需生成单位向量的场景。

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