Skip to content
This commit does not belong to any branch on this repository, and may belong to a fork outside of the repository.

Commit 3be85df

Browse files
kennytmkennytm
committedApr 19, 2019
Generalize the slice methods to use the Needle API.
Known issue: will require additional type annotations.
1 parent a795af0 commit 3be85df

File tree

5 files changed

+232
-538
lines changed

5 files changed

+232
-538
lines changed
 

‎src/liballoc/tests/slice.rs

+28-28
Original file line numberDiff line numberDiff line change
@@ -844,88 +844,88 @@ fn test_splitator() {
844844
let xs = &[1, 2, 3, 4, 5];
845845

846846
let splits: &[&[_]] = &[&[1], &[3], &[5]];
847-
assert_eq!(xs.split(|x| *x % 2 == 0).collect::<Vec<_>>(), splits);
847+
assert_eq!(xs.split(|x: &i32| *x % 2 == 0).collect::<Vec<_>>(), splits);
848848
let splits: &[&[_]] = &[&[], &[2, 3, 4, 5]];
849-
assert_eq!(xs.split(|x| *x == 1).collect::<Vec<_>>(), splits);
849+
assert_eq!(xs.split(|x: &i32| *x == 1).collect::<Vec<_>>(), splits);
850850
let splits: &[&[_]] = &[&[1, 2, 3, 4], &[]];
851-
assert_eq!(xs.split(|x| *x == 5).collect::<Vec<_>>(), splits);
851+
assert_eq!(xs.split(|x: &i32| *x == 5).collect::<Vec<_>>(), splits);
852852
let splits: &[&[_]] = &[&[1, 2, 3, 4, 5]];
853-
assert_eq!(xs.split(|x| *x == 10).collect::<Vec<_>>(), splits);
853+
assert_eq!(xs.split(|x: &i32| *x == 10).collect::<Vec<_>>(), splits);
854854
let splits: &[&[_]] = &[&[], &[], &[], &[], &[], &[]];
855-
assert_eq!(xs.split(|_| true).collect::<Vec<&[i32]>>(), splits);
855+
assert_eq!(xs.split(|_: &i32| true).collect::<Vec<&[i32]>>(), splits);
856856

857857
let xs: &[i32] = &[];
858858
let splits: &[&[i32]] = &[&[]];
859-
assert_eq!(xs.split(|x| *x == 5).collect::<Vec<&[i32]>>(), splits);
859+
assert_eq!(xs.split(|x: &i32| *x == 5).collect::<Vec<&[i32]>>(), splits);
860860
}
861861

862862
#[test]
863863
fn test_splitnator() {
864864
let xs = &[1, 2, 3, 4, 5];
865865

866866
let splits: &[&[_]] = &[&[1, 2, 3, 4, 5]];
867-
assert_eq!(xs.splitn(1, |x| *x % 2 == 0).collect::<Vec<_>>(), splits);
867+
assert_eq!(xs.splitn(1, |x: &i32| *x % 2 == 0).collect::<Vec<_>>(), splits);
868868
let splits: &[&[_]] = &[&[1], &[3, 4, 5]];
869-
assert_eq!(xs.splitn(2, |x| *x % 2 == 0).collect::<Vec<_>>(), splits);
869+
assert_eq!(xs.splitn(2, |x: &i32| *x % 2 == 0).collect::<Vec<_>>(), splits);
870870
let splits: &[&[_]] = &[&[], &[], &[], &[4, 5]];
871-
assert_eq!(xs.splitn(4, |_| true).collect::<Vec<_>>(), splits);
871+
assert_eq!(xs.splitn(4, |_: &i32| true).collect::<Vec<_>>(), splits);
872872

873873
let xs: &[i32] = &[];
874874
let splits: &[&[i32]] = &[&[]];
875-
assert_eq!(xs.splitn(2, |x| *x == 5).collect::<Vec<_>>(), splits);
875+
assert_eq!(xs.splitn(2, |x: &i32| *x == 5).collect::<Vec<_>>(), splits);
876876
}
877877

878878
#[test]
879879
fn test_splitnator_mut() {
880880
let xs = &mut [1, 2, 3, 4, 5];
881881

882882
let splits: &[&mut [_]] = &[&mut [1, 2, 3, 4, 5]];
883-
assert_eq!(xs.splitn_mut(1, |x| *x % 2 == 0).collect::<Vec<_>>(),
883+
assert_eq!(xs.splitn_mut(1, |x: &i32| *x % 2 == 0).collect::<Vec<_>>(),
884884
splits);
885885
let splits: &[&mut [_]] = &[&mut [1], &mut [3, 4, 5]];
886-
assert_eq!(xs.splitn_mut(2, |x| *x % 2 == 0).collect::<Vec<_>>(),
886+
assert_eq!(xs.splitn_mut(2, |x: &i32| *x % 2 == 0).collect::<Vec<_>>(),
887887
splits);
888888
let splits: &[&mut [_]] = &[&mut [], &mut [], &mut [], &mut [4, 5]];
889-
assert_eq!(xs.splitn_mut(4, |_| true).collect::<Vec<_>>(), splits);
889+
assert_eq!(xs.splitn_mut(4, |_: &i32| true).collect::<Vec<_>>(), splits);
890890

891891
let xs: &mut [i32] = &mut [];
892892
let splits: &[&mut [i32]] = &[&mut []];
893-
assert_eq!(xs.splitn_mut(2, |x| *x == 5).collect::<Vec<_>>(), splits);
893+
assert_eq!(xs.splitn_mut(2, |x: &i32| *x == 5).collect::<Vec<_>>(), splits);
894894
}
895895

896896
#[test]
897897
fn test_rsplitator() {
898898
let xs = &[1, 2, 3, 4, 5];
899899

900900
let splits: &[&[_]] = &[&[5], &[3], &[1]];
901-
assert_eq!(xs.split(|x| *x % 2 == 0).rev().collect::<Vec<_>>(), splits);
901+
assert_eq!(xs.split(|x: &i32| *x % 2 == 0).rev().collect::<Vec<_>>(), splits);
902902
let splits: &[&[_]] = &[&[2, 3, 4, 5], &[]];
903-
assert_eq!(xs.split(|x| *x == 1).rev().collect::<Vec<_>>(), splits);
903+
assert_eq!(xs.split(|x: &i32| *x == 1).rev().collect::<Vec<_>>(), splits);
904904
let splits: &[&[_]] = &[&[], &[1, 2, 3, 4]];
905-
assert_eq!(xs.split(|x| *x == 5).rev().collect::<Vec<_>>(), splits);
905+
assert_eq!(xs.split(|x: &i32| *x == 5).rev().collect::<Vec<_>>(), splits);
906906
let splits: &[&[_]] = &[&[1, 2, 3, 4, 5]];
907-
assert_eq!(xs.split(|x| *x == 10).rev().collect::<Vec<_>>(), splits);
907+
assert_eq!(xs.split(|x: &i32| *x == 10).rev().collect::<Vec<_>>(), splits);
908908

909909
let xs: &[i32] = &[];
910910
let splits: &[&[i32]] = &[&[]];
911-
assert_eq!(xs.split(|x| *x == 5).rev().collect::<Vec<&[i32]>>(), splits);
911+
assert_eq!(xs.split(|x: &i32| *x == 5).rev().collect::<Vec<&[i32]>>(), splits);
912912
}
913913

914914
#[test]
915915
fn test_rsplitnator() {
916916
let xs = &[1, 2, 3, 4, 5];
917917

918918
let splits: &[&[_]] = &[&[1, 2, 3, 4, 5]];
919-
assert_eq!(xs.rsplitn(1, |x| *x % 2 == 0).collect::<Vec<_>>(), splits);
919+
assert_eq!(xs.rsplitn(1, |x: &i32| *x % 2 == 0).collect::<Vec<_>>(), splits);
920920
let splits: &[&[_]] = &[&[5], &[1, 2, 3]];
921-
assert_eq!(xs.rsplitn(2, |x| *x % 2 == 0).collect::<Vec<_>>(), splits);
921+
assert_eq!(xs.rsplitn(2, |x: &i32| *x % 2 == 0).collect::<Vec<_>>(), splits);
922922
let splits: &[&[_]] = &[&[], &[], &[], &[1, 2]];
923-
assert_eq!(xs.rsplitn(4, |_| true).collect::<Vec<_>>(), splits);
923+
assert_eq!(xs.rsplitn(4, |_: &i32| true).collect::<Vec<_>>(), splits);
924924

925925
let xs: &[i32] = &[];
926926
let splits: &[&[i32]] = &[&[]];
927-
assert_eq!(xs.rsplitn(2, |x| *x == 5).collect::<Vec<&[i32]>>(), splits);
928-
assert!(xs.rsplitn(0, |x| *x % 2 == 0).next().is_none());
927+
assert_eq!(xs.rsplitn(2, |x: &i32| *x == 5).collect::<Vec<&[i32]>>(), splits);
928+
assert!(xs.rsplitn(0, |x: &i32| *x % 2 == 0).next().is_none());
929929
}
930930

931931
#[test]
@@ -1218,14 +1218,14 @@ fn test_ends_with() {
12181218
#[test]
12191219
fn test_mut_splitator() {
12201220
let mut xs = [0, 1, 0, 2, 3, 0, 0, 4, 5, 0];
1221-
assert_eq!(xs.split_mut(|x| *x == 0).count(), 6);
1222-
for slice in xs.split_mut(|x| *x == 0) {
1221+
assert_eq!(xs.split_mut(|x: &i32| *x == 0).count(), 6);
1222+
for slice in xs.split_mut(|x: &i32| *x == 0) {
12231223
slice.reverse();
12241224
}
12251225
assert!(xs == [0, 1, 0, 3, 2, 0, 0, 5, 4, 0]);
12261226

12271227
let mut xs = [0, 1, 0, 2, 3, 0, 0, 4, 5, 0, 6, 7];
1228-
for slice in xs.split_mut(|x| *x == 0).take(5) {
1228+
for slice in xs.split_mut(|x: &i32| *x == 0).take(5) {
12291229
slice.reverse();
12301230
}
12311231
assert!(xs == [0, 1, 0, 3, 2, 0, 0, 5, 4, 0, 6, 7]);
@@ -1234,7 +1234,7 @@ fn test_mut_splitator() {
12341234
#[test]
12351235
fn test_mut_splitator_rev() {
12361236
let mut xs = [1, 2, 0, 3, 4, 0, 0, 5, 6, 0];
1237-
for slice in xs.split_mut(|x| *x == 0).rev().take(4) {
1237+
for slice in xs.split_mut(|x: &i32| *x == 0).rev().take(4) {
12381238
slice.reverse();
12391239
}
12401240
assert!(xs == [1, 2, 0, 4, 3, 0, 0, 6, 5, 0]);

‎src/liballoc/vec.rs

+40-3
Original file line numberDiff line numberDiff line change
@@ -65,11 +65,16 @@ use core::marker::PhantomData;
6565
use core::mem;
6666
use core::ops::{self, Index, IndexMut, RangeBounds};
6767
use core::ops::Bound::{Excluded, Included, Unbounded};
68-
use core::ptr::{self, NonNull};
69-
use core::slice::{self, SliceIndex};
68+
use core::ops::{Index, IndexMut, RangeBounds};
69+
use core::ops;
70+
use core::ptr;
71+
use core::ptr::NonNull;
72+
use core::slice;
73+
use core::needle::Needle;
7074

71-
use crate::borrow::{ToOwned, Cow};
7275
use crate::collections::CollectionAllocErr;
76+
use crate::borrow::ToOwned;
77+
use crate::borrow::Cow;
7378
use crate::boxed::Box;
7479
use crate::raw_vec::RawVec;
7580

@@ -2724,3 +2729,35 @@ impl<T, F> Drop for DrainFilter<'_, T, F>
27242729
}
27252730
}
27262731
}
2732+
2733+
#[unstable(feature = "needle", issue = "56345")]
2734+
impl<'p, 'h, T: PartialEq + 'p + 'h> Needle<&'h [T]> for &'p Vec<T> {
2735+
type Searcher = <&'p [T] as Needle<&'h [T]>>::Searcher;
2736+
type Consumer = <&'p [T] as Needle<&'h [T]>>::Consumer;
2737+
2738+
#[inline]
2739+
fn into_searcher(self) -> Self::Searcher {
2740+
<&'p [T] as Needle<&'h [T]>>::into_searcher(&**self)
2741+
}
2742+
2743+
#[inline]
2744+
fn into_consumer(self) -> Self::Consumer {
2745+
<&'p [T] as Needle<&'h [T]>>::into_consumer(&**self)
2746+
}
2747+
}
2748+
2749+
#[unstable(feature = "needle", issue = "56345")]
2750+
impl<'p, 'h, T: PartialEq + 'p + 'h> Needle<&'h mut [T]> for &'p Vec<T> {
2751+
type Searcher = <&'p [T] as Needle<&'h mut [T]>>::Searcher;
2752+
type Consumer = <&'p [T] as Needle<&'h mut [T]>>::Consumer;
2753+
2754+
#[inline]
2755+
fn into_searcher(self) -> Self::Searcher {
2756+
<&'p [T] as Needle<&'h mut [T]>>::into_searcher(&**self)
2757+
}
2758+
2759+
#[inline]
2760+
fn into_consumer(self) -> Self::Consumer {
2761+
<&'p [T] as Needle<&'h mut [T]>>::into_consumer(&**self)
2762+
}
2763+
}

‎src/libcore/slice/mod.rs

+147-501
Large diffs are not rendered by default.

‎src/libcore/slice/needles.rs

+15-4
Original file line numberDiff line numberDiff line change
@@ -699,8 +699,8 @@ where
699699
}
700700

701701
macro_rules! impl_needle_for_slice_searcher {
702-
(<[$($gen:tt)*]> $ty:ty) => {
703-
impl<$($gen)*> Needle<$ty> for &'p [T]
702+
(@<$haystack:ty> for $ty:ty) => {
703+
impl<'p, 'h, T> Needle<$haystack> for $ty
704704
where
705705
T: PartialEq + 'p,
706706
{
@@ -717,8 +717,19 @@ macro_rules! impl_needle_for_slice_searcher {
717717
NaiveSearcher::new(self)
718718
}
719719
}
720+
};
721+
722+
($($index:expr),*) => {
723+
impl_needle_for_slice_searcher!(@<&'h [T]> for &'p [T]);
724+
impl_needle_for_slice_searcher!(@<&'h mut [T]> for &'p [T]);
725+
$(
726+
impl_needle_for_slice_searcher!(@<&'h [T]> for &'p [T; $index]);
727+
impl_needle_for_slice_searcher!(@<&'h mut [T]> for &'p [T; $index]);
728+
)*
720729
}
721730
}
722731

723-
impl_needle_for_slice_searcher!(<['p, 'h, T]> &'h [T]);
724-
impl_needle_for_slice_searcher!(<['p, 'h, T]> &'h mut [T]);
732+
impl_needle_for_slice_searcher!(
733+
0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16,
734+
17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32
735+
);

‎src/libstd/path.rs

+2-2
Original file line numberDiff line numberDiff line change
@@ -315,7 +315,7 @@ unsafe fn u8_slice_as_os_str(s: &[u8]) -> &OsStr {
315315

316316
// Detect scheme on Redox
317317
fn has_redox_scheme(s: &[u8]) -> bool {
318-
cfg!(target_os = "redox") && s.split(|b| *b == b'/').next().unwrap_or(b"").contains(&b':')
318+
cfg!(target_os = "redox") && s.split(b"/").next().unwrap_or(b"").contains(&b':')
319319
}
320320

321321
////////////////////////////////////////////////////////////////////////////////
@@ -344,7 +344,7 @@ fn split_file_at_dot(file: &OsStr) -> (Option<&OsStr>, Option<&OsStr>) {
344344
// contents of the encoding and (2) new &OsStr values are produced
345345
// only from ASCII-bounded slices of existing &OsStr values.
346346

347-
let mut iter = os_str_as_u8_slice(file).rsplitn(2, |b| *b == b'.');
347+
let mut iter = os_str_as_u8_slice(file).rsplitn(2, b".");
348348
let after = iter.next();
349349
let before = iter.next();
350350
if before == Some(b"") {

0 commit comments

Comments
 (0)
Please sign in to comment.