---

yaml
---
r: 56814
b: refs/heads/try
c: a9741bd
h: refs/heads/master
v: v3

Author: brson

[refs]

@@ -2,7 +2,7 @@
 refs/heads/master: c081ffbd1e845687202a975ea2e698b623e5722f
 refs/heads/snap-stage1: e33de59e47c5076a89eadeb38f4934f58a3618a6
 refs/heads/snap-stage3: 79a2b2eafc3c766cecec8a5f76317693bae9ed17
-refs/heads/try: c97c03cd6a5c4ac37f2e68226c9f8ec49c786fcf
+refs/heads/try: a9741bd33d7e55401f506bb82b99411d03ce7e3f
 refs/tags/release-0.1: 1f5c5126e96c79d22cb7862f75304136e204f105
 refs/heads/ndm: f3868061cd7988080c30d6d5bf352a5a5fe2460b
 refs/heads/try2: 147ecfdd8221e4a4d4e090486829a06da1e0ca3c

branches/try/doc/tutorial.md

@@ -495,7 +495,11 @@ omitted.
 
 A powerful application of pattern matching is *destructuring*:
 matching in order to bind names to the contents of data
-types. Assuming that `(float, float)` is a tuple of two floats:
+types.
+
+> ***Note:*** The following code makes use of tuples (`(float, float)`) which
+> are explained in section 5.3. For now you can think of tuples as a list of
+> items.
 
 ~~~~
 fn angle(vector: (float, float)) -> float {

branches/try/src/libcore/cmp.rs

@@ -116,19 +116,6 @@ totalord_impl!(i64)
 totalord_impl!(int)
 totalord_impl!(uint)
 
-pub fn cmp2<A:TotalOrd,B:TotalOrd>(
-    a1: &A, b1: &B,
-    a2: &A, b2: &B) -> Ordering
-{
-    //! Compares (a1, b1) against (a2, b2), where the a values are more significant.
-
-    match a1.cmp(a2) {
-        Less => Less,
-        Greater => Greater,
-        Equal => b1.cmp(b2)
-    }
-}
-
 /**
 * Trait for values that can be compared for a sort-order.
 *
@@ -206,14 +193,6 @@ mod test {
         assert_eq!(12.cmp(-5), Greater);
     }
 
-    #[test]
-    fn test_cmp2() {
-        assert_eq!(cmp2(1, 2, 3, 4), Less);
-        assert_eq!(cmp2(3, 2, 3, 4), Less);
-        assert_eq!(cmp2(5, 2, 3, 4), Greater);
-        assert_eq!(cmp2(5, 5, 5, 4), Greater);
-    }
-
     #[test]
     fn test_int_totaleq() {
         assert!(5.equals(&5));

branches/try/src/libcore/condition.rs

@@ -28,7 +28,7 @@ pub struct Condition<'self, T, U> {
 }
 
 pub impl<'self, T, U> Condition<'self, T, U> {
-    fn trap(&'self self, h: &'self fn(T) -> U) -> Trap<'self, T, U> {
+    fn trap(&self, h: &'self fn(T) -> U) -> Trap<'self, T, U> {
         unsafe {
             let p : *RustClosure = ::cast::transmute(&h);
             let prev = task::local_data::local_data_get(self.key);

branches/try/src/libcore/container.rs

@@ -25,7 +25,6 @@ pub trait Mutable: Container {
     fn clear(&mut self);
 }
 
-#[cfg(stage0)]
 pub trait Map<K, V>: Mutable {
     /// Return true if the map contains a value for the specified key
     fn contains_key(&self, key: &K) -> bool;
@@ -58,41 +57,6 @@ pub trait Map<K, V>: Mutable {
     fn remove(&mut self, key: &K) -> bool;
 }
 
-#[cfg(stage1)]
-#[cfg(stage2)]
-#[cfg(stage3)]
-pub trait Map<K, V>: Mutable {
-    /// Return true if the map contains a value for the specified key
-    fn contains_key(&self, key: &K) -> bool;
-
-    // Visits all keys and values
-    fn each<'a>(&'a self, f: &fn(&K, &'a V) -> bool);
-
-    /// Visit all keys
-    fn each_key(&self, f: &fn(&K) -> bool);
-
-    /// Visit all values
-    fn each_value<'a>(&'a self, f: &fn(&'a V) -> bool);
-
-    /// Iterate over the map and mutate the contained values
-    fn mutate_values(&mut self, f: &fn(&K, &mut V) -> bool);
-
-    /// Return a reference to the value corresponding to the key
-    fn find<'a>(&'a self, key: &K) -> Option<&'a V>;
-
-    /// Return a mutable reference to the value corresponding to the key
-    fn find_mut<'a>(&'a mut self, key: &K) -> Option<&'a mut V>;
-
-    /// Insert a key-value pair into the map. An existing value for a
-    /// key is replaced by the new value. Return true if the key did
-    /// not already exist in the map.
-    fn insert(&mut self, key: K, value: V) -> bool;
-
-    /// Remove a key-value pair from the map. Return true if the key
-    /// was present in the map, otherwise false.
-    fn remove(&mut self, key: &K) -> bool;
-}
-
 pub trait Set<T>: Mutable {
     /// Return true if the set contains a value
     fn contains(&self, value: &T) -> bool;