Rust split_at_mut 的实现

Question

I've been reading the Rust Book, and in the section about Unsafe Rust, it shows how to implement a simple version of the split_at_mut method. The given implementation is:

use std::slice;

fn split_at_mut(values: &mut [i32], mid: usize) -> (&mut [i32], &mut [i32]) {
    let len = values.len();
    let ptr = values.as_mut_ptr();

    assert!(mid <= len);

    unsafe {
        (
            slice::from_raw_parts_mut(ptr, mid),
            slice::from_raw_parts_mut(ptr.add(mid), len - mid),
        )
    }
}

However, I came up with this:

fn split_at_mut(values: &mut [i32], mid: usize) -> (&mut [i32], &mut [i32]) {
    let len = values.len();
    assert!(mid <= len);

    let begin = &mut values[..mid] as *mut [i32];
    let end = &mut values[mid..] as *mut [i32];
    
    unsafe {
        (&mut *begin, &mut *end)
    }
}

which produces (as far as I know) the same result, but is, in my opinion, easier to read.

So what makes the given solution "better" than mine? Does my solution has a safety (or other) issue? Is the given solution, in fact, easier to read? Is it about extending this method over other slices? Is it about coding style and "good practice"?

Looking forward to your answers

Answer 1

Here is what I think is going on with why (as another answer wrote) Miri rejects your code:

(
    slice::from_raw_parts_mut(ptr, mid),
    slice::from_raw_parts_mut(ptr.add(mid), len - mid),
)

In this case, you are constructing two non-overlapping &mut references from a pointer that came from the single &mut reference values .

let begin = &mut values[..mid] as *mut [i32];
let end = &mut values[mid..] as *mut [i32];
    
unsafe {
    (&mut *begin, &mut *end)
}

In this case, you are constructing two temporary mutable references, both of which borrow from values (and thus cannot be live at the same time), then “resurrecting” (not a technical term) them from pointers.

Here is a version of the same code which expands some temporaries and syntax sugar:

use std::ops::IndexMut;

let begin = {
    let v1 = &mut values;
    IndexMut::index_mut(v1, ..mid) as *mut [i32]
};
let end = {
    let v2 = &mut values;
    IndexMut::index_mut(v2, mid..) as *mut [i32]
};

unsafe { (&mut *begin, &mut *end) }

Your two pointers begin and end are derived from v1 and v2 , and therefore they are only valid to use as long as v1 and v2 are, but v1 and v2 conflict with each other.

All that said, I can't say for sure whether it wouldn't be okay to allow this program since, after all, it does not create any actual mutable aliasing. I am definitely not educated in the theoretical basis of the Stacked Borrows model that Miri checks.