You need higher-ranked trait bounds (HRTBs), which are described in the advanced Rust book Rustonomicon and well as on Stack Overflow. They allow a type constraint to say that trait must be implemented not just for references with a particular lifetime but for any lifetime. They use the where for<> syntax. Here is the function … Read more
There is one thing that is easily overlooked: if you have a trait Bar and you want to have a boxed trait object Box<dyn Bar>, the compiler automatically adds a ‘static lifetime bound (as specified in RFC 599). This means that Box<dyn Bar> and Box<dyn Bar + ‘static> are equivalent! In your case, the compiler … Read more
A temporary object is destroyed when the full-expression that lexically contains the rvalue whose evaluation created that temporary object is completely evaluated. Let me demonstrate with ASCII art: ____________________ full-expression ranges from ‘b’ to last ‘)’ bar( foo().c_str() ); ^^^^^ ^ | | birth funeral
Warning: I’m speaking from a level of expertise that I don’t really have. Given the length of this post, I’m probably wrong a large number of times. TL;DR: Lifetimes of top-level values are covariant. Lifetimes of referenced values are invariant. Introducing the problem You can simplify your example significantly, by replacing VecRef<‘a> with &’a mut … Read more
Yes, lifetime of a local variable is within the scope({,}) in which it is created. Local variables have automatic or local storage. Automatic because they are automatically destroyed once the scope within which they are created ends. However, What you have here is an string literal, which is allocated in an implementation defined read-only memory. … Read more
I found an answer from Serde issue 891: I should use DeserializeOwned instead of Deserialize.
You can’t compile this because mutable references are more restrictive than immutable references. A shortened version that illustrates the issue is this: struct MutIntRef<‘a> { r: &’a mut i32 } impl<‘a> MutIntRef<‘a> { fn mut_get(&mut self) -> &’a mut i32 { &mut *self.r } } fn main() { let mut i = 42; let mut … Read more
The c_str() result becomes invalid if the std::string is destroyed or if a non-const member function of the string is called. So, usually you will want to make a copy of it if you need to keep it around. In the case of your example, it appears that the results of c_str() are used safely, … Read more
The other answers all have salient points (fjh’s concrete example where an explicit lifetime is needed), but are missing one key thing: why are explicit lifetimes needed when the compiler will tell you you’ve got them wrong? This is actually the same question as “why are explicit types needed when the compiler can infer them”. … Read more
As far as I understand, you want want the iterator to return a vector of references into itself, right? Unfortunately, it is not possible in Rust. This is the trimmed down Iterator trait: trait Iterator { type Item; fn next(&mut self) -> Option<Item>; } Note that there is no lifetime connection between &mut self and … Read more