Change enum variant while moving the field to the new variant

by

This doesn’t work because we can’t move s from &mut X.

Then don’t do that… take the struct by value and return a new one:

enum X {
    X1(String),
    X2(String),
}

fn increment_x(x: X) -> X {
    match x {
        X::X1(s) => X::X2(s),
        X::X2(s) => X::X1(s),
    }
}

Ultimately, the compiler is protecting you because if you could move the string out of the enumeration, then it would be in some half-constructed state. Who would be responsible for freeing the string if the function were to panic at that exact moment? Should it free the string in the enum or the string in the local variable? It can’t be both as a double-free is a memory-safety issue.

If you had to implement it on a mutable reference, you could store a dummy value in there temporarily:

use std::mem;

fn increment_x_inline(x: &mut X) {
    let old = mem::replace(x, X::X1(String::new()));
    *x = increment_x(old);
}

Creating an empty String isn’t too bad (it’s just a few pointers, no heap allocation), but it’s not always possible. In that case, you can use Option:

fn increment_x_inline(x: &mut Option<X>) {
    let old = x.take();
    *x = old.map(increment_x);
}

See also:

More Related Contents:

  1. Why can’t I store a value and a reference to that value in the same struct?
  2. The compiler suggests I add a ‘static lifetime because the parameter type may not live long enough, but I don’t think that’s what I want
  3. Is it possible to control the size of an array using the type parameter of a generic?
  4. Does println! borrow or own the variable?
  5. How do I pass disjoint slices from a vector to different threads?
  6. Why does Iterator::take_while take ownership of the iterator?
  7. When should I implement std::convert::From vs std::convert::Into?
  8. Sending trait objects between threads in Rust
  9. Why would I implement methods on a trait instead of as part of the trait?
  10. How to initialize struct fields which reference each other
  11. “Expected fn item, found a different fn item” when working with function pointers
  12. How do you unwrap a Result on Ok or return from the function on Err?
  13. What does “mismatched types: expected `()`” mean when using an if expression?
  14. How do I read the entire body of a Tokio-based Hyper request?
  15. How can I downcast from Box to a trait object type?
  16. How do I ‘pass down’ feature flags to subdependencies in Cargo?
  17. How does Rust pattern matching determine if the bound variable will be a reference or a value?
  18. Using generic trait methods like .into() when type inference is impossible
  19. Why does an enum require extra memory size?
  20. What is a crate attribute and where do I add it?
  21. Parameter type may not live long enough?
  22. How to model complex recursive data structures (graphs)?
  23. Why can’t I reuse a &mut reference after passing it to a function that accepts a generic type?
  24. How can I define an async method in a trait?
  25. How do I specify the linker path in Rust?
  26. How to get an Option’s value or set it if it’s empty?
  27. Rust equivalent to Swift’s extension methods to a protocol?
  28. How can I solve “use of moved value” and “which does not implement the `Copy` trait”?
  29. Why does using Option::map to Box::new a trait object not work?
  30. How can I download Rust API docs?

Leave a Comment