---

yaml
---
r: 158045
b: refs/heads/master
c: 768caf1
h: refs/heads/master
i:
  158043: 25d8cea
v: v3

Author: alexcrichton

[refs]

@@ -1,5 +1,5 @@
 ---
-refs/heads/master: b11b706545ec986b0416a14383170c60004644a5
+refs/heads/master: 768caf1083f916f47cfa2aaa2134083e572ef8b1
 refs/heads/snap-stage1: e33de59e47c5076a89eadeb38f4934f58a3618a6
 refs/heads/snap-stage3: 1b2ad7831f1745bf4a4709a1fa1772afb47c933c
 refs/heads/try: 98bd84a3300f974f400a3eeb56567ad3f77b13f0

trunk/src/doc/guide-testing.md

@@ -287,7 +287,7 @@ The benchmarking runner offers two ways to avoid this. Either, the
 closure that the `iter` method receives can return an arbitrary value
 which forces the optimizer to consider the result used and ensures it
 cannot remove the computation entirely. This could be done for the
-example above by adjusting the `b.iter` call to
+example above by adjusting the `bh.iter` call to
 
 ~~~
 # struct X; impl X { fn iter<T>(&self, _: || -> T) {} } let b = X;

trunk/src/doc/intro.md

@@ -494,14 +494,14 @@ non-deterministic aspect:
 $ cargo run
    Compiling hello_world v0.0.1 (file:///Users/you/src/hello_world)
      Running `target/hello_world`
-numbers[1] is 3
-numbers[0] is 2
-numbers[2] is 4
+numbers[1] is 2
+numbers[0] is 1
+numbers[2] is 3
 $ cargo run
      Running `target/hello_world`
-numbers[2] is 4
-numbers[1] is 3
-numbers[0] is 2
+numbers[2] is 3
+numbers[1] is 2
+numbers[0] is 1
 ```
 
 Each time, we get a slightly different output, because each thread works in a

trunk/src/doc/reference.md

@@ -400,11 +400,11 @@ An _integer literal_ has one of four forms:
 * A _decimal literal_ starts with a *decimal digit* and continues with any
   mixture of *decimal digits* and _underscores_.
 * A _hex literal_ starts with the character sequence `U+0030` `U+0078`
-  (`0x`) and continues as any mixture of hex digits and underscores.
+  (`0x`) and continues as any mixture hex digits and underscores.
 * An _octal literal_ starts with the character sequence `U+0030` `U+006F`
-  (`0o`) and continues as any mixture of octal digits and underscores.
+  (`0o`) and continues as any mixture octal digits and underscores.
 * A _binary literal_ starts with the character sequence `U+0030` `U+0062`
-  (`0b`) and continues as any mixture of binary digits and underscores.
+  (`0b`) and continues as any mixture binary digits and underscores.
 
 An integer literal may be followed (immediately, without any spaces) by an
 _integer suffix_, which changes the type of the literal. There are two kinds of
@@ -944,10 +944,10 @@ An example of `use` declarations:
 ```
 use std::iter::range_step;
 use std::option::{Some, None};
-use std::collections::hash_map::{mod, HashMap};
+use std::collections::hashmap::{mod, HashMap};
 
-fn foo<T>(_: T){}
-fn bar(map1: HashMap<String, uint>, map2: hash_map::HashMap<String, uint>){}
+# fn foo<T>(_: T){}
+# fn bar(map: HashMap<String, uint>, set: hashmap::HashSet<String>){}
 
 fn main() {
     // Equivalent to 'std::iter::range_step(0u, 10u, 2u);'
@@ -957,10 +957,10 @@ fn main() {
     // std::option::None]);'
     foo(vec![Some(1.0f64), None]);
 
-    // Both `hash_map` and `HashMap` are in scope.
-    let map1 = HashMap::new();
-    let map2 = hash_map::HashMap::new();
-    bar(map1, map2);
+    // Both `hash` and `HashMap` are in scope.
+    let map = HashMap::new();
+    let set = hashmap::HashSet::new();
+    bar(map, set);
 }
 ```
 
@@ -2100,15 +2100,15 @@ plugins](guide-plugin.html#lint-plugins) can provide additional lint checks.
 ```{.ignore}
 mod m1 {
     // Missing documentation is ignored here
-    #[allow(missing_docs)]
+    #[allow(missing_doc)]
     pub fn undocumented_one() -> int { 1 }
 
     // Missing documentation signals a warning here
-    #[warn(missing_docs)]
+    #[warn(missing_doc)]
     pub fn undocumented_too() -> int { 2 }
 
     // Missing documentation signals an error here
-    #[deny(missing_docs)]
+    #[deny(missing_doc)]
     pub fn undocumented_end() -> int { 3 }
 }
 ```
@@ -2117,16 +2117,16 @@ This example shows how one can use `allow` and `warn` to toggle a particular
 check on and off.
 
 ```{.ignore}
-#[warn(missing_docs)]
+#[warn(missing_doc)]
 mod m2{
-    #[allow(missing_docs)]
+    #[allow(missing_doc)]
     mod nested {
         // Missing documentation is ignored here
         pub fn undocumented_one() -> int { 1 }
 
         // Missing documentation signals a warning here,
         // despite the allow above.
-        #[warn(missing_docs)]
+        #[warn(missing_doc)]
         pub fn undocumented_two() -> int { 2 }
     }
 
@@ -2139,10 +2139,10 @@ This example shows how one can use `forbid` to disallow uses of `allow` for
 that lint check.
 
 ```{.ignore}
-#[forbid(missing_docs)]
+#[forbid(missing_doc)]
 mod m3 {
     // Attempting to toggle warning signals an error here
-    #[allow(missing_docs)]
+    #[allow(missing_doc)]
     /// Returns 2.
     pub fn undocumented_too() -> int { 2 }
 }
@@ -4096,7 +4096,7 @@ cause transitions between the states. The lifecycle states of a task are:
 
 * running
 * blocked
-* panicked
+* panicked 
 * dead
 
 A task begins its lifecycle &mdash; once it has been spawned &mdash; in the

trunk/src/doc/rust.css

@@ -62,10 +62,6 @@ body {
     font-size: 18px;
     color: #333;
     line-height: 1.428571429;
-
-    -webkit-font-feature-settings: "kern", "liga";
-    -moz-font-feature-settings: "kern", "liga";
-    font-feature-settings: "kern", "liga";
 }
 @media (min-width: 768px) {
     body {

trunk/src/etc/unicode.py

@@ -34,7 +34,7 @@
 
 // NOTE: The following code was generated by "src/etc/unicode.py", do not edit directly
 
-#![allow(missing_docs, non_uppercase_statics, non_snake_case)]
+#![allow(missing_doc, non_uppercase_statics, non_snake_case)]
 '''
 
 # Mapping taken from Table 12 from:

trunk/src/libcollections/bit.rs renamed to trunk/src/libcollections/bitv.rs

@@ -8,9 +8,6 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-// FIXME(Gankro): Bitv and BitvSet are very tightly coupled. Ideally (for maintenance),
-// they should be in separate files/modules, with BitvSet only using Bitv's public API.
-
 //! Collections implemented with bit vectors.
 //!
 //! # Example
@@ -1657,7 +1654,7 @@ mod tests {
     use std::rand::Rng;
     use test::Bencher;
 
-    use super::{Bitv, BitvSet, from_fn, from_bytes};
+    use bitv::{Bitv, BitvSet, from_fn, from_bytes};
     use bitv;
     use vec::Vec;
 

trunk/src/libcollections/btree/map.rs

@@ -23,7 +23,7 @@ use core::default::Default;
 use core::{iter, fmt, mem};
 use core::fmt::Show;
 
-use ring_buf::RingBuf;
+use ringbuf::RingBuf;
 
 /// A map based on a B-Tree.
 ///

trunk/src/libcollections/btree/mod.rs

@@ -8,6 +8,27 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
+pub use self::map::BTreeMap;
+pub use self::map::Entries;
+pub use self::map::MutEntries;
+pub use self::map::MoveEntries;
+pub use self::map::Keys;
+pub use self::map::Values;
+pub use self::map::Entry;
+pub use self::map::Occupied;
+pub use self::map::Vacant;
+pub use self::map::OccupiedEntry;
+pub use self::map::VacantEntry;
+
+pub use self::set::BTreeSet;
+pub use self::set::Items;
+pub use self::set::MoveItems;
+pub use self::set::DifferenceItems;
+pub use self::set::UnionItems;
+pub use self::set::SymDifferenceItems;
+pub use self::set::IntersectionItems;
+
+
 mod node;
-pub mod map;
-pub mod set;
+mod map;
+mod set;

trunk/src/libcollections/btree/set.rs

@@ -13,7 +13,7 @@
 
 use core::prelude::*;
 
-use btree_map::{BTreeMap, Keys, MoveEntries};
+use super::{BTreeMap, Keys, MoveEntries};
 use std::hash::Hash;
 use core::default::Default;
 use core::{iter, fmt};

trunk/src/libcollections/enum_set.rs

@@ -155,7 +155,7 @@ mod test {
     use std::prelude::*;
     use std::mem;
 
-    use super::{EnumSet, CLike};
+    use enum_set::{EnumSet, CLike};
 
     #[deriving(PartialEq, Show)]
     #[repr(uint)]

trunk/src/libcollections/lib.rs

@@ -37,72 +37,34 @@ extern crate alloc;
 #[cfg(test)] #[phase(plugin, link)] extern crate std;
 #[cfg(test)] #[phase(plugin, link)] extern crate log;
 
-
-pub use binary_heap::BinaryHeap;
-pub use bitv::Bitv;
-pub use bitv_set::BitvSet;
-pub use btree_map::BTreeMap;
-pub use btree_set::BTreeSet;
+pub use bitv::{Bitv, BitvSet};
+pub use btree::{BTreeMap, BTreeSet};
 pub use dlist::DList;
 pub use enum_set::EnumSet;
-pub use ring_buf::RingBuf;
+pub use priority_queue::PriorityQueue;
+pub use ringbuf::RingBuf;
+pub use smallintmap::SmallIntMap;
 pub use string::String;
-pub use tree_map::TreeMap;
-pub use tree_set::TreeSet;
-pub use trie_map::TrieMap;
-pub use trie_set::TrieSet;
+pub use treemap::{TreeMap, TreeSet};
+pub use trie::{TrieMap, TrieSet};
 pub use vec::Vec;
-pub use vec_map::VecMap;
 
 mod macros;
 
-pub mod binary_heap;
-mod bit;
-mod btree;
+pub mod bitv;
+pub mod btree;
 pub mod dlist;
 pub mod enum_set;
-pub mod ring_buf;
-mod tree;
-mod trie;
+pub mod priority_queue;
+pub mod ringbuf;
+pub mod smallintmap;
+pub mod treemap;
+pub mod trie;
 pub mod slice;
 pub mod str;
 pub mod string;
 pub mod vec;
 pub mod hash;
-pub mod vec_map;
-
-pub mod bitv {
-    pub use bit::{Bitv, Bits, from_fn, from_bytes};
-}
-
-pub mod bitv_set {
-    pub use bit::{BitvSet, BitPositions, TwoBitPositions};
-}
-
-pub mod tree_map {
-    pub use tree::map::*;
-}
-
-pub mod tree_set {
-    pub use tree::set::*;
-}
-
-pub mod trie_map {
-    pub use trie::map::*;
-}
-
-pub mod trie_set {
-    pub use trie::set::*;
-}
-
-pub mod btree_map {
-    pub use btree::map::*;
-}
-
-pub mod btree_set {
-    pub use btree::set::*;
-}
-
 
 #[cfg(test)] mod bench;