---

yaml
---
r: 79863
b: refs/heads/master
c: b0e13e0
h: refs/heads/master
i:
  79861: 54ed520
  79859: 32f1f51
  79855: 2039d4e
v: v3

Author: fhahn

[refs]

@@ -1,5 +1,5 @@
 ---
-refs/heads/master: 49eb7bd2716f59e0cd47c427a4c60f49e8ce6e50
+refs/heads/master: b0e13e0d0e61b4147c8c62856c50cf727f7c918f
 refs/heads/snap-stage1: e33de59e47c5076a89eadeb38f4934f58a3618a6
 refs/heads/snap-stage3: 54ae2800ffb30513f89ce13d27ac3c8d095d98ac
 refs/heads/try: 71bebebc37fbb229877da88dde13c2f35913bd77

trunk/doc/rust.md

@@ -2459,12 +2459,25 @@ do k(3) |j| {
 ### For expressions
 
 ~~~~~~~~{.ebnf .gram}
-for_expr : "for" pat "in" expr '{' block '}' ;
+for_expr : "for" expr [ '|' ident_list '|' ] ? '{' block '}' ;
 ~~~~~~~~
 
-A `for` expression is a syntactic construct for looping
-over elements provided by an implementation of
-`std::iterator::Iterator`.
+A _for expression_ is similar to a [`do` expression](#do-expressions),
+in that it provides a special block-form of lambda expression,
+suited to passing the `block` function to a higher-order function implementing a loop.
+
+In contrast to a `do` expression, a `for` expression is designed to work
+with methods such as `each` and `times`, that require the body block to
+return a boolean. The `for` expression accommodates this by implicitly
+returning `true` at the end of each block, unless a `break` expression
+is evaluated.
+
+In addition, [`break`](#break-expressions) and [`loop`](#loop-expressions) expressions
+are rewritten inside `for` expressions in the same way that `return` expressions are,
+with a combination of local flag variables,
+and early boolean-valued returns from the `block` function,
+such that the meaning of `break` and `loop` is preserved in a primitive loop
+when rewritten as a `for` loop controlled by a higher order function.
 
 An example of a for loop over the contents of a vector:
 

trunk/src/libstd/hashmap.rs

@@ -687,6 +687,17 @@ impl<T:Hash + Eq> HashSet<T> {
         HashSet { map: HashMap::with_capacity(capacity) }
     }
 
+    /// Create an empty HashSet with space for at least `capacity`
+    /// elements in the hash table, using `k0` and `k1` as the keys.
+    ///
+    /// Warning: `k0` and `k1` are normally randomly generated, and
+    /// are designed to allow HashSets to be resistant to attacks that
+    /// cause many collisions and very poor performance. Setting them
+    /// manually using this function can expose a DoS attack vector.
+    pub fn with_capacity_and_keys(k0: u64, k1: u64, capacity: uint) -> HashSet<T> {
+        HashSet { map: HashMap::with_capacity_and_keys(k0, k1, capacity) }
+    }
+
     /// Reserve space for at least `n` elements in the hash table.
     pub fn reserve_at_least(&mut self, n: uint) {
         self.map.reserve_at_least(n)