Move Slice Iterators

src/impls/mod.rs

@@ -0,0 +1,2 @@
+pub mod slice;
+mod vec;

src/impls.rs → src/impls/slice.rs

@@ -1,11 +1,27 @@
 use std::{mem, raw};
-use {IntrusiveIterator, FromIntrusiveIterator};
+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;
 
@@ -51,14 +67,6 @@ impl<'a, T> IntrusiveIterator<&'a mut T> for &'a mut [T] {
     }
 }
 
-impl<T> FromIntrusiveIterator<T> for Vec<T> {
-    fn collect<I: IntrusiveIterator<T>>(iter: I) -> Vec<T> {
-        let mut vec = Vec::new();
-        iter.iterate(|&mut: elem| vec.push(elem));
-        vec
-    }
-}
-
 #[cfg(test)]
 mod test {
     pub use super::*;
@@ -67,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());
         }
 
@@ -82,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/impls/vec.rs

@@ -0,0 +1,10 @@
+use {IntrusiveIterator, FromIntrusiveIterator};
+
+impl<T> FromIntrusiveIterator<T> for Vec<T> {
+    fn collect<I: IntrusiveIterator<T>>(iter: I) -> Vec<T> {
+        let mut vec = Vec::new();
+        iter.iterate(|&mut: elem| vec.push(elem));
+        vec
+    }
+}
+

src/lib.rs

@@ -9,6 +9,9 @@ extern crate stainless;
 #[cfg(test)]
 extern crate test;
 
+pub use self::impls::slice;
+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;
+