(feat) Move slice iterators to Items and ItemsMut.

Author: reem

src/impls/mod.rs

@@ -1,2 +1,4 @@
+pub use self::slice::{SliceIntrusiveIter, Items, ItemsMut};
+
 mod slice;
 mod vec;

src/impls/slice.rs

@@ -1,11 +1,27 @@
 use std::{mem, raw};
 use {IntrusiveIterator};
 
-impl<'a, T> IntrusiveIterator<&'a T> for &'a [T] {
+pub trait SliceIntrusiveIter<T> for Sized? {
+    fn intrusive_iter(&self) -> Items<T>;
+    fn intrusive_iter_mut(&mut self) -> ItemsMut<T>;
+}
+
+pub struct Items<'a, T: 'a>(&'a [T]);
+pub struct ItemsMut<'a, T: 'a>(&'a mut [T]);
+
+impl<T> SliceIntrusiveIter<T> for [T] {
+    #[inline]
+    fn intrusive_iter(&self) -> Items<T> { Items(self) }
+
+    #[inline]
+    fn intrusive_iter_mut(&mut self) -> ItemsMut<T> { ItemsMut(self) }
+}
+
+impl<'a, T> IntrusiveIterator<&'a T> for Items<'a, T> {
     #[inline]
     fn traverse<F: FnMut(&'a T) -> bool>(self, mut f: F) {
         unsafe {
-            let slice = mem::transmute::<&'a [T], raw::Slice<T>>(self);
+            let slice = mem::transmute::<&'a [T], raw::Slice<T>>(self.0);
 
             let is_zero_size = mem::size_of::<T>() == 0;
 
@@ -26,11 +42,11 @@ impl<'a, T> IntrusiveIterator<&'a T> for &'a [T] {
     }
 }
 
-impl<'a, T> IntrusiveIterator<&'a mut T> for &'a mut [T] {
+impl<'a, T> IntrusiveIterator<&'a mut T> for ItemsMut<'a, T> {
     #[inline]
     fn traverse<F: FnMut(&'a mut T) -> bool>(self, mut f: F) {
         unsafe {
-            let slice = mem::transmute::<&'a mut [T], raw::Slice<T>>(self);
+            let slice = mem::transmute::<&'a mut [T], raw::Slice<T>>(self.0);
 
             let is_zero_size = mem::size_of::<T>() == 0;
 
@@ -59,13 +75,13 @@ mod test {
     describe! intrusive_slice_iter {
         it "should yield all elements of a slice in order" {
             let data = [1u, 2, 5, 4, 6, 7];
-            let intrusive: Vec<uint> = data.as_slice().map(|&x| x).collect();
+            let intrusive: Vec<uint> = data.intrusive_iter().map(|&x| x).collect();
             assert_eq!(&*intrusive, data.as_slice());
         }
 
         it "should work with zero-sized types" {
             let data = [(), (), ()];
-            let intrusive: Vec<()> = data.as_slice().map(|&x| x).collect();
+            let intrusive: Vec<()> = data.intrusive_iter().map(|&x| x).collect();
             assert_eq!(&*intrusive, data.as_slice());
         }
 
@@ -74,7 +90,7 @@ mod test {
 
             let data = Vec::from_fn(10000, |_| random::<uint>());
             bench.iter(|| {
-                data.as_slice().iterate(|&: x| ::test::black_box(x));
+                data.intrusive_iter().iterate(|&: x| ::test::black_box(x));
             });
         }
 

src/lib.rs

@@ -9,6 +9,9 @@ extern crate stainless;
 #[cfg(test)]
 extern crate test;
 
+pub use self::impls::{SliceIntrusiveIter, Items, ItemsMut};
+pub mod utils;
+
 /// Intrusive Iterators.
 pub trait IntrusiveIterator<T> {
     /// Run this Iterator using the provided closure.
@@ -180,4 +183,4 @@ pub struct Cloned<I> {
 
 mod ext;
 mod impls;
-pub mod utils;
+