---

yaml
---
r: 50588
b: refs/heads/try
c: 86cf248
h: refs/heads/master
v: v3

Author: jdm

[refs]

@@ -2,7 +2,7 @@
 refs/heads/master: 5f13e9ccc2e3328d4cd8ca49f84e6840dd998346
 refs/heads/snap-stage1: e33de59e47c5076a89eadeb38f4934f58a3618a6
 refs/heads/snap-stage3: f7a2371c176663d59062ec5158f39faecba45768
-refs/heads/try: d55225f04a459c574d9533dcc4c06f953fa8fce5
+refs/heads/try: 86cf2482624b89150615313662d2e823cdcaa31d
 refs/tags/release-0.1: 1f5c5126e96c79d22cb7862f75304136e204f105
 refs/heads/ndm: f3868061cd7988080c30d6d5bf352a5a5fe2460b
 refs/heads/try2: 147ecfdd8221e4a4d4e090486829a06da1e0ca3c

branches/try/src/libcore/cell.rs

@@ -15,6 +15,7 @@ use prelude::*;
 ///
 /// Similar to a mutable option type, but friendlier.
 
+#[deriving_eq]
 pub struct Cell<T> {
     mut value: Option<T>
 }

branches/try/src/libstd/treemap.rs

@@ -77,13 +77,21 @@ pure fn lt<K: Ord + TotalOrd, V>(a: &TreeMap<K, V>,
 
 impl<K: Ord + TotalOrd, V> Ord for TreeMap<K, V> {
     #[inline(always)]
-    pure fn lt(&self, other: &TreeMap<K, V>) -> bool { lt(self, other) }
+    pure fn lt(&self, other: &TreeMap<K, V>) -> bool {
+        lt(self, other)
+    }
     #[inline(always)]
-    pure fn le(&self, other: &TreeMap<K, V>) -> bool { !lt(other, self) }
+    pure fn le(&self, other: &TreeMap<K, V>) -> bool {
+        !lt(other, self)
+    }
     #[inline(always)]
-    pure fn ge(&self, other: &TreeMap<K, V>) -> bool { !lt(self, other) }
+    pure fn ge(&self, other: &TreeMap<K, V>) -> bool {
+        !lt(self, other)
+    }
     #[inline(always)]
-    pure fn gt(&self, other: &TreeMap<K, V>) -> bool { lt(other, self) }
+    pure fn gt(&self, other: &TreeMap<K, V>) -> bool {
+        lt(other, self)
+    }
 }
 
 impl<'self, K: TotalOrd, V> BaseIter<(&'self K, &'self V)> for TreeMap<K, V> {
@@ -141,9 +149,9 @@ impl<K: TotalOrd, V> Map<K, V> for TreeMap<K, V> {
             match *current {
               Some(ref r) => {
                 match key.cmp(&r.key) {
-                  Less => current = &r.left,
-                  Greater => current = &r.right,
-                  Equal => return Some(&r.value)
+                   Less => current = &r.left,
+                   Greater => current = &r.right,
+                   Equal => return Some(&r.value)
                 }
               }
               None => return None
@@ -236,24 +244,19 @@ pub struct TreeSet<T> {
 
 impl<T: TotalOrd> BaseIter<T> for TreeSet<T> {
     /// Visit all values in order
-    #[inline(always)]
     pure fn each(&self, f: &fn(&T) -> bool) { self.map.each_key(f) }
-    #[inline(always)]
     pure fn size_hint(&self) -> Option<uint> { Some(self.len()) }
 }
 
 impl<T: TotalOrd> ReverseIter<T> for TreeSet<T> {
     /// Visit all values in reverse order
-    #[inline(always)]
     pure fn each_reverse(&self, f: &fn(&T) -> bool) {
         self.map.each_key_reverse(f)
     }
 }
 
 impl<T: Eq + TotalOrd> Eq for TreeSet<T> {
-    #[inline(always)]
     pure fn eq(&self, other: &TreeSet<T>) -> bool { self.map == other.map }
-    #[inline(always)]
     pure fn ne(&self, other: &TreeSet<T>) -> bool { self.map != other.map }
 }
 
@@ -270,35 +273,29 @@ impl<T: Ord + TotalOrd> Ord for TreeSet<T> {
 
 impl<T: TotalOrd> Container for TreeSet<T> {
     /// Return the number of elements in the set
-    #[inline(always)]
     pure fn len(&self) -> uint { self.map.len() }
 
     /// Return true if the set contains no elements
-    #[inline(always)]
     pure fn is_empty(&self) -> bool { self.map.is_empty() }
 }
 
 impl<T: TotalOrd> Mutable for TreeSet<T> {
     /// Clear the set, removing all values.
-    #[inline(always)]
     fn clear(&mut self) { self.map.clear() }
 }
 
 impl<T: TotalOrd> Set<T> for TreeSet<T> {
     /// Return true if the set contains a value
-    #[inline(always)]
     pure fn contains(&self, value: &T) -> bool {
         self.map.contains_key(value)
     }
 
     /// Add a value to the set. Return true if the value was not already
     /// present in the set.
-    #[inline(always)]
     fn insert(&mut self, value: T) -> bool { self.map.insert(value, ()) }
 
     /// Remove a value from the set. Return true if the value was
     /// present in the set.
-    #[inline(always)]
     fn remove(&mut self, value: &T) -> bool { self.map.remove(value) }
 
     /// Return true if the set has no elements in common with `other`.
@@ -323,7 +320,6 @@ impl<T: TotalOrd> Set<T> for TreeSet<T> {
     }
 
     /// Return true if the set is a subset of another
-    #[inline(always)]
     pure fn is_subset(&self, other: &TreeSet<T>) -> bool {
         other.is_superset(self)
     }
@@ -492,12 +488,10 @@ impl<T: TotalOrd> Set<T> for TreeSet<T> {
 
 pub impl <T: TotalOrd> TreeSet<T> {
     /// Create an empty TreeSet
-    #[inline(always)]
     static pure fn new() -> TreeSet<T> { TreeSet{map: TreeMap::new()} }
 
     /// Get a lazy iterator over the values in the set.
     /// Requires that it be frozen (immutable).
-    #[inline(always)]
     pure fn iter(&self) -> TreeSetIterator/&self<T> {
         TreeSetIterator{iter: self.map.iter()}
     }
@@ -510,15 +504,13 @@ pub struct TreeSetIterator<T> {
 
 /// Advance the iterator to the next node (in order). If this iterator is
 /// finished, does nothing.
-#[inline(always)]
 pub fn set_next<T>(iter: &mut TreeSetIterator/&r<T>) -> Option<&r/T> {
     do map_next(&mut iter.iter).map |&(value, _)| { value }
 }
 
 /// Advance the iterator through the set
-#[inline(always)]
-pub fn set_advance<T>(iter: &mut TreeSetIterator/&r<T>,
-                      f: &fn(&r/T) -> bool) {
+fn set_advance<T>(iter: &mut TreeSetIterator/&r<T>,
+                       f: &fn(&r/T) -> bool) {
     do map_advance(&mut iter.iter) |(k, _)| { f(k) }
 }
 
@@ -540,15 +532,15 @@ pub impl<K: TotalOrd, V> TreeNode<K, V> {
 }
 
 pure fn each<K: TotalOrd, V>(node: &r/Option<~TreeNode<K, V>>,
-                             f: &fn(&(&r/K, &r/V)) -> bool) {
+                        f: &fn(&(&r/K, &r/V)) -> bool) {
     for node.each |x| {
         each(&x.left, f);
         if f(&(&x.key, &x.value)) { each(&x.right, f) }
     }
 }
 
 pure fn each_reverse<K: TotalOrd, V>(node: &r/Option<~TreeNode<K, V>>,
-                                     f: &fn(&(&r/K, &r/V)) -> bool) {
+                                f: &fn(&(&r/K, &r/V)) -> bool) {
     for node.each |x| {
         each_reverse(&x.right, f);
         if f(&(&x.key, &x.value)) { each_reverse(&x.left, f) }
@@ -673,20 +665,20 @@ fn remove<K: TotalOrd, V>(node: &mut Option<~TreeNode<K, V>>,
                 skew(save);
 
                 match save.right {
-                  Some(ref mut right) => {
-                    skew(right);
-                    match right.right {
-                      Some(ref mut x) => { skew(x) },
-                      None => ()
+                    Some(ref mut right) => {
+                        skew(right);
+                        match right.right {
+                            Some(ref mut x) => { skew(x) },
+                            None => ()
+                        }
                     }
-                  }
-                  None => ()
+                    None => ()
                 }
 
                 split(save);
                 match save.right {
-                  Some(ref mut x) => { split(x) },
-                  None => ()
+                    Some(ref mut x) => { split(x) },
+                    None => ()
                 }
             }
 
@@ -1141,30 +1133,25 @@ mod test_set {
 
     #[test]
     fn test_difference() {
-        fn check_difference(a: &[int], b: &[int], expected: &[int]) {
-            let mut set_a = TreeSet::new();
-            let mut set_b = TreeSet::new();
+        let mut a = TreeSet::new();
+        let mut b = TreeSet::new();
 
-            for a.each |x| { fail_unless!(set_a.insert(*x)) }
-            for b.each |y| { fail_unless!(set_b.insert(*y)) }
+        fail_unless!(a.insert(1));
+        fail_unless!(a.insert(3));
+        fail_unless!(a.insert(5));
+        fail_unless!(a.insert(9));
+        fail_unless!(a.insert(11));
 
-            let mut i = 0;
-            for set_a.difference(&set_b) |x| {
-                fail_unless!(*x == expected[i]);
-                i += 1;
-            }
-            fail_unless!(i == expected.len());
-        }
+        fail_unless!(b.insert(3));
+        fail_unless!(b.insert(9));
 
-        check_difference([], [], []);
-        check_difference([1, 12], [], [1, 12]);
-        check_difference([], [1, 2, 3, 9], []);
-        check_difference([1, 3, 5, 9, 11],
-                         [3, 9],
-                         [1, 5, 11]);
-        check_difference([-5, 11, 22, 33, 40, 42],
-                         [-12, -5, 14, 23, 34, 38, 39, 50],
-                         [11, 22, 33, 40, 42]);
+        let mut i = 0;
+        let expected = [1, 5, 11];
+        for a.difference(&b) |x| {
+            fail_unless!(*x == expected[i]);
+            i += 1
+        }
+        fail_unless!(i == expected.len());
     }
 
     #[test]