使用 Into 特性强制借用

Question

struct Foo(i32);

impl<'a> Into<i32> for &'a Foo {
    fn into(self) -> i32 {
        self.0
    }
}

fn test<I: Into<i32>>(i: I) {
    let n: i32 = i.into();
    println!("{}", n);
}

fn main() {
    let f = Foo(42);
    test(&f);
}

playground

This works but just looking at test

fn test<I: Into<i32>>(i: I) {
    let n: i32 = i.into();
    println!("{}", n);
}

The function can access both a borrow and a move/copy depending on how the Into trait is implemented.

impl<'a> Into<i32> for &'a Foo
// vs
impl Into<i32> for Foo

Now the user could try to call test like test(f); instead of test(&f); and would receive the following error message.

error[E0277]: the trait bound `i32: std::convert::From<Foo>` is not satisfied
  --> <anon>:16:5
   |
16 |     test(f);
   |     ^^^^ trait `i32: std::convert::From<Foo>` not satisfied
   |

Would it be possible to always force a borrow? Something similar to this

fn test<I: Into<i32>>(i: &I) {
    let n: i32 = i.into();
    println!("{}", n);
}

So that the user would get an error message similar to, "Expected &XX but found YY".

Answer 1

A where -clause works here by specifying the lifetime:

fn test<'a, I>(i: &'a I) where &'a I: Into<i32> {
    let n: i32 = i.into();
    println!("{}", n);
}

Now when you attempt to build with test(f); , the message is clearer:

error[E0308]: mismatched types
  --> src/main.rs:16:10
   |
16 |     test(f);
   |          ^
   |          |
   |          expected `&Foo`, found struct `Foo`
   |          help: consider borrowing here: `&f`