Rust struct 可以两次借用“&'a mut self”，为什么 trait 不能？

Question

The following Rust code compiles successfully :

struct StructNothing;

impl<'a> StructNothing {
    fn nothing(&'a mut self) -> () {}

    fn twice_nothing(&'a mut self) -> () {
        self.nothing();
        self.nothing();
    }
}

However, if we try to package it in a trait, it fails :

pub trait TraitNothing<'a> {
    fn nothing(&'a mut self) -> () {}

    fn twice_nothing(&'a mut self) -> () {
        self.nothing();
        self.nothing();
    }
}

This gives us:

error[E0499]: cannot borrow `*self` as mutable more than once at a time
 --> src/lib.rs:6:9
  |
1 | pub trait TraitNothing<'a> {
  |                        -- lifetime `'a` defined here
...
5 |         self.nothing();
  |         --------------
  |         |
  |         first mutable borrow occurs here
  |         argument requires that `*self` is borrowed for `'a`
6 |         self.nothing();
  |         ^^^^ second mutable borrow occurs here

• Why is the first version allowed, but the second version forbidden?
• Is there any way to convince the compiler that the second version is OK?

Background and motivation

Libraries like rust-csv would like to support streaming, zero-copy parsing because it's 25 to 50 times faster than allocating memory (according to benchmarks). But Rust's built-in Iterator trait can't be used for this , because there's no way to implement collect() . The goal is to define a StreamingIterator trait which can be shared by rust-csv and several similar libraries, but every attempt to implement it so far has run into the problem above.

Answer 1

The following is an extension of Francis's answer using implicit lifetimes but it allows for the return value to be lifetime bound:

pub trait TraitNothing<'a> {
    fn change_it(&mut self);

    fn nothing(&mut self) -> &Self {
        self.change_it();
        self
    }

    fn bounded_nothing(&'a mut self) -> &'a Self {
        self.nothing()
    }

    fn twice_nothing(&'a mut self) -> &'a Self {
        // uncomment to show old fail
        // self.bounded_nothing();
        // self.bounded_nothing()
        self.nothing();
        self.nothing()
    }
}

It's less than perfect, but you can call the methods with implicit lifetimes change_it and nothing multiple times within other methods. I don't know if this will solve your real problem because ultimately self has the generic type &mut Self in the trait methods whereas in the struct it has type &mut StructNothing and the compiler can't guarantee that Self doesn't contain a reference. This workaround does solve the code example.

Answer 2

If you put the lifetime parameters on each method rather than on the trait itself, it compiles :

pub trait TraitNothing {
    fn nothing<'a>(&'a mut self) -> () {}

    fn twice_nothing<'a>(&'a mut self) -> () {
        self.nothing();
        self.nothing();
    }
}

Answer 3

Nobody seemed to answer the "why?" so here I am.

Here's the point: In the trait, we're calling methods from the same trait. However, in the free impl, we're not calling methods from the same impl .

What? Surely we call methods from the same impl?

Let's be more precise: we're calling methods from the same impl, but not with the same generic parameters .

Your free impl is essentially equivalent to the following:

impl StructNothing {
    fn nothing<'a>(&'a mut self) {}

    fn twice_nothing<'a>(&'a mut self) {
        self.nothing();
        self.nothing();
    }
}

Because the impl's generic lifetime is floating, it can be chosen separately for each method. The compiler does not call <Self<'a>>::nothing(self) , but rather it calls <Self<'some_shorter_lifetime>>::nothing(&mut *self) .

With the trait, on the other hand, the situation is completely different. The only thing we can know for sure is that Self: Trait<'b> . We cannot call nothing() with a shorter lifetime, because maybe Self doesn't implement Trait with the shorter lifetime . Therefore, we are forced to call <Self as Trait<'a>>::nothing(self) , and the result is that we're borrowing for overlapping regions.

From this we can infer that if we tell the compiler that Self implements Trait for any lifetime it will work:

fn twice_nothing(&'a mut self)
where
    Self: for<'b> TraitNothing<'b>,
{
    (&mut *self).nothing();
    (&mut *self).nothing();
}

...except it fails to compile because of issue #84435 , so I don't know whether this would have succeeded:(

Answer 4

Is this really surprising?

The assertion you're making is that &mut self lasts for at least the lifetime 'a .

In the former case, &mut self is a pointer to a struct. No pointer aliasing occurs because the borrow is entirely contained in nothing() .

In the latter case, the &mut self is a pointer to a pointer to a struct + a vtable for the trait. You're locking the pointed to struct that implements TraitNothing for the duration of 'a ; ie the whole function each time.

By removing 'a , you're implicitly using 'static , which says the impl lasts forever, so its fine.

If you want to work around it, transmute the &'a TraitNothing to &'static TraitNothing ... but I'm pretty sure that's not what you want to do.

This is why we need block scopes ( 'b: { .... } ) in Rust...

Try using dummy lifetimes perhaps?