Error: Use of moved value, while it cannot be used

Question

Consider the following code:

fn print_or(opt: Option<()>, tail: Vec<i32>) -> Vec<i32> {
    opt.map_or(tail, |_| {
        println!("{:?}", tail);
        tail
    })
}

Playground

The error message says that:

error[E0382]: use of moved value: `tail`
 --> src/lib.rs:2:22
  |
1 | fn print_or(opt: Option<()>, tail: Vec<i32>) -> Vec<i32> {
  |                              ---- move occurs because `tail` has type `Vec<i32>`, which does not implement the `Copy` trait
2 |     opt.map_or(tail, |_| {
  |                ----  ^^^ value used here after move
  |                |
  |                value moved here
3 |         println!("{:?}", tail);
4 |         tail
  |         ---- use occurs due to use in closure
  |
help: consider cloning the value if the performance cost is acceptable
  |
2 |     opt.map_or(tail.clone(), |_| {
  |                    ++++++++

And it's clear since I use owned Vec<i32> type here. But the problem is that it's pretty obvious that it cannot be used after move since Option cannot be Some and None at the same time. Is there a way to overcome the problem without clone or Rc?

drewtato · Accepted Answer · 2024-05-31 05:45:43Z

6

Rust doesn't really have a way to say that only one argument of a function will be used, but it does know that only one branch of a control flow statement will run, so you can use match:

match opt {
    None => tail,
    Some(()) => {
        println!("{:?}", tail);
        tail
    }
}

Similarly, you can use if let:

if let Some(()) = opt {
    println!("{:?}", tail);
    tail
} else {
    tail
}

And in this case, you can just check if opt is Some since both branches end in the same thing:

if opt.is_some() {
    println!("{:?}", tail);
}
tail

answered May 31, 2024 at 5:45

drewtato

13.2k1 gold badge22 silver badges25 bronze badges

Sign up to request clarification or add additional context in comments.

Comments

Aleksander Krauze · Accepted Answer · 2024-05-31 05:44:22Z

1

You can inline Option::map_or to help compiler understand that it should move tail to each branch conditionally.

fn print_or(opt: Option<()>, tail: Vec<i32>) -> Vec<i32> {
    match opt {
        Some(()) => {
            println!("{:?}", tail);
            tail
        }
        None => tail,
    }
}

answered May 31, 2024 at 5:44

Aleksander Krauze

6,4552 gold badges16 silver badges32 bronze badges

Collectives™ on Stack Overflow

Error: Use of moved value, while it cannot be used

2 Answers 2

Comments

Comments

Your Answer

Hot Network Questions

Collectives™ on Stack Overflow

2 Answers 2

Comments

Comments

Your Answer

Sign up or log in

Post as a guest

Related