CODEWITHSUNDEEP
rustlifetime
tomjw64
tomjw64

Reputation: 113

How does one restrict a lifetime to a closure environment in rust?

I am calling closures with a fold function inside another closure. While I am intending for nothing in this some_closure function to live outside the closure environment, I am receiving an error that I am dropping a value while it is still borrowed.

I have tried removing all lifetime specifiers from some_closure, because I find the compiler is much smarter than myself at figuring out lifetimes, but I'm also finding no success in this (the compiler will always ask for lifetime specifiers leading up to the point of the shown example).

What I would desire to do here is to specify a lifetime restricted to the length of the closure inside the function, rather than the function itself. But I have a feeling that what I think is the problem may not actually be my problem, and that there is some gap in my understanding of lifetimes in closures.

I've tried to minimize the example as much as possible:

struct HoldStr<'a>(&'a str);

fn clone_slice_borrows_into_vec<'a>() -> impl Fn(&[&'a HoldStr]) -> Vec<&'a HoldStr<'a>> {
  |slice| {
    let mut temp = vec![];
    temp.clone_from_slice(slice);
    temp
  }
}

fn clone_slice_borrows_into_vec_same<'a>() -> impl Fn(&[&'a HoldStr]) -> Vec<&'a HoldStr<'a>> {
  // Same as last function for the sake of example, but one can assume it does something else
}

fn some_closure<'a>() -> impl Fn() {
  || {
    let my_vec = vec![HoldStr("one"), HoldStr("two")];
    let my_vec_holding_borrow: Vec<&'a HoldStr> = my_vec.iter().collect();

    let called_closures: [Box<dyn Fn(&[&'a HoldStr]) -> Vec<&'a HoldStr<'a>>>; 2] = [
      Box::new(clone_slice_borrows_into_vec()),
      Box::new(clone_slice_borrows_into_vec_same())
    ];

    let _result = called_closures
      .iter()
      .fold(my_vec_holding_borrow, |acc, closure| closure(&acc));
  }
}

I would expect everything to be dropped by the end of the closure inside some_closure and for this to be fine, especially since I am specifying that lifetime 'a does not relate to anything the function itself returns. But it seems that the borrowed value is expected to live until the end of the function itself. I get this error:

error[E0597]: `my_vec` does not live long enough
  --> src/lib.rs:61:51
   |
## | fn some_closure<'a>() -> impl Fn() {
   |                 -- lifetime `'a` defined here
...
## |     let my_vec_holding_borrow: Vec<&'a HoldStr> = my_vec.iter().collect();
   |                                ----------------   ^^^^^^ borrowed value does not live long enough
   |                                |
   |                                type annotation requires that `my_vec` is borrowed for `'a`
...
## |   }
   |   - `my_vec` dropped here while still borrowed

I'd be happy to hear anything from how to resolve the error, to that I've been going about this the wrong way in the first place.

Upvotes: 3

Views: 696

Answers (1)

Sven Marnach
Sven Marnach

Reputation: 601639

You need higher-rank trait bounds for your closure types:

fn clone_slice_borrows_into_vec() -> impl for<'a> Fn(&[&'a HoldStr]) -> Vec<&'a HoldStr<'a>> {
...

(Full code in the playground)

The lifetime 'a isn't fixed for your closure. It should return a vector of references with lifetime 'a for any input slice with references of this lifetime. Your code used an externally fixed lifetime instead, which could be chosen by the caller of clone_slice_borrows_into_vec().

If you have a funciton definition like

fn foo<'a>() -> &'a Foo

then it's basically always a mistake. This lets the caller request an arbitrary lifetime, and the function promises to create a reference of this lifetime out of thin air, which is only possible if it gets static references from some global storage, in which case it should simply return &'static Foo.

Upvotes: 1

Related Questions