Note on the version of Rust used: at the time this question and answer were written, the Iterator trait used generics; it has changed to use associated types and is now defined thus: pub trait Iterator { type Item; fn next(&mut self) -> Option<Self::Item>; … } And so the incorrect implementation shown here would be … Read more
An item signature is the bit which gives the name and types of your function, i.e. everything you need to call it (without needing to know how it’s implemented); for example: fn foo(x: u32) -> u32; Here’s another which takes a &str reference: fn bar<‘a>(s: &’a str) -> &’a str; In Rust, all references have … Read more
I can’t give you a definite answer, but I’ll try to explain a few things here. Let’s start with clarifying something: The compiler knows drop() drops x This is not true. While there are a few “magic” things in the standard library that the compiler knows about, drop() is not such a lang item. In … Read more
A great thing about Rust is that the type-checking across functions is done solely by the function signature. That means you can replace most of the bodies of functions with unimplemented!() and preserve type-checking errors. Repeat that process a few times, and you end up not calling a lot of functions – remove those. Inlining … Read more
std::initializer_list is not a container, don’t use it to pass values around and expect them to persist DR 1290 changed the wording, you should also be aware of 1565 and 1599 which aren’t ready yet. Then the return value’s array should also survive into the calling function, and it should be possible to preserve it … Read more
After staying up way too late, I was able to come up with an example case where the lifetimes matter. Here is the code: static ZERO: i32 = 0; struct Foo<‘a, ‘b> { x: &’a i32, y: &’b i32, } fn get_x_or_zero_ref<‘a, ‘b>(x: &’a i32, y: &’b i32) -> &’a i32 { if *x > … Read more
Here’s a smaller example that reproduces the problem: struct FontLoader(String); struct Font<‘a>(&’a str); impl FontLoader { fn load(&self) -> Font { Font(&self.0) } } struct Window; struct Phi<‘window> { window: &’window Window, loader: FontLoader, font: Option<Font<‘window>>, } impl<‘window> Phi<‘window> { fn do_the_thing(&mut self) { let font = self.loader.load(); self.font = Some(font); } } fn main() … Read more
As originally pointed out by DK., you can use a function to apply extra constraints to a closure’s arguments and return values: fn constrain<F>(f: F) -> F where F: for<‘a> Fn(&’a mut SplitWhitespace) -> Result<&’a str, ParserError>, { f } This gives you the full abilities of the where clause; in this case you can … Read more
This is unspecified which is supported by N3751: Object Lifetime, Low-level Programming, and memcpy which says amongst other things: The C++ standards is currently silent on whether the use of memcpy to copy object representation bytes is conceptually an assignment or an object construction. The difference does matter for semantics-based program analysis and transformation tools, … Read more
You need to implement Add on &Vector rather than on Vector. impl<‘a, ‘b> Add<&’b Vector> for &’a Vector { type Output = Vector; fn add(self, other: &’b Vector) -> Vector { Vector { x: self.x + other.x, y: self.y + other.y, } } } In its definition, Add::add always takes self by value. But references … Read more