Rename slice::exact_chunks() to slice::chunks_exact()
See https://github.com/rust-lang/rust/issues/47115#issuecomment-403090815 and https://github.com/rust-lang/rust/issues/47115#issuecomment-424053547
This commit is contained in:
Sebastian Dröge
parent
a072d1bca6
commit
e09e45041b
7 changed files with 77 additions and 77 deletions
|
|
@ -116,7 +116,7 @@
|
|||
#![feature(unsize)]
|
||||
#![feature(allocator_internals)]
|
||||
#![feature(on_unimplemented)]
|
||||
#![feature(exact_chunks)]
|
||||
#![feature(chunks_exact)]
|
||||
#![feature(rustc_const_unstable)]
|
||||
#![feature(const_vec_new)]
|
||||
#![feature(maybe_uninit)]
|
||||
|
|
|
|||
|
|
@ -123,7 +123,7 @@ pub use core::slice::{from_raw_parts, from_raw_parts_mut};
|
|||
pub use core::slice::{from_ref, from_mut};
|
||||
#[stable(feature = "slice_get_slice", since = "1.28.0")]
|
||||
pub use core::slice::SliceIndex;
|
||||
#[unstable(feature = "exact_chunks", issue = "47115")]
|
||||
#[unstable(feature = "chunks_exact", issue = "47115")]
|
||||
pub use core::slice::{ExactChunks, ExactChunksMut};
|
||||
|
||||
////////////////////////////////////////////////////////////////////////////////
|
||||
|
|
|
|||
|
|
@ -20,7 +20,7 @@
|
|||
#![feature(str_escape)]
|
||||
#![feature(try_reserve)]
|
||||
#![feature(unboxed_closures)]
|
||||
#![feature(exact_chunks)]
|
||||
#![feature(chunks_exact)]
|
||||
#![feature(repeat_generic_slice)]
|
||||
|
||||
extern crate alloc_system;
|
||||
|
|
|
|||
|
|
@ -975,27 +975,27 @@ fn test_chunksator_0() {
|
|||
}
|
||||
|
||||
#[test]
|
||||
fn test_exact_chunksator() {
|
||||
fn test_chunks_exactator() {
|
||||
let v = &[1, 2, 3, 4, 5];
|
||||
|
||||
assert_eq!(v.exact_chunks(2).len(), 2);
|
||||
assert_eq!(v.chunks_exact(2).len(), 2);
|
||||
|
||||
let chunks: &[&[_]] = &[&[1, 2], &[3, 4]];
|
||||
assert_eq!(v.exact_chunks(2).collect::<Vec<_>>(), chunks);
|
||||
assert_eq!(v.chunks_exact(2).collect::<Vec<_>>(), chunks);
|
||||
let chunks: &[&[_]] = &[&[1, 2, 3]];
|
||||
assert_eq!(v.exact_chunks(3).collect::<Vec<_>>(), chunks);
|
||||
assert_eq!(v.chunks_exact(3).collect::<Vec<_>>(), chunks);
|
||||
let chunks: &[&[_]] = &[];
|
||||
assert_eq!(v.exact_chunks(6).collect::<Vec<_>>(), chunks);
|
||||
assert_eq!(v.chunks_exact(6).collect::<Vec<_>>(), chunks);
|
||||
|
||||
let chunks: &[&[_]] = &[&[3, 4], &[1, 2]];
|
||||
assert_eq!(v.exact_chunks(2).rev().collect::<Vec<_>>(), chunks);
|
||||
assert_eq!(v.chunks_exact(2).rev().collect::<Vec<_>>(), chunks);
|
||||
}
|
||||
|
||||
#[test]
|
||||
#[should_panic]
|
||||
fn test_exact_chunksator_0() {
|
||||
fn test_chunks_exactator_0() {
|
||||
let v = &[1, 2, 3, 4];
|
||||
let _it = v.exact_chunks(0);
|
||||
let _it = v.chunks_exact(0);
|
||||
}
|
||||
|
||||
#[test]
|
||||
|
|
@ -1235,10 +1235,10 @@ fn test_mut_chunks_0() {
|
|||
}
|
||||
|
||||
#[test]
|
||||
fn test_mut_exact_chunks() {
|
||||
fn test_mut_chunks_exact() {
|
||||
let mut v = [0, 1, 2, 3, 4, 5, 6];
|
||||
assert_eq!(v.exact_chunks_mut(2).len(), 3);
|
||||
for (i, chunk) in v.exact_chunks_mut(3).enumerate() {
|
||||
assert_eq!(v.chunks_exact_mut(2).len(), 3);
|
||||
for (i, chunk) in v.chunks_exact_mut(3).enumerate() {
|
||||
for x in chunk {
|
||||
*x = i as u8;
|
||||
}
|
||||
|
|
@ -1248,9 +1248,9 @@ fn test_mut_exact_chunks() {
|
|||
}
|
||||
|
||||
#[test]
|
||||
fn test_mut_exact_chunks_rev() {
|
||||
fn test_mut_chunks_exact_rev() {
|
||||
let mut v = [0, 1, 2, 3, 4, 5, 6];
|
||||
for (i, chunk) in v.exact_chunks_mut(3).rev().enumerate() {
|
||||
for (i, chunk) in v.chunks_exact_mut(3).rev().enumerate() {
|
||||
for x in chunk {
|
||||
*x = i as u8;
|
||||
}
|
||||
|
|
@ -1261,9 +1261,9 @@ fn test_mut_exact_chunks_rev() {
|
|||
|
||||
#[test]
|
||||
#[should_panic]
|
||||
fn test_mut_exact_chunks_0() {
|
||||
fn test_mut_chunks_exact_0() {
|
||||
let mut v = [1, 2, 3, 4];
|
||||
let _it = v.exact_chunks_mut(0);
|
||||
let _it = v.chunks_exact_mut(0);
|
||||
}
|
||||
|
||||
#[test]
|
||||
|
|
|
|||
|
|
@ -624,7 +624,7 @@ impl<T> [T] {
|
|||
/// not divide the length of the slice, then the last chunk will
|
||||
/// not have length `chunk_size`.
|
||||
///
|
||||
/// See [`exact_chunks`] for a variant of this iterator that returns chunks
|
||||
/// See [`chunks_exact`] for a variant of this iterator that returns chunks
|
||||
/// of always exactly `chunk_size` elements.
|
||||
///
|
||||
/// # Panics
|
||||
|
|
@ -642,7 +642,7 @@ impl<T> [T] {
|
|||
/// assert!(iter.next().is_none());
|
||||
/// ```
|
||||
///
|
||||
/// [`exact_chunks`]: #method.exact_chunks
|
||||
/// [`chunks_exact`]: #method.chunks_exact
|
||||
#[stable(feature = "rust1", since = "1.0.0")]
|
||||
#[inline]
|
||||
pub fn chunks(&self, chunk_size: usize) -> Chunks<T> {
|
||||
|
|
@ -655,7 +655,7 @@ impl<T> [T] {
|
|||
/// not divide the length of the slice, then the last chunk will not
|
||||
/// have length `chunk_size`.
|
||||
///
|
||||
/// See [`exact_chunks_mut`] for a variant of this iterator that returns chunks
|
||||
/// See [`chunks_exact_mut`] for a variant of this iterator that returns chunks
|
||||
/// of always exactly `chunk_size` elements.
|
||||
///
|
||||
/// # Panics
|
||||
|
|
@ -677,7 +677,7 @@ impl<T> [T] {
|
|||
/// assert_eq!(v, &[1, 1, 2, 2, 3]);
|
||||
/// ```
|
||||
///
|
||||
/// [`exact_chunks_mut`]: #method.exact_chunks_mut
|
||||
/// [`chunks_exact_mut`]: #method.chunks_exact_mut
|
||||
#[stable(feature = "rust1", since = "1.0.0")]
|
||||
#[inline]
|
||||
pub fn chunks_mut(&mut self, chunk_size: usize) -> ChunksMut<T> {
|
||||
|
|
@ -702,19 +702,19 @@ impl<T> [T] {
|
|||
/// # Examples
|
||||
///
|
||||
/// ```
|
||||
/// #![feature(exact_chunks)]
|
||||
/// #![feature(chunks_exact)]
|
||||
///
|
||||
/// let slice = ['l', 'o', 'r', 'e', 'm'];
|
||||
/// let mut iter = slice.exact_chunks(2);
|
||||
/// let mut iter = slice.chunks_exact(2);
|
||||
/// assert_eq!(iter.next().unwrap(), &['l', 'o']);
|
||||
/// assert_eq!(iter.next().unwrap(), &['r', 'e']);
|
||||
/// assert!(iter.next().is_none());
|
||||
/// ```
|
||||
///
|
||||
/// [`chunks`]: #method.chunks
|
||||
#[unstable(feature = "exact_chunks", issue = "47115")]
|
||||
#[unstable(feature = "chunks_exact", issue = "47115")]
|
||||
#[inline]
|
||||
pub fn exact_chunks(&self, chunk_size: usize) -> ExactChunks<T> {
|
||||
pub fn chunks_exact(&self, chunk_size: usize) -> ExactChunks<T> {
|
||||
assert!(chunk_size != 0);
|
||||
let rem = self.len() % chunk_size;
|
||||
let len = self.len() - rem;
|
||||
|
|
@ -739,12 +739,12 @@ impl<T> [T] {
|
|||
/// # Examples
|
||||
///
|
||||
/// ```
|
||||
/// #![feature(exact_chunks)]
|
||||
/// #![feature(chunks_exact)]
|
||||
///
|
||||
/// let v = &mut [0, 0, 0, 0, 0];
|
||||
/// let mut count = 1;
|
||||
///
|
||||
/// for chunk in v.exact_chunks_mut(2) {
|
||||
/// for chunk in v.chunks_exact_mut(2) {
|
||||
/// for elem in chunk.iter_mut() {
|
||||
/// *elem += count;
|
||||
/// }
|
||||
|
|
@ -754,9 +754,9 @@ impl<T> [T] {
|
|||
/// ```
|
||||
///
|
||||
/// [`chunks_mut`]: #method.chunks_mut
|
||||
#[unstable(feature = "exact_chunks", issue = "47115")]
|
||||
#[unstable(feature = "chunks_exact", issue = "47115")]
|
||||
#[inline]
|
||||
pub fn exact_chunks_mut(&mut self, chunk_size: usize) -> ExactChunksMut<T> {
|
||||
pub fn chunks_exact_mut(&mut self, chunk_size: usize) -> ExactChunksMut<T> {
|
||||
assert!(chunk_size != 0);
|
||||
let rem = self.len() % chunk_size;
|
||||
let len = self.len() - rem;
|
||||
|
|
@ -3657,20 +3657,20 @@ unsafe impl<'a, T> TrustedRandomAccess for ChunksMut<'a, T> {
|
|||
/// up to `chunk_size-1` elements will be omitted but can be retrieved from
|
||||
/// the [`remainder`] function from the iterator.
|
||||
///
|
||||
/// This struct is created by the [`exact_chunks`] method on [slices].
|
||||
/// This struct is created by the [`chunks_exact`] method on [slices].
|
||||
///
|
||||
/// [`exact_chunks`]: ../../std/primitive.slice.html#method.exact_chunks
|
||||
/// [`chunks_exact`]: ../../std/primitive.slice.html#method.chunks_exact
|
||||
/// [`remainder`]: ../../std/slice/struct.ExactChunks.html#method.remainder
|
||||
/// [slices]: ../../std/primitive.slice.html
|
||||
#[derive(Debug)]
|
||||
#[unstable(feature = "exact_chunks", issue = "47115")]
|
||||
#[unstable(feature = "chunks_exact", issue = "47115")]
|
||||
pub struct ExactChunks<'a, T:'a> {
|
||||
v: &'a [T],
|
||||
rem: &'a [T],
|
||||
chunk_size: usize
|
||||
}
|
||||
|
||||
#[unstable(feature = "exact_chunks", issue = "47115")]
|
||||
#[unstable(feature = "chunks_exact", issue = "47115")]
|
||||
impl<'a, T> ExactChunks<'a, T> {
|
||||
/// Return the remainder of the original slice that is not going to be
|
||||
/// returned by the iterator. The returned slice has at most `chunk_size-1`
|
||||
|
|
@ -3681,7 +3681,7 @@ impl<'a, T> ExactChunks<'a, T> {
|
|||
}
|
||||
|
||||
// FIXME(#26925) Remove in favor of `#[derive(Clone)]`
|
||||
#[unstable(feature = "exact_chunks", issue = "47115")]
|
||||
#[unstable(feature = "chunks_exact", issue = "47115")]
|
||||
impl<'a, T> Clone for ExactChunks<'a, T> {
|
||||
fn clone(&self) -> ExactChunks<'a, T> {
|
||||
ExactChunks {
|
||||
|
|
@ -3692,7 +3692,7 @@ impl<'a, T> Clone for ExactChunks<'a, T> {
|
|||
}
|
||||
}
|
||||
|
||||
#[unstable(feature = "exact_chunks", issue = "47115")]
|
||||
#[unstable(feature = "chunks_exact", issue = "47115")]
|
||||
impl<'a, T> Iterator for ExactChunks<'a, T> {
|
||||
type Item = &'a [T];
|
||||
|
||||
|
|
@ -3737,7 +3737,7 @@ impl<'a, T> Iterator for ExactChunks<'a, T> {
|
|||
}
|
||||
}
|
||||
|
||||
#[unstable(feature = "exact_chunks", issue = "47115")]
|
||||
#[unstable(feature = "chunks_exact", issue = "47115")]
|
||||
impl<'a, T> DoubleEndedIterator for ExactChunks<'a, T> {
|
||||
#[inline]
|
||||
fn next_back(&mut self) -> Option<&'a [T]> {
|
||||
|
|
@ -3751,7 +3751,7 @@ impl<'a, T> DoubleEndedIterator for ExactChunks<'a, T> {
|
|||
}
|
||||
}
|
||||
|
||||
#[unstable(feature = "exact_chunks", issue = "47115")]
|
||||
#[unstable(feature = "chunks_exact", issue = "47115")]
|
||||
impl<'a, T> ExactSizeIterator for ExactChunks<'a, T> {
|
||||
fn is_empty(&self) -> bool {
|
||||
self.v.is_empty()
|
||||
|
|
@ -3761,7 +3761,7 @@ impl<'a, T> ExactSizeIterator for ExactChunks<'a, T> {
|
|||
#[unstable(feature = "trusted_len", issue = "37572")]
|
||||
unsafe impl<'a, T> TrustedLen for ExactChunks<'a, T> {}
|
||||
|
||||
#[unstable(feature = "exact_chunks", issue = "47115")]
|
||||
#[unstable(feature = "chunks_exact", issue = "47115")]
|
||||
impl<'a, T> FusedIterator for ExactChunks<'a, T> {}
|
||||
|
||||
#[doc(hidden)]
|
||||
|
|
@ -3780,20 +3780,20 @@ unsafe impl<'a, T> TrustedRandomAccess for ExactChunks<'a, T> {
|
|||
/// `chunk_size-1` elements will be omitted but can be retrieved from the
|
||||
/// [`into_remainder`] function from the iterator.
|
||||
///
|
||||
/// This struct is created by the [`exact_chunks_mut`] method on [slices].
|
||||
/// This struct is created by the [`chunks_exact_mut`] method on [slices].
|
||||
///
|
||||
/// [`exact_chunks_mut`]: ../../std/primitive.slice.html#method.exact_chunks_mut
|
||||
/// [`chunks_exact_mut`]: ../../std/primitive.slice.html#method.chunks_exact_mut
|
||||
/// [`into_remainder`]: ../../std/slice/struct.ExactChunksMut.html#method.into_remainder
|
||||
/// [slices]: ../../std/primitive.slice.html
|
||||
#[derive(Debug)]
|
||||
#[unstable(feature = "exact_chunks", issue = "47115")]
|
||||
#[unstable(feature = "chunks_exact", issue = "47115")]
|
||||
pub struct ExactChunksMut<'a, T:'a> {
|
||||
v: &'a mut [T],
|
||||
rem: &'a mut [T],
|
||||
chunk_size: usize
|
||||
}
|
||||
|
||||
#[unstable(feature = "exact_chunks", issue = "47115")]
|
||||
#[unstable(feature = "chunks_exact", issue = "47115")]
|
||||
impl<'a, T> ExactChunksMut<'a, T> {
|
||||
/// Return the remainder of the original slice that is not going to be
|
||||
/// returned by the iterator. The returned slice has at most `chunk_size-1`
|
||||
|
|
@ -3803,7 +3803,7 @@ impl<'a, T> ExactChunksMut<'a, T> {
|
|||
}
|
||||
}
|
||||
|
||||
#[unstable(feature = "exact_chunks", issue = "47115")]
|
||||
#[unstable(feature = "chunks_exact", issue = "47115")]
|
||||
impl<'a, T> Iterator for ExactChunksMut<'a, T> {
|
||||
type Item = &'a mut [T];
|
||||
|
||||
|
|
@ -3850,7 +3850,7 @@ impl<'a, T> Iterator for ExactChunksMut<'a, T> {
|
|||
}
|
||||
}
|
||||
|
||||
#[unstable(feature = "exact_chunks", issue = "47115")]
|
||||
#[unstable(feature = "chunks_exact", issue = "47115")]
|
||||
impl<'a, T> DoubleEndedIterator for ExactChunksMut<'a, T> {
|
||||
#[inline]
|
||||
fn next_back(&mut self) -> Option<&'a mut [T]> {
|
||||
|
|
@ -3866,7 +3866,7 @@ impl<'a, T> DoubleEndedIterator for ExactChunksMut<'a, T> {
|
|||
}
|
||||
}
|
||||
|
||||
#[unstable(feature = "exact_chunks", issue = "47115")]
|
||||
#[unstable(feature = "chunks_exact", issue = "47115")]
|
||||
impl<'a, T> ExactSizeIterator for ExactChunksMut<'a, T> {
|
||||
fn is_empty(&self) -> bool {
|
||||
self.v.is_empty()
|
||||
|
|
@ -3876,7 +3876,7 @@ impl<'a, T> ExactSizeIterator for ExactChunksMut<'a, T> {
|
|||
#[unstable(feature = "trusted_len", issue = "37572")]
|
||||
unsafe impl<'a, T> TrustedLen for ExactChunksMut<'a, T> {}
|
||||
|
||||
#[unstable(feature = "exact_chunks", issue = "47115")]
|
||||
#[unstable(feature = "chunks_exact", issue = "47115")]
|
||||
impl<'a, T> FusedIterator for ExactChunksMut<'a, T> {}
|
||||
|
||||
#[doc(hidden)]
|
||||
|
|
|
|||
|
|
@ -33,7 +33,7 @@
|
|||
#![feature(trusted_len)]
|
||||
#![feature(try_from)]
|
||||
#![feature(try_trait)]
|
||||
#![feature(exact_chunks)]
|
||||
#![feature(chunks_exact)]
|
||||
#![feature(align_offset)]
|
||||
#![feature(reverse_bits)]
|
||||
#![feature(inner_deref)]
|
||||
|
|
|
|||
|
|
@ -221,115 +221,115 @@ fn test_chunks_mut_zip() {
|
|||
}
|
||||
|
||||
#[test]
|
||||
fn test_exact_chunks_count() {
|
||||
fn test_chunks_exact_count() {
|
||||
let v: &[i32] = &[0, 1, 2, 3, 4, 5];
|
||||
let c = v.exact_chunks(3);
|
||||
let c = v.chunks_exact(3);
|
||||
assert_eq!(c.count(), 2);
|
||||
|
||||
let v2: &[i32] = &[0, 1, 2, 3, 4];
|
||||
let c2 = v2.exact_chunks(2);
|
||||
let c2 = v2.chunks_exact(2);
|
||||
assert_eq!(c2.count(), 2);
|
||||
|
||||
let v3: &[i32] = &[];
|
||||
let c3 = v3.exact_chunks(2);
|
||||
let c3 = v3.chunks_exact(2);
|
||||
assert_eq!(c3.count(), 0);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn test_exact_chunks_nth() {
|
||||
fn test_chunks_exact_nth() {
|
||||
let v: &[i32] = &[0, 1, 2, 3, 4, 5];
|
||||
let mut c = v.exact_chunks(2);
|
||||
let mut c = v.chunks_exact(2);
|
||||
assert_eq!(c.nth(1).unwrap(), &[2, 3]);
|
||||
assert_eq!(c.next().unwrap(), &[4, 5]);
|
||||
|
||||
let v2: &[i32] = &[0, 1, 2, 3, 4, 5, 6];
|
||||
let mut c2 = v2.exact_chunks(3);
|
||||
let mut c2 = v2.chunks_exact(3);
|
||||
assert_eq!(c2.nth(1).unwrap(), &[3, 4, 5]);
|
||||
assert_eq!(c2.next(), None);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn test_exact_chunks_last() {
|
||||
fn test_chunks_exact_last() {
|
||||
let v: &[i32] = &[0, 1, 2, 3, 4, 5];
|
||||
let c = v.exact_chunks(2);
|
||||
let c = v.chunks_exact(2);
|
||||
assert_eq!(c.last().unwrap(), &[4, 5]);
|
||||
|
||||
let v2: &[i32] = &[0, 1, 2, 3, 4];
|
||||
let c2 = v2.exact_chunks(2);
|
||||
let c2 = v2.chunks_exact(2);
|
||||
assert_eq!(c2.last().unwrap(), &[2, 3]);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn test_exact_chunks_remainder() {
|
||||
fn test_chunks_exact_remainder() {
|
||||
let v: &[i32] = &[0, 1, 2, 3, 4];
|
||||
let c = v.exact_chunks(2);
|
||||
let c = v.chunks_exact(2);
|
||||
assert_eq!(c.remainder(), &[4]);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn test_exact_chunks_zip() {
|
||||
fn test_chunks_exact_zip() {
|
||||
let v1: &[i32] = &[0, 1, 2, 3, 4];
|
||||
let v2: &[i32] = &[6, 7, 8, 9, 10];
|
||||
|
||||
let res = v1.exact_chunks(2)
|
||||
.zip(v2.exact_chunks(2))
|
||||
let res = v1.chunks_exact(2)
|
||||
.zip(v2.chunks_exact(2))
|
||||
.map(|(a, b)| a.iter().sum::<i32>() + b.iter().sum::<i32>())
|
||||
.collect::<Vec<_>>();
|
||||
assert_eq!(res, vec![14, 22]);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn test_exact_chunks_mut_count() {
|
||||
fn test_chunks_exact_mut_count() {
|
||||
let v: &mut [i32] = &mut [0, 1, 2, 3, 4, 5];
|
||||
let c = v.exact_chunks_mut(3);
|
||||
let c = v.chunks_exact_mut(3);
|
||||
assert_eq!(c.count(), 2);
|
||||
|
||||
let v2: &mut [i32] = &mut [0, 1, 2, 3, 4];
|
||||
let c2 = v2.exact_chunks_mut(2);
|
||||
let c2 = v2.chunks_exact_mut(2);
|
||||
assert_eq!(c2.count(), 2);
|
||||
|
||||
let v3: &mut [i32] = &mut [];
|
||||
let c3 = v3.exact_chunks_mut(2);
|
||||
let c3 = v3.chunks_exact_mut(2);
|
||||
assert_eq!(c3.count(), 0);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn test_exact_chunks_mut_nth() {
|
||||
fn test_chunks_exact_mut_nth() {
|
||||
let v: &mut [i32] = &mut [0, 1, 2, 3, 4, 5];
|
||||
let mut c = v.exact_chunks_mut(2);
|
||||
let mut c = v.chunks_exact_mut(2);
|
||||
assert_eq!(c.nth(1).unwrap(), &[2, 3]);
|
||||
assert_eq!(c.next().unwrap(), &[4, 5]);
|
||||
|
||||
let v2: &mut [i32] = &mut [0, 1, 2, 3, 4, 5, 6];
|
||||
let mut c2 = v2.exact_chunks_mut(3);
|
||||
let mut c2 = v2.chunks_exact_mut(3);
|
||||
assert_eq!(c2.nth(1).unwrap(), &[3, 4, 5]);
|
||||
assert_eq!(c2.next(), None);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn test_exact_chunks_mut_last() {
|
||||
fn test_chunks_exact_mut_last() {
|
||||
let v: &mut [i32] = &mut [0, 1, 2, 3, 4, 5];
|
||||
let c = v.exact_chunks_mut(2);
|
||||
let c = v.chunks_exact_mut(2);
|
||||
assert_eq!(c.last().unwrap(), &[4, 5]);
|
||||
|
||||
let v2: &mut [i32] = &mut [0, 1, 2, 3, 4];
|
||||
let c2 = v2.exact_chunks_mut(2);
|
||||
let c2 = v2.chunks_exact_mut(2);
|
||||
assert_eq!(c2.last().unwrap(), &[2, 3]);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn test_exact_chunks_mut_remainder() {
|
||||
fn test_chunks_exact_mut_remainder() {
|
||||
let v: &mut [i32] = &mut [0, 1, 2, 3, 4];
|
||||
let c = v.exact_chunks_mut(2);
|
||||
let c = v.chunks_exact_mut(2);
|
||||
assert_eq!(c.into_remainder(), &[4]);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn test_exact_chunks_mut_zip() {
|
||||
fn test_chunks_exact_mut_zip() {
|
||||
let v1: &mut [i32] = &mut [0, 1, 2, 3, 4];
|
||||
let v2: &[i32] = &[6, 7, 8, 9, 10];
|
||||
|
||||
for (a, b) in v1.exact_chunks_mut(2).zip(v2.exact_chunks(2)) {
|
||||
for (a, b) in v1.chunks_exact_mut(2).zip(v2.chunks_exact(2)) {
|
||||
let sum = b.iter().sum::<i32>();
|
||||
for v in a {
|
||||
*v += sum;
|
||||
|
|
|
|||
Loading…
Add table
Reference in a new issue