Rollup merge of #127668 - spencer3035:improve-slice-doc, r=jhpratt · model-checking/verify-rust-std@a7c1f60 (original) (raw)

`@@ -388,6 +388,9 @@ pub(super) trait SplitIter: DoubleEndedIterator {

`

388

388

```` /// ```

`389`

`389`

`/// let slice = [10, 40, 33, 20];

`

`390`

`390`

`/// let mut iter = slice.split(|num| num % 3 == 0);

`

``

`391`

`+

/// assert_eq!(iter.next(), Some(&[10, 40][..]));

`

``

`392`

`+

/// assert_eq!(iter.next(), Some(&[20][..]));

`

``

`393`

`+

/// assert_eq!(iter.next(), None);

`

`391`

`394`

```` /// ```

392

395

`///

`

393

396

`` /// [split]: slice::split

``

`@@ -541,6 +544,9 @@ impl<T, P> FusedIterator for Split<'_, T, P> where P: FnMut(&T) -> bool {}

`

541

544

```` /// ```

`542`

`545`

`/// let slice = [10, 40, 33, 20];

`

`543`

`546`

`/// let mut iter = slice.split_inclusive(|num| num % 3 == 0);

`

``

`547`

`+

/// assert_eq!(iter.next(), Some(&[10, 40, 33][..]));

`

``

`548`

`+

/// assert_eq!(iter.next(), Some(&[20][..]));

`

``

`549`

`+

/// assert_eq!(iter.next(), None);

`

`544`

`550`

```` /// ```

545

551

`///

`

546

552

`` /// [split_inclusive]: slice::split_inclusive

``

`@@ -914,7 +920,10 @@ impl<T, P> FusedIterator for SplitInclusiveMut<'_, T, P> where P: FnMut(&T) -> b

`

914

920

`///

`

915

921

```` /// ```

`916`

`922`

`/// let slice = [11, 22, 33, 0, 44, 55];

`

`917`

``

`-

/// let iter = slice.rsplit(|num| *num == 0);

`

``

`923`

`+

/// let mut iter = slice.rsplit(|num| *num == 0);

`

``

`924`

`+

/// assert_eq!(iter.next(), Some(&[44, 55][..]));

`

``

`925`

`+

/// assert_eq!(iter.next(), Some(&[11, 22, 33][..]));

`

``

`926`

`+

/// assert_eq!(iter.next(), None);

`

`918`

`927`

```` /// ```

919

928

`///

`

920

929

`` /// [rsplit]: slice::rsplit

``

`@@ -1134,7 +1143,10 @@ impl<T, I: SplitIter<Item = T>> Iterator for GenericSplitN {

`

1134

1143

`///

`

1135

1144

```` /// ```

`1136`

`1145`

`/// let slice = [10, 40, 30, 20, 60, 50];

`

`1137`

``

`-

/// let iter = slice.splitn(2, |num| *num % 3 == 0);

`

``

`1146`

`+

/// let mut iter = slice.splitn(2, |num| *num % 3 == 0);

`

``

`1147`

`+

/// assert_eq!(iter.next(), Some(&[10, 40][..]));

`

``

`1148`

`+

/// assert_eq!(iter.next(), Some(&[20, 60, 50][..]));

`

``

`1149`

`+

/// assert_eq!(iter.next(), None);

`

`1138`

`1150`

```` /// ```

1139

1151

`///

`

1140

1152

`` /// [splitn]: slice::splitn

``

`@@ -1175,7 +1187,10 @@ where

`

1175

1187

`///

`

1176

1188

```` /// ```

`1177`

`1189`

`/// let slice = [10, 40, 30, 20, 60, 50];

`

`1178`

``

`-

/// let iter = slice.rsplitn(2, |num| *num % 3 == 0);

`

``

`1190`

`+

/// let mut iter = slice.rsplitn(2, |num| *num % 3 == 0);

`

``

`1191`

`+

/// assert_eq!(iter.next(), Some(&[50][..]));

`

``

`1192`

`+

/// assert_eq!(iter.next(), Some(&[10, 40, 30, 20][..]));

`

``

`1193`

`+

/// assert_eq!(iter.next(), None);

`

`1179`

`1194`

```` /// ```

1180

1195

`///

`

1181

1196

`` /// [rsplitn]: slice::rsplitn

``

`@@ -1300,7 +1315,11 @@ forward_iterator! { RSplitNMut: T, &'a mut [T] }

`

1300

1315

`///

`

1301

1316

```` /// ```

`1302`

`1317`

`/// let slice = ['r', 'u', 's', 't'];

`

`1303`

``

`-

/// let iter = slice.windows(2);

`

``

`1318`

`+

/// let mut iter = slice.windows(2);

`

``

`1319`

`+

/// assert_eq!(iter.next(), Some(&['r', 'u'][..]));

`

``

`1320`

`+

/// assert_eq!(iter.next(), Some(&['u', 's'][..]));

`

``

`1321`

`+

/// assert_eq!(iter.next(), Some(&['s', 't'][..]));

`

``

`1322`

`+

/// assert_eq!(iter.next(), None);

`

`1304`

`1323`

```` /// ```

1305

1324

`///

`

1306

1325

`` /// [windows]: slice::windows

``

`@@ -1448,7 +1467,11 @@ unsafe impl<'a, T> TrustedRandomAccessNoCoerce for Windows<'a, T> {

`

1448

1467

`///

`

1449

1468

```` /// ```

`1450`

`1469`

`/// let slice = ['l', 'o', 'r', 'e', 'm'];

`

`1451`

``

`-

/// let iter = slice.chunks(2);

`

``

`1470`

`+

/// let mut iter = slice.chunks(2);

`

``

`1471`

`+

/// assert_eq!(iter.next(), Some(&['l', 'o'][..]));

`

``

`1472`

`+

/// assert_eq!(iter.next(), Some(&['r', 'e'][..]));

`

``

`1473`

`+

/// assert_eq!(iter.next(), Some(&['m'][..]));

`

``

`1474`

`+

/// assert_eq!(iter.next(), None);

`

`1452`

`1475`

```` /// ```

1453

1476

`///

`

1454

1477

`` /// [chunks]: slice::chunks

``

`@@ -1819,7 +1842,10 @@ unsafe impl Sync for ChunksMut<'_, T> where T: Sync {}

`

1819

1842

`///

`

1820

1843

```` /// ```

`1821`

`1844`

`/// let slice = ['l', 'o', 'r', 'e', 'm'];

`

`1822`

``

`-

/// let iter = slice.chunks_exact(2);

`

``

`1845`

`+

/// let mut iter = slice.chunks_exact(2);

`

``

`1846`

`+

/// assert_eq!(iter.next(), Some(&['l', 'o'][..]));

`

``

`1847`

`+

/// assert_eq!(iter.next(), Some(&['r', 'e'][..]));

`

``

`1848`

`+

/// assert_eq!(iter.next(), None);

`

`1823`

`1849`

```` /// ```

1824

1850

`///

`

1825

1851

`` /// [chunks_exact]: slice::chunks_exact

``

`@@ -2163,7 +2189,11 @@ unsafe impl Sync for ChunksExactMut<'_, T> where T: Sync {}

`

2163

2189

`/// #![feature(array_windows)]

`

2164

2190

`///

`

2165

2191

`/// let slice = [0, 1, 2, 3];

`

2166

``

`-

/// let iter = slice.array_windows::<2>();

`

``

2192

`+

/// let mut iter = slice.array_windows::<2>();

`

``

2193

`+

/// assert_eq!(iter.next(), Some(&[0, 1]));

`

``

2194

`+

/// assert_eq!(iter.next(), Some(&[1, 2]));

`

``

2195

`+

/// assert_eq!(iter.next(), Some(&[2, 3]));

`

``

2196

`+

/// assert_eq!(iter.next(), None);

`

2167

2197

```` /// ```

`2168`

`2198`

`///

`

`2169`

`2199`

`` /// [`array_windows`]: slice::array_windows

``

`@@ -2285,7 +2315,10 @@ impl<T, const N: usize> ExactSizeIterator for ArrayWindows<'_, T, N> {

`

`2285`

`2315`

`/// #![feature(array_chunks)]

`

`2286`

`2316`

`///

`

`2287`

`2317`

`/// let slice = ['l', 'o', 'r', 'e', 'm'];

`

`2288`

``

`-

/// let iter = slice.array_chunks::<2>();

`

``

`2318`

`+

/// let mut iter = slice.array_chunks::<2>();

`

``

`2319`

`+

/// assert_eq!(iter.next(), Some(&['l', 'o']));

`

``

`2320`

`+

/// assert_eq!(iter.next(), Some(&['r', 'e']));

`

``

`2321`

`+

/// assert_eq!(iter.next(), None);

`

`2289`

`2322`

```` /// ```

2290

2323

`///

`

2291

2324

`` /// [array_chunks]: slice::array_chunks

``

`@@ -2526,7 +2559,11 @@ unsafe impl<'a, T, const N: usize> TrustedRandomAccessNoCoerce for ArrayChunksMu

`

2526

2559

`///

`

2527

2560

```` /// ```

`2528`

`2561`

`/// let slice = ['l', 'o', 'r', 'e', 'm'];

`

`2529`

``

`-

/// let iter = slice.rchunks(2);

`

``

`2562`

`+

/// let mut iter = slice.rchunks(2);

`

``

`2563`

`+

/// assert_eq!(iter.next(), Some(&['e', 'm'][..]));

`

``

`2564`

`+

/// assert_eq!(iter.next(), Some(&['o', 'r'][..]));

`

``

`2565`

`+

/// assert_eq!(iter.next(), Some(&['l'][..]));

`

``

`2566`

`+

/// assert_eq!(iter.next(), None);

`

`2530`

`2567`

```` /// ```

2531

2568

`///

`

2532

2569

`` /// [rchunks]: slice::rchunks

``

`@@ -2892,7 +2929,10 @@ unsafe impl Sync for RChunksMut<'_, T> where T: Sync {}

`

2892

2929

`///

`

2893

2930

```` /// ```

`2894`

`2931`

`/// let slice = ['l', 'o', 'r', 'e', 'm'];

`

`2895`

``

`-

/// let iter = slice.rchunks_exact(2);

`

``

`2932`

`+

/// let mut iter = slice.rchunks_exact(2);

`

``

`2933`

`+

/// assert_eq!(iter.next(), Some(&['e', 'm'][..]));

`

``

`2934`

`+

/// assert_eq!(iter.next(), Some(&['o', 'r'][..]));

`

``

`2935`

`+

/// assert_eq!(iter.next(), None);

`

`2896`

`2936`

```` /// ```

2897

2937

`///

`

2898

2938

`` /// [rchunks_exact]: slice::rchunks_exact

``