---

yaml
---
r: 125807
b: refs/heads/try
c: ce20571
h: refs/heads/master
i:
  125805: 30f0fe7
  125803: 9659b3e
  125799: 9c33a74
  125791: 06f5df5
v: v3

Author: brson

[refs]

@@ -2,7 +2,7 @@
 refs/heads/master: f2fa55903e378368ed9173560f03a0ef16e371c2
 refs/heads/snap-stage1: e33de59e47c5076a89eadeb38f4934f58a3618a6
 refs/heads/snap-stage3: 9fc8394d3bce22ab483f98842434c84c396212ae
-refs/heads/try: c080d26d328d6e8bbf4b159b5c5f3cd55c86f621
+refs/heads/try: ce20571a55ecc7915eaaa95bfedb67d389d2899c
 refs/tags/release-0.1: 1f5c5126e96c79d22cb7862f75304136e204f105
 refs/heads/ndm: f3868061cd7988080c30d6d5bf352a5a5fe2460b
 refs/heads/try2: 147ecfdd8221e4a4d4e090486829a06da1e0ca3c

branches/try/mk/dist.mk

@@ -205,17 +205,19 @@ distcheck-osx: dist-osx
 # Unix binary installer tarballs
 ######################################################################
 
-define DEF_PREPARE_DIST_DIR
-
-dist-install-dir-$(1)$(3): PREPARE_HOST=$(1)
-dist-install-dir-$(1)$(3): PREPARE_TARGETS=$(2)
-dist-install-dir-$(1)$(3): PREPARE_DEST_DIR=tmp/dist/$$(PKG_NAME)-$(1)
-dist-install-dir-$(1)$(3): PREPARE_DIR_CMD=$(DEFAULT_PREPARE_DIR_CMD)
-dist-install-dir-$(1)$(3): PREPARE_BIN_CMD=$(DEFAULT_PREPARE_BIN_CMD)
-dist-install-dir-$(1)$(3): PREPARE_LIB_CMD=$(DEFAULT_PREPARE_LIB_CMD)
-dist-install-dir-$(1)$(3): PREPARE_MAN_CMD=$(DEFAULT_PREPARE_MAN_CMD)
-dist-install-dir-$(1)$(3): PREPARE_CLEAN=true
-dist-install-dir-$(1)$(3): prepare-base-dir-$(1) docs compiler-docs
+define DEF_INSTALLER
+
+$$(eval $$(call DEF_PREPARE,dir-$(1)))
+
+dist-install-dir-$(1): PREPARE_HOST=$(1)
+dist-install-dir-$(1): PREPARE_TARGETS=$(1)
+dist-install-dir-$(1): PREPARE_DEST_DIR=tmp/dist/$$(PKG_NAME)-$(1)
+dist-install-dir-$(1): PREPARE_DIR_CMD=$(DEFAULT_PREPARE_DIR_CMD)
+dist-install-dir-$(1): PREPARE_BIN_CMD=$(DEFAULT_PREPARE_BIN_CMD)
+dist-install-dir-$(1): PREPARE_LIB_CMD=$(DEFAULT_PREPARE_LIB_CMD)
+dist-install-dir-$(1): PREPARE_MAN_CMD=$(DEFAULT_PREPARE_MAN_CMD)
+dist-install-dir-$(1): PREPARE_CLEAN=true
+dist-install-dir-$(1): prepare-base-dir-$(1) docs compiler-docs
 	$$(Q)(cd $$(PREPARE_DEST_DIR)/ && find . -type f | sed 's/^\.\///') \
       > tmp/dist/manifest-$(1).in
 	$$(Q)mv tmp/dist/manifest-$(1).in $$(PREPARE_DEST_DIR)/$$(CFG_LIBDIR_RELATIVE)/rustlib/manifest.in
@@ -227,16 +229,6 @@ dist-install-dir-$(1)$(3): prepare-base-dir-$(1) docs compiler-docs
 	$$(Q)cp -r doc $$(PREPARE_DEST_DIR)
 	$$(Q)$$(PREPARE_BIN_CMD) $$(S)src/etc/install.sh $$(PREPARE_DEST_DIR)
 
-endef
-
-define DEF_INSTALLER
-
-$$(eval $$(call DEF_PREPARE,dir-$(1)))
-
-$$(eval $$(call DEF_PREPARE_DIST_DIR,$(1),$(1),))
-
-$$(eval $$(call DEF_PREPARE_DIST_DIR,$(1),$(CFG_TARGET),-with-target-libs))
-
 dist/$$(PKG_NAME)-$(1).tar.gz: dist-install-dir-$(1)
 	@$(call E, build: $$@)
 	$$(Q)tar -czf dist/$$(PKG_NAME)-$(1).tar.gz -C tmp/dist $$(PKG_NAME)-$(1)

branches/try/mk/install.mk

@@ -14,12 +14,12 @@ else
 MAYBE_DISABLE_VERIFY=
 endif
 
-install: dist-install-dir-$(CFG_BUILD)-with-target-libs | tmp/empty_dir
+install: dist-install-dir-$(CFG_BUILD) | tmp/empty_dir
 	$(Q)cd tmp/empty_dir && sh ../../tmp/dist/$(PKG_NAME)-$(CFG_BUILD)/install.sh --prefix="$(DESTDIR)$(CFG_PREFIX)" --libdir="$(DESTDIR)$(CFG_LIBDIR)" --mandir="$(DESTDIR)$(CFG_MANDIR)" "$(MAYBE_DISABLE_VERIFY)"
 # Remove tmp files while we can because they may have been created under sudo
 	$(Q)rm -R tmp/dist
 
-uninstall: dist-install-dir-$(CFG_BUILD)-with-target-libs | tmp/empty_dir
+uninstall: dist-install-dir-$(CFG_BUILD) | tmp/empty_dir
 	$(Q)cd tmp/empty_dir && sh ../../tmp/dist/$(PKG_NAME)-$(CFG_BUILD)/install.sh --uninstall --prefix="$(DESTDIR)$(CFG_PREFIX)" --libdir="$(DESTDIR)$(CFG_LIBDIR)" --mandir="$(DESTDIR)$(CFG_MANDIR)"
 # Remove tmp files while we can because they may have been created under sudo
 	$(Q)rm -R tmp/dist

branches/try/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/try/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/try/src/libcollections/trie.rs

@@ -17,7 +17,6 @@ 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};
@@ -41,15 +40,6 @@ pub struct TrieMap<T> {
     length: uint
 }
 
-impl<T: PartialEq> PartialEq for TrieMap<T> {
-    fn eq(&self, other: &TrieMap<T>) -> bool {
-        self.len() == other.len() &&
-            self.iter().zip(other.iter()).all(|(a, b)| a == b)
-    }
-}
-
-impl<T: Eq> Eq for TrieMap<T> {}
-
 impl<T> Collection for TrieMap<T> {
     /// Return the number of elements in the map
     #[inline]
@@ -302,16 +292,7 @@ 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, PartialEq, Eq)]
 pub struct TrieSet {
     map: TrieMap<()>
 }
@@ -680,7 +661,6 @@ mod test_map {
     use std::prelude::*;
     use std::iter::range_step;
     use std::uint;
-    use std::hash;
 
     use {MutableMap, Map};
     use super::{TrieMap, TrieNode, Internal, External, Nothing};
@@ -953,41 +933,6 @@ mod test_map {
         assert!(m_lower.iter().all(|(_, &x)| x == 0));
         assert!(m_upper.iter().all(|(_, &x)| x == 0));
     }
-
-    #[test]
-    fn test_eq() {
-        let mut a = TrieMap::new();
-        let mut b = TrieMap::new();
-
-        assert!(a == b);
-        assert!(a.insert(0, 5i));
-        assert!(a != b);
-        assert!(b.insert(0, 4i));
-        assert!(a != b);
-        assert!(a.insert(5, 19));
-        assert!(a != b);
-        assert!(!b.insert(0, 5));
-        assert!(a != b);
-        assert!(b.insert(5, 19));
-        assert!(a == b);
-    }
-
-    #[test]
-    fn test_hash() {
-      let mut x = TrieMap::new();
-      let mut y = TrieMap::new();
-
-      assert!(hash::hash(&x) == hash::hash(&y));
-      x.insert(1, 'a');
-      x.insert(2, 'b');
-      x.insert(3, 'c');
-
-      y.insert(3, 'c');
-      y.insert(2, 'b');
-      y.insert(1, 'a');
-
-      assert!(hash::hash(&x) == hash::hash(&y));
-    }
 }
 
 #[cfg(test)]