when shouldn’t I implement this? Asked another way, why doesn’t the compiler automatically implement this for me? Since it currently doesn’t, I assume there must be cases where having this implementation would be disadvantageous. As an example, the Default trait immediately came to mind. pub trait Default { fn default() -> Self; } I could … Read more
a is of type [i32; 3]; an array of three i32s. [i32; 3] does not implement an iter method, but it does dereference into &[i32]. &[i32] implements an iter method which produces an iterator. This iterator implements Iterator<Item=&i32>. It uses &i32 rather than i32 because the iterator has to work on arrays of any type, … Read more
So normally when you use for i in list, the loop variable i would be of type &i32. But when instead you use for &i in list, you are not dereferencing anything, but instead you are using pattern matching to explicitly destructure the reference and that will make i just be of type i32. See … Read more
The type of the expression &l you match against is &Option<i32>, so if we are strict the patterns should be &None and &Some(x), and if we use these patterns, the type of x indeed is i32. If we omit the ampersand in the patterns, as you did in your code, it first looks like the … Read more
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
(playground links to solutions using type parameters and associated types) In this case &T and &mut T are just two different types. Code that is generic over different types (at both compile-time and run-time) is idiomatically written in Rust using traits. For example, given: struct Foo { value: i32 } struct Bar { foo: Foo … Read more
Cannot move out of borrowed content when trying to transfer ownership At a high-level, this is against-the-grain for Rust. You cannot transfer ownership of something borrowed because you don’t own it. You shouldn’t borrow my car (&Car) and then give it to the first person you see on the street! This is still true even … 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
A MRE of your problem can be reduced to this: // This applies to the version of Rust this question // was asked about; see below for updated examples. fn main() { let mut items = vec![1]; let item = items.last(); items.push(2); } error[E0502]: cannot borrow `items` as mutable because it is also borrowed as … 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