在 Rust 的元组中传递多个引用

Question

I have a trait with some associated type, and some of its functions take as input a reference of that type:

trait Trait {
    type Value;

    fn do_something(&self, value: &Self::Value);
}

In one structure that implements this trait, Value is a tuple, because I need to pass multiple values to do_something :

struct Struct {}

impl Trait for Struct {
    type Value = (i64, String);

    fn do_something(&self, (a, b): &(i64, String)) {
        println!("{} {}", a, b);
    }
}

However, when I then use Struct in practice, I hit a wall. Either I do this:

fn main() {
    let a = 10;
    let b = "foo".to_owned();
    let s = Struct {};

    s.do_something(&(a, b));  // This works...
    println!("{}", b);  // ...but the borrow checker complains here
}

but then I lose ownership of any non- Copy type in the tuple. Alternatively, I can do this:

fn main() {
    let a = 10;
    let b = "foo".to_owned();
    let s = Struct {};

    let t = (a, b);
    s.do_something(&t);
    let (a, b) = t;
    println!("{}", b);
}

which works, but the syntax is extremely heavy.

Does anyone have some idea of how I can accomplish what I want in a more concise way? I tried to have Struct::Value be of type (&i64, &String) , but then the borrow checker complains about needing a lifetime for those references, which I'd like to avoid if possible.

Another alternative I tried was to use a type parameter (so, Trait<Value> ) instead of an associated type. In that case, I can have Struct implement Trait<(&i64, &String)> without the lifetime issue I had with an associated type. It works, but in my project it never makes sense for Struct to have more than one implementation of Trait , so I'd much prefer to use an associated type.

Thanks for your time:-)

Answer 1

I tried to have Struct::Value be of type (&i64, &String) , but then the borrow checker complains about needing a lifetime for those references, which I'd like to avoid if possible.

It's not possible to avoid lifetimes. All references have lifetimes, some of which the compiler can infer for you and some of which you have to explicitly annotate yourself. Note: the compiler isn't always right so sometimes you have to explicitly annotate lifetimes anyway despite the compiler's inferences.

In that case, I can have Struct implement Trait<(&i64, &String)> without the lifetime issue I had with an associated type.

Right, because the lifetimes the compiler inferred for those references happened to work, but you shouldn't be afraid of explicitly annotating them yourself when you need to.

It works, but in my project it never makes sense for Struct to have more than one implementation of Trait , so I'd much prefer to use an associated type.

Alright then let's use an associated type. Here's the code with all the necessary lifetime annotations:

trait Trait<'a> {
    type Value;

    fn do_something(&self, value: Self::Value);
}

struct Struct {}

impl<'a> Trait<'a> for Struct {
    type Value = (&'a i64, &'a String);

    fn do_something(&self, (a, b): Self::Value) {
        println!("{} {}", a, b);
    }
}

fn main() {
    let a = 10;
    let b = "foo".to_owned();
    let s = Struct {};

    s.do_something((&a, &b)); // compiles
    println!("{}", b); // compiles
}

playground