---

yaml
---
r: 190326
b: refs/heads/tmp
c: 0b01a9b
h: refs/heads/master
v: v3

Author: tamird

[refs]

@@ -34,6 +34,6 @@ refs/heads/building: 126db549b038c84269a1e4fe46f051b2c15d6970
 refs/heads/beta: 522d09dfecbeca1595f25ac58c6d0178bbd21d7d
 refs/heads/windistfix: 7608dbad651f02e837ed05eef3d74a6662a6e928
 refs/tags/1.0.0-alpha: e42bd6d93a1d3433c486200587f8f9e12590a4d7
-refs/heads/tmp: 7a306b1b005eb7c870f7ebad75f6d19b6e995236
+refs/heads/tmp: 0b01a9bb4b93e3f763b4ab924179462b415991d4
 refs/tags/1.0.0-alpha.2: 4c705f6bc559886632d3871b04f58aab093bfa2f
 refs/tags/homu-tmp: 4a5101a42f8ea36bdbe14749e672ab78cb971726

branches/tmp/src/libcollections/lib.rs

@@ -33,7 +33,6 @@
 #![feature(unsafe_destructor)]
 #![feature(unique)]
 #![feature(unsafe_no_drop_flag)]
-#![feature(step_by)]
 #![cfg_attr(test, feature(rand, rustc_private, test))]
 #![cfg_attr(test, allow(deprecated))] // rand
 

branches/tmp/src/libcollections/slice.rs

@@ -92,7 +92,7 @@ use core::clone::Clone;
 use core::cmp::Ordering::{self, Greater, Less};
 use core::cmp::{self, Ord, PartialEq};
 use core::iter::{Iterator, IteratorExt};
-use core::iter::MultiplicativeIterator;
+use core::iter::{range_step, MultiplicativeIterator};
 use core::marker::Sized;
 use core::mem::size_of;
 use core::mem;
@@ -1387,7 +1387,7 @@ fn merge_sort<T, F>(v: &mut [T], mut compare: F) where F: FnMut(&T, &T) -> Order
     // We could hardcode the sorting comparisons here, and we could
     // manipulate/step the pointers themselves, rather than repeatedly
     // .offset-ing.
-    for start in (0.. len).step_by(insertion) {
+    for start in range_step(0, len, insertion) {
         // start <= i < len;
         for i in start..cmp::min(start + insertion, len) {
             // j satisfies: start <= j <= i;
@@ -1427,7 +1427,7 @@ fn merge_sort<T, F>(v: &mut [T], mut compare: F) where F: FnMut(&T, &T) -> Order
         // a time, placing the result in `buf_tmp`.
 
         // 0 <= start <= len.
-        for start in (0..len).step_by(2 * width) {
+        for start in range_step(0, len, 2 * width) {
             // manipulate pointers directly for speed (rather than
             // using a `for` loop with `range` and `.offset` inside
             // that loop).

branches/tmp/src/libcore/iter.rs

@@ -65,7 +65,7 @@ use default::Default;
 use marker;
 use mem;
 use num::{ToPrimitive, Int};
-use ops::{Add, Deref, FnMut, RangeFrom};
+use ops::{Add, Deref, FnMut};
 use option::Option;
 use option::Option::{Some, None};
 use marker::Sized;
@@ -2366,101 +2366,34 @@ impl<A, St, F> Iterator for Unfold<St, F> where F: FnMut(&mut St) -> Option<A> {
     }
 }
 
-/// An adapter for stepping range iterators by a custom amount.
-///
-/// The resulting iterator handles overflow by stopping. The `A`
-/// parameter is the type being iterated over, while `R` is the range
-/// type (usually one of `std::ops::{Range, RangeFrom}`.
-#[derive(Clone)]
-#[unstable(feature = "step_by", reason = "recent addition")]
-pub struct StepBy<A, R> {
-    step_by: A,
-    range: R,
-}
-
-impl<A: Add> RangeFrom<A> {
-    /// Creates an iterator starting at the same point, but stepping by
-    /// the given amount at each iteration.
-    ///
-    /// # Examples
-    ///
-    /// ```ignore
-    /// for i in (0u8..).step_by(2) {
-    ///     println!("{}", i);
-    /// }
-    /// ```
-    ///
-    /// This prints all even `u8` values.
-    #[unstable(feature = "step_by", reason = "recent addition")]
-    pub fn step_by(self, by: A) -> StepBy<A, Self> {
-        StepBy {
-            step_by: by,
-            range: self
-        }
-    }
-}
-
-impl<A: Int> ::ops::Range<A> {
-    /// Creates an iterator with the same range, but stepping by the
-    /// given amount at each iteration.
-    ///
-    /// The resulting iterator handles overflow by stopping.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// # #![feature(step_by, core)]
-    /// for i in (0..10).step_by(2) {
-    ///     println!("{}", i);
-    /// }
-    /// ```
-    ///
-    /// This prints:
-    ///
-    /// ```text
-    /// 0
-    /// 2
-    /// 4
-    /// 6
-    /// 8
-    /// ```
-    #[unstable(feature = "step_by", reason = "recent addition")]
-    pub fn step_by(self, by: A) -> StepBy<A, Self> {
-        StepBy {
-            step_by: by,
-            range: self
-        }
-    }
-}
-
 /// An infinite iterator starting at `start` and advancing by `step` with each
 /// iteration
+#[derive(Clone)]
 #[unstable(feature = "core",
            reason = "may be renamed or replaced by range notation adapters")]
-#[deprecated(since = "1.0.0-beta", reason = "use range notation and step_by")]
-pub type Counter<A> = StepBy<A, RangeFrom<A>>;
+pub struct Counter<A> {
+    /// The current state the counter is at (next value to be yielded)
+    state: A,
+    /// The amount that this iterator is stepping by
+    step: A,
+}
 
-/// Deprecated: use `(start..).step_by(step)` instead.
+/// Creates a new counter with the specified start/step
 #[inline]
 #[unstable(feature = "core",
            reason = "may be renamed or replaced by range notation adapters")]
-#[deprecated(since = "1.0.0-beta", reason = "use (start..).step_by(step) instead")]
-#[allow(deprecated)]
 pub fn count<A>(start: A, step: A) -> Counter<A> {
-    StepBy {
-        range: RangeFrom { start: start },
-        step_by: step,
-    }
+    Counter{state: start, step: step}
 }
 
 #[stable(feature = "rust1", since = "1.0.0")]
-impl<A: Add<Output=A> + Clone> Iterator for StepBy<A, RangeFrom<A>> {
+impl<A: Add<Output=A> + Clone> Iterator for Counter<A> {
     type Item = A;
 
     #[inline]
     fn next(&mut self) -> Option<A> {
-        let result = self.range.start.clone();
-        self.range.start = result.clone() + self.step_by.clone();
+        let result = self.state.clone();
+        self.state = self.state.clone() + self.step.clone();
         Some(result)
     }
 
@@ -2471,22 +2404,31 @@ impl<A: Add<Output=A> + Clone> Iterator for StepBy<A, RangeFrom<A>> {
 }
 
 /// An iterator over the range [start, stop)
-#[allow(deprecated)]
 #[derive(Clone)]
 #[unstable(feature = "core",
            reason = "will be replaced by range notation")]
-#[deprecated(since = "1.0.0-beta", reason = "use range notation")]
 pub struct Range<A> {
     state: A,
     stop: A,
     one: A,
 }
 
-/// Deprecated: use `(start..stop)` instead.
+/// Returns an iterator over the given range [start, stop) (that is, starting
+/// at start (inclusive), and ending at stop (exclusive)).
+///
+/// # Examples
+///
+/// ```
+/// let array = [0, 1, 2, 3, 4];
+///
+/// for i in range(0, 5) {
+///     println!("{}", i);
+///     assert_eq!(i,  array[i]);
+/// }
+/// ```
 #[inline]
-#[unstable(feature = "core", reason = "will be replaced by range notation")]
-#[deprecated(since = "1.0.0-beta", reason = "use (start..stop) instead")]
-#[allow(deprecated)]
+#[unstable(feature = "core",
+           reason = "will be replaced by range notation")]
 pub fn range<A: Int>(start: A, stop: A) -> Range<A> {
     Range {
         state: start,
@@ -2498,8 +2440,6 @@ pub fn range<A: Int>(start: A, stop: A) -> Range<A> {
 // FIXME: #10414: Unfortunate type bound
 #[unstable(feature = "core",
            reason = "will be replaced by range notation")]
-#[deprecated(since = "1.0.0-beta", reason = "use range notation")]
-#[allow(deprecated)]
 impl<A: Int + ToPrimitive> Iterator for Range<A> {
     type Item = A;
 
@@ -2551,8 +2491,6 @@ impl<A: Int + ToPrimitive> Iterator for Range<A> {
 /// the direction it is consumed.
 #[unstable(feature = "core",
            reason = "will be replaced by range notation")]
-#[deprecated(since = "1.0.0-beta", reason = "use range notation")]
-#[allow(deprecated)]
 impl<A: Int + ToPrimitive> DoubleEndedIterator for Range<A> {
     #[inline]
     fn next_back(&mut self) -> Option<A> {
@@ -2569,7 +2507,6 @@ impl<A: Int + ToPrimitive> DoubleEndedIterator for Range<A> {
 #[derive(Clone)]
 #[unstable(feature = "core",
            reason = "likely to be replaced by range notation and adapters")]
-#[allow(deprecated)]
 pub struct RangeInclusive<A> {
     range: Range<A>,
     done: bool,
@@ -2579,7 +2516,6 @@ pub struct RangeInclusive<A> {
 #[inline]
 #[unstable(feature = "core",
            reason = "likely to be replaced by range notation and adapters")]
-#[allow(deprecated)]
 pub fn range_inclusive<A: Int>(start: A, stop: A) -> RangeInclusive<A> {
     RangeInclusive {
         range: range(start, stop),
@@ -2589,7 +2525,6 @@ pub fn range_inclusive<A: Int>(start: A, stop: A) -> RangeInclusive<A> {
 
 #[unstable(feature = "core",
            reason = "likely to be replaced by range notation and adapters")]
-#[allow(deprecated)]
 impl<A: Int + ToPrimitive> Iterator for RangeInclusive<A> {
     type Item = A;
 
@@ -2626,7 +2561,6 @@ impl<A: Int + ToPrimitive> Iterator for RangeInclusive<A> {
 
 #[unstable(feature = "core",
            reason = "likely to be replaced by range notation and adapters")]
-#[allow(deprecated)]
 impl<A: Int + ToPrimitive> DoubleEndedIterator for RangeInclusive<A> {
     #[inline]
     fn next_back(&mut self) -> Option<A> {
@@ -2644,39 +2578,61 @@ impl<A: Int + ToPrimitive> DoubleEndedIterator for RangeInclusive<A> {
 }
 
 /// An iterator over the range [start, stop) by `step`. It handles overflow by stopping.
+#[derive(Clone)]
 #[unstable(feature = "core",
            reason = "likely to be replaced by range notation and adapters")]
-#[deprecated(since = "1.0.0-beta", reason = "use range notation and step_by")]
-pub type RangeStep<A> = StepBy<A, ::ops::Range<A>>;
+pub struct RangeStep<A> {
+    state: A,
+    stop: A,
+    step: A,
+    rev: bool,
+}
 
-/// Deprecated: use `(start..stop).step_by(step)` instead.
+/// Return an iterator over the range [start, stop) by `step`.
+///
+/// It handles overflow by stopping.
+///
+/// # Examples
+///
+/// ```
+/// use std::iter::range_step;
+///
+/// for i in range_step(0, 10, 2) {
+///     println!("{}", i);
+/// }
+/// ```
+///
+/// This prints:
+///
+/// ```text
+/// 0
+/// 2
+/// 4
+/// 6
+/// 8
+/// ```
 #[inline]
 #[unstable(feature = "core",
            reason = "likely to be replaced by range notation and adapters")]
-#[deprecated(since = "1.0.0-beta",
-             reason = "use `(start..stop).step_by(step)` instead")]
-#[allow(deprecated)]
 pub fn range_step<A: Int>(start: A, stop: A, step: A) -> RangeStep<A> {
-    StepBy {
-        step_by: step,
-        range: ::ops::Range { start: start, end: stop },
-    }
+    let rev = step < Int::zero();
+    RangeStep{state: start, stop: stop, step: step, rev: rev}
 }
 
-#[stable(feature = "rust1", since = "1.0.0")]
-impl<A: Int> Iterator for StepBy<A, ::ops::Range<A>> {
+#[unstable(feature = "core",
+           reason = "likely to be replaced by range notation and adapters")]
+impl<A: Int> Iterator for RangeStep<A> {
     type Item = A;
 
     #[inline]
     fn next(&mut self) -> Option<A> {
-        let rev = self.step_by < Int::zero();
-        let start = self.range.start;
-        if (rev && start > self.range.end) || (!rev && start < self.range.end) {
-            match start.checked_add(self.step_by) {
-                Some(x) => self.range.start = x,
-                None => self.range.start = self.range.end.clone()
+        if (self.rev && self.state > self.stop) || (!self.rev && self.state < self.stop) {
+            let result = self.state;
+            match self.state.checked_add(self.step) {
+                Some(x) => self.state = x,
+                None => self.state = self.stop.clone()
             }
-            Some(start)
+            Some(result)
         } else {
             None
         }

branches/tmp/src/libcore/prelude.rs

@@ -29,7 +29,6 @@ pub use marker::{Copy, Send, Sized, Sync};
 pub use ops::{Drop, Fn, FnMut, FnOnce};
 
 // Reexported functions
-#[allow(deprecated)]
 pub use iter::range;
 pub use mem::drop;
 

branches/tmp/src/libcoretest/iter.rs

@@ -775,12 +775,12 @@ fn test_range_inclusive() {
 
 #[test]
 fn test_range_step() {
-    assert_eq!((0..20).step_by(5).collect::<Vec<int>>(), [0, 5, 10, 15]);
-    assert_eq!((20..0).step_by(-5).collect::<Vec<int>>(), [20, 15, 10, 5]);
-    assert_eq!((20..0).step_by(-6).collect::<Vec<int>>(), [20, 14, 8, 2]);
-    assert_eq!((200..255).step_by(50).collect::<Vec<u8>>(), [200, 250]);
-    assert_eq!((200..-5).step_by(1).collect::<Vec<int>>(), []);
-    assert_eq!((200..200).step_by(1).collect::<Vec<int>>(), []);
+    assert_eq!(range_step(0, 20, 5).collect::<Vec<int>>(), [0, 5, 10, 15]);
+    assert_eq!(range_step(20, 0, -5).collect::<Vec<int>>(), [20, 15, 10, 5]);
+    assert_eq!(range_step(20, 0, -6).collect::<Vec<int>>(), [20, 14, 8, 2]);
+    assert_eq!(range_step(200, 255, 50).collect::<Vec<u8>>(), [200, 250]);
+    assert_eq!(range_step(200, -5, 1).collect::<Vec<int>>(), []);
+    assert_eq!(range_step(200, 200, 1).collect::<Vec<int>>(), []);
 }
 
 #[test]

branches/tmp/src/librand/distributions/mod.rs

@@ -17,6 +17,8 @@
 //! internally. The `IndependentSample` trait is for generating values
 //! that do not need to record state.
 
+#![unstable(feature = "rand")]
+
 use core::prelude::*;
 use core::num::{Float, Int};
 use core::marker::PhantomData;

branches/tmp/src/librustc/middle/infer/combine.rs

@@ -154,7 +154,7 @@ pub trait Combine<'tcx> : Sized {
                                                                  b_tys.len())));
             }
 
-            (0.. a_tys.len()).map(|i| {
+            range(0, a_tys.len()).map(|i| {
                 let a_ty = a_tys[i];
                 let b_ty = b_tys[i];
                 let v = variances.map_or(ty::Invariant, |v| v[i]);

branches/tmp/src/librustc_back/lib.rs

@@ -48,7 +48,6 @@
 #![feature(path_ext)]
 #![feature(std_misc)]
 #![feature(path_relative_from)]
-#![feature(step_by)]
 
 extern crate syntax;
 extern crate serialize;