53

I have a struct with a field:

struct A {
    field: SomeType,
}

Given a &mut A, how can I move the value of field and swap in a new value?

fn foo(a: &mut A) {
    let mut my_local_var = a.field;
    a.field = SomeType::new();

    // ...
    // do things with my_local_var
    // some operations may modify the NEW field's value as well.
}

The end goal would be the equivalent of a get_and_set() operation. I'm not worried about concurrency in this case.

Shepmaster
  • 388,571
  • 95
  • 1,107
  • 1,366
arcyqwerty
  • 10,325
  • 4
  • 47
  • 84

2 Answers2

61

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());
}
Shepmaster
  • 388,571
  • 95
  • 1,107
  • 1,366
Francis Gagné
  • 60,274
  • 7
  • 180
  • 155
36

If your type implements Default, you can use std::mem::take:

#[derive(Default)]
struct SomeType;

fn foo(a: &mut A) {
    let mut my_local_var = std::mem::take(&mut a.field);
}

If your field happens to be an Option, there's a specific method you can use — Option::take:

struct A {
    field: Option<SomeType>,
}

fn foo(a: &mut A) {
    let old = a.field.take();
    // a.field is now None, old is whatever a.field used to be
}

The implementation of Option::take uses mem::take, just like the more generic answer above shows, but it is wrapped up nicely for you:

pub fn take(&mut self) -> Option<T> {
    mem::take(self)
}

See also:

Shepmaster
  • 388,571
  • 95
  • 1,107
  • 1,366