Pass two arguments to a function where one borrows from the other

help
1

I'm trying to factor out some complex logic into a function, however I would need to pass two arguments where one is borrowed from another. MWE: Rust Playground

/// Split
fn f1(x: &mut Vec<i32>) {
    let slice: &mut [i32] = x.as_mut_slice();
    f1_sub(x, slice)
}

fn f1_sub(x: &mut Vec<i32>, slice: &mut [i32]) {
    slice[1] *= 2;
    x.push(123)
}

/// "Inlined"
fn f2(x: &mut Vec<i32>) {
    let slice: &mut [i32] = x.as_mut_slice();
    slice[1] *= 2;
    x.push(123)
}

I understand why f1 fails to compile, but my question is whether there is a workaround or an idiom to use in this case. The code is sound, because if we "inline" f1_sub into f1, yielding f2, the compiler correctly sees that x is only used after the mutably borrowed slice ends. But splitting it does not seem to be possible.

To elaborate, in my use-case the portion equivalent here to "f1_sub" is quite complex, and I'm failing to see a way to avoid copy-pasting it everywhere (beyond macros I guess).

1 Like
2

Can you share your actual code? Otherwise it's hard to speculate on what would let you avoid this illegal borrowing in a clean way.

3

that's not possible with exclusive references, a.k.a. &mut borrows.

you are not using any unsafe, so sound is not the correct term here.

it depends very much on the actual implementation. if you cannot share the actual work, it's impossible to give advices that would be actually useful.

for example, if your code has some kind of interleaving pattern similar to this:

fn foo(container: &mut Container, data: &mut [Data]) {
    // ...
    // a chunk of code process the data, e.g.
    slice.iter_mut().filter(...).find(...);
    // ...
    // modify the container. e.g.
    x.push(...); x.dedup(...); x.retain(...);
    // ...
    // some other code to process the data
    data.iter_mut(...).filter_map(...).fold(...);
    // ...
}

you can then break it up into smaller units, in other words, reduce the borrowed region to minimum, something like:

process_data_step1(x.as_mut_slice());
update_container_step1(&mut x);
process_data_step2(x.as_mut_slice());
update_container_step2(&mut x);

this is just an example. how exactly you can refactor really depends on what you are doing. the most important principle is do not hold borrowed stuff longer than necessary.

1 Like
4

Like others have wrote; restructure so you don't, is probably best.

To still self borrow anyway;

use ouroboros::self_referencing;

#[self_referencing]
struct TwoArgs<'a> {
	x: &'a mut Vec<i32>,
	#[borrows(mut x)]
	slice: &'this mut [i32],
}

/// Split
fn f1(x: &mut Vec<i32>) {
    f1_sub(
		TwoArgsBuilder {
			x,
			slice_builder: |x_data: &mut &mut Vec<i32>| x_data.as_mut_slice(),
			}.build()
    )
}

fn f1_sub(mut a: TwoArgs) {
	a.with_mut(|fields| fields.slice[1] *= 2);

	let crate::ouroboros_impl_two_args::Heads{ x, .. } = a.into_heads();
    x.push(123)
}
5

If you used unsafe to call the method in the manner described, it would be UB due to &mut's no-alias rule, as the borrows must both be active at the point of the function call. Moreover, the borrows that are part of input parameters are considered to last throughout the entirety of the function (and the compiler does optimize based on that condition). The analysis you describe only applies to borrows created locally.

Perhaps think of the "inlining" as so:

/// "Inlined"
fn f2(x: &mut Vec<i32>) {
    let slice: &mut [i32] = x.as_mut_slice();
    let __pass_args_to_fn = (x, slice);
    slice[1] *= 2;
    x.push(123);
    let __borrows_active_throughout_fn = (slice, x);
}