user0/rust
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

Stabilize slice_select_nth_unstable

Browse source 
This stabilizes the functionality in slice_partition_at_index,
but under the names `select_nth_unstable*`.  The functions
`partition_at_index*` are left as deprecated, to be removed in
a later release.

Closes #55300
This commit is contained in:
James Gill 2020-10-06 21:54:05 -04:00 • committed by James Gill
parent 576e2277ac
commit 01ac5a97c9
2 changed files with 69 additions and 31 deletions
Download patch file Download diff file Expand all files Collapse all files

68
library/core/src/slice/mod.rs
View file

@ -2034,6 +2034,50 @@ impl<T> [T] {
sort::quicksort(self, |a, b| f(a).lt(&f(b)));
}
/// Reorder the slice such that the element at `index` is at its final sorted position.
#[unstable(feature = "slice_partition_at_index", issue = "55300")]
#[rustc_deprecated(since = "1.49.0", reason = "use the select_nth_unstable() instead")]
#[inline]
pub fn partition_at_index(&mut self, index: usize) -> (&mut [T], &mut T, &mut [T])
where
T: Ord,
{
self.select_nth_unstable(index)
}
/// Reorder the slice with a comparator function such that the element at `index` is at its
/// final sorted position.
#[unstable(feature = "slice_partition_at_index", issue = "55300")]
#[rustc_deprecated(since = "1.49.0", reason = "use select_nth_unstable_by() instead")]
#[inline]
pub fn partition_at_index_by<F>(
&mut self,
index: usize,
compare: F,
) -> (&mut [T], &mut T, &mut [T])
where
F: FnMut(&T, &T) -> Ordering,
{
self.select_nth_unstable_by(index, compare)
}
/// Reorder the slice with a key extraction function such that the element at `index` is at its
/// final sorted position.
#[unstable(feature = "slice_partition_at_index", issue = "55300")]
#[rustc_deprecated(since = "1.49.0", reason = "use the select_nth_unstable_by_key() instead")]
#[inline]
pub fn partition_at_index_by_key<K, F>(
&mut self,
index: usize,
f: F,
) -> (&mut [T], &mut T, &mut [T])
where
F: FnMut(&T) -> K,
K: Ord,
{
self.select_nth_unstable_by_key(index, f)
}
/// Reorder the slice such that the element at `index` is at its final sorted position.
///
/// This reordering has the additional property that any value at position `i < index` will be
@ -2058,12 +2102,10 @@ impl<T> [T] {
/// # Examples
///
/// ```
/// #![feature(slice_partition_at_index)]
///
/// let mut v = [-5i32, 4, 1, -3, 2];
///
/// // Find the median
/// v.partition_at_index(2);
/// v.select_nth_unstable(2);
///
/// // We are only guaranteed the slice will be one of the following, based on the way we sort
/// // about the specified index.
@ -2072,9 +2114,9 @@ impl<T> [T] {
/// v == [-3, -5, 1, 4, 2] ||
/// v == [-5, -3, 1, 4, 2]);
/// ```
#[unstable(feature = "slice_partition_at_index", issue = "55300")]
#[stable(feature = "slice_select_nth_unstable", since = "1.49.0")]
#[inline]
pub fn partition_at_index(&mut self, index: usize) -> (&mut [T], &mut T, &mut [T])
pub fn select_nth_unstable(&mut self, index: usize) -> (&mut [T], &mut T, &mut [T])
where
T: Ord,
{
@ -2108,12 +2150,10 @@ impl<T> [T] {
/// # Examples
///
/// ```
/// #![feature(slice_partition_at_index)]
///
/// let mut v = [-5i32, 4, 1, -3, 2];
///
/// // Find the median as if the slice were sorted in descending order.
/// v.partition_at_index_by(2, |a, b| b.cmp(a));
/// v.select_nth_unstable_by(2, |a, b| b.cmp(a));
///
/// // We are only guaranteed the slice will be one of the following, based on the way we sort
/// // about the specified index.
@ -2122,9 +2162,9 @@ impl<T> [T] {
/// v == [4, 2, 1, -5, -3] ||
/// v == [4, 2, 1, -3, -5]);
/// ```
#[unstable(feature = "slice_partition_at_index", issue = "55300")]
#[stable(feature = "slice_select_nth_unstable", since = "1.49.0")]
#[inline]
pub fn partition_at_index_by<F>(
pub fn select_nth_unstable_by<F>(
&mut self,
index: usize,
mut compare: F,
@ -2162,12 +2202,10 @@ impl<T> [T] {
/// # Examples
///
/// ```
/// #![feature(slice_partition_at_index)]
///
/// let mut v = [-5i32, 4, 1, -3, 2];
///
/// // Return the median as if the array were sorted according to absolute value.
/// v.partition_at_index_by_key(2, |a| a.abs());
/// v.select_nth_unstable_by_key(2, |a| a.abs());
///
/// // We are only guaranteed the slice will be one of the following, based on the way we sort
/// // about the specified index.
@ -2176,9 +2214,9 @@ impl<T> [T] {
/// v == [2, 1, -3, 4, -5] ||
/// v == [2, 1, -3, -5, 4]);
/// ```
#[unstable(feature = "slice_partition_at_index", issue = "55300")]
#[stable(feature = "slice_select_nth_unstable", since = "1.49.0")]
#[inline]
pub fn partition_at_index_by_key<K, F>(
pub fn select_nth_unstable_by_key<K, F>(
&mut self,
index: usize,
mut f: F,