From e09e45041b5cab9d849b554824c6683de6372e41 Mon Sep 17 00:00:00 2001 From: =?utf8?q?Sebastian=20Dr=C3=B6ge?= Date: Mon, 24 Sep 2018 22:43:06 +0300 Subject: [PATCH] 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 --- src/liballoc/lib.rs | 2 +- src/liballoc/slice.rs | 2 +- src/liballoc/tests/lib.rs | 2 +- src/liballoc/tests/slice.rs | 30 +++++++++---------- src/libcore/slice/mod.rs | 58 ++++++++++++++++++------------------- src/libcore/tests/lib.rs | 2 +- src/libcore/tests/slice.rs | 58 ++++++++++++++++++------------------- 7 files changed, 77 insertions(+), 77 deletions(-) diff --git a/src/liballoc/lib.rs b/src/liballoc/lib.rs index 089480c06d2..63ab5043ec5 100644 --- a/src/liballoc/lib.rs +++ b/src/liballoc/lib.rs @@ -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)] diff --git a/src/liballoc/slice.rs b/src/liballoc/slice.rs index 6c0b1c33a1f..22c15fd8a51 100644 --- a/src/liballoc/slice.rs +++ b/src/liballoc/slice.rs @@ -123,7 +123,7 @@ 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}; //////////////////////////////////////////////////////////////////////////////// diff --git a/src/liballoc/tests/lib.rs b/src/liballoc/tests/lib.rs index 710c659ac53..6ff39227555 100644 --- a/src/liballoc/tests/lib.rs +++ b/src/liballoc/tests/lib.rs @@ -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; diff --git a/src/liballoc/tests/slice.rs b/src/liballoc/tests/slice.rs index f33bf64d40b..c214c59618d 100644 --- a/src/liballoc/tests/slice.rs +++ b/src/liballoc/tests/slice.rs @@ -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::>(), chunks); + assert_eq!(v.chunks_exact(2).collect::>(), chunks); let chunks: &[&[_]] = &[&[1, 2, 3]]; - assert_eq!(v.exact_chunks(3).collect::>(), chunks); + assert_eq!(v.chunks_exact(3).collect::>(), chunks); let chunks: &[&[_]] = &[]; - assert_eq!(v.exact_chunks(6).collect::>(), chunks); + assert_eq!(v.chunks_exact(6).collect::>(), chunks); let chunks: &[&[_]] = &[&[3, 4], &[1, 2]]; - assert_eq!(v.exact_chunks(2).rev().collect::>(), chunks); + assert_eq!(v.chunks_exact(2).rev().collect::>(), 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] diff --git a/src/libcore/slice/mod.rs b/src/libcore/slice/mod.rs index aed9020d9d1..68cefe4b6a8 100644 --- a/src/libcore/slice/mod.rs +++ b/src/libcore/slice/mod.rs @@ -624,7 +624,7 @@ pub fn windows(&self, size: usize) -> Windows { /// 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 @@ pub fn windows(&self, size: usize) -> Windows { /// 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 { @@ -655,7 +655,7 @@ pub fn chunks(&self, chunk_size: usize) -> Chunks { /// 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 @@ pub fn chunks(&self, chunk_size: usize) -> Chunks { /// 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 { @@ -702,19 +702,19 @@ pub fn chunks_mut(&mut self, chunk_size: usize) -> ChunksMut { /// # 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 { + pub fn chunks_exact(&self, chunk_size: usize) -> ExactChunks { assert!(chunk_size != 0); let rem = self.len() % chunk_size; let len = self.len() - rem; @@ -739,12 +739,12 @@ pub fn exact_chunks(&self, chunk_size: usize) -> ExactChunks { /// # 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 @@ pub fn exact_chunks(&self, chunk_size: usize) -> ExactChunks { /// ``` /// /// [`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 { + pub fn chunks_exact_mut(&mut self, chunk_size: usize) -> ExactChunksMut { assert!(chunk_size != 0); let rem = self.len() % chunk_size; let len = self.len() - rem; @@ -3657,20 +3657,20 @@ fn may_have_side_effect() -> bool { false } /// 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 @@ pub fn remainder(&self) -> &'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 @@ fn clone(&self) -> 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 @@ fn last(mut self) -> Option { } } -#[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 @@ fn next_back(&mut self) -> Option<&'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 @@ fn is_empty(&self) -> bool { #[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 @@ fn may_have_side_effect() -> bool { false } /// `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 @@ pub fn into_remainder(self) -> &'a mut [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 @@ fn last(mut self) -> Option { } } -#[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 @@ fn next_back(&mut self) -> Option<&'a mut [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 @@ fn is_empty(&self) -> bool { #[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)] diff --git a/src/libcore/tests/lib.rs b/src/libcore/tests/lib.rs index 8fc32f40b99..97e5a5cee39 100644 --- a/src/libcore/tests/lib.rs +++ b/src/libcore/tests/lib.rs @@ -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)] diff --git a/src/libcore/tests/slice.rs b/src/libcore/tests/slice.rs index d46a35ab82c..b82ffb60b89 100644 --- a/src/libcore/tests/slice.rs +++ b/src/libcore/tests/slice.rs @@ -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::() + b.iter().sum::()) .collect::>(); 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::(); for v in a { *v += sum; -- 2.44.0