---

yaml
---
r: 151227
b: refs/heads/try2
c: 4baff4e
h: refs/heads/master
i:
  151225: 8549181
  151223: 26b7e56
v: v3

Author: pcwalton

[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: fb72d7cfea9ba44581f708b13aa82ab23ee4fa7e
+refs/heads/try2: 4baff4e15f003260de0cc17f419c418332e77149
 refs/heads/dist-snap: ba4081a5a8573875fed17545846f6f6902c8ba8d
 refs/tags/release-0.2: c870d2dffb391e14efb05aa27898f1f6333a9596
 refs/tags/release-0.3: b5f0d0f648d9a6153664837026ba1be43d3e2503

branches/try2/src/doc/guide-container.md

@@ -120,13 +120,12 @@ differently.
 Containers implement iteration over the contained elements by returning an
 iterator object. For example, vector slices several iterators available:
 
-* `iter()` for immutable references to the elements
-* `mut_iter()` for mutable references to the elements
-* `move_iter()` to move the elements out by-value
+* `iter()` and `rev_iter()`, for immutable references to the elements
+* `mut_iter()` and `mut_rev_iter()`, for mutable references to the elements
+* `move_iter()` and `move_rev_iter()`, to move the elements out by-value
 
 A typical mutable container will implement at least `iter()`, `mut_iter()` and
-`move_iter()`. If it maintains an order, the returned iterators will be
-`DoubleEndedIterator`s, which are described below.
+`move_iter()` along with the reverse variants if it maintains an order.
 
 ### Freezing
 
@@ -266,7 +265,7 @@ Iterators offer generic conversion to containers with the `collect` adaptor:
 
 ~~~
 let xs = [0, 1, 1, 2, 3, 5, 8];
-let ys = xs.iter().rev().skip(1).map(|&x| x * 2).collect::<~[int]>();
+let ys = xs.rev_iter().skip(1).map(|&x| x * 2).collect::<~[int]>();
 assert_eq!(ys, ~[10, 6, 4, 2, 2, 0]);
 ~~~
 
@@ -359,6 +358,9 @@ for &x in it.rev() {
 }
 ~~~
 
+The `rev_iter` and `mut_rev_iter` methods on vectors just return an inverted
+version of the standard immutable and mutable vector iterators.
+
 The `chain`, `map`, `filter`, `filter_map` and `inspect` adaptors are
 `DoubleEndedIterator` implementations if the underlying iterators are.
 

branches/try2/src/doc/tutorial.md

@@ -1197,7 +1197,7 @@ fn eq(xs: &List, ys: &List) -> bool {
     match (xs, ys) {
         // If we have reached the end of both lists, they are equal.
         (&Nil, &Nil) => true,
-        // If the current elements of both lists are equal, keep going.
+        // If the current element in both lists is equal, keep going.
         (&Cons(x, ~ref next_xs), &Cons(y, ~ref next_ys))
                 if x == y => eq(next_xs, next_ys),
         // If the current elements are not equal, the lists are not equal.
@@ -1304,7 +1304,7 @@ fn eq<T: Eq>(xs: &List<T>, ys: &List<T>) -> bool {
     match (xs, ys) {
         // If we have reached the end of both lists, they are equal.
         (&Nil, &Nil) => true,
-        // If the current elements of both lists are equal, keep going.
+        // If the current element in both lists is equal, keep going.
         (&Cons(ref x, ~ref next_xs), &Cons(ref y, ~ref next_ys))
                 if x == y => eq(next_xs, next_ys),
         // If the current elements are not equal, the lists are not equal.
@@ -1333,7 +1333,7 @@ impl<T: Eq> Eq for List<T> {
         match (self, ys) {
             // If we have reached the end of both lists, they are equal.
             (&Nil, &Nil) => true,
-            // If the current elements of both lists are equal, keep going.
+            // If the current element in both lists is equal, keep going.
             (&Cons(ref x, ~ref next_xs), &Cons(ref y, ~ref next_ys))
                     if x == y => next_xs == next_ys,
             // If the current elements are not equal, the lists are not equal.
@@ -2965,7 +2965,7 @@ use farm::*;
 ~~~
 
 > *Note:* This feature of the compiler is currently gated behind the
-> `#![feature(globs)]` directive. More about these directives can be found in
+> `#[feature(globs)]` directive. More about these directives can be found in
 > the manual.
 
 However, that's not all. You can also rename an item while you're bringing it into scope:

branches/try2/src/libcollections/bitv.rs

@@ -425,7 +425,6 @@ impl Bitv {
     }
 
     #[inline]
-    #[deprecated = "replaced by .iter().rev()"]
     pub fn rev_iter<'a>(&'a self) -> Rev<Bits<'a>> {
         self.iter().rev()
     }

branches/try2/src/libcollections/dlist.rs

@@ -1,4 +1,4 @@
-// Copyright 2012-2014 The Rust Project Developers. See the COPYRIGHT
+// Copyright 2012-2013 The Rust Project Developers. See the COPYRIGHT
 // file at the top-level directory of this distribution and at
 // http://rust-lang.org/COPYRIGHT.
 //
@@ -370,8 +370,8 @@ impl<T> DList<T> {
         Items{nelem: self.len(), head: &self.list_head, tail: self.list_tail}
     }
 
+    /// Provide a reverse iterator
     #[inline]
-    #[deprecated = "replaced by .iter().rev()"]
     pub fn rev_iter<'a>(&'a self) -> Rev<Items<'a, T>> {
         self.iter().rev()
     }
@@ -390,9 +390,8 @@ impl<T> DList<T> {
             list: self
         }
     }
-
+    /// Provide a reverse iterator with mutable references
     #[inline]
-    #[deprecated = "replaced by .mut_iter().rev()"]
     pub fn mut_rev_iter<'a>(&'a mut self) -> Rev<MutItems<'a, T>> {
         self.mut_iter().rev()
     }
@@ -404,8 +403,8 @@ impl<T> DList<T> {
         MoveItems{list: self}
     }
 
+    /// Consume the list into an iterator yielding elements by value, in reverse
     #[inline]
-    #[deprecated = "replaced by .move_iter().rev()"]
     pub fn move_rev_iter(self) -> Rev<MoveItems<T>> {
         self.move_iter().rev()
     }
@@ -850,13 +849,13 @@ mod tests {
     #[test]
     fn test_rev_iter() {
         let m = generate_test();
-        for (i, elt) in m.iter().rev().enumerate() {
+        for (i, elt) in m.rev_iter().enumerate() {
             assert_eq!((6 - i) as int, *elt);
         }
         let mut n = DList::new();
-        assert_eq!(n.iter().rev().next(), None);
+        assert_eq!(n.rev_iter().next(), None);
         n.push_front(4);
-        let mut it = n.iter().rev();
+        let mut it = n.rev_iter();
         assert_eq!(it.size_hint(), (1, Some(1)));
         assert_eq!(it.next().unwrap(), &4);
         assert_eq!(it.size_hint(), (0, Some(0)));
@@ -959,13 +958,13 @@ mod tests {
     #[test]
     fn test_mut_rev_iter() {
         let mut m = generate_test();
-        for (i, elt) in m.mut_iter().rev().enumerate() {
+        for (i, elt) in m.mut_rev_iter().enumerate() {
             assert_eq!((6-i) as int, *elt);
         }
         let mut n = DList::new();
-        assert!(n.mut_iter().rev().next().is_none());
+        assert!(n.mut_rev_iter().next().is_none());
         n.push_front(4);
-        let mut it = n.mut_iter().rev();
+        let mut it = n.mut_rev_iter();
         assert!(it.next().is_some());
         assert!(it.next().is_none());
     }
@@ -1165,15 +1164,15 @@ mod tests {
         let v = &[0, ..128];
         let m: DList<int> = v.iter().map(|&x|x).collect();
         b.iter(|| {
-            assert!(m.iter().rev().len() == 128);
+            assert!(m.rev_iter().len() == 128);
         })
     }
     #[bench]
     fn bench_iter_mut_rev(b: &mut test::Bencher) {
         let v = &[0, ..128];
         let mut m: DList<int> = v.iter().map(|&x|x).collect();
         b.iter(|| {
-            assert!(m.mut_iter().rev().len() == 128);
+            assert!(m.mut_rev_iter().len() == 128);
         })
     }
 }

branches/try2/src/libcollections/priority_queue.rs

@@ -1,4 +1,4 @@
-// Copyright 2013-2014 The Rust Project Developers. See the COPYRIGHT
+// Copyright 2013 The Rust Project Developers. See the COPYRIGHT
 // file at the top-level directory of this distribution and at
 // http://rust-lang.org/COPYRIGHT.
 //
@@ -382,7 +382,7 @@ mod tests {
     fn test_from_iter() {
         let xs = vec!(9u, 8, 7, 6, 5, 4, 3, 2, 1);
 
-        let mut q: PriorityQueue<uint> = xs.as_slice().iter().rev().map(|&x| x).collect();
+        let mut q: PriorityQueue<uint> = xs.as_slice().rev_iter().map(|&x| x).collect();
 
         for &x in xs.iter() {
             assert_eq!(q.pop(), x);

branches/try2/src/libcollections/ringbuf.rs

@@ -1,4 +1,4 @@
-// Copyright 2012-2014 The Rust Project Developers. See the COPYRIGHT
+// Copyright 2012-2013 The Rust Project Developers. See the COPYRIGHT
 // file at the top-level directory of this distribution and at
 // http://rust-lang.org/COPYRIGHT.
 //
@@ -190,7 +190,7 @@ impl<T> RingBuf<T> {
         Items{index: 0, rindex: self.nelts, lo: self.lo, elts: self.elts.as_slice()}
     }
 
-    #[deprecated = "replaced by .iter().rev()"]
+    /// Back-to-front iterator.
     pub fn rev_iter<'a>(&'a self) -> Rev<Items<'a, T>> {
         self.iter().rev()
     }
@@ -221,7 +221,7 @@ impl<T> RingBuf<T> {
         }
     }
 
-    #[deprecated = "replaced by .mut_iter().rev()"]
+    /// Back-to-front iterator which returns mutable values.
     pub fn mut_rev_iter<'a>(&'a mut self) -> Rev<MutItems<'a, T>> {
         self.mut_iter().rev()
     }
@@ -702,31 +702,31 @@ mod tests {
     #[test]
     fn test_rev_iter() {
         let mut d = RingBuf::new();
-        assert_eq!(d.iter().rev().next(), None);
+        assert_eq!(d.rev_iter().next(), None);
 
         for i in range(0, 5) {
             d.push_back(i);
         }
-        assert_eq!(d.iter().rev().collect::<Vec<&int>>().as_slice(), &[&4,&3,&2,&1,&0]);
+        assert_eq!(d.rev_iter().collect::<Vec<&int>>().as_slice(), &[&4,&3,&2,&1,&0]);
 
         for i in range(6, 9) {
             d.push_front(i);
         }
-        assert_eq!(d.iter().rev().collect::<Vec<&int>>().as_slice(), &[&4,&3,&2,&1,&0,&6,&7,&8]);
+        assert_eq!(d.rev_iter().collect::<Vec<&int>>().as_slice(), &[&4,&3,&2,&1,&0,&6,&7,&8]);
     }
 
     #[test]
     fn test_mut_rev_iter_wrap() {
         let mut d = RingBuf::with_capacity(3);
-        assert!(d.mut_iter().rev().next().is_none());
+        assert!(d.mut_rev_iter().next().is_none());
 
         d.push_back(1);
         d.push_back(2);
         d.push_back(3);
         assert_eq!(d.pop_front(), Some(1));
         d.push_back(4);
 
-        assert_eq!(d.mut_iter().rev().map(|x| *x).collect::<Vec<int>>(),
+        assert_eq!(d.mut_rev_iter().map(|x| *x).collect::<Vec<int>>(),
                    vec!(4, 3, 2));
     }
 
@@ -756,19 +756,19 @@ mod tests {
     #[test]
     fn test_mut_rev_iter() {
         let mut d = RingBuf::new();
-        assert!(d.mut_iter().rev().next().is_none());
+        assert!(d.mut_rev_iter().next().is_none());
 
         for i in range(0u, 3) {
             d.push_front(i);
         }
 
-        for (i, elt) in d.mut_iter().rev().enumerate() {
+        for (i, elt) in d.mut_rev_iter().enumerate() {
             assert_eq!(*elt, i);
             *elt = i;
         }
 
         {
-            let mut it = d.mut_iter().rev();
+            let mut it = d.mut_rev_iter();
             assert_eq!(*it.next().unwrap(), 0);
             assert_eq!(*it.next().unwrap(), 1);
             assert_eq!(*it.next().unwrap(), 2);

branches/try2/src/libcollections/smallintmap.rs

@@ -1,4 +1,4 @@
-// Copyright 2012-2014 The Rust Project Developers. See the COPYRIGHT
+// Copyright 2012 The Rust Project Developers. See the COPYRIGHT
 // file at the top-level directory of this distribution and at
 // http://rust-lang.org/COPYRIGHT.
 //
@@ -142,13 +142,16 @@ impl<V> SmallIntMap<V> {
         }
     }
 
-    #[deprecated = "replaced by .iter().rev()"]
-    pub fn rev_iter<'r>(&'r self) -> Rev<Entries<'r, V>> {
+    /// An iterator visiting all key-value pairs in descending order by the keys.
+    /// Iterator element type is (uint, &'r V)
+    pub fn rev_iter<'r>(&'r self) -> RevEntries<'r, V> {
         self.iter().rev()
     }
 
-    #[deprecated = "replaced by .mut_iter().rev()"]
-    pub fn mut_rev_iter<'r>(&'r mut self) -> Rev<MutEntries<'r, V>> {
+    /// An iterator visiting all key-value pairs in descending order by the keys,
+    /// with mutable references to the values
+    /// Iterator element type is (uint, &'r mut V)
+    pub fn mut_rev_iter<'r>(&'r mut self) -> RevMutEntries <'r, V> {
         self.mut_iter().rev()
     }
 
@@ -243,7 +246,6 @@ pub struct Entries<'a, T> {
 
 iterator!(impl Entries -> (uint, &'a T), get_ref)
 double_ended_iterator!(impl Entries -> (uint, &'a T), get_ref)
-#[deprecated = "replaced by Rev<Entries<'a, T>>"]
 pub type RevEntries<'a, T> = Rev<Entries<'a, T>>;
 
 pub struct MutEntries<'a, T> {
@@ -254,7 +256,6 @@ pub struct MutEntries<'a, T> {
 
 iterator!(impl MutEntries -> (uint, &'a mut T), get_mut_ref)
 double_ended_iterator!(impl MutEntries -> (uint, &'a mut T), get_mut_ref)
-#[deprecated = "replaced by Rev<MutEntries<'a, T>"]
 pub type RevMutEntries<'a, T> = Rev<MutEntries<'a, T>>;
 
 #[cfg(test)]
@@ -386,9 +387,9 @@ mod test_map {
         assert!(m.insert(10, 11));
 
         assert_eq!(m.iter().size_hint(), (0, Some(11)));
-        assert_eq!(m.iter().rev().size_hint(), (0, Some(11)));
+        assert_eq!(m.rev_iter().size_hint(), (0, Some(11)));
         assert_eq!(m.mut_iter().size_hint(), (0, Some(11)));
-        assert_eq!(m.mut_iter().rev().size_hint(), (0, Some(11)));
+        assert_eq!(m.mut_rev_iter().size_hint(), (0, Some(11)));
     }
 
     #[test]
@@ -424,7 +425,7 @@ mod test_map {
         assert!(m.insert(6, 10));
         assert!(m.insert(10, 11));
 
-        let mut it = m.iter().rev();
+        let mut it = m.rev_iter();
         assert_eq!(it.next().unwrap(), (10, &11));
         assert_eq!(it.next().unwrap(), (6, &10));
         assert_eq!(it.next().unwrap(), (3, &5));
@@ -443,7 +444,7 @@ mod test_map {
         assert!(m.insert(6, 10));
         assert!(m.insert(10, 11));
 
-        for (k, v) in m.mut_iter().rev() {
+        for (k, v) in m.mut_rev_iter() {
             *v += k as int;
         }
 

branches/try2/src/libcollections/trie.rs

@@ -395,7 +395,7 @@ impl<T> TrieNode<T> {
 
 impl<T> TrieNode<T> {
     fn each_reverse<'a>(&'a self, f: |&uint, &'a T| -> bool) -> bool {
-        for elt in self.children.iter().rev() {
+        for elt in self.children.rev_iter() {
             match *elt {
                 Internal(ref x) => if !x.each_reverse(|i,t| f(i,t)) { return false },
                 External(k, ref v) => if !f(&k, v) { return false },

branches/try2/src/libnum/bigint.rs

@@ -439,7 +439,7 @@ impl Integer for BigUint {
             let bn = *b.data.last().unwrap();
             let mut d = Vec::with_capacity(an.len());
             let mut carry = 0;
-            for elt in an.iter().rev() {
+            for elt in an.rev_iter() {
                 let ai = BigDigit::to_uint(carry, *elt);
                 let di = ai / (bn as uint);
                 assert!(di < BigDigit::base);
@@ -668,7 +668,7 @@ impl ToStrRadix for BigUint {
         fn fill_concat(v: &[BigDigit], radix: uint, l: uint) -> ~str {
             if v.is_empty() { return "0".to_owned() }
             let mut s = StrBuf::with_capacity(v.len() * l);
-            for n in v.iter().rev() {
+            for n in v.rev_iter() {
                 let ss = (*n as uint).to_str_radix(radix);
                 s.push_str("0".repeat(l - ss.len()));
                 s.push_str(ss);
@@ -2187,7 +2187,7 @@ mod bigint_tests {
     fn test_cmp() {
         let vs = [ &[2 as BigDigit], &[1, 1], &[2, 1], &[1, 1, 1] ];
         let mut nums = Vec::new();
-        for s in vs.iter().rev() {
+        for s in vs.rev_iter() {
             nums.push(BigInt::from_slice(Minus, *s));
         }
         nums.push(Zero::zero());