libs (slice)
Safe memcpy from one slice to another of the same type and length.
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.
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.
One new method on slice.
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.
None, as far as I can tell.