Here’s a minimal reproduction: #[derive(Debug)] pub struct Canvas; impl Canvas { fn new() -> Self { Canvas } fn color(&self) -> &Canvas { self } } fn main() { let mut canvas = Canvas::new().color(); // 1 ^~~~~~~~~~~~~ // 2 ^~~~~ println!(“{:?}”, canvas); } Rust 2015 error[E0597]: borrowed value does not live long enough –> src/main.rs:15:22 … Read more
There is a merged RFC “non-lexical lifetimes” which solves this in the long run. Using the non-lexical lifetimes in Rust 2018, available in Rust 1.31, your code works as-is: Playground use std::collections::HashMap; pub struct Pivot { pub min_key: u64, pub child: HashMap<u64, ()>, } fn update_or_append(pivots: &mut Vec<Pivot>, key: u64, value: ()) { match pivots.iter_mut().find(|ref … 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
There is no other way; using blocks is the way to do it. Before Rust 2018 (available in Rust 1.31) all borrows are lexical, that is, they always correspond to some lexical scope. The only scope which is larger than a single statement is that of a block, so blocks are your only tool to … Read more
This is a limitation of the current implementation of non-lexical lifetimes This can be shown with this reduced case: fn next<‘buf>(buffer: &’buf mut String) -> &’buf str { loop { let event = parse(buffer); if true { return event; } } } fn parse<‘buf>(_buffer: &’buf mut String) -> &’buf str { unimplemented!() } fn main() … Read more
This line: n.set(n.get() + 1); is desugared into Number::set(&mut n, n.get() + 1); The error message might be a bit more clear now: error[E0502]: cannot borrow `n` as immutable because it is also borrowed as mutable –> <anon>:18:25 | 18 | Number::set(&mut n, n.get() + 1); | – ^ – mutable borrow ends here | … Read more
You are completely right with both your reasoning and your observations. It definitely looks like things should be happening the way you describe it. However, the compiler applies some convenience magic here. Move semantics generally apply in Rust for all types that do not implement the Copy trait. Shared references are Copy, so they are … Read more
Usually the borrow checker can distinguish between the different fields of a structure, but this doesn’t work within closures (lambdas). Instead, borrow the second field outside the closure: let field2 = &strct.field2; strct.field1.retain(|v| !field2.contains(v));
Currently your Ball struct needs to know about the Field it’s contained in to be able to update itself. This doesn’t compile because the result would be cyclic references combined with mutation. You could make this work by using Cell or RefCell (the latter having a performance cost) but it would be even better to … Read more
This is a known issue that will be solved by a future iteration of non-lexical lifetimes, but is not currently handled as of Rust 1.57. If you are inserting to the same key that you are looking up, I’d encourage you to use the entry API instead. You can add a smidgen of inefficiency to … Read more