CODEWITHSUNDEEP
concurrencyrust
Dash83
Dash83

Reputation: 1468

"error: underscore lifetimes are unstable" when implementing From<std::sync::PoisonError>

I'm working on a function that looks like this:

fn do_stuff(&mut self, a: MyStruct) -> Result<(), MyError> {
    let x = try!(serde_json::to_vec(a));

    let cache = Arc::clone(self.data); // Get shared reference
    {
        let cache = try!(cache.lock()); // Get lock
        cache.push(x);
    }

    /* Do stuff with other resources */

    Ok(())
}

Where the definition of MyError is:

#[derive(Debug)]
pub enum MyError {
    Serialization(serde_json::Error),
    Synch(PoisonError<MutexGuard<'_, Vec<u8>>>),
}

Before I even get to implementing From<std::sync::PoisonError> for MyError, the compiler already tells me the definition of the Synch variant of my enum is wrong:

error: underscore lifetimes are unstable (see issue #44524)

The declaration using underscore lifetimes actually came from an earlier hint from the compiler when I was trying to figure out the error I should convert from when the lock operation fails. I read the aforementioned issue and that doesn't help me.

What's the full type I should be converting from in order to catch the error from the Mutex::lock operation?

Upvotes: 2

Views: 179

Answers (1)

DK.
DK.

Reputation: 59115

Like so:

#[derive(Debug)]
pub enum MyError<'a> {
    Serialization(serde_json::Error),
    Synch(PoisonError<MutexGuard<'a, Vec<u8>>>),
}

The closest explanation I can find in the book is the section on Lifetime Annotations in Struct Definitions (enums behave the same way).

The compiler suggesting unstable syntax as a solution is quite unfair.

Upvotes: 3

Related Questions