Skip to content

Commit 5997694

Browse files
committed
Use slice syntax instead of slice_to, etc.
1 parent b5ba2f5 commit 5997694

Some content is hidden

Large Commits have some content hidden by default. Use the searchbox below for content that may be hidden.

84 files changed

+313
-317
lines changed

src/compiletest/runtest.rs

Lines changed: 1 addition & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -874,7 +874,7 @@ fn check_error_patterns(props: &TestProps,
874874
if done { return; }
875875

876876
let missing_patterns =
877-
props.error_patterns.slice(next_err_idx, props.error_patterns.len());
877+
props.error_patterns[next_err_idx..];
878878
if missing_patterns.len() == 1u {
879879
fatal_proc_rec(format!("error pattern '{}' not found!",
880880
missing_patterns[0]).as_slice(),

src/libcollections/bitv.rs

Lines changed: 1 addition & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -194,7 +194,7 @@ impl Bitv {
194194
if start > self.storage.len() {
195195
start = self.storage.len();
196196
}
197-
let mut iter = self.storage.slice_from(start).iter();
197+
let mut iter = self.storage[start..].iter();
198198
MaskWords {
199199
next_word: iter.next(),
200200
iter: iter,

src/libcollections/ringbuf.rs

Lines changed: 2 additions & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -271,7 +271,7 @@ impl<T> RingBuf<T> {
271271
/// *num = *num - 2;
272272
/// }
273273
/// let b: &[_] = &[&mut 3, &mut 1, &mut 2];
274-
/// assert_eq!(buf.iter_mut().collect::<Vec<&mut int>>().as_slice(), b);
274+
/// assert_eq!(buf.iter_mut().collect::<Vec<&mut int>>()[], b);
275275
/// ```
276276
pub fn iter_mut<'a>(&'a mut self) -> MutItems<'a, T> {
277277
let start_index = raw_index(self.lo, self.elts.len(), 0);
@@ -291,7 +291,7 @@ impl<T> RingBuf<T> {
291291
} else {
292292
// Items to iterate goes from start_index to end_index:
293293
let (empty, elts) = self.elts.split_at_mut(0);
294-
let remaining1 = elts.slice_mut(start_index, end_index);
294+
let remaining1 = elts[mut start_index..end_index];
295295
MutItems { remaining1: remaining1,
296296
remaining2: empty,
297297
nelts: self.nelts }

src/libcollections/slice.rs

Lines changed: 32 additions & 24 deletions
Original file line numberDiff line numberDiff line change
@@ -44,14 +44,16 @@
4444
//!
4545
//! A number of traits add methods that allow you to accomplish tasks with slices.
4646
//! These traits include `ImmutableSlice`, which is defined for `&[T]` types,
47-
//! and `MutableSlice`, defined for `&mut [T]` types.
47+
//! `MutableSlice`, defined for `&mut [T]` types, and `Slice` and `SliceMut`
48+
//! which are defined for `[T]`.
4849
//!
49-
//! An example is the method `.slice(a, b)` that returns an immutable "view" into
50-
//! a `Vec` or another slice from the index interval `[a, b)`:
50+
//! An example is the `slice` method which enables slicing syntax `[a..b]` that
51+
//! returns an immutable "view" into a `Vec` or another slice from the index
52+
//! interval `[a, b)`:
5153
//!
5254
//! ```rust
5355
//! let numbers = [0i, 1i, 2i];
54-
//! let last_numbers = numbers.slice(1, 3);
56+
//! let last_numbers = numbers[1..3];
5557
//! // last_numbers is now &[1i, 2i]
5658
//! ```
5759
//!
@@ -610,7 +612,7 @@ impl<'a,T> MutableSliceAllocating<'a, T> for &'a mut [T] {
610612

611613
#[inline]
612614
fn move_from(self, mut src: Vec<T>, start: uint, end: uint) -> uint {
613-
for (a, b) in self.iter_mut().zip(src.slice_mut(start, end).iter_mut()) {
615+
for (a, b) in self.iter_mut().zip(src[mut start..end].iter_mut()) {
614616
mem::swap(a, b);
615617
}
616618
cmp::min(self.len(), end-start)
@@ -702,7 +704,7 @@ impl<'a, T: Ord> MutableOrdSlice<T> for &'a mut [T] {
702704
self.swap(j, i-1);
703705

704706
// Step 4: Reverse the (previously) weakly decreasing part
705-
self.slice_from_mut(i).reverse();
707+
self[mut i..].reverse();
706708

707709
true
708710
}
@@ -723,7 +725,7 @@ impl<'a, T: Ord> MutableOrdSlice<T> for &'a mut [T] {
723725
}
724726

725727
// Step 2: Reverse the weakly increasing part
726-
self.slice_from_mut(i).reverse();
728+
self[mut i..].reverse();
727729

728730
// Step 3: Find the rightmost element equal to or bigger than the pivot (i-1)
729731
let mut j = self.len() - 1;
@@ -990,24 +992,24 @@ mod tests {
990992
fn test_slice() {
991993
// Test fixed length vector.
992994
let vec_fixed = [1i, 2, 3, 4];
993-
let v_a = vec_fixed.slice(1u, vec_fixed.len()).to_vec();
995+
let v_a = vec_fixed[1u..vec_fixed.len()].to_vec();
994996
assert_eq!(v_a.len(), 3u);
995997
let v_a = v_a.as_slice();
996998
assert_eq!(v_a[0], 2);
997999
assert_eq!(v_a[1], 3);
9981000
assert_eq!(v_a[2], 4);
9991001

10001002
// Test on stack.
1001-
let vec_stack = &[1i, 2, 3];
1002-
let v_b = vec_stack.slice(1u, 3u).to_vec();
1003+
let vec_stack: &[_] = &[1i, 2, 3];
1004+
let v_b = vec_stack[1u..3u].to_vec();
10031005
assert_eq!(v_b.len(), 2u);
10041006
let v_b = v_b.as_slice();
10051007
assert_eq!(v_b[0], 2);
10061008
assert_eq!(v_b[1], 3);
10071009

10081010
// Test `Box<[T]>`
10091011
let vec_unique = vec![1i, 2, 3, 4, 5, 6];
1010-
let v_d = vec_unique.slice(1u, 6u).to_vec();
1012+
let v_d = vec_unique[1u..6u].to_vec();
10111013
assert_eq!(v_d.len(), 5u);
10121014
let v_d = v_d.as_slice();
10131015
assert_eq!(v_d[0], 2);
@@ -1020,21 +1022,21 @@ mod tests {
10201022
#[test]
10211023
fn test_slice_from() {
10221024
let vec: &[int] = &[1, 2, 3, 4];
1023-
assert_eq!(vec.slice_from(0), vec);
1025+
assert_eq!(vec[0..], vec);
10241026
let b: &[int] = &[3, 4];
1025-
assert_eq!(vec.slice_from(2), b);
1027+
assert_eq!(vec[2..], b);
10261028
let b: &[int] = &[];
1027-
assert_eq!(vec.slice_from(4), b);
1029+
assert_eq!(vec[4..], b);
10281030
}
10291031

10301032
#[test]
10311033
fn test_slice_to() {
10321034
let vec: &[int] = &[1, 2, 3, 4];
1033-
assert_eq!(vec.slice_to(4), vec);
1035+
assert_eq!(vec[..4], vec);
10341036
let b: &[int] = &[1, 2];
1035-
assert_eq!(vec.slice_to(2), b);
1037+
assert_eq!(vec[..2], b);
10361038
let b: &[int] = &[];
1037-
assert_eq!(vec.slice_to(0), b);
1039+
assert_eq!(vec[..0], b);
10381040
}
10391041

10401042

@@ -1975,7 +1977,7 @@ mod tests {
19751977
assert!(a == [7i,2,3,4]);
19761978
let mut a = [1i,2,3,4,5];
19771979
let b = vec![5i,6,7,8,9,0];
1978-
assert_eq!(a.slice_mut(2,4).move_from(b,1,6), 2);
1980+
assert_eq!(a[mut 2..4].move_from(b,1,6), 2);
19791981
assert!(a == [1i,2,6,7,5]);
19801982
}
19811983

@@ -1995,7 +1997,7 @@ mod tests {
19951997
#[test]
19961998
fn test_reverse_part() {
19971999
let mut values = [1i,2,3,4,5];
1998-
values.slice_mut(1, 4).reverse();
2000+
values[mut 1..4].reverse();
19992001
assert!(values == [1,4,3,2,5]);
20002002
}
20012003

@@ -2042,9 +2044,9 @@ mod tests {
20422044
fn test_bytes_set_memory() {
20432045
use slice::bytes::MutableByteVector;
20442046
let mut values = [1u8,2,3,4,5];
2045-
values.slice_mut(0,5).set_memory(0xAB);
2047+
values[mut 0..5].set_memory(0xAB);
20462048
assert!(values == [0xAB, 0xAB, 0xAB, 0xAB, 0xAB]);
2047-
values.slice_mut(2,4).set_memory(0xFF);
2049+
values[mut 2..4].set_memory(0xFF);
20482050
assert!(values == [0xAB, 0xAB, 0xFF, 0xFF, 0xAB]);
20492051
}
20502052

@@ -2070,12 +2072,18 @@ mod tests {
20702072
let mut values = [1u8,2,3,4,5];
20712073
{
20722074
let (left, right) = values.split_at_mut(2);
2073-
assert!(left.slice(0, left.len()) == [1, 2]);
2075+
{
2076+
let left: &[_] = left;
2077+
assert!(left[0..left.len()] == [1, 2]);
2078+
}
20742079
for p in left.iter_mut() {
20752080
*p += 1;
20762081
}
20772082

2078-
assert!(right.slice(0, right.len()) == [3, 4, 5]);
2083+
{
2084+
let right: &[_] = right;
2085+
assert!(right[0..right.len()] == [3, 4, 5]);
2086+
}
20792087
for p in right.iter_mut() {
20802088
*p += 2;
20812089
}
@@ -2099,7 +2107,7 @@ mod tests {
20992107
}
21002108
assert_eq!(cnt, 3);
21012109

2102-
for f in v.slice(1, 3).iter() {
2110+
for f in v[1..3].iter() {
21032111
assert!(*f == Foo);
21042112
cnt += 1;
21052113
}

src/libcollections/str.rs

Lines changed: 2 additions & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -1678,7 +1678,7 @@ mod tests {
16781678
let mut bytes = [0u8, ..4];
16791679
for c in range(0u32, 0x110000).filter_map(|c| ::core::char::from_u32(c)) {
16801680
let len = c.encode_utf8(bytes).unwrap_or(0);
1681-
let s = ::core::str::from_utf8(bytes.slice_to(len)).unwrap();
1681+
let s = ::core::str::from_utf8(bytes[..len]).unwrap();
16821682
if Some(c) != s.chars().next() {
16831683
fail!("character {:x}={} does not decode correctly", c as u32, c);
16841684
}
@@ -1690,7 +1690,7 @@ mod tests {
16901690
let mut bytes = [0u8, ..4];
16911691
for c in range(0u32, 0x110000).filter_map(|c| ::core::char::from_u32(c)) {
16921692
let len = c.encode_utf8(bytes).unwrap_or(0);
1693-
let s = ::core::str::from_utf8(bytes.slice_to(len)).unwrap();
1693+
let s = ::core::str::from_utf8(bytes[..len]).unwrap();
16941694
if Some(c) != s.chars().rev().next() {
16951695
fail!("character {:x}={} does not decode correctly", c as u32, c);
16961696
}

src/libcollections/string.rs

Lines changed: 3 additions & 3 deletions
Original file line numberDiff line numberDiff line change
@@ -160,7 +160,7 @@ impl String {
160160

161161
if i > 0 {
162162
unsafe {
163-
res.as_mut_vec().push_all(v.slice_to(i))
163+
res.as_mut_vec().push_all(v[..i])
164164
};
165165
}
166166

@@ -177,7 +177,7 @@ impl String {
177177
macro_rules! error(() => ({
178178
unsafe {
179179
if subseqidx != i_ {
180-
res.as_mut_vec().push_all(v.slice(subseqidx, i_));
180+
res.as_mut_vec().push_all(v[subseqidx..i_]);
181181
}
182182
subseqidx = i;
183183
res.as_mut_vec().push_all(REPLACEMENT);
@@ -246,7 +246,7 @@ impl String {
246246
}
247247
if subseqidx < total {
248248
unsafe {
249-
res.as_mut_vec().push_all(v.slice(subseqidx, total))
249+
res.as_mut_vec().push_all(v[subseqidx..total])
250250
};
251251
}
252252
Owned(res.into_string())

src/libcollections/trie.rs

Lines changed: 4 additions & 3 deletions
Original file line numberDiff line numberDiff line change
@@ -24,6 +24,7 @@ use core::fmt;
2424
use core::fmt::Show;
2525
use core::mem::zeroed;
2626
use core::mem;
27+
use core::ops::{Slice,SliceMut};
2728
use core::uint;
2829
use core::iter;
2930
use std::hash::{Writer, Hash};
@@ -378,7 +379,7 @@ macro_rules! bound {
378379
}
379380
};
380381
// push to the stack.
381-
it.stack[it.length] = children.$slice_from(slice_idx).$iter();
382+
it.stack[it.length] = children.$slice_from(&slice_idx).$iter();
382383
it.length += 1;
383384
if ret { return it }
384385
})
@@ -392,7 +393,7 @@ impl<T> TrieMap<T> {
392393
fn bound<'a>(&'a self, key: uint, upper: bool) -> Entries<'a, T> {
393394
bound!(Entries, self = self,
394395
key = key, is_upper = upper,
395-
slice_from = slice_from, iter = iter,
396+
slice_from = slice_from_, iter = iter,
396397
mutability = )
397398
}
398399

@@ -434,7 +435,7 @@ impl<T> TrieMap<T> {
434435
fn bound_mut<'a>(&'a mut self, key: uint, upper: bool) -> MutEntries<'a, T> {
435436
bound!(MutEntries, self = self,
436437
key = key, is_upper = upper,
437-
slice_from = slice_from_mut, iter = iter_mut,
438+
slice_from = slice_from_mut_, iter = iter_mut,
438439
mutability = mut)
439440
}
440441

0 commit comments

Comments
 (0)