Use std::mem::swap(). fn foo(a: &mut A) { let mut my_local_var = SomeType::new(); mem::swap(&mut a.field, &mut my_local_var); } Or std::mem::replace(). fn foo(a: &mut A) { let mut my_local_var = mem::replace(&mut a.field, SomeType::new()); }
Trait objects The most extensible way to implement a heterogeneous collection (in this case a vector) of objects is exactly what you have: Vec<Box<dyn ThingTrait + ‘static>> Although there are times where you might want a lifetime that’s not ‘static, so you’d need something like: Vec<Box<dyn ThingTrait + ‘a>> You could also have a collection … Read more
TL;DR: The iterator returned by into_iter may yield any of T, &T or &mut T, depending on the context. The iterator returned by iter will yield &T, by convention. The iterator returned by iter_mut will yield &mut T, by convention. The first question is: “What is into_iter?” into_iter comes from the IntoIterator trait: pub trait … Read more
I’ve found it useful to let the compiler guide me: fn to_words(text: &str) { // Note no return type text.split(‘ ‘) } Compiling gives: error[E0308]: mismatched types –> src/lib.rs:5:5 | 5 | text.split(‘ ‘) | ^^^^^^^^^^^^^^^ expected (), found struct `std::str::Split` | = note: expected type `()` found type `std::str::Split<‘_, char>` help: try adding a … Read more
Your pseudo-code is pretty much correct. For this example, suppose we had a method call foo.bar() where foo: T. I’m going to use the fully qualified syntax (FQS) to be unambiguous about what type the method is being called with, e.g. A::bar(foo) or A::bar(&***foo). I’m just going to write a pile of random capital letters, … Read more
No, you cannot do it. There are at least two explanations why it is so. First, remember that references are borrowed, i.e. they point to some data but do not own it, it is owned by someone else. In this particular case the string, a slice to which you want to return, is owned by … Read more
It’s easiest to understand what non-lexical lifetimes are by understanding what lexical lifetimes are. In versions of Rust before non-lexical lifetimes are present, this code will fail: fn main() { let mut scores = vec![1, 2, 3]; let score = &scores[0]; scores.push(4); } The Rust compiler sees that scores is borrowed by the score variable, … Read more
Non-answer answer Avoid global state in general. Instead, construct the object somewhere early (perhaps in main), then pass mutable references to that object into the places that need it. This will usually make your code easier to reason about and doesn’t require as much bending over backwards. Look hard at yourself in the mirror before … Read more
Let’s look at a simple implementation of this: struct Parent { count: u32, } struct Child<‘a> { parent: &’a Parent, } struct Combined<‘a> { parent: Parent, child: Child<‘a>, } impl<‘a> Combined<‘a> { fn new() -> Self { let parent = Parent { count: 42 }; let child = Child { parent: &parent }; Combined { … Read more
That block defines a new trait called Foo, which then allows you to use the trait in various places such as the impl block you have posted. The : Bar part says that any type that implements Foo must also implement the Bar trait.