Rust lifetimes: can't re-borrow mutable field inside a method - rust

Question

I'm trying to write a data structure ScopedSet that mutably borrows a HashSet, adding an element to it, and then removes that element when the ScopedSet is dropped:
let mut s = HashSet::new();
if let Some(mut s) = ScopedSet::new_with(&mut s, 1) {
// Do something knowing `s.set` contains `1`
}
// `s` no longer contains `1`
I managed to get a working implementation for this:
use std::collections::HashSet;
use std::cmp::Eq;
use std::hash::Hash;
struct ScopedSet<'s, T: Eq + Hash> {
value: T,
set: &'s mut HashSet<T>,
}
impl<'s, T: Eq + Hash> Drop for ScopedSet<'s, T> {
fn drop(&mut self) {
self.set.remove(&self.value);
}
}
impl<'s, T: Clone + Eq + Hash> ScopedSet<'s, T> {
fn new_with(set: &'s mut HashSet<T>, value: T) -> Option<Self> {
if set.insert(value.clone()) {
Some(Self { value, set })
} else {
None
}
}
}
However, trouble arises when I try to do stacked borrows. I can do the following:
if let Some(mut s) = ScopedSet::new_with(&mut s, 1) {
if let Some(mut s) = ScopedSet::new_with(&mut s.set, 2) {
// Do something knowing `s.set` contains both `1` and `2`
}
};
but I would like to have a method on ScopedSet that would allow me to do this:
if let Some(mut s) = ScopedSet::new_with(&mut s, 1) {
if let Some(mut s) = s.with(2) {
// Do something knowing `s.set` contains both `1` and `2`
}
};
I haven't found a way to write ScopedSet::with that's accepted by the borrow checker. For example:
impl<'s, T: Clone + Eq + Hash> ScopedSet<'s, T> {
fn with<'a, 'b>(&'a mut self, value: T) -> Option<ScopedSet<'b, T>>
where
's: 'a,
'a: 'b,
{
if self.set.insert(value.clone()) {
Some(Self {
value,
set: &mut self.set,
})
} else {
None
}
}
}
Here, the rational is that I want to create a ScopedSet containing a borrow &'b mut HashSet<T> which is outlived by the parent ScopedSet borrow (&'a mut self), giving me 'a: 'b. I also know that the parent borrow must be outlived by the data borrow &'s mut HashSet<T>, so we have 's: 'a. Unfortunately, this does not compile:
error: lifetime may not live long enough
--> src/main.rs:35:22
|
26 | impl<'s, T: Clone + Eq + Hash> ScopedSet<'s, T> {
| -- lifetime `'s` defined here
27 | fn with<'a, 'b>(&'a mut self, value: T) -> Option<ScopedSet<'b, T>>
| -- lifetime `'a` defined here
...
35 | set: &mut self.set,
| ^^^^^^^^^^^^^ this usage requires that `'a` must outlive `'s`
|
= help: consider adding the following bound: `'a: 's`
Does anybody have an idea of how I could get ScopedSet::with working?

Answer 1

The problem with your implementation is very simple: you're using Self where you need to use ScopedSet.
This:
Some(Self {
value,
set: &mut self.set,
})
Needs to be this:
Some(ScopedSet {
value,
set: &mut self.set,
})
And it will work.
Self in the context of the implementation is ScopedSet<'s, T>, but you need ScopedSet<'b, T>.