---

yaml
---
r: 72115
b: refs/heads/dist-snap
c: 8ae6b33
h: refs/heads/master
i:
  72113: 588f5b4
  72111: 20d9f07
v: v3

Author: huonw

[refs]

@@ -7,7 +7,7 @@ refs/tags/release-0.1: 1f5c5126e96c79d22cb7862f75304136e204f105
 refs/heads/ndm: f3868061cd7988080c30d6d5bf352a5a5fe2460b
 refs/heads/try2: 147ecfdd8221e4a4d4e090486829a06da1e0ca3c
 refs/heads/incoming: b50030718cf28f2a5a81857a26b57442734fe854
-refs/heads/dist-snap: 962a753890f801c378b3cb244b7d7ca3cae164a5
+refs/heads/dist-snap: 8ae6b33ed0cf2b1793773f31b8f5249347ef0983
 refs/tags/release-0.2: c870d2dffb391e14efb05aa27898f1f6333a9596
 refs/tags/release-0.3: b5f0d0f648d9a6153664837026ba1be43d3e2503
 refs/heads/try3: 9387340aab40a73e8424c48fd42f0c521a4875c0

branches/dist-snap/src/libcore/iterator.rs

@@ -22,10 +22,8 @@ pub trait IteratorUtil<A> {
     // FIXME: #5898: should be called map
     fn transform<'r, B>(self, f: &'r fn(A) -> B) -> MapIterator<'r, A, B, Self>;
     fn filter<'r>(self, predicate: &'r fn(&A) -> bool) -> FilterIterator<'r, A, Self>;
-    fn skip_while<'r>(self, predicate: &'r fn(&A) -> bool) -> SkipWhileIterator<'r, A, Self>;
-    fn take_while<'r>(self, predicate: &'r fn(&A) -> bool) -> TakeWhileIterator<'r, A, Self>;
-    fn skip(self, n: uint) -> SkipIterator<Self>;
-    fn take(self, n: uint) -> TakeIterator<Self>;
+    fn dropwhile<'r>(self, predicate: &'r fn(&A) -> bool) -> DropWhileIterator<'r, A, Self>;
+    fn takewhile<'r>(self, predicate: &'r fn(&A) -> bool) -> TakeWhileIterator<'r, A, Self>;
     fn enumerate(self) -> EnumerateIterator<Self>;
     fn advance(&mut self, f: &fn(A) -> bool);
 }
@@ -53,25 +51,15 @@ impl<A, T: Iterator<A>> IteratorUtil<A> for T {
     }
 
     #[inline(always)]
-    fn skip_while<'r>(self, predicate: &'r fn(&A) -> bool) -> SkipWhileIterator<'r, A, T> {
-        SkipWhileIterator{iter: self, flag: false, predicate: predicate}
+    fn dropwhile<'r>(self, predicate: &'r fn(&A) -> bool) -> DropWhileIterator<'r, A, T> {
+        DropWhileIterator{iter: self, flag: false, predicate: predicate}
     }
 
     #[inline(always)]
-    fn take_while<'r>(self, predicate: &'r fn(&A) -> bool) -> TakeWhileIterator<'r, A, T> {
+    fn takewhile<'r>(self, predicate: &'r fn(&A) -> bool) -> TakeWhileIterator<'r, A, T> {
         TakeWhileIterator{iter: self, flag: false, predicate: predicate}
     }
 
-    #[inline(always)]
-    fn skip(self, n: uint) -> SkipIterator<T> {
-        SkipIterator{iter: self, n: n}
-    }
-
-    #[inline(always)]
-    fn take(self, n: uint) -> TakeIterator<T> {
-        TakeIterator{iter: self, n: n}
-    }
-
     /// A shim implementing the `for` loop iteration protocol for iterator objects
     #[inline]
     fn advance(&mut self, f: &fn(A) -> bool) {
@@ -154,13 +142,13 @@ impl<A, T: Iterator<A>> Iterator<(uint, A)> for EnumerateIterator<T> {
     }
 }
 
-pub struct SkipWhileIterator<'self, A, T> {
+pub struct DropWhileIterator<'self, A, T> {
     priv iter: T,
     priv flag: bool,
     priv predicate: &'self fn(&A) -> bool
 }
 
-impl<'self, A, T: Iterator<A>> Iterator<A> for SkipWhileIterator<'self, A, T> {
+impl<'self, A, T: Iterator<A>> Iterator<A> for DropWhileIterator<'self, A, T> {
     #[inline]
     fn next(&mut self) -> Option<A> {
         let mut next = self.iter.next();
@@ -211,52 +199,3 @@ impl<'self, A, T: Iterator<A>> Iterator<A> for TakeWhileIterator<'self, A, T> {
         }
     }
 }
-
-pub struct SkipIterator<T> {
-    priv iter: T,
-    priv n: uint
-}
-
-impl<A, T: Iterator<A>> Iterator<A> for SkipIterator<T> {
-    #[inline]
-    fn next(&mut self) -> Option<A> {
-        let mut next = self.iter.next();
-        if self.n == 0 {
-            next
-        } else {
-            let n = self.n;
-            for n.times {
-                match next {
-                    Some(_) => {
-                        next = self.iter.next();
-                        loop
-                    }
-                    None => {
-                        self.n = 0;
-                        return None
-                    }
-                }
-            }
-            self.n = 0;
-            next
-        }
-    }
-}
-
-pub struct TakeIterator<T> {
-    priv iter: T,
-    priv n: uint
-}
-
-impl<A, T: Iterator<A>> Iterator<A> for TakeIterator<T> {
-    #[inline]
-    fn next(&mut self) -> Option<A> {
-        let next = self.iter.next();
-        if self.n != 0 {
-            self.n -= 1;
-            next
-        } else {
-            None
-        }
-    }
-}

branches/dist-snap/src/libcore/str.rs

@@ -1863,7 +1863,7 @@ pub fn char_range_at(s: &str, i: uint) -> CharRange {
     return CharRange {ch: val as char, next: i};
 }
 
-/// Plucks the `n`th character from the beginning of a string
+/// Plucks the character starting at the `i`th byte of a string
 pub fn char_at(s: &str, i: uint) -> char {
     return char_range_at(s, i).ch;
 }
@@ -1874,11 +1874,11 @@ pub struct CharRange {
 }
 
 /**
- * Given a byte position and a str, return the previous char and its position
+ * Given a byte position and a str, return the previous char and its position.
  *
  * This function can be used to iterate over a unicode string in reverse.
  *
- * returns 0 for next index if called on start index 0
+ * Returns 0 for next index if called on start index 0.
  */
 pub fn char_range_at_reverse(ss: &str, start: uint) -> CharRange {
     let mut prev = start;
@@ -1900,7 +1900,7 @@ pub fn char_range_at_reverse(ss: &str, start: uint) -> CharRange {
     return CharRange {ch:ch, next:prev};
 }
 
-/// Plucks the `n`th character from the end of a string
+/// Plucks the character ending at the `i`th byte of a string
 pub fn char_at_reverse(s: &str, i: uint) -> char {
     char_range_at_reverse(s, i).ch
 }

branches/dist-snap/src/libcore/vec.rs

@@ -4512,32 +4512,4 @@ mod tests {
         }
         assert_eq!(i, ys.len());
     }
-
-    #[test]
-    fn test_iterator_skip() {
-        use iterator::*;
-        let xs = [0u, 1, 2, 3, 5, 13, 15, 16, 17, 19, 20, 30];
-        let ys = [13, 15, 16, 17, 19, 20, 30];
-        let mut it = xs.iter().skip(5);
-        let mut i = 0;
-        for it.advance |&x: &uint| {
-            assert_eq!(x, ys[i]);
-            i += 1;
-        }
-        assert_eq!(i, ys.len());
-    }
-
-    #[test]
-    fn test_iterator_take() {
-        use iterator::*;
-        let xs = [0u, 1, 2, 3, 5, 13, 15, 16, 17, 19];
-        let ys = [0u, 1, 2, 3, 5];
-        let mut it = xs.iter().take(5);
-        let mut i = 0;
-        for it.advance |&x: &uint| {
-            assert_eq!(x, ys[i]);
-            i += 1;
-        }
-        assert_eq!(i, ys.len());
-    }
 }