//! }
//! ```
//!
-//! * `.mut_iter()` returns an iterator that allows modifying each value.
+//! * `.iter_mut()` returns an iterator that allows modifying each value.
//! * Further iterators exist that split, chunk or permute the slice.
#![doc(primitive = "slice")]
pub use core::slice::{Chunks, Slice, ImmutableSlice, ImmutablePartialEqSlice};
pub use core::slice::{ImmutableOrdSlice, MutableSlice, Items, MutItems};
pub use core::slice::{MutSplits, MutChunks, Splits};
-pub use core::slice::{bytes, ref_slice, MutableCloneableSlice};
+pub use core::slice::{bytes, mut_ref_slice, ref_slice, MutableCloneableSlice};
pub use core::slice::{Found, NotFound};
// Functional utilities
self.sdir.as_mut_slice().swap(i, j);
// Swap the direction of each larger SizeDirection
- for x in self.sdir.mut_iter() {
+ for x in self.sdir.iter_mut() {
if x.size > sd.size {
x.dir = match x.dir { Pos => Neg, Neg => Pos };
}
#[inline]
fn move_from(self, mut src: Vec<T>, start: uint, end: uint) -> uint {
- for (a, b) in self.mut_iter().zip(src.mut_slice(start, end).mut_iter()) {
+ for (a, b) in self.iter_mut().zip(src.slice_mut(start, end).iter_mut()) {
mem::swap(a, b);
}
cmp::min(self.len(), end-start)
/// # Example
///
/// ```rust
- /// let v = &mut [0i, 1, 2];
+ /// let v: &mut [_] = &mut [0i, 1, 2];
/// v.next_permutation();
- /// assert_eq!(v, &mut [0i, 2, 1]);
+ /// let b: &mut [_] = &mut [0i, 2, 1];
+ /// assert!(v == b);
/// v.next_permutation();
- /// assert_eq!(v, &mut [1i, 0, 2]);
+ /// let b: &mut [_] = &mut [1i, 0, 2];
+ /// assert!(v == b);
/// ```
fn next_permutation(self) -> bool;
/// # Example
///
/// ```rust
- /// let v = &mut [1i, 0, 2];
+ /// let v: &mut [_] = &mut [1i, 0, 2];
/// v.prev_permutation();
- /// assert_eq!(v, &mut [0i, 2, 1]);
+ /// let b: &mut [_] = &mut [0i, 2, 1];
+ /// assert!(v == b);
/// v.prev_permutation();
- /// assert_eq!(v, &mut [0i, 1, 2]);
+ /// let b: &mut [_] = &mut [0i, 1, 2];
+ /// assert!(v == b);
/// ```
fn prev_permutation(self) -> bool;
}
self.swap(j, i-1);
// Step 4: Reverse the (previously) weakly decreasing part
- self.mut_slice_from(i).reverse();
+ self.slice_from_mut(i).reverse();
true
}
}
// Step 2: Reverse the weakly increasing part
- self.mut_slice_from(i).reverse();
+ self.slice_from_mut(i).reverse();
// Step 3: Find the rightmost element equal to or bigger than the pivot (i-1)
let mut j = self.len() - 1;
#[test]
fn test_tail() {
let mut a = vec![11i];
- assert_eq!(a.tail(), &[]);
+ let b: &[int] = &[];
+ assert_eq!(a.tail(), b);
a = vec![11i, 12];
- assert_eq!(a.tail(), &[12]);
+ let b: &[int] = &[12];
+ assert_eq!(a.tail(), b);
}
#[test]
}
#[test]
+ #[allow(deprecated)]
fn test_tailn() {
let mut a = vec![11i, 12, 13];
- assert_eq!(a.tailn(0), &[11, 12, 13]);
+ let b: &[int] = &[11, 12, 13];
+ assert_eq!(a.tailn(0), b);
a = vec![11i, 12, 13];
- assert_eq!(a.tailn(2), &[13]);
+ let b: &[int] = &[13];
+ assert_eq!(a.tailn(2), b);
}
#[test]
#[should_fail]
+ #[allow(deprecated)]
fn test_tailn_empty() {
let a: Vec<int> = vec![];
a.tailn(2);
#[test]
fn test_init() {
let mut a = vec![11i];
- assert_eq!(a.init(), &[]);
+ let b: &[int] = &[];
+ assert_eq!(a.init(), b);
a = vec![11i, 12];
- assert_eq!(a.init(), &[11]);
+ let b: &[int] = &[11];
+ assert_eq!(a.init(), b);
}
#[test]
#[test]
fn test_initn() {
let mut a = vec![11i, 12, 13];
- assert_eq!(a.as_slice().initn(0), &[11, 12, 13]);
+ let b: &[int] = &[11, 12, 13];
+ assert_eq!(a.as_slice().initn(0), b);
a = vec![11i, 12, 13];
- assert_eq!(a.as_slice().initn(2), &[11]);
+ let b: &[int] = &[11];
+ assert_eq!(a.as_slice().initn(2), b);
}
#[test]
#[should_fail]
+ #[allow(deprecated)]
fn test_initn_empty() {
let a: Vec<int> = vec![];
a.as_slice().initn(2);
#[test]
fn test_slice_from() {
- let vec = &[1i, 2, 3, 4];
+ let vec: &[int] = &[1, 2, 3, 4];
assert_eq!(vec.slice_from(0), vec);
- assert_eq!(vec.slice_from(2), &[3, 4]);
- assert_eq!(vec.slice_from(4), &[]);
+ let b: &[int] = &[3, 4];
+ assert_eq!(vec.slice_from(2), b);
+ let b: &[int] = &[];
+ assert_eq!(vec.slice_from(4), b);
}
#[test]
fn test_slice_to() {
- let vec = &[1i, 2, 3, 4];
+ let vec: &[int] = &[1, 2, 3, 4];
assert_eq!(vec.slice_to(4), vec);
- assert_eq!(vec.slice_to(2), &[1, 2]);
- assert_eq!(vec.slice_to(0), &[]);
+ let b: &[int] = &[1, 2];
+ assert_eq!(vec.slice_to(2), b);
+ let b: &[int] = &[];
+ assert_eq!(vec.slice_to(0), b);
}
let v : &mut[int] = &mut[1i, 2, 3, 4, 5];
assert!(v.prev_permutation() == false);
assert!(v.next_permutation());
- assert_eq!(v, &mut[1, 2, 3, 5, 4]);
+ let b: &mut[int] = &mut[1, 2, 3, 5, 4];
+ assert!(v == b);
assert!(v.prev_permutation());
- assert_eq!(v, &mut[1, 2, 3, 4, 5]);
+ let b: &mut[int] = &mut[1, 2, 3, 4, 5];
+ assert!(v == b);
assert!(v.next_permutation());
assert!(v.next_permutation());
- assert_eq!(v, &mut[1, 2, 4, 3, 5]);
+ let b: &mut[int] = &mut[1, 2, 4, 3, 5];
+ assert!(v == b);
assert!(v.next_permutation());
- assert_eq!(v, &mut[1, 2, 4, 5, 3]);
+ let b: &mut[int] = &mut[1, 2, 4, 5, 3];
+ assert!(v == b);
let v : &mut[int] = &mut[1i, 0, 0, 0];
assert!(v.next_permutation() == false);
assert!(v.prev_permutation());
- assert_eq!(v, &mut[0, 1, 0, 0]);
+ let b: &mut[int] = &mut[0, 1, 0, 0];
+ assert!(v == b);
assert!(v.prev_permutation());
- assert_eq!(v, &mut[0, 0, 1, 0]);
+ let b: &mut[int] = &mut[0, 0, 1, 0];
+ assert!(v == b);
assert!(v.prev_permutation());
- assert_eq!(v, &mut[0, 0, 0, 1]);
+ let b: &mut[int] = &mut[0, 0, 0, 1];
+ assert!(v == b);
assert!(v.prev_permutation() == false);
}
fn test_lexicographic_permutations_empty_and_short() {
let empty : &mut[int] = &mut[];
assert!(empty.next_permutation() == false);
- assert_eq!(empty, &mut[]);
+ let b: &mut[int] = &mut[];
+ assert!(empty == b);
assert!(empty.prev_permutation() == false);
- assert_eq!(empty, &mut[]);
+ assert!(empty == b);
let one_elem : &mut[int] = &mut[4i];
assert!(one_elem.prev_permutation() == false);
- assert_eq!(one_elem, &mut[4]);
+ let b: &mut[int] = &mut[4];
+ assert!(one_elem == b);
assert!(one_elem.next_permutation() == false);
- assert_eq!(one_elem, &mut[4]);
+ assert!(one_elem == b);
let two_elem : &mut[int] = &mut[1i, 2];
assert!(two_elem.prev_permutation() == false);
- assert_eq!(two_elem, &mut[1, 2]);
+ let b : &mut[int] = &mut[1, 2];
+ let c : &mut[int] = &mut[2, 1];
+ assert!(two_elem == b);
assert!(two_elem.next_permutation());
- assert_eq!(two_elem, &mut[2, 1]);
+ assert!(two_elem == c);
assert!(two_elem.next_permutation() == false);
- assert_eq!(two_elem, &mut[2, 1]);
+ assert!(two_elem == c);
assert!(two_elem.prev_permutation());
- assert_eq!(two_elem, &mut[1, 2]);
+ assert!(two_elem == b);
assert!(two_elem.prev_permutation() == false);
- assert_eq!(two_elem, &mut[1, 2]);
+ assert!(two_elem == b);
}
#[test]
assert_eq!(v.concat_vec(), vec![]);
assert_eq!([vec![1i], vec![2i,3i]].concat_vec(), vec![1, 2, 3]);
- assert_eq!([&[1i], &[2i,3i]].concat_vec(), vec![1, 2, 3]);
+ let v: [&[int], ..2] = [&[1], &[2, 3]];
+ assert_eq!(v.connect_vec(&0), vec![1, 0, 2, 3]);
+ let v: [&[int], ..3] = [&[1], &[2], &[3]];
+ assert_eq!(v.connect_vec(&0), vec![1, 0, 2, 0, 3]);
}
#[test]
assert_eq!([vec![1i], vec![2i, 3]].connect_vec(&0), vec![1, 0, 2, 3]);
assert_eq!([vec![1i], vec![2i], vec![3i]].connect_vec(&0), vec![1, 0, 2, 0, 3]);
- assert_eq!([&[1i], &[2i, 3]].connect_vec(&0), vec![1, 0, 2, 3]);
- assert_eq!([&[1i], &[2i], &[3]].connect_vec(&0), vec![1, 0, 2, 0, 3]);
+ let v: [&[int], ..2] = [&[1], &[2, 3]];
+ assert_eq!(v.connect_vec(&0), vec![1, 0, 2, 3]);
+ let v: [&[int], ..3] = [&[1], &[2], &[3]];
+ assert_eq!(v.connect_vec(&0), vec![1, 0, 2, 0, 3]);
}
#[test]
}
#[test]
+ #[allow(deprecated)]
fn test_unshift() {
let mut x = vec![1i, 2, 3];
x.unshift(0);
#[test]
fn test_total_ord() {
- [1i, 2, 3, 4].cmp(& &[1, 2, 3]) == Greater;
- [1i, 2, 3].cmp(& &[1, 2, 3, 4]) == Less;
- [1i, 2, 3, 4].cmp(& &[1, 2, 3, 4]) == Equal;
- [1i, 2, 3, 4, 5, 5, 5, 5].cmp(& &[1, 2, 3, 4, 5, 6]) == Less;
- [2i, 2].cmp(& &[1, 2, 3, 4]) == Greater;
+ let c: &[int] = &[1, 2, 3];
+ [1, 2, 3, 4].cmp(& c) == Greater;
+ let c: &[int] = &[1, 2, 3, 4];
+ [1, 2, 3].cmp(& c) == Less;
+ let c: &[int] = &[1, 2, 3, 6];
+ [1, 2, 3, 4].cmp(& c) == Equal;
+ let c: &[int] = &[1, 2, 3, 4, 5, 6];
+ [1, 2, 3, 4, 5, 5, 5, 5].cmp(& c) == Less;
+ let c: &[int] = &[1, 2, 3, 4];
+ [2, 2].cmp(& c) == Greater;
}
#[test]
fn test_iter_size_hints() {
let mut xs = [1i, 2, 5, 10, 11];
assert_eq!(xs.iter().size_hint(), (5, Some(5)));
- assert_eq!(xs.mut_iter().size_hint(), (5, Some(5)));
+ assert_eq!(xs.iter_mut().size_hint(), (5, Some(5)));
}
#[test]
#[test]
fn test_mut_iterator() {
let mut xs = [1i, 2, 3, 4, 5];
- for x in xs.mut_iter() {
+ for x in xs.iter_mut() {
*x += 1;
}
assert!(xs == [2, 3, 4, 5, 6])
#[test]
fn test_mut_rev_iterator() {
let mut xs = [1u, 2, 3, 4, 5];
- for (i,x) in xs.mut_iter().rev().enumerate() {
+ for (i,x) in xs.iter_mut().rev().enumerate() {
*x += i;
}
assert!(xs == [5, 5, 5, 5, 5])
#[test]
fn test_move_iterator() {
let xs = vec![1u,2,3,4,5];
- assert_eq!(xs.move_iter().fold(0, |a: uint, b: uint| 10*a + b), 12345);
+ assert_eq!(xs.into_iter().fold(0, |a: uint, b: uint| 10*a + b), 12345);
}
#[test]
fn test_move_rev_iterator() {
let xs = vec![1u,2,3,4,5];
- assert_eq!(xs.move_iter().rev().fold(0, |a: uint, b: uint| 10*a + b), 54321);
+ assert_eq!(xs.into_iter().rev().fold(0, |a: uint, b: uint| 10*a + b), 54321);
}
#[test]
fn test_splitator() {
let xs = &[1i,2,3,4,5];
+ let splits: &[&[int]] = &[&[1], &[3], &[5]];
assert_eq!(xs.split(|x| *x % 2 == 0).collect::<Vec<&[int]>>().as_slice(),
- &[&[1], &[3], &[5]]);
+ splits);
+ let splits: &[&[int]] = &[&[], &[2,3,4,5]];
assert_eq!(xs.split(|x| *x == 1).collect::<Vec<&[int]>>().as_slice(),
- &[&[], &[2,3,4,5]]);
+ splits);
+ let splits: &[&[int]] = &[&[1,2,3,4], &[]];
assert_eq!(xs.split(|x| *x == 5).collect::<Vec<&[int]>>().as_slice(),
- &[&[1,2,3,4], &[]]);
+ splits);
+ let splits: &[&[int]] = &[&[1,2,3,4,5]];
assert_eq!(xs.split(|x| *x == 10).collect::<Vec<&[int]>>().as_slice(),
- &[&[1,2,3,4,5]]);
+ splits);
+ let splits: &[&[int]] = &[&[], &[], &[], &[], &[], &[]];
assert_eq!(xs.split(|_| true).collect::<Vec<&[int]>>().as_slice(),
- &[&[], &[], &[], &[], &[], &[]]);
+ splits);
let xs: &[int] = &[];
- assert_eq!(xs.split(|x| *x == 5).collect::<Vec<&[int]>>().as_slice(), &[&[]]);
+ let splits: &[&[int]] = &[&[]];
+ assert_eq!(xs.split(|x| *x == 5).collect::<Vec<&[int]>>().as_slice(), splits);
}
#[test]
fn test_splitnator() {
let xs = &[1i,2,3,4,5];
+ let splits: &[&[int]] = &[&[1,2,3,4,5]];
assert_eq!(xs.splitn(0, |x| *x % 2 == 0).collect::<Vec<&[int]>>().as_slice(),
- &[&[1,2,3,4,5]]);
+ splits);
+ let splits: &[&[int]] = &[&[1], &[3,4,5]];
assert_eq!(xs.splitn(1, |x| *x % 2 == 0).collect::<Vec<&[int]>>().as_slice(),
- &[&[1], &[3,4,5]]);
+ splits);
+ let splits: &[&[int]] = &[&[], &[], &[], &[4,5]];
assert_eq!(xs.splitn(3, |_| true).collect::<Vec<&[int]>>().as_slice(),
- &[&[], &[], &[], &[4,5]]);
+ splits);
let xs: &[int] = &[];
- assert_eq!(xs.splitn(1, |x| *x == 5).collect::<Vec<&[int]>>().as_slice(), &[&[]]);
+ let splits: &[&[int]] = &[&[]];
+ assert_eq!(xs.splitn(1, |x| *x == 5).collect::<Vec<&[int]>>().as_slice(), splits);
}
#[test]
fn test_rsplitator() {
let xs = &[1i,2,3,4,5];
+ let splits: &[&[int]] = &[&[5], &[3], &[1]];
assert_eq!(xs.split(|x| *x % 2 == 0).rev().collect::<Vec<&[int]>>().as_slice(),
- &[&[5], &[3], &[1]]);
+ splits);
+ let splits: &[&[int]] = &[&[2,3,4,5], &[]];
assert_eq!(xs.split(|x| *x == 1).rev().collect::<Vec<&[int]>>().as_slice(),
- &[&[2,3,4,5], &[]]);
+ splits);
+ let splits: &[&[int]] = &[&[], &[1,2,3,4]];
assert_eq!(xs.split(|x| *x == 5).rev().collect::<Vec<&[int]>>().as_slice(),
- &[&[], &[1,2,3,4]]);
+ splits);
+ let splits: &[&[int]] = &[&[1,2,3,4,5]];
assert_eq!(xs.split(|x| *x == 10).rev().collect::<Vec<&[int]>>().as_slice(),
- &[&[1,2,3,4,5]]);
+ splits);
let xs: &[int] = &[];
- assert_eq!(xs.split(|x| *x == 5).rev().collect::<Vec<&[int]>>().as_slice(), &[&[]]);
+ let splits: &[&[int]] = &[&[]];
+ assert_eq!(xs.split(|x| *x == 5).rev().collect::<Vec<&[int]>>().as_slice(), splits);
}
#[test]
fn test_rsplitnator() {
let xs = &[1,2,3,4,5];
+ let splits: &[&[int]] = &[&[1,2,3,4,5]];
assert_eq!(xs.rsplitn(0, |x| *x % 2 == 0).collect::<Vec<&[int]>>().as_slice(),
- &[&[1,2,3,4,5]]);
+ splits);
+ let splits: &[&[int]] = &[&[5], &[1,2,3]];
assert_eq!(xs.rsplitn(1, |x| *x % 2 == 0).collect::<Vec<&[int]>>().as_slice(),
- &[&[5], &[1,2,3]]);
+ splits);
+ let splits: &[&[int]] = &[&[], &[], &[], &[1,2]];
assert_eq!(xs.rsplitn(3, |_| true).collect::<Vec<&[int]>>().as_slice(),
- &[&[], &[], &[], &[1,2]]);
+ splits);
let xs: &[int] = &[];
- assert_eq!(xs.rsplitn(1, |x| *x == 5).collect::<Vec<&[int]>>().as_slice(), &[&[]]);
+ let splits: &[&[int]] = &[&[]];
+ assert_eq!(xs.rsplitn(1, |x| *x == 5).collect::<Vec<&[int]>>().as_slice(), splits);
}
#[test]
fn test_windowsator() {
let v = &[1i,2,3,4];
- assert_eq!(v.windows(2).collect::<Vec<&[int]>>().as_slice(), &[&[1,2], &[2,3], &[3,4]]);
- assert_eq!(v.windows(3).collect::<Vec<&[int]>>().as_slice(), &[&[1i,2,3], &[2,3,4]]);
+ let wins: &[&[int]] = &[&[1,2], &[2,3], &[3,4]];
+ assert_eq!(v.windows(2).collect::<Vec<&[int]>>().as_slice(), wins);
+ let wins: &[&[int]] = &[&[1i,2,3], &[2,3,4]];
+ assert_eq!(v.windows(3).collect::<Vec<&[int]>>().as_slice(), wins);
assert!(v.windows(6).next().is_none());
}
fn test_chunksator() {
let v = &[1i,2,3,4,5];
- assert_eq!(v.chunks(2).collect::<Vec<&[int]>>().as_slice(), &[&[1i,2], &[3,4], &[5]]);
- assert_eq!(v.chunks(3).collect::<Vec<&[int]>>().as_slice(), &[&[1i,2,3], &[4,5]]);
- assert_eq!(v.chunks(6).collect::<Vec<&[int]>>().as_slice(), &[&[1i,2,3,4,5]]);
+ let chunks: &[&[int]] = &[&[1i,2], &[3,4], &[5]];
+ assert_eq!(v.chunks(2).collect::<Vec<&[int]>>().as_slice(), chunks);
+ let chunks: &[&[int]] = &[&[1i,2,3], &[4,5]];
+ assert_eq!(v.chunks(3).collect::<Vec<&[int]>>().as_slice(), chunks);
+ let chunks: &[&[int]] = &[&[1i,2,3,4,5]];
+ assert_eq!(v.chunks(6).collect::<Vec<&[int]>>().as_slice(), chunks);
- assert_eq!(v.chunks(2).rev().collect::<Vec<&[int]>>().as_slice(), &[&[5i], &[3,4], &[1,2]]);
+ let chunks: &[&[int]] = &[&[5i], &[3,4], &[1,2]];
+ assert_eq!(v.chunks(2).rev().collect::<Vec<&[int]>>().as_slice(), chunks);
let mut it = v.chunks(2);
assert_eq!(it.indexable(), 3);
- assert_eq!(it.idx(0).unwrap(), &[1,2]);
- assert_eq!(it.idx(1).unwrap(), &[3,4]);
- assert_eq!(it.idx(2).unwrap(), &[5]);
+ let chunk: &[int] = &[1,2];
+ assert_eq!(it.idx(0).unwrap(), chunk);
+ let chunk: &[int] = &[3,4];
+ assert_eq!(it.idx(1).unwrap(), chunk);
+ let chunk: &[int] = &[5];
+ assert_eq!(it.idx(2).unwrap(), chunk);
assert_eq!(it.idx(3), None);
}
assert!(a == [7i,2,3,4]);
let mut a = [1i,2,3,4,5];
let b = vec![5i,6,7,8,9,0];
- assert_eq!(a.mut_slice(2,4).move_from(b,1,6), 2);
+ assert_eq!(a.slice_mut(2,4).move_from(b,1,6), 2);
assert!(a == [1i,2,6,7,5]);
}
#[test]
fn test_reverse_part() {
let mut values = [1i,2,3,4,5];
- values.mut_slice(1, 4).reverse();
+ values.slice_mut(1, 4).reverse();
assert!(values == [1,4,3,2,5]);
}
let empty_mut: &mut [int] = &mut[];
test_show_vec!(empty_mut, "[]".to_string());
- test_show_vec!(&mut[1i], "[1]".to_string());
- test_show_vec!(&mut[1i, 2, 3], "[1, 2, 3]".to_string());
- test_show_vec!(&mut[&mut[], &mut[1u], &mut[1u, 1u]],
- "[[], [1], [1, 1]]".to_string());
+ let v: &mut[int] = &mut[1];
+ test_show_vec!(v, "[1]".to_string());
+ let v: &mut[int] = &mut[1, 2, 3];
+ test_show_vec!(v, "[1, 2, 3]".to_string());
+ let v: &mut [&mut[uint]] = &mut[&mut[], &mut[1u], &mut[1u, 1u]];
+ test_show_vec!(v, "[[], [1], [1, 1]]".to_string());
}
#[test]
fn test_bytes_set_memory() {
use slice::bytes::MutableByteVector;
let mut values = [1u8,2,3,4,5];
- values.mut_slice(0,5).set_memory(0xAB);
+ values.slice_mut(0,5).set_memory(0xAB);
assert!(values == [0xAB, 0xAB, 0xAB, 0xAB, 0xAB]);
- values.mut_slice(2,4).set_memory(0xFF);
+ values.slice_mut(2,4).set_memory(0xFF);
assert!(values == [0xAB, 0xAB, 0xFF, 0xFF, 0xAB]);
}
fn test_mut_split_at() {
let mut values = [1u8,2,3,4,5];
{
- let (left, right) = values.mut_split_at(2);
+ let (left, right) = values.split_at_mut(2);
assert!(left.slice(0, left.len()) == [1, 2]);
- for p in left.mut_iter() {
+ for p in left.iter_mut() {
*p += 1;
}
assert!(right.slice(0, right.len()) == [3, 4, 5]);
- for p in right.mut_iter() {
+ for p in right.iter_mut() {
*p += 2;
}
}
}
assert_eq!(cnt, 5);
- for f in v.mut_iter() {
+ for f in v.iter_mut() {
assert!(*f == Foo);
cnt += 1;
}
assert_eq!(cnt, 8);
- for f in v.move_iter() {
+ for f in v.into_iter() {
assert!(f == Foo);
cnt += 1;
}
}
#[test]
+ #[allow(deprecated)]
fn test_shift_ref() {
let mut x: &[int] = [1, 2, 3, 4, 5];
let h = x.shift_ref();
}
#[test]
+ #[allow(deprecated)]
fn test_pop_ref() {
let mut x: &[int] = [1, 2, 3, 4, 5];
let h = x.pop_ref();
#[test]
fn test_mut_splitator() {
let mut xs = [0i,1,0,2,3,0,0,4,5,0];
- assert_eq!(xs.mut_split(|x| *x == 0).count(), 6);
- for slice in xs.mut_split(|x| *x == 0) {
+ assert_eq!(xs.split_mut(|x| *x == 0).count(), 6);
+ for slice in xs.split_mut(|x| *x == 0) {
slice.reverse();
}
assert!(xs == [0,1,0,3,2,0,0,5,4,0]);
let mut xs = [0i,1,0,2,3,0,0,4,5,0,6,7];
- for slice in xs.mut_split(|x| *x == 0).take(5) {
+ for slice in xs.split_mut(|x| *x == 0).take(5) {
slice.reverse();
}
assert!(xs == [0,1,0,3,2,0,0,5,4,0,6,7]);
#[test]
fn test_mut_splitator_rev() {
let mut xs = [1i,2,0,3,4,0,0,5,6,0];
- for slice in xs.mut_split(|x| *x == 0).rev().take(4) {
+ for slice in xs.split_mut(|x| *x == 0).rev().take(4) {
slice.reverse();
}
assert!(xs == [1,2,0,4,3,0,0,6,5,0]);
#[test]
fn test_mut_chunks() {
let mut v = [0u8, 1, 2, 3, 4, 5, 6];
- for (i, chunk) in v.mut_chunks(3).enumerate() {
- for x in chunk.mut_iter() {
+ for (i, chunk) in v.chunks_mut(3).enumerate() {
+ for x in chunk.iter_mut() {
*x = i as u8;
}
}
#[test]
fn test_mut_chunks_rev() {
let mut v = [0u8, 1, 2, 3, 4, 5, 6];
- for (i, chunk) in v.mut_chunks(3).rev().enumerate() {
- for x in chunk.mut_iter() {
+ for (i, chunk) in v.chunks_mut(3).rev().enumerate() {
+ for x in chunk.iter_mut() {
*x = i as u8;
}
}
#[should_fail]
fn test_mut_chunks_0() {
let mut v = [1i, 2, 3, 4];
- let _it = v.mut_chunks(0);
+ let _it = v.chunks_mut(0);
}
#[test]
+ #[allow(deprecated)]
fn test_mut_shift_ref() {
let mut x: &mut [int] = [1, 2, 3, 4, 5];
let h = x.mut_shift_ref();
}
#[test]
+ #[allow(deprecated)]
fn test_mut_pop_ref() {
let mut x: &mut [int] = [1, 2, 3, 4, 5];
let h = x.mut_pop_ref();
#[test]
fn test_mut_last() {
let mut x = [1i, 2, 3, 4, 5];
- let h = x.mut_last();
+ let h = x.last_mut();
assert_eq!(*h.unwrap(), 5);
let y: &mut [int] = [];
- assert!(y.mut_last().is_none());
+ assert!(y.last_mut().is_none());
}
}
b.iter(|| {
let mut i = 0i;
- for x in v.mut_iter() {
+ for x in v.iter_mut() {
*x = i;
i += 1;
}
unsafe {
v.set_len(1024);
}
- for x in v.mut_iter() {
+ for x in v.iter_mut() {
*x = 0i;
}
v
b.iter(|| {
v.sort();
});
- b.bytes = (v.len() * mem::size_of_val(v.get(0))) as u64;
+ b.bytes = (v.len() * mem::size_of_val(&v[0])) as u64;
}
type BigSortable = (u64,u64,u64,u64);
b.iter(|| {
v.sort();
});
- b.bytes = (v.len() * mem::size_of_val(v.get(0))) as u64;
+ b.bytes = (v.len() * mem::size_of_val(&v[0])) as u64;
}
}
projects / rust.git / blobdiff