Keyboard shortcuts

Press or to navigate between chapters

Press S or / to search in the book

Press ? to show this help

Press Esc to hide this help

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.