---

yaml
---
r: 145084
b: refs/heads/try2
c: 653ffa8
h: refs/heads/master
v: v3

Author: lkuper

[refs]

@@ -5,7 +5,7 @@ refs/heads/snap-stage3: 78a7676898d9f80ab540c6df5d4c9ce35bb50463
 refs/heads/try: 519addf6277dbafccbb4159db4b710c37eaa2ec5
 refs/tags/release-0.1: 1f5c5126e96c79d22cb7862f75304136e204f105
 refs/heads/ndm: f3868061cd7988080c30d6d5bf352a5a5fe2460b
-refs/heads/try2: 0dbd509e0f90bc13f7b49c24e48a281928b2ee9c
+refs/heads/try2: 653ffa845d70b26a49e227ae4445729c369c9f80
 refs/heads/dist-snap: ba4081a5a8573875fed17545846f6f6902c8ba8d
 refs/tags/release-0.2: c870d2dffb391e14efb05aa27898f1f6333a9596
 refs/tags/release-0.3: b5f0d0f648d9a6153664837026ba1be43d3e2503

branches/try2/src/libstd/iter.rs

@@ -21,7 +21,7 @@ use cmp;
 use num::{Zero, One, Integer, CheckedAdd, CheckedSub, Saturating};
 use option::{Option, Some, None};
 use ops::{Add, Mul, Sub};
-use cmp::{Eq, Ord};
+use cmp::Ord;
 use clone::Clone;
 use uint;
 use util;
@@ -1719,21 +1719,7 @@ pub fn count<A>(start: A, step: A) -> Counter<A> {
     Counter{state: start, step: step}
 }
 
-impl<A: Add<A, A> + Clone> Iterator<A> for Counter<A> {
-    #[inline]
-    fn next(&mut self) -> Option<A> {
-        let result = self.state.clone();
-        self.state = self.state + self.step;
-        Some(result)
-    }
-
-    #[inline]
-    fn size_hint(&self) -> (uint, Option<uint>) {
-        (uint::max_value, None) // Too bad we can't specify an infinite lower bound
-    }
-}
-
-/// An iterator over the range [start, stop)
+/// A range of numbers from [0, N)
 #[deriving(Clone, DeepClone)]
 pub struct Range<A> {
     priv state: A,
@@ -1763,12 +1749,14 @@ impl<A: Add<A, A> + Ord + Clone> Iterator<A> for Range<A> {
     // Blocked on #8605 Need numeric trait for converting to `Option<uint>`
 }
 
-/// `Integer` is required to ensure the range will be the same regardless of
-/// the direction it is consumed.
-impl<A: Integer + Ord + Clone> DoubleEndedIterator<A> for Range<A> {
+impl<A: Sub<A, A> + Integer + Ord + Clone> DoubleEndedIterator<A> for Range<A> {
     #[inline]
     fn next_back(&mut self) -> Option<A> {
         if self.stop > self.state {
+            // Integer doesn't technically define this rule, but we're going to assume that every
+            // Integer is reachable from every other one by adding or subtracting enough Ones. This
+            // seems like a reasonable-enough rule that every Integer should conform to, even if it
+            // can't be statically checked.
             self.stop = self.stop - self.one;
             Some(self.stop.clone())
         } else {
@@ -1777,7 +1765,7 @@ impl<A: Integer + Ord + Clone> DoubleEndedIterator<A> for Range<A> {
     }
 }
 
-/// An iterator over the range [start, stop]
+/// A range of numbers from [0, N]
 #[deriving(Clone, DeepClone)]
 pub struct RangeInclusive<A> {
     priv range: Range<A>,
@@ -1838,78 +1826,17 @@ impl<A: Sub<A, A> + Integer + Ord + Clone> DoubleEndedIterator<A> for RangeInclu
     }
 }
 
-/// An iterator over the range [start, stop) by `step`. It handles overflow by stopping.
-#[deriving(Clone, DeepClone)]
-pub struct RangeStep<A> {
-    priv state: A,
-    priv stop: A,
-    priv step: A,
-    priv rev: bool
-}
-
-/// Return an iterator over the range [start, stop) by `step`. It handles overflow by stopping.
-#[inline]
-pub fn range_step<A: CheckedAdd + Ord + Clone + Zero>(start: A, stop: A, step: A) -> RangeStep<A> {
-    let rev = step < Zero::zero();
-    RangeStep{state: start, stop: stop, step: step, rev: rev}
-}
-
-impl<A: CheckedAdd + Ord + Clone> Iterator<A> for RangeStep<A> {
+impl<A: Add<A, A> + Clone> Iterator<A> for Counter<A> {
     #[inline]
     fn next(&mut self) -> Option<A> {
-        if (self.rev && self.state > self.stop) || self.state < self.stop {
-            let result = self.state.clone();
-            match self.state.checked_add(&self.step) {
-                Some(x) => self.state = x,
-                None => self.state = self.stop.clone()
-            }
-            Some(result)
-        } else {
-            None
-        }
+        let result = self.state.clone();
+        self.state = self.state + self.step;
+        Some(result)
     }
-}
-
-/// An iterator over the range [start, stop] by `step`. It handles overflow by stopping.
-#[deriving(Clone, DeepClone)]
-pub struct RangeStepInclusive<A> {
-    priv state: A,
-    priv stop: A,
-    priv step: A,
-    priv rev: bool,
-    priv done: bool
-}
 
-/// Return an iterator over the range [start, stop] by `step`. It handles overflow by stopping.
-#[inline]
-pub fn range_step_inclusive<A: CheckedAdd + Ord + Clone + Zero>(start: A, stop: A,
-                                                                step: A) -> RangeStepInclusive<A> {
-    let rev = step < Zero::zero();
-    RangeStepInclusive{state: start, stop: stop, step: step, rev: rev, done: false}
-}
-
-impl<A: CheckedAdd + Ord + Clone + Eq> Iterator<A> for RangeStepInclusive<A> {
     #[inline]
-    fn next(&mut self) -> Option<A> {
-        if !self.done {
-            if (self.rev && self.state > self.stop) || self.state < self.stop {
-                let result = self.state.clone();
-                match self.state.checked_add(&self.step) {
-                    Some(x) => self.state = x,
-                    None => self.done = true
-                }
-                Some(result)
-            } else {
-                if self.state == self.stop {
-                    self.done = true;
-                    Some(self.state.clone())
-                } else {
-                    None
-                }
-            }
-        } else {
-            None
-        }
+    fn size_hint(&self) -> (uint, Option<uint>) {
+        (uint::max_value, None) // Too bad we can't specify an infinite lower bound
     }
 }
 
@@ -2722,20 +2649,6 @@ mod tests {
         assert_eq!(range_inclusive(0i, 5).invert().collect::<~[int]>(), ~[5i, 4, 3, 2, 1, 0]);
     }
 
-    #[test]
-    fn test_range_step() {
-        assert_eq!(range_step(0i, 20, 5).collect::<~[int]>(), ~[0, 5, 10, 15]);
-        assert_eq!(range_step(20i, 0, -5).collect::<~[int]>(), ~[20, 15, 10, 5]);
-        assert_eq!(range_step(200u8, 255, 50).collect::<~[u8]>(), ~[200u8, 250]);
-    }
-
-    #[test]
-    fn test_range_step_inclusive() {
-        assert_eq!(range_step_inclusive(0i, 20, 5).collect::<~[int]>(), ~[0, 5, 10, 15, 20]);
-        assert_eq!(range_step_inclusive(20i, 0, -5).collect::<~[int]>(), ~[20, 15, 10, 5, 0]);
-        assert_eq!(range_step_inclusive(200u8, 255, 50).collect::<~[u8]>(), ~[200u8, 250]);
-    }
-
     #[test]
     fn test_reverse() {
         let mut ys = [1, 2, 3, 4, 5];

branches/try2/src/libsyntax/ast_util.rs

@@ -519,20 +519,11 @@ impl Visitor<()> for IdVisitor {
         visit::walk_stmt(self, statement, env)
     }
 
-    // XXX: Default
-    fn visit_arm(&mut self, arm: &Arm, env: ()) {
-        visit::walk_arm(self, arm, env)
-    }
-
     fn visit_pat(&mut self, pattern: @Pat, env: ()) {
         (self.visit_callback)(pattern.id);
         visit::walk_pat(self, pattern, env)
     }
 
-    // XXX: Default
-    fn visit_decl(&mut self, declaration: @Decl, env: ()) {
-        visit::walk_decl(self, declaration, env)
-    }
 
     fn visit_expr(&mut self, expression: @Expr, env: ()) {
         {
@@ -545,11 +536,6 @@ impl Visitor<()> for IdVisitor {
         visit::walk_expr(self, expression, env)
     }
 
-    // XXX: Default
-    fn visit_expr_post(&mut self, _: @Expr, _: ()) {
-        // Empty!
-    }
-
     fn visit_ty(&mut self, typ: &Ty, env: ()) {
         (self.visit_callback)(typ.id);
         match typ.node {
@@ -612,31 +598,6 @@ impl Visitor<()> for IdVisitor {
         }
     }
 
-    // XXX: Default
-    fn visit_ty_method(&mut self, type_method: &TypeMethod, env: ()) {
-        visit::walk_ty_method(self, type_method, env)
-    }
-
-    // XXX: Default
-    fn visit_trait_method(&mut self, trait_method: &trait_method, env: ()) {
-        visit::walk_trait_method(self, trait_method, env)
-    }
-
-    // XXX: Default
-    fn visit_struct_def(&mut self,
-                        struct_definition: @struct_def,
-                        identifier: Ident,
-                        generics: &Generics,
-                        node_id: NodeId,
-                        env: ()) {
-        visit::walk_struct_def(self,
-                                struct_definition,
-                                identifier,
-                                generics,
-                                node_id,
-                                env)
-    }
-
     fn visit_struct_field(&mut self, struct_field: @struct_field, env: ()) {
         (self.visit_callback)(struct_field.node.id);
         visit::walk_struct_field(self, struct_field, env)