Conditionally clone when you need a reference

Question

I have a reference to a struct.

I need a reference to a struct. Sometimes it's the same, but sometimes it's a cloned then modified one.

Right now, I do

if condition {
    let mut copy = original.clone();
    copy.select();
    do_big_thing(&copy);
} else {
    do_big_thing(original);
}

But do_big_thing takes other arguments, I don't like to duplicate this line.

Is there a way to

• first build the reference, which would either be the original one or a reference to a local modified clone
• then use it in do_big_thing (it doesn't have to live longer)

?

Of course this doesn't work because copy doesn't live long enough:

let mut reference = if condition {
    let mut copy = original.clone();
    copy.select();
    &copy
} else {
    original
};
do_big_thing(reference);

As this question is about finding a cleaner and less cluttered way to write the same thing (either use the original reference or clone), I can't accept a solution which would add overhead at runtime or some unsafe.

playground

Answer 1

Since you don't intend to return the value from your function (which is shown in Is it possible to return either a borrowed or owned type in Rust?), you don't need to use Cow. Instead, you can declare the copy variable outside of the conditional:

fn do_huge_thing_stack(original: &Big, a: usize, condition: bool) {
    let mut copy;

    let r = if condition {
        copy = original.clone();
        copy.select();
        &copy
    } else {
        original
    };

    do_big_thing(r, a);
}

The compiler will ensure that a reference is only taken when the value is valid. This generates the same assembly as the Cow version, and I think the Cow version is more obvious, but it's still a useful technique to know.

See also:

• Are polymorphic variables allowed?

Answer 2

You can use std::borrow::Cow to abstract over a value which is either borrowed or owned:

fn do_big_thing(b: Cow<Big>, a: usize) {
    println!("{}", a + b.c);
}

fn do_huge_thing(original: &Big, a: usize, condition: bool) {
    if condition {
        let mut copy = original.clone();
        copy.select();
        do_big_thing(Cow::Owned(copy), a);
    } else {
        do_big_thing(Cow::Borrowed(original), a);
    }
}

Which you can then refactor to something like:

pub fn do_huge_thing_cow(original: &Big, a: usize, condition: bool) {
    let mut r = Cow::Borrowed(original);

    if condition {
        r.to_mut().select();
    }

    do_big_thing(&r, a);
}

As you can see, this is optimized away.