---

yaml
---
r: 124966
b: refs/heads/auto
c: 9e83d29
h: refs/heads/master
v: v3

Author: nham

[refs]

@@ -13,7 +13,7 @@ refs/heads/try3: 9387340aab40a73e8424c48fd42f0c521a4875c0
 refs/tags/release-0.3.1: 495bae036dfe5ec6ceafd3312b4dca48741e845b
 refs/tags/release-0.4: e828ea2080499553b97dfe33b3f4d472b4562ad7
 refs/tags/release-0.5: 7e3bcfbf21278251ee936ad53e92e9b719702d73
-refs/heads/auto: 826b8358134f909f0b8aeb4c1d67a3fdda50b4b0
+refs/heads/auto: 9e83d29f30046292f43e982893517f9aee47fa48
 refs/heads/servo: af82457af293e2a842ba6b7759b70288da276167
 refs/tags/release-0.6: b4ebcfa1812664df5e142f0134a5faea3918544c
 refs/tags/0.1: b19db808c2793fe2976759b85a355c3ad8c8b336

branches/auto/src/doc/guide.md

@@ -624,10 +624,15 @@ let x = (let y = 5i); // found `let` in ident position
 The compiler is telling us here that it was expecting to see the beginning of
 an expression, and a `let` can only begin a statement, not an expression.
 
-Note that assigning to an already-bound variable (e.g. `y = 5i`) is still an
-expression, although its value is not particularly useful. Unlike C, where an
-assignment evaluates to the assigned value (e.g. `5i` in the previous example),
-in Rust the value of an assignment is the unit type `()` (which we'll cover later).
+However, assigning to a variable binding is an expression:
+
+```{rust}
+let x;
+let y = x = 5i;
+```
+
+In this case, we have an assignment expression (`x = 5`) whose value is
+being used as part of a `let` declaration statement (`let y = ...`).
 
 The second kind of statement in Rust is the **expression statement**. Its
 purpose is to turn any expression into a statement. In practical terms, Rust's

branches/auto/src/libcollections/treemap.rs

@@ -190,38 +190,33 @@ impl<K: Ord, V> TreeMap<K, V> {
 }
 
 impl<K, V> TreeMap<K, V> {
-    /// Return the value for which `f(key)` returns `Equal`. `f` is invoked
-    /// with current key and guides tree navigation. That means `f` should
-    /// be aware of natural ordering of the tree.
+    /// Return the value for which f(key) returns Equal. f is invoked
+    /// with current key and helps to navigate the tree
     ///
     /// # Example
     ///
     /// ```
-    /// use collections::treemap::TreeMap;
+    /// use std::ascii::StrAsciiExt;
     ///
-    /// fn get_headers() -> TreeMap<String, String> {
-    ///     let mut result = TreeMap::new();
-    ///     result.insert("Content-Type".to_string(), "application/xml".to_string());
-    ///     result.insert("User-Agent".to_string(), "Curl-Rust/0.1".to_string());
-    ///     result
-    /// }
+    /// let mut t = collections::treemap::TreeMap::new();
+    /// t.insert("Content-Type", "application/xml");
+    /// t.insert("User-Agent", "Curl-Rust/0.1");
     ///
-    /// let headers = get_headers();
-    /// let ua_key = "User-Agent";
-    /// let ua = headers.find_with(|k| {
-    ///    ua_key.cmp(&k.as_slice())
+    /// let ua_key = "user-agent";
+    /// let ua = t.find_with(|&k| {
+    ///    ua_key.cmp(&k.to_ascii_lower().as_slice())
     /// });
     ///
-    /// assert_eq!((*ua.unwrap()).as_slice(), "Curl-Rust/0.1");
+    /// assert_eq!(*ua.unwrap(), "Curl-Rust/0.1");
     /// ```
     #[inline]
     pub fn find_with<'a>(&'a self, f:|&K| -> Ordering) -> Option<&'a V> {
         tree_find_with(&self.root, f)
     }
 
-    /// Return the value for which `f(key)` returns `Equal`. `f` is invoked
-    /// with current key and guides tree navigation. That means `f` should
-    /// be aware of natural ordering of the tree.
+    /// Return the value for which f(key) returns Equal. f is invoked
+    /// with current key and helps to navigate the tree
+    ///
     /// # Example
     ///
     /// ```
@@ -918,9 +913,14 @@ fn split<K: Ord, V>(node: &mut Box<TreeNode<K, V>>) {
     }
 }
 
-// Next 2 functions have the same convention: comparator gets
-// at input current key and returns search_key cmp cur_key
-// (i.e. search_key.cmp(&cur_key))
+// Next 2 functions have the same conventions
+//
+// The only difference is that non-mutable version uses loop instead
+// of recursion (performance considerations)
+// It seems to be impossible to avoid recursion with mutability
+//
+// So convention is that comparator is gets at input current key
+// and returns search_key cmp cur_key (i.e. search_key.cmp(cur_key))
 fn tree_find_with<'r, K, V>(node: &'r Option<Box<TreeNode<K, V>>>,
                             f: |&K| -> Ordering) -> Option<&'r V> {
     let mut current: &'r Option<Box<TreeNode<K, V>>> = node;

branches/auto/src/libcollections/trie.rs

@@ -17,6 +17,7 @@ use core::default::Default;
 use core::mem::zeroed;
 use core::mem;
 use core::uint;
+use std::hash::{Writer, Hash};
 
 use {Collection, Mutable, Map, MutableMap, Set, MutableSet};
 use slice::{Items, MutItems};
@@ -292,7 +293,16 @@ impl<T> Extendable<(uint, T)> for TrieMap<T> {
     }
 }
 
+impl<S: Writer, T: Hash<S>> Hash<S> for TrieMap<T> {
+    fn hash(&self, state: &mut S) {
+        for elt in self.iter() {
+            elt.hash(state);
+        }
+    }
+}
+
 #[allow(missing_doc)]
+#[deriving(Hash)]
 pub struct TrieSet {
     map: TrieMap<()>
 }
@@ -1049,6 +1059,7 @@ mod bench_map {
 mod test_set {
     use std::prelude::*;
     use std::uint;
+    use std::hash;
 
     use {MutableSet, Set};
     use super::TrieSet;
@@ -1082,4 +1093,20 @@ mod test_set {
             assert!(set.contains(x));
         }
     }
+
+    #[test]
+    fn test_hash() {
+      let mut x = TrieSet::new();
+      let mut y = TrieSet::new();
+
+      x.insert(1);
+      x.insert(2);
+      x.insert(3);
+
+      y.insert(3);
+      y.insert(2);
+      y.insert(1);
+
+      assert!(hash::hash(&x) == hash::hash(&y));
+    }
 }