Skip to content

Commit 203cf2d

Browse files
author
Jethro Beekman
committed
Add rsplit_array variants to slices and arrays
1 parent 0b42dea commit 203cf2d

File tree

4 files changed

+222
-0
lines changed

4 files changed

+222
-0
lines changed

‎library/core/src/array/mod.rs

+78
Original file line numberDiff line numberDiff line change
@@ -645,6 +645,84 @@ impl<T, const N: usize> [T; N] {
645645
pub fn split_array_mut<const M: usize>(&mut self) -> (&mut [T; M], &mut [T]) {
646646
(&mut self[..]).split_array_mut::<M>()
647647
}
648+
649+
/// Divides one array reference into two at an index from the end.
650+
///
651+
/// The first will contain all indices from `[0, N - M)` (excluding
652+
/// the index `N - M` itself) and the second will contain all
653+
/// indices from `[N - M, N)` (excluding the index `N` itself).
654+
///
655+
/// # Panics
656+
///
657+
/// Panics if `M > N`.
658+
///
659+
/// # Examples
660+
///
661+
/// ```
662+
/// #![feature(split_array)]
663+
///
664+
/// let v = [1, 2, 3, 4, 5, 6];
665+
///
666+
/// {
667+
/// let (left, right) = v.rsplit_array_ref::<0>();
668+
/// assert_eq!(left, &[1, 2, 3, 4, 5, 6]);
669+
/// assert_eq!(right, &[]);
670+
/// }
671+
///
672+
/// {
673+
/// let (left, right) = v.rsplit_array_ref::<2>();
674+
/// assert_eq!(left, &[1, 2, 3, 4]);
675+
/// assert_eq!(right, &[5, 6]);
676+
/// }
677+
///
678+
/// {
679+
/// let (left, right) = v.rsplit_array_ref::<6>();
680+
/// assert_eq!(left, &[]);
681+
/// assert_eq!(right, &[1, 2, 3, 4, 5, 6]);
682+
/// }
683+
/// ```
684+
#[unstable(
685+
feature = "split_array",
686+
reason = "return type should have array as 2nd element",
687+
issue = "90091"
688+
)]
689+
#[inline]
690+
pub fn rsplit_array_ref<const M: usize>(&self) -> (&[T], &[T; M]) {
691+
(&self[..]).rsplit_array_ref::<M>()
692+
}
693+
694+
/// Divides one mutable array reference into two at an index from the end.
695+
///
696+
/// The first will contain all indices from `[0, N - M)` (excluding
697+
/// the index `N - M` itself) and the second will contain all
698+
/// indices from `[N - M, N)` (excluding the index `N` itself).
699+
///
700+
/// # Panics
701+
///
702+
/// Panics if `M > N`.
703+
///
704+
/// # Examples
705+
///
706+
/// ```
707+
/// #![feature(split_array)]
708+
///
709+
/// let mut v = [1, 0, 3, 0, 5, 6];
710+
/// let (left, right) = v.rsplit_array_mut::<4>();
711+
/// assert_eq!(left, &mut [1, 0]);
712+
/// assert_eq!(right, &mut [3, 0, 5, 6][..]);
713+
/// left[1] = 2;
714+
/// right[1] = 4;
715+
/// assert_eq!(v, [1, 2, 3, 4, 5, 6]);
716+
/// ```
717+
#[unstable(
718+
feature = "split_array",
719+
reason = "return type should have array as 2nd element",
720+
issue = "90091"
721+
)]
722+
#[inline]
723+
pub fn rsplit_array_mut<const M: usize>(&mut self) -> (&mut [T], &mut [T; M]) {
724+
(&mut self[..]).rsplit_array_mut::<M>()
725+
}
648726
}
649727

650728
/// Pulls `N` items from `iter` and returns them as an array. If the iterator

‎library/core/src/slice/mod.rs

+78
Original file line numberDiff line numberDiff line change
@@ -1705,6 +1705,84 @@ impl<T> [T] {
17051705
unsafe { (&mut *(a.as_mut_ptr() as *mut [T; N]), b) }
17061706
}
17071707

1708+
/// Divides one slice into an array and a remainder slice at an index from
1709+
/// the end.
1710+
///
1711+
/// The slice will contain all indices from `[0, len - N)` (excluding
1712+
/// the index `len - N` itself) and the array will contain all
1713+
/// indices from `[len - N, len)` (excluding the index `len` itself).
1714+
///
1715+
/// # Panics
1716+
///
1717+
/// Panics if `N > len`.
1718+
///
1719+
/// # Examples
1720+
///
1721+
/// ```
1722+
/// #![feature(split_array)]
1723+
///
1724+
/// let v = &[1, 2, 3, 4, 5, 6][..];
1725+
///
1726+
/// {
1727+
/// let (left, right) = v.rsplit_array_ref::<0>();
1728+
/// assert_eq!(left, [1, 2, 3, 4, 5, 6]);
1729+
/// assert_eq!(right, &[]);
1730+
/// }
1731+
///
1732+
/// {
1733+
/// let (left, right) = v.rsplit_array_ref::<2>();
1734+
/// assert_eq!(left, [1, 2, 3, 4]);
1735+
/// assert_eq!(right, &[5, 6]);
1736+
/// }
1737+
///
1738+
/// {
1739+
/// let (left, right) = v.rsplit_array_ref::<6>();
1740+
/// assert_eq!(left, []);
1741+
/// assert_eq!(right, &[1, 2, 3, 4, 5, 6]);
1742+
/// }
1743+
/// ```
1744+
#[unstable(feature = "split_array", reason = "new API", issue = "90091")]
1745+
#[inline]
1746+
pub fn rsplit_array_ref<const N: usize>(&self) -> (&[T], &[T; N]) {
1747+
assert!(N <= self.len());
1748+
let (a, b) = self.split_at(self.len() - N);
1749+
// SAFETY: b points to [T; N]? Yes it's [T] of length N (checked by split_at)
1750+
unsafe { (a, &*(b.as_ptr() as *const [T; N])) }
1751+
}
1752+
1753+
/// Divides one mutable slice into an array and a remainder slice at an
1754+
/// index from the end.
1755+
///
1756+
/// The slice will contain all indices from `[0, len - N)` (excluding
1757+
/// the index `N` itself) and the array will contain all
1758+
/// indices from `[len - N, len)` (excluding the index `len` itself).
1759+
///
1760+
/// # Panics
1761+
///
1762+
/// Panics if `N > len`.
1763+
///
1764+
/// # Examples
1765+
///
1766+
/// ```
1767+
/// #![feature(split_array)]
1768+
///
1769+
/// let mut v = &mut [1, 0, 3, 0, 5, 6][..];
1770+
/// let (left, right) = v.rsplit_array_mut::<4>();
1771+
/// assert_eq!(left, [1, 0]);
1772+
/// assert_eq!(right, &mut [3, 0, 5, 6]);
1773+
/// left[1] = 2;
1774+
/// right[1] = 4;
1775+
/// assert_eq!(v, [1, 2, 3, 4, 5, 6]);
1776+
/// ```
1777+
#[unstable(feature = "split_array", reason = "new API", issue = "90091")]
1778+
#[inline]
1779+
pub fn rsplit_array_mut<const N: usize>(&mut self) -> (&mut [T], &mut [T; N]) {
1780+
assert!(N <= self.len());
1781+
let (a, b) = self.split_at_mut(self.len() - N);
1782+
// SAFETY: b points to [T; N]? Yes it's [T] of length N (checked by split_at_mut)
1783+
unsafe { (a, &mut *(b.as_mut_ptr() as *mut [T; N])) }
1784+
}
1785+
17081786
/// Returns an iterator over subslices separated by elements that match
17091787
/// `pred`. The matched element is not contained in the subslices.
17101788
///

‎library/core/tests/array.rs

+33
Original file line numberDiff line numberDiff line change
@@ -459,6 +459,23 @@ fn array_split_array_mut() {
459459
}
460460
}
461461

462+
#[test]
463+
fn array_rsplit_array_mut() {
464+
let mut v = [1, 2, 3, 4, 5, 6];
465+
466+
{
467+
let (left, right) = v.rsplit_array_mut::<0>();
468+
assert_eq!(left, &mut [1, 2, 3, 4, 5, 6]);
469+
assert_eq!(right, &mut []);
470+
}
471+
472+
{
473+
let (left, right) = v.rsplit_array_mut::<6>();
474+
assert_eq!(left, &mut []);
475+
assert_eq!(right, &mut [1, 2, 3, 4, 5, 6]);
476+
}
477+
}
478+
462479
#[should_panic]
463480
#[test]
464481
fn array_split_array_ref_out_of_bounds() {
@@ -475,6 +492,22 @@ fn array_split_array_mut_out_of_bounds() {
475492
v.split_array_mut::<7>();
476493
}
477494

495+
#[should_panic]
496+
#[test]
497+
fn array_rsplit_array_ref_out_of_bounds() {
498+
let v = [1, 2, 3, 4, 5, 6];
499+
500+
v.rsplit_array_ref::<7>();
501+
}
502+
503+
#[should_panic]
504+
#[test]
505+
fn array_rsplit_array_mut_out_of_bounds() {
506+
let mut v = [1, 2, 3, 4, 5, 6];
507+
508+
v.rsplit_array_mut::<7>();
509+
}
510+
478511
#[test]
479512
fn array_intoiter_advance_by() {
480513
use std::cell::Cell;

‎library/core/tests/slice.rs

+33
Original file line numberDiff line numberDiff line change
@@ -2219,6 +2219,23 @@ fn slice_split_array_mut() {
22192219
}
22202220
}
22212221

2222+
#[test]
2223+
fn slice_rsplit_array_mut() {
2224+
let v = &mut [1, 2, 3, 4, 5, 6][..];
2225+
2226+
{
2227+
let (left, right) = v.rsplit_array_mut::<0>();
2228+
assert_eq!(left, [1, 2, 3, 4, 5, 6]);
2229+
assert_eq!(right, &mut []);
2230+
}
2231+
2232+
{
2233+
let (left, right) = v.rsplit_array_mut::<6>();
2234+
assert_eq!(left, []);
2235+
assert_eq!(right, &mut [1, 2, 3, 4, 5, 6]);
2236+
}
2237+
}
2238+
22222239
#[should_panic]
22232240
#[test]
22242241
fn slice_split_array_ref_out_of_bounds() {
@@ -2235,6 +2252,22 @@ fn slice_split_array_mut_out_of_bounds() {
22352252
v.split_array_mut::<7>();
22362253
}
22372254

2255+
#[should_panic]
2256+
#[test]
2257+
fn slice_rsplit_array_ref_out_of_bounds() {
2258+
let v = &[1, 2, 3, 4, 5, 6][..];
2259+
2260+
v.rsplit_array_ref::<7>();
2261+
}
2262+
2263+
#[should_panic]
2264+
#[test]
2265+
fn slice_rsplit_array_mut_out_of_bounds() {
2266+
let v = &mut [1, 2, 3, 4, 5, 6][..];
2267+
2268+
v.rsplit_array_mut::<7>();
2269+
}
2270+
22382271
macro_rules! take_tests {
22392272
(slice: &[], $($tts:tt)*) => {
22402273
take_tests!(ty: &[()], slice: &[], $($tts)*);

0 commit comments

Comments
 (0)