Extend lifetime of variable

by

You can’t forcibly extend a value’s lifetime; you just have to return the full Vec. If I may ask, why do you want to return the slice itself? It is almost always unnecessary, since a Vec can be cheaply (both in the sense of easy syntax and low-overhead at runtime) coerced to a slice.

Alternatively, you could return the iterator:

use std::iter;

pub fn find<'a>(&'a self, name: &str) -> Box<Iterator<Item = &'a Element> + 'a> {
    Box::new(self.iter_elements()
       .filter(move |&elem| elem.name.borrow().local_name == name))
}

For now, you will have to use an iterator trait object, since closure have types that are unnameable.

NB. I had to change the filter closure to capture-by-move (the move keyword) to ensure that it can be returned, or else the name variable would just passed into the closure pointer into find‘s stack frame, and hence would be restricted from leaving find.

More Related Contents:

  1. Why can’t I store a value and a reference to that value in the same struct?
  2. What are non-lexical lifetimes?
  3. The compiler suggests I add a ‘static lifetime because the parameter type may not live long enough, but I don’t think that’s what I want
  4. How can I create my own data structure with an iterator that returns mutable references?
  5. Lifetime error when creating a function that returns a value implementing serde::Deserialize
  6. Why does linking lifetimes matter only with mutable references?
  7. Why is adding a lifetime to a trait with the plus operator (Iterator + ‘a) needed?
  8. Cannot infer an appropriate lifetime for autoref due to conflicting requirements
  9. When is it useful to define multiple lifetimes in a struct?
  10. Lifetime troubles sharing references between threads
  11. Moved variable still borrowing after calling `drop`?
  12. What is lifetime elision in very simple terms?
  13. “borrowed value does not live long enough” when using the builder pattern
  14. How can this instance seemingly outlive its own parameter lifetime?
  15. How do I specify lifetime parameters in an associated type?
  16. How to operate on 2 mutable slices of a Rust array?
  17. When returning the outcome of consuming a StdinLock, why was the borrow to stdin retained?
  18. Why does my variable not live long enough?
  19. Why is the bound `T: ‘a` required in order to store a reference `&’a T`?
  20. Sharing a struct with trait objects as properties across threads
  21. Why can’t I return an &str value generated from a String?
  22. Type mismatches resolving a closure that takes arguments by reference
  23. How to fix lifetime error when function returns a serde Deserialize type?
  24. Why does Rust disallow mutable aliasing?
  25. Why does the Rust compiler request I constrain a generic type parameter’s lifetime (error E0309)?
  26. Is it possible to use `impl Trait` as a function’s return type in a trait definition?
  27. Cannot borrow as immutable because it is also borrowed as mutable in function arguments
  28. What is the relation between auto-dereferencing and deref coercion?
  29. What is the return type of the indexing operation?
  30. What does Rust’s unary || (parallel pipe) mean?

Leave a Comment