使用Option <＆mut> 2次

Question

The following program compiles fine:

fn write_u16(bytes: &mut Vec<u8>, value: u16) {
    bytes.push((value >> 8) as u8);
    bytes.push(value as u8);
}

fn write_u32(bytes: &mut Vec<u8>, value: u32) {
    write_u16(bytes, (value >> 16) as u16);
    write_u16(bytes, value as u16);
}

now I'll change bytes type to Option<&mut Vec>:

fn write_u16(bytes_opt: Option<&mut Vec<u8>>, value: u16) {
    if let Some(bytes) = bytes_opt {
        bytes.push((value >> 8) as u8);
        bytes.push(value as u8);
    }
}

fn write_u32(bytes_opt: Option<&mut Vec<u8>>, value: u32) {
    write_u16(bytes_opt, (value >> 16) as u16);
    write_u16(bytes_opt, value as u16);
}

The program doesn't compile now:

main.rs:10:15: 10:24 error: use of moved value: `bytes_opt`
main.rs:10     write_u16(bytes_opt, value as u16);
                         ^~~~~~~~~
main.rs:9:15: 9:24 note: `bytes_opt` moved here because it has type `core::option::Option<&mut collections::vec::Vec<u8>>`, which is non-copyable
main.rs:9     write_u16(bytes_opt, (value >> 16) as u16);
                        ^~~~~~~~~
error: aborting due to previous error

I don't really understand, why I can't use Option twice and how do I solve this problem?

The only way I can imagine to solve this problem is:

fn write_u32(bytes_opt: Option<&mut Vec<u8>>, value: u32) {
    if let Some(bytes) = bytes_opt {
        write_u16(Some(bytes), (value >> 16) as u16);
        write_u16(Some(bytes), value as u16);
    } else {
        write_u16(None, (value >> 16) as u16);
        write_u16(None, value as u16);
    }
}

but that's not very nice code.

Answer 1

Although I suspect in this case you should not be doing this (as commented already), it is possible to reborrow mutable references for this sort of a case where it is safe:

fn write_u32(mut bytes_opt: Option<&mut Vec<u8>>, value: u32) {
    write_u16(bytes_opt.as_mut().map(|x| &mut **x), (value >> 16) as u16);
    write_u16(bytes_opt, value as u16);
}

The bytes_opt.as_mut().map(|x| &mut **x) could also be written match bytes_opt { Some(&mut ref mut x) => Some(x), None => None, } . A pretty mind-bending pattern (read it from left to right: &mut —dereference the contained value, ref mut —and then take a new mutable reference to it), but it works and avoids the ownership issue.

Answer 2

The error message is telling you they key things:

bytes_opt moved here because it has type core::option::Option<&mut collections::vec::Vec<u8>> , which is non-copyable

Your function signature states that it is going to consume the argument:

fn write_u16(bytes_opt: Option<&mut Vec<u8>>, value: u16)
//                      ^~~~~~~~~~~~~~~~~~~~

However, by consuming it, it also consumes the mutable reference. If you had another type like Option<u8> or Option<&Vec<u8>> , then the compiler could just insert an implicit copy of the variable for you. However, you aren't allowed to make copies of mutable references , because then you would have mutable aliases , which the compiler disallows for memory-safety reasons.

When you pass just the &mut Vec<u8> , the compiler is able to track the reference and see that only one item has the reference at a time, so it allows it. However, it is unable to track that when the mutable reference is embedded in another type.

To actually get it to work, it's a bit ugly, with more mut qualifiers than I would like:

fn write_u16(bytes_opt: &mut Option<&mut Vec<u8>>, value: u16) {
    if let Some(ref mut bytes) = *bytes_opt {
        bytes.push((value >> 8) as u8);
        bytes.push(value as u8);
    }
}

fn write_u32(mut bytes_opt: Option<&mut Vec<u8>>, value: u32) {
    write_u16(&mut bytes_opt, (value >> 16) as u16);
    write_u16(&mut bytes_opt, value as u16);
}

Prompted by @ChrisMorgan, I got something that fits your original API:

fn write_u16(bytes_opt: Option<&mut Vec<u8>>, value: u16) {
    if let Some(bytes) = bytes_opt {
        bytes.push((value >> 8) as u8);
        bytes.push(value as u8);
    }
}

fn write_u32(bytes_opt: Option<&mut Vec<u8>>, value: u32) {
    if let Some(bytes) = bytes_opt {
        write_u16(Some(bytes), (value >> 16) as u16);
        write_u16(Some(bytes), value as u16);
    }
}