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

diff --git a/src/liballoc/lib.rs b/src/liballoc/lib.rs
index 089480c06d20da7beb417fb8eafa08c3fe8e38ae..63ab5043ec51b61b668bf0b86df5d4db071309f5 100644 (file)
--- 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 6c0b1c33a1f7673ee3c4a2ed40a789214a20be4d..22c15fd8a519f8ddfd7d03dcf19c6fc41f62e9e6 100644 (file)
--- 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 710c659ac53962b18c1b6bb4bf75900171ac9fca..6ff39227555fe179872fd8597071228679b73885 100644 (file)
--- 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 f33bf64d40bdef79e987a809039b44891e0aad13..c214c59618d3eb06d07849902fa1f23af16ca051 100644 (file)
--- 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::<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]

diff --git a/src/libcore/slice/mod.rs b/src/libcore/slice/mod.rs
index aed9020d9d14a09b8124310dd23716310e4efc7c..68cefe4b6a8a73fe41891bdab12181f6a6555ce0 100644 (file)
--- a/src/libcore/slice/mod.rs
+++ b/src/libcore/slice/mod.rs
@@ -624,7 +624,7 @@ pub fn windows(&self, size: usize) -> Windows<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 @@ pub fn windows(&self, size: usize) -> Windows<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 @@ pub fn chunks(&self, chunk_size: usize) -> Chunks<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 @@ pub fn chunks(&self, chunk_size: usize) -> Chunks<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 @@ pub fn chunks_mut(&mut self, chunk_size: usize) -> ChunksMut<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 @@ pub fn exact_chunks(&self, chunk_size: usize) -> ExactChunks<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 @@ pub fn exact_chunks(&self, chunk_size: usize) -> ExactChunks<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 @@ 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<Self::Item> {
     }
 }
 
-#[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<Self::Item> {
     }
 }
 
-#[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 8fc32f40b9920275a3f364edd5b0e44d556fe257..97e5a5cee39d8691ac638a2217941e43f5e05b6f 100644 (file)
--- 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 d46a35ab82cfcae93dbaed7f6f3ceba5853adba7..b82ffb60b8955d8d0371032890de0ef5db36ae0e 100644 (file)
--- 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::<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;