rust - 我应该如何在不重复代码的情况下为 &MyType 和 &mut MyType 实现 Into ？

Question

这是一个玩具示例:

#[derive(Debug)]
struct Int {
    v: i32,
}

#[derive(Debug)]
struct Double {
    v: f64,
}

impl Into<Double> for Int {
    fn into(self) -> Double {
        Double {
            v: f64::from(self.v),
        }
    }
}

这行得通，但我真的想实现 Into<Double>对于 &Int和 &mut Int .这不起作用:

impl<T> Into<Double> for T
where
    T: AsRef<Int>,
{
    fn into(self) -> Double {
        Double {
            v: f64::from(self.as_ref().v),
        }
    }
}

因为trait Into未在我的 crate 中定义:

error[E0119]: conflicting implementations of trait `std::convert::Into<Double>`:
  --> src/main.rs:19:1
   |
19 | / impl<T> Into<Double> for T
20 | | where
21 | |     T: AsRef<Int>,
22 | | {
...  |
27 | |     }
28 | | }
   | |_^
   |
   = note: conflicting implementation in crate `core`:
           - impl<T, U> std::convert::Into<U> for T
             where U: std::convert::From<T>;

error[E0210]: type parameter `T` must be used as the type parameter for some local type (e.g. `MyStruct<T>`); only traits defined in the current crate can be implemented for a type parameter
  --> src/main.rs:19:1
   |
19 | / impl<T> Into<Double> for T
20 | | where
21 | |     T: AsRef<Int>,
22 | | {
...  |
27 | |     }
28 | | }
   | |_^

我应该如何实现 Into<Double>对于 &Int和 &mut Int ,没有代码重复，例如:

impl<'a> Into<Double> for &'a Int {
impl<'a> Into<Double> for &'a mut Int {

Answer 1

您可以通过实现 From 来做您想做的事而不是它的 friend Into :

impl<T> From<T> for Double
where
    T: AsRef<Int>,
{
    fn from(i: T) -> Self {
        Double {
            v: f64::from(i.as_ref().v),
        }
    }
}

这样我们就可以避免为泛型参数(for T 部分)实现孤立规则不允许的特征。 From 和 Into 与 this awesome blanket impl 链接在一起:

impl<T, U> Into<U> for T 
where
    U: From<T>, 

---

然而，AsRef不是你在这里寻找的特征(我认为)。 Borrow可能更适合您的情况:

impl<T> From<T> for Double
where
    T: Borrow<Int>,
{
    fn from(i: T) -> Self {
        Double {
            v: f64::from(i.borrow().v),
        }
    }
}

这样，对于Int、&Int 和&mut Int 的转换是可能的:

fn foo<T: Into<Double>>(_: T) {}

foo(Int { v: 3 });
foo(&Int { v: 3 });
foo(&mut Int { v: 3 });

另见:

• When should I implement std::convert::From vs std::convert::Into?