What's the best way to mutate a nested enum?

Question

I have an enum which roughly looks like this simplified example:

use std::collections::BTreeMap;

enum Value {
    Null,
    Object(BTreeMap<String, Value>)
}

Now I would like to, based on a list of field names, drill down into a Value::Object and initialize it with the given fields. The leaf field should always receive the Value::Null variant.

What I would like to, and am used to, do is the following:

fn set_null_to_how_i_want_it(fields: &[&str], mut v: &mut Value) {
    debug_assert!(fields.len() > 0);

    for (fid, field) in fields.iter().enumerate() {
        v = 
            match *v {
                Value::Object(ref mut map) => {
                    let val_to_insert = 
                        if fid == fields.len() - 1 {
                            Value::Null
                        } else {
                            Value::Object(Default::default())
                        };
                    map.entry(field.to_string()).or_insert(val_to_insert)
                }
                _ => unreachable!(),
            }
    }
}

However, the borrow checker will not allow it.

Interestingly, what worked is the following, more complex and probably less performant implementation:

fn set_null_how_borrow_chk_allows_it(fields: &[&str], v: &mut Value) {
    let next = 
        match *v {
            Value::Object(ref mut map) => {
                let val_to_insert = 
                    if fields.len() == 1 {
                        Value::Null
                    } else {
                        Value::Object(Default::default())
                    };
                map.entry(fields[0].to_string()).or_insert(val_to_insert)
            },
            _ => unreachable!()
        };
    if fields.len() > 1 {
        set_null_how_borrow_chk_allows_it(&fields[1..], next)
    }
}

With the version above, all the following code runs fine:

let mut v = Value::Object(Default::default());
let fields = ["foo", "bar", "baz"];
set_null_how_borrow_chk_allows_it(&fields, &mut v);


let mut map_count = 0;
for (fid, field) in fields.iter().enumerate() {
    let next = 
        match v {
            Value::Object(mut map) => {
                map_count += 1;
                map.remove(&field.to_string()).unwrap()
            },
            _ => unreachable!()
        };
    v = next;
}
assert_eq!(map_count, fields.len());
match v {
    Value::Null => (),
    Value::Object(_) => unreachable!(),
}

Is there a better way to initialize a nested enumeration or to get set_null_to_how_i_want_it(...) to work ?

How to reproduce

You can have a look at the complete example on github, and play around with it as follows:

git clone https://github.com/Byron/depot
cd depot/src/rust/hello
cargo test --test lang
# edit src/rust/hello/tests/lang.rs for testing

Meta

➜  hello git:(master) ✗ rustc --version --verbose
rustc 1.1.0-nightly (4b88e8f63 2015-05-11) (built 2015-05-12)
binary: rustc
commit-hash: 4b88e8f63eeaf557c916a0a1e73150b028c44c52
commit-date: 2015-05-11
build-date: 2015-05-12
host: x86_64-apple-darwin
release: 1.1.0-nightly

Answer 1

The borrow checker works on names, and so some examples like your first approach don’t work; this can be worked around by moving the value v to a different name first and then assigning the new value to v:

fn set_null_to_how_i_want_it(fields: &[&str], mut v: &mut Value) {
    debug_assert!(fields.len() > 0);

    for (fid, field) in fields.iter().enumerate() {
        let tmp = v;
        v = match *tmp {
            Value::Object(ref mut map) => {
                let val_to_insert = 
                    if fid == fields.len() - 1 {
                        Value::Null
                    } else {
                        Value::Object(Default::default())
                    };
                map.entry(field.to_string()).or_insert(val_to_insert)
            }
            _ => unreachable!(),
        };
    }
}