Rust 我怎样才能要求对泛型类型的引用可以与泛型类型进行相等性比较？

我正在尝试实现一个依赖于模幂运算的算法。我找不到任何适用于本机类型（如

u64

）的模幂构造（仅适用于bigint），因此我想我应该编写一个标准

以下是我的想法：

fn powm(base: &u64, exponent: &u64, modulus: &u64) -> u64 {
    if *modulus == 1u64 {
        0
    } else {
        let mut result = 1;
        let mut base = self % modulus;
        let mut exp = *exponent;
        while exp > 0 {
            if exp % 2 == 1 {
                result = (result * base) % modulus;
            }
            exp >>= 1;
            base = (base * base) % modulus;
        }
        result
    }
}

这个很好用。现在，我想将此函数设置为通用函数，以便它也适用于除

u64

之外的数值类型。这就是我开始迷路的地方

我找到了板条箱，它有一个指定基本数值操作的

Num

特性。在分离出一个新的

PowM

trait并创建一组trait边界后，我最终得到：

extern crate num;

use num::Num;
use std::ops::{ShrAssign,Rem};

pub trait PowM {
    fn powm(&self, exponent: &Self, modulus: &Self) -> Self;
}

pub trait Two {
    fn two() -> Self;
}

impl Two for u64 {
    fn two() -> u64 { return 2u64 }
}

impl Two for usize {
    fn two() -> usize { return 2usize }
}

impl<T> PowM for T 
    where T: Num + Two + ShrAssign<T> + Rem<T> + PartialOrd<T> {
    fn powm(&self, exponent: &T, modulus: &T) -> T {
        if modulus == T::one() {
            T::zero()
        } else {
            let mut result = T::one();
            let mut base = *self % *modulus;
            let mut exp = *exponent;
            while exp > T::zero() {
                if exp % T::two() == T::one() {
                    result = (result * base) % *modulus;
                }
                exp >>= T::one();
                base = (base * base) % *modulus;
            }
            result
        }
    }
}

extern板条箱数量；
使用num：：num；
使用std:：ops:：{shrsassign，Rem}；
公共权力{
fn功率（&self，指数：&self，模数：&self）->self；
}
酒吧特征二{
fn-two（）->Self；
}
u64的impl 2{
fn two（）->u64{return 2u64}
}
使用两个{
fn two（）->usize{return 2usize}
}
T的impl-PowM
其中T:Num+Two+shrsign+Rem+PartialOrd{
fn功率（&self，指数：&T，模量：&T）->T{
如果模数==T:：one（）{
T：：零（）
}否则{
让mut result=T:：one（）；
设mut base=*self%*模数；
设mut exp=*指数；
而exp>T:：zero（）{
如果exp%T:：two（）==T:：one（）{
结果=（结果*基础）%*模数；
}
exp>>=T:：one（）；
基底=（基底*基底）%*模量；
}
结果
}
}
}

编译器给出的唯一抱怨如下

error[E0277]：未满足特性绑定“%T:std:：cmp:：PartialEq”
|
30 |如果模数==T:：one（）{
|^^无法将“&t”与“t”进行比较`
|
=帮助：`&T未实现特性`std:：cmp:：PartialEq``
=帮助：考虑添加一个“WH&T：STD:：CMP::Pultaleq”绑定

我试图添加trait边界，但最终发现了许多编译器错误，这些错误与我不完全理解的生命周期有关，并最终导致以下问题：

impl<'a, T> PowM for T 
    where T: 'a + Num + Two + ShrAssign<T> + Rem<T> + PartialOrd<T>,
          &'a T: PartialEq<T> {
    fn powm(&self, exponent: &T, modulus: &T) -> T {
        if modulus == T::one() {
[...]

---

impl您可以忽略该问题并将引用与引用或非引用与非引用进行比较：

if modulus == &T::one() {
// Or
if *modulus == T::one() {

或者您可以使用更高等级的特征界限：

T的impl功率
哪里
T:Num+Two+shrsign+Rem+PartialOrd，
对于
impl<T> PowM for T
where
    T: Num + Two + ShrAssign<T> + Rem<T> + PartialOrd<T>,
    for <'a> &'a T: PartialEq<T>,
{
    // ...
}