The short version is that there’s a difference between the lifetimes that are inferred if the closure is written inline or stored as a variable. Write the closure inline and remove all the extraneous types: fn test(points: &[Point]) -> (&Point, f32) { let init = points.first().expect(“No initial”); fold(&points, (init, 0.), |(q, max_d), p| { let … Read more
This is 90% a duplicate of Return local String as a slice (&str), see that for multiple other solutions. There’s one extra possibility since this is all in one function: You can declare a variable for the String and only set it when you need to allocate. The compiler (obliquely) suggests this: consider using a … Read more
A really common pitfall in C++ programs, and even in Java programs, is modifying a collection while iterating over it, like this: for (it: collection) { if (predicate(*it)) { collection.remove(it); } } For C++ standard library collections, this causes undefined behaviour. Maybe the iteration will work until you get to the last entry, but the … Read more
This seems to be a bug in the compiler. You can make the compiler happy by using an explicit return statement: use std::io::{stdin, BufRead}; fn foo() -> usize { let stdin = stdin(); let stdinlock = stdin.lock(); return stdinlock .lines() .count(); } fn main() {} playground As mentioned in the comments, there are multiple Rust … Read more
First, let’s take a look at what lifetime is actually expected. There is an implicit lifetime in the signature of description: fn description(&self) -> &str // Can be rewritten as fn description<‘a>(&’a self) -> &’a str The returned pointer must be valid for at least as long as self. Now consider s. It will hold … Read more
Lifetime ‘a in fn foo(&’a self, …) … is defined for impl<‘a>, that is it is the same for all foo calls. Lifetime ‘a in fn get_mut<‘a>(&’a mut self) … is defined for the function. Different calls of get_mut can have different values for ‘a. Your code impl<‘a> Foo<‘a> { fn foo(&’a self, path: &str) … Read more
Lifetime elision infers that the full type of fn get_str(s: &str) -> &str is fn get_str<‘a>(s: &’a str) -> &’a str which basically means that the return value of get_str has to be valid as long as s is valid. The actual type of the string literal “Hello world” is &’static str, which means that … Read more
c99 support variable length arrays but c90 does not support variable length arrays, you can see this more clearly if you are using gcc and try to compile with these arguments: gcc -std=c89 -pedantic this will give you the following warning: warning: ISO C90 forbids variable length array ‘y’ [-Wvla] but if you compile using … Read more
There are a two solutions to your problem. Let’s start with the simplest one: Add a lifetime to your trait trait Foo<‘a> { type Item: AsRef<Path>; type Iter: Iterator<Item = Self::Item>; fn get(&’a self) -> Self::Iter; } This requires you to annotate the lifetime everywhere you use the trait. When you implement the trait, you … Read more
I found an answer from Serde issue 891: I should use DeserializeOwned instead of Deserialize.