remove unecessary lifetimes from a bunch of collections code

Gankra · Gankra · commit 1420cebebd48 · 2015-02-05T18:25:03.000-05:00
diff --git a/src/libcollections/binary_heap.rs b/src/libcollections/binary_heap.rs
@@ -708,7 +708,7 @@ mod tests {
         let iterout = vec![3, 5, 9];
         let pq = BinaryHeap::from_vec(data);
 
-        let v: Vec<_> = pq.iter().rev().map(|&x| x).collect();
+        let v: Vec<_> = pq.iter().rev().cloned().collect();
         assert_eq!(v, iterout);
     }
 
diff --git a/src/libcollections/ring_buf.rs b/src/libcollections/ring_buf.rs
@@ -529,13 +529,13 @@ impl<T> RingBuf<T> {
     /// assert_eq!(&buf.iter_mut().collect::<Vec<&mut i32>>()[], b);
     /// ```
     #[stable(feature = "rust1", since = "1.0.0")]
-    pub fn iter_mut<'a>(&'a mut self) -> IterMut<'a, T> {
+    pub fn iter_mut(&mut self) -> IterMut<T> {
         IterMut {
             tail: self.tail,
             head: self.head,
             cap: self.cap,
             ptr: self.ptr,
-            marker: marker::ContravariantLifetime::<'a>,
+            marker: marker::ContravariantLifetime,
         }
     }
 
@@ -552,7 +552,7 @@ impl<T> RingBuf<T> {
     #[inline]
     #[unstable(feature = "collections",
                reason = "matches collection reform specification, waiting for dust to settle")]
-    pub fn as_slices<'a>(&'a self) -> (&'a [T], &'a [T]) {
+    pub fn as_slices(&self) -> (&[T], &[T]) {
         unsafe {
             let contiguous = self.is_contiguous();
             let buf = self.buffer_as_slice();
@@ -572,7 +572,7 @@ impl<T> RingBuf<T> {
     #[inline]
     #[unstable(feature = "collections",
                reason = "matches collection reform specification, waiting for dust to settle")]
-    pub fn as_mut_slices<'a>(&'a mut self) -> (&'a mut [T], &'a mut [T]) {
+    pub fn as_mut_slices(&mut self) -> (&mut [T], &mut [T]) {
         unsafe {
             let contiguous = self.is_contiguous();
             let head = self.head;
@@ -1584,7 +1584,7 @@ impl<A> Index<usize> for RingBuf<A> {
     type Output = A;
 
     #[inline]
-    fn index<'a>(&'a self, i: &usize) -> &'a A {
+    fn index(&self, i: &usize) -> &A {
         self.get(*i).expect("Out of bounds access")
     }
 }
@@ -1594,7 +1594,7 @@ impl<A> IndexMut<usize> for RingBuf<A> {
     type Output = A;
 
     #[inline]
-    fn index_mut<'a>(&'a mut self, i: &usize) -> &'a mut A {
+    fn index_mut(&mut self, i: &usize) -> &mut A {
         self.get_mut(*i).expect("Out of bounds access")
     }
 }
diff --git a/src/libcollections/slice.rs b/src/libcollections/slice.rs
@@ -812,27 +812,27 @@ impl<T> SliceExt for [T] {
     }
 
     #[inline]
-    fn slice<'a>(&'a self, start: usize, end: usize) -> &'a [T] {
+    fn slice(&self, start: usize, end: usize) -> &[T] {
         &self[start .. end]
     }
 
     #[inline]
-    fn slice_from<'a>(&'a self, start: usize) -> &'a [T] {
+    fn slice_from(&self, start: usize) -> &[T] {
         &self[start ..]
     }
 
     #[inline]
-    fn slice_to<'a>(&'a self, end: usize) -> &'a [T] {
+    fn slice_to(&self, end: usize) -> &[T] {
         &self[.. end]
     }
 
     #[inline]
-    fn split_at<'a>(&'a self, mid: usize) -> (&'a [T], &'a [T]) {
+    fn split_at(&self, mid: usize) -> (&[T], &[T]) {
         core_slice::SliceExt::split_at(self, mid)
     }
 
     #[inline]
-    fn iter<'a>(&'a self) -> Iter<'a, T> {
+    fn iter(&self) -> Iter<T> {
         core_slice::SliceExt::iter(self)
     }
 
@@ -855,42 +855,42 @@ impl<T> SliceExt for [T] {
     }
 
     #[inline]
-    fn windows<'a>(&'a self, size: usize) -> Windows<'a, T> {
+    fn windows(&self, size: usize) -> Windows<T> {
         core_slice::SliceExt::windows(self, size)
     }
 
     #[inline]
-    fn chunks<'a>(&'a self, size: usize) -> Chunks<'a, T> {
+    fn chunks(&self, size: usize) -> Chunks<T> {
         core_slice::SliceExt::chunks(self, size)
     }
 
     #[inline]
-    fn get<'a>(&'a self, index: usize) -> Option<&'a T> {
+    fn get(&self, index: usize) -> Option<&T> {
         core_slice::SliceExt::get(self, index)
     }
 
     #[inline]
-    fn first<'a>(&'a self) -> Option<&'a T> {
+    fn first(&self) -> Option<&T> {
         core_slice::SliceExt::first(self)
     }
 
     #[inline]
-    fn tail<'a>(&'a self) -> &'a [T] {
+    fn tail(&self) -> &[T] {
         core_slice::SliceExt::tail(self)
     }
 
     #[inline]
-    fn init<'a>(&'a self) -> &'a [T] {
+    fn init(&self) -> &[T] {
         core_slice::SliceExt::init(self)
     }
 
     #[inline]
-    fn last<'a>(&'a self) -> Option<&'a T> {
+    fn last(&self) -> Option<&T> {
         core_slice::SliceExt::last(self)
     }
 
     #[inline]
-    unsafe fn get_unchecked<'a>(&'a self, index: usize) -> &'a T {
+    unsafe fn get_unchecked(&self, index: usize) -> &T {
         core_slice::SliceExt::get_unchecked(self, index)
     }
 
@@ -916,52 +916,52 @@ impl<T> SliceExt for [T] {
     }
 
     #[inline]
-    fn get_mut<'a>(&'a mut self, index: usize) -> Option<&'a mut T> {
+    fn get_mut(&mut self, index: usize) -> Option<&mut T> {
         core_slice::SliceExt::get_mut(self, index)
     }
 
     #[inline]
-    fn as_mut_slice<'a>(&'a mut self) -> &'a mut [T] {
+    fn as_mut_slice(&mut self) -> &mut [T] {
         core_slice::SliceExt::as_mut_slice(self)
     }
 
     #[inline]
-    fn slice_mut<'a>(&'a mut self, start: usize, end: usize) -> &'a mut [T] {
+    fn slice_mut(&mut self, start: usize, end: usize) -> &mut [T] {
         &mut self[start .. end]
     }
 
     #[inline]
-    fn slice_from_mut<'a>(&'a mut self, start: usize) -> &'a mut [T] {
+    fn slice_from_mut(&mut self, start: usize) -> &mut [T] {
         &mut self[start ..]
     }
 
     #[inline]
-    fn slice_to_mut<'a>(&'a mut self, end: usize) -> &'a mut [T] {
+    fn slice_to_mut(&mut self, end: usize) -> &mut [T] {
         &mut self[.. end]
     }
 
     #[inline]
-    fn iter_mut<'a>(&'a mut self) -> IterMut<'a, T> {
+    fn iter_mut(&mut self) -> IterMut<T> {
         core_slice::SliceExt::iter_mut(self)
     }
 
     #[inline]
-    fn first_mut<'a>(&'a mut self) -> Option<&'a mut T> {
+    fn first_mut(&mut self) -> Option<&mut T> {
         core_slice::SliceExt::first_mut(self)
     }
 
     #[inline]
-    fn tail_mut<'a>(&'a mut self) -> &'a mut [T] {
+    fn tail_mut(&mut self) -> &mut [T] {
         core_slice::SliceExt::tail_mut(self)
     }
 
     #[inline]
-    fn init_mut<'a>(&'a mut self) -> &'a mut [T] {
+    fn init_mut(&mut self) -> &mut [T] {
         core_slice::SliceExt::init_mut(self)
     }
 
     #[inline]
-    fn last_mut<'a>(&'a mut self) -> Option<&'a mut T> {
+    fn last_mut(&mut self) -> Option<&mut T> {
         core_slice::SliceExt::last_mut(self)
     }
 
@@ -984,7 +984,7 @@ impl<T> SliceExt for [T] {
     }
 
     #[inline]
-    fn chunks_mut<'a>(&'a mut self, chunk_size: usize) -> ChunksMut<'a, T> {
+    fn chunks_mut(&mut self, chunk_size: usize) -> ChunksMut<T> {
         core_slice::SliceExt::chunks_mut(self, chunk_size)
     }
 
@@ -994,7 +994,7 @@ impl<T> SliceExt for [T] {
     }
 
     #[inline]
-    fn split_at_mut<'a>(&'a mut self, mid: usize) -> (&'a mut [T], &'a mut [T]) {
+    fn split_at_mut(&mut self, mid: usize) -> (&mut [T], &mut [T]) {
         core_slice::SliceExt::split_at_mut(self, mid)
     }
 
@@ -1004,7 +1004,7 @@ impl<T> SliceExt for [T] {
     }
 
     #[inline]
-    unsafe fn get_unchecked_mut<'a>(&'a mut self, index: usize) -> &'a mut T {
+    unsafe fn get_unchecked_mut(&mut self, index: usize) -> &mut T {
         core_slice::SliceExt::get_unchecked_mut(self, index)
     }
 
diff --git a/src/libcollections/str.rs b/src/libcollections/str.rs
@@ -464,7 +464,7 @@ pub trait StrExt: Index<RangeFull, Output = str> {
     #[inline]
     #[unstable(feature = "collections",
                reason = "this functionality may be moved to libunicode")]
-    fn nfd_chars<'a>(&'a self) -> Decompositions<'a> {
+    fn nfd_chars(&self) -> Decompositions {
         Decompositions {
             iter: self[].chars(),
             buffer: Vec::new(),
@@ -478,7 +478,7 @@ pub trait StrExt: Index<RangeFull, Output = str> {
     #[inline]
     #[unstable(feature = "collections",
                reason = "this functionality may be moved to libunicode")]
-    fn nfkd_chars<'a>(&'a self) -> Decompositions<'a> {
+    fn nfkd_chars(&self) -> Decompositions {
         Decompositions {
             iter: self[].chars(),
             buffer: Vec::new(),
@@ -492,7 +492,7 @@ pub trait StrExt: Index<RangeFull, Output = str> {
     #[inline]
     #[unstable(feature = "collections",
                reason = "this functionality may be moved to libunicode")]
-    fn nfc_chars<'a>(&'a self) -> Recompositions<'a> {
+    fn nfc_chars(&self) -> Recompositions {
         Recompositions {
             iter: self.nfd_chars(),
             state: Composing,
@@ -507,7 +507,7 @@ pub trait StrExt: Index<RangeFull, Output = str> {
     #[inline]
     #[unstable(feature = "collections",
                reason = "this functionality may be moved to libunicode")]
-    fn nfkc_chars<'a>(&'a self) -> Recompositions<'a> {
+    fn nfkc_chars(&self) -> Recompositions {
         Recompositions {
             iter: self.nfkd_chars(),
             state: Composing,
diff --git a/src/libcollections/string.rs b/src/libcollections/string.rs
@@ -488,7 +488,7 @@ impl String {
     /// ```
     #[inline]
     #[stable(feature = "rust1", since = "1.0.0")]
-    pub fn as_bytes<'a>(&'a self) -> &'a [u8] {
+    pub fn as_bytes(&self) -> &[u8] {
         &self.vec
     }
 
@@ -627,7 +627,7 @@ impl String {
     /// ```
     #[inline]
     #[stable(feature = "rust1", since = "1.0.0")]
-    pub unsafe fn as_mut_vec<'a>(&'a mut self) -> &'a mut Vec<u8> {
+    pub unsafe fn as_mut_vec(&mut self) -> &mut Vec<u8> {
         &mut self.vec
     }
 
@@ -803,7 +803,7 @@ impl<'a, 'b> PartialEq<CowString<'a>> for &'b str {
 impl Str for String {
     #[inline]
     #[stable(feature = "rust1", since = "1.0.0")]
-    fn as_slice<'a>(&'a self) -> &'a str {
+    fn as_slice(&self) -> &str {
         unsafe { mem::transmute(&*self.vec) }
     }
 }
@@ -891,7 +891,7 @@ impl ops::Deref for String {
     type Target = str;
 
     #[inline]
-    fn deref<'a>(&'a self) -> &'a str {
+    fn deref(&self) -> &str {
         unsafe { mem::transmute(&self.vec[]) }
     }
 }
diff --git a/src/libcollections/vec.rs b/src/libcollections/vec.rs
@@ -425,7 +425,7 @@ impl<T> Vec<T> {
     /// ```
     #[inline]
     #[stable(feature = "rust1", since = "1.0.0")]
-    pub fn as_mut_slice<'a>(&'a mut self) -> &'a mut [T] {
+    pub fn as_mut_slice(&mut self) -> &mut [T] {
         unsafe {
             mem::transmute(RawSlice {
                 data: *self.ptr,
@@ -737,7 +737,7 @@ impl<T> Vec<T> {
     #[inline]
     #[unstable(feature = "collections",
                reason = "matches collection reform specification, waiting for dust to settle")]
-    pub fn drain<'a>(&'a mut self) -> Drain<'a, T> {
+    pub fn drain(&mut self) -> Drain<T> {
         unsafe {
             let begin = *self.ptr as *const T;
             let end = if mem::size_of::<T>() == 0 {
@@ -1278,7 +1278,7 @@ impl<T> Index<usize> for Vec<T> {
     type Output = T;
 
     #[inline]
-    fn index<'a>(&'a self, index: &usize) -> &'a T {
+    fn index(&self, index: &usize) -> &T {
         // NB built-in indexing via `&[T]`
         &(**self)[*index]
     }
@@ -1289,7 +1289,7 @@ impl<T> IndexMut<usize> for Vec<T> {
     type Output = T;
 
     #[inline]
-    fn index_mut<'a>(&'a mut self, index: &usize) -> &'a mut T {
+    fn index_mut(&mut self, index: &usize) -> &mut T {
         // NB built-in indexing via `&mut [T]`
         &mut (**self)[*index]
     }
@@ -1366,12 +1366,12 @@ impl<T> ops::IndexMut<ops::RangeFull> for Vec<T> {
 impl<T> ops::Deref for Vec<T> {
     type Target = [T];
 
-    fn deref<'a>(&'a self) -> &'a [T] { self.as_slice() }
+    fn deref(&self) -> &[T] { self.as_slice() }
 }
 
 #[stable(feature = "rust1", since = "1.0.0")]
 impl<T> ops::DerefMut for Vec<T> {
-    fn deref_mut<'a>(&'a mut self) -> &'a mut [T] { self.as_mut_slice() }
+    fn deref_mut(&mut self) -> &mut [T] { self.as_mut_slice() }
 }
 
 #[stable(feature = "rust1", since = "1.0.0")]
@@ -1519,7 +1519,7 @@ impl<T> AsSlice<T> for Vec<T> {
     /// ```
     #[inline]
     #[stable(feature = "rust1", since = "1.0.0")]
-    fn as_slice<'a>(&'a self) -> &'a [T] {
+    fn as_slice(&self) -> &[T] {
         unsafe {
             mem::transmute(RawSlice {
                 data: *self.ptr,
@@ -1636,7 +1636,7 @@ impl<T> Iterator for IntoIter<T> {
     type Item = T;
 
     #[inline]
-    fn next<'a>(&'a mut self) -> Option<T> {
+    fn next(&mut self) -> Option<T> {
         unsafe {
             if self.ptr == self.end {
                 None
@@ -1671,7 +1671,7 @@ impl<T> Iterator for IntoIter<T> {
 #[stable(feature = "rust1", since = "1.0.0")]
 impl<T> DoubleEndedIterator for IntoIter<T> {
     #[inline]
-    fn next_back<'a>(&'a mut self) -> Option<T> {
+    fn next_back(&mut self) -> Option<T> {
         unsafe {
             if self.end == self.ptr {
                 None

Original file line number	Diff line number	Diff line change
`@@ -708,7 +708,7 @@ mod tests {`
`708`	`708`	`let iterout = vec![3, 5, 9];`
`709`	`709`	`let pq = BinaryHeap::from_vec(data);`
`710`	`710`
`711`		`- let v: Vec<_> = pq.iter().rev().map(\|&x\| x).collect();`
	`711`	`+ let v: Vec<_> = pq.iter().rev().cloned().collect();`
`712`	`712`	`assert_eq!(v, iterout);`
`713`	`713`	`}`
`714`	`714`
Original file line number	Diff line number	Diff line change
`@@ -812,27 +812,27 @@ impl<T> SliceExt for [T] {`
`812`	`812`	`}`
`813`	`813`
`814`	`814`	`#[inline]`
`815`		`- fn slice<'a>(&'a self, start: usize, end: usize) -> &'a [T] {`
	`815`	`+ fn slice(&self, start: usize, end: usize) -> &[T] {`
`816`	`816`	`&self[start .. end]`
`817`	`817`	`}`
`818`	`818`
`819`	`819`	`#[inline]`
`820`		`- fn slice_from<'a>(&'a self, start: usize) -> &'a [T] {`
	`820`	`+ fn slice_from(&self, start: usize) -> &[T] {`
`821`	`821`	`&self[start ..]`
`822`	`822`	`}`
`823`	`823`
`824`	`824`	`#[inline]`
`825`		`- fn slice_to<'a>(&'a self, end: usize) -> &'a [T] {`
	`825`	`+ fn slice_to(&self, end: usize) -> &[T] {`
`826`	`826`	`&self[.. end]`
`827`	`827`	`}`
`828`	`828`
`829`	`829`	`#[inline]`
`830`		`- fn split_at<'a>(&'a self, mid: usize) -> (&'a [T], &'a [T]) {`
	`830`	`+ fn split_at(&self, mid: usize) -> (&[T], &[T]) {`
`831`	`831`	`core_slice::SliceExt::split_at(self, mid)`
`832`	`832`	`}`
`833`	`833`
`834`	`834`	`#[inline]`
`835`		`- fn iter<'a>(&'a self) -> Iter<'a, T> {`
	`835`	`+ fn iter(&self) -> Iter<T> {`
`836`	`836`	`core_slice::SliceExt::iter(self)`
`837`	`837`	`}`
`838`	`838`
`@@ -855,42 +855,42 @@ impl<T> SliceExt for [T] {`
`855`	`855`	`}`
`856`	`856`
`857`	`857`	`#[inline]`
`858`		`- fn windows<'a>(&'a self, size: usize) -> Windows<'a, T> {`
	`858`	`+ fn windows(&self, size: usize) -> Windows<T> {`
`859`	`859`	`core_slice::SliceExt::windows(self, size)`
`860`	`860`	`}`
`861`	`861`
`862`	`862`	`#[inline]`
`863`		`- fn chunks<'a>(&'a self, size: usize) -> Chunks<'a, T> {`
	`863`	`+ fn chunks(&self, size: usize) -> Chunks<T> {`
`864`	`864`	`core_slice::SliceExt::chunks(self, size)`
`865`	`865`	`}`
`866`	`866`
`867`	`867`	`#[inline]`
`868`		`- fn get<'a>(&'a self, index: usize) -> Option<&'a T> {`
	`868`	`+ fn get(&self, index: usize) -> Option<&T> {`
`869`	`869`	`core_slice::SliceExt::get(self, index)`
`870`	`870`	`}`
`871`	`871`
`872`	`872`	`#[inline]`
`873`		`- fn first<'a>(&'a self) -> Option<&'a T> {`
	`873`	`+ fn first(&self) -> Option<&T> {`
`874`	`874`	`core_slice::SliceExt::first(self)`
`875`	`875`	`}`
`876`	`876`
`877`	`877`	`#[inline]`
`878`		`- fn tail<'a>(&'a self) -> &'a [T] {`
	`878`	`+ fn tail(&self) -> &[T] {`
`879`	`879`	`core_slice::SliceExt::tail(self)`
`880`	`880`	`}`
`881`	`881`
`882`	`882`	`#[inline]`
`883`		`- fn init<'a>(&'a self) -> &'a [T] {`
	`883`	`+ fn init(&self) -> &[T] {`
`884`	`884`	`core_slice::SliceExt::init(self)`
`885`	`885`	`}`
`886`	`886`
`887`	`887`	`#[inline]`
`888`		`- fn last<'a>(&'a self) -> Option<&'a T> {`
	`888`	`+ fn last(&self) -> Option<&T> {`
`889`	`889`	`core_slice::SliceExt::last(self)`
`890`	`890`	`}`
`891`	`891`
`892`	`892`	`#[inline]`
`893`		`- unsafe fn get_unchecked<'a>(&'a self, index: usize) -> &'a T {`
	`893`	`+ unsafe fn get_unchecked(&self, index: usize) -> &T {`
`894`	`894`	`core_slice::SliceExt::get_unchecked(self, index)`
`895`	`895`	`}`
`896`	`896`
`@@ -916,52 +916,52 @@ impl<T> SliceExt for [T] {`
`916`	`916`	`}`
`917`	`917`
`918`	`918`	`#[inline]`
`919`		`- fn get_mut<'a>(&'a mut self, index: usize) -> Option<&'a mut T> {`
	`919`	`+ fn get_mut(&mut self, index: usize) -> Option<&mut T> {`
`920`	`920`	`core_slice::SliceExt::get_mut(self, index)`
`921`	`921`	`}`
`922`	`922`
`923`	`923`	`#[inline]`
`924`		`- fn as_mut_slice<'a>(&'a mut self) -> &'a mut [T] {`
	`924`	`+ fn as_mut_slice(&mut self) -> &mut [T] {`
`925`	`925`	`core_slice::SliceExt::as_mut_slice(self)`
`926`	`926`	`}`
`927`	`927`
`928`	`928`	`#[inline]`
`929`		`- fn slice_mut<'a>(&'a mut self, start: usize, end: usize) -> &'a mut [T] {`
	`929`	`+ fn slice_mut(&mut self, start: usize, end: usize) -> &mut [T] {`
`930`	`930`	`&mut self[start .. end]`
`931`	`931`	`}`
`932`	`932`
`933`	`933`	`#[inline]`
`934`		`- fn slice_from_mut<'a>(&'a mut self, start: usize) -> &'a mut [T] {`
	`934`	`+ fn slice_from_mut(&mut self, start: usize) -> &mut [T] {`
`935`	`935`	`&mut self[start ..]`
`936`	`936`	`}`
`937`	`937`
`938`	`938`	`#[inline]`
`939`		`- fn slice_to_mut<'a>(&'a mut self, end: usize) -> &'a mut [T] {`
	`939`	`+ fn slice_to_mut(&mut self, end: usize) -> &mut [T] {`
`940`	`940`	`&mut self[.. end]`
`941`	`941`	`}`
`942`	`942`
`943`	`943`	`#[inline]`
`944`		`- fn iter_mut<'a>(&'a mut self) -> IterMut<'a, T> {`
	`944`	`+ fn iter_mut(&mut self) -> IterMut<T> {`
`945`	`945`	`core_slice::SliceExt::iter_mut(self)`
`946`	`946`	`}`
`947`	`947`
`948`	`948`	`#[inline]`
`949`		`- fn first_mut<'a>(&'a mut self) -> Option<&'a mut T> {`
	`949`	`+ fn first_mut(&mut self) -> Option<&mut T> {`
`950`	`950`	`core_slice::SliceExt::first_mut(self)`
`951`	`951`	`}`
`952`	`952`
`953`	`953`	`#[inline]`
`954`		`- fn tail_mut<'a>(&'a mut self) -> &'a mut [T] {`
	`954`	`+ fn tail_mut(&mut self) -> &mut [T] {`
`955`	`955`	`core_slice::SliceExt::tail_mut(self)`
`956`	`956`	`}`
`957`	`957`
`958`	`958`	`#[inline]`
`959`		`- fn init_mut<'a>(&'a mut self) -> &'a mut [T] {`
	`959`	`+ fn init_mut(&mut self) -> &mut [T] {`
`960`	`960`	`core_slice::SliceExt::init_mut(self)`
`961`	`961`	`}`
`962`	`962`
`963`	`963`	`#[inline]`
`964`		`- fn last_mut<'a>(&'a mut self) -> Option<&'a mut T> {`
	`964`	`+ fn last_mut(&mut self) -> Option<&mut T> {`
`965`	`965`	`core_slice::SliceExt::last_mut(self)`
`966`	`966`	`}`
`967`	`967`
`@@ -984,7 +984,7 @@ impl<T> SliceExt for [T] {`
`984`	`984`	`}`
`985`	`985`
`986`	`986`	`#[inline]`
`987`		`- fn chunks_mut<'a>(&'a mut self, chunk_size: usize) -> ChunksMut<'a, T> {`
	`987`	`+ fn chunks_mut(&mut self, chunk_size: usize) -> ChunksMut<T> {`
`988`	`988`	`core_slice::SliceExt::chunks_mut(self, chunk_size)`
`989`	`989`	`}`
`990`	`990`
`@@ -994,7 +994,7 @@ impl<T> SliceExt for [T] {`
`994`	`994`	`}`
`995`	`995`
`996`	`996`	`#[inline]`
`997`		`- fn split_at_mut<'a>(&'a mut self, mid: usize) -> (&'a mut [T], &'a mut [T]) {`
	`997`	`+ fn split_at_mut(&mut self, mid: usize) -> (&mut [T], &mut [T]) {`
`998`	`998`	`core_slice::SliceExt::split_at_mut(self, mid)`
`999`	`999`	`}`
`1000`	`1000`
`@@ -1004,7 +1004,7 @@ impl<T> SliceExt for [T] {`
`1004`	`1004`	`}`
`1005`	`1005`
`1006`	`1006`	`#[inline]`
`1007`		`- unsafe fn get_unchecked_mut<'a>(&'a mut self, index: usize) -> &'a mut T {`
	`1007`	`+ unsafe fn get_unchecked_mut(&mut self, index: usize) -> &mut T {`
`1008`	`1008`	`core_slice::SliceExt::get_unchecked_mut(self, index)`
`1009`	`1009`	`}`
`1010`	`1010`
Original file line number	Diff line number	Diff line change
`@@ -488,7 +488,7 @@ impl String {`
`488`	`488`	/// ```
`489`	`489`	`#[inline]`
`490`	`490`	`#[stable(feature = "rust1", since = "1.0.0")]`
`491`		`- pub fn as_bytes<'a>(&'a self) -> &'a [u8] {`
	`491`	`+ pub fn as_bytes(&self) -> &[u8] {`
`492`	`492`	`&self.vec`
`493`	`493`	`}`
`494`	`494`
`@@ -627,7 +627,7 @@ impl String {`
`627`	`627`	/// ```
`628`	`628`	`#[inline]`
`629`	`629`	`#[stable(feature = "rust1", since = "1.0.0")]`
`630`		`- pub unsafe fn as_mut_vec<'a>(&'a mut self) -> &'a mut Vec<u8> {`
	`630`	`+ pub unsafe fn as_mut_vec(&mut self) -> &mut Vec<u8> {`
`631`	`631`	`&mut self.vec`
`632`	`632`	`}`
`633`	`633`
`@@ -803,7 +803,7 @@ impl<'a, 'b> PartialEq<CowString<'a>> for &'b str {`
`803`	`803`	`impl Str for String {`
`804`	`804`	`#[inline]`
`805`	`805`	`#[stable(feature = "rust1", since = "1.0.0")]`
`806`		`- fn as_slice<'a>(&'a self) -> &'a str {`
	`806`	`+ fn as_slice(&self) -> &str {`
`807`	`807`	`unsafe { mem::transmute(&*self.vec) }`
`808`	`808`	`}`
`809`	`809`	`}`
`@@ -891,7 +891,7 @@ impl ops::Deref for String {`
`891`	`891`	`type Target = str;`
`892`	`892`
`893`	`893`	`#[inline]`
`894`		`- fn deref<'a>(&'a self) -> &'a str {`
	`894`	`+ fn deref(&self) -> &str {`
`895`	`895`	`unsafe { mem::transmute(&self.vec[]) }`
`896`	`896`	`}`
`897`	`897`	`}`