Summary

Safe memcpy from one slice to another of the same type and length.

Motivation

Currently, the only way to quickly copy from one non-u8 slice to another is to use a loop, or unsafe methods like std::ptr::copy_nonoverlapping. This allows us to guarantee a memcpy for Copy types, and is safe.

Detailed design

Add one method to Primitive Type slice.

impl<T> [T] where T: Copy {
    pub fn copy_from_slice(&mut self, src: &[T]);
}

copy_from_slice asserts that src.len() == self.len(), then memcpys the members into self from src. Calling copy_from_slice is semantically equivalent to a memcpy. self shall have exactly the same members as src after a call to copy_from_slice.

Drawbacks

One new method on slice.

Alternatives

copy_from_slice could be called copy_to, and have the order of the arguments switched around. This would follow ptr::copy_nonoverlapping ordering, and not dst = src or .clone_from_slice() ordering.

copy_from_slice could panic only if dst.len() < src.len(). This would be the same as what came before, but we would also lose the guarantee that an uninitialized slice would be fully initialized.

copy_from_slice could be a free function, as it was in the original draft of this document. However, there was overwhelming support for it as a method.

copy_from_slice could be not merged, and clone_from_slice could be specialized to memcpy in cases of T: Copy. I think it’s good to have a specific function to do this, however, which asserts that T: Copy.

Unresolved questions

None, as far as I can tell.