---

yaml
---
r: 120508
b: refs/heads/dist-snap
c: c9ab33a
h: refs/heads/master
v: v3

Author: brson

[refs]

@@ -6,7 +6,7 @@ refs/heads/try: 1813e5aa1a03b0596b8de7abd1af31edf5d6098f
 refs/tags/release-0.1: 1f5c5126e96c79d22cb7862f75304136e204f105
 refs/heads/ndm: f3868061cd7988080c30d6d5bf352a5a5fe2460b
 refs/heads/try2: 147ecfdd8221e4a4d4e090486829a06da1e0ca3c
-refs/heads/dist-snap: 26e4680ae52bb98517cff07ff89446c5010db01e
+refs/heads/dist-snap: c9ab33a8fde708c8a4cf70b03f5d69370220665c
 refs/tags/release-0.2: c870d2dffb391e14efb05aa27898f1f6333a9596
 refs/tags/release-0.3: b5f0d0f648d9a6153664837026ba1be43d3e2503
 refs/heads/try3: 9387340aab40a73e8424c48fd42f0c521a4875c0

branches/dist-snap/src/libcore/cell.rs

@@ -54,7 +54,7 @@
 //! containers that can be cloned and shared between multiple parties.
 //! Because the contained values may be multiply-aliased, they can
 //! only be borrowed as shared references, not mutable references.
-//! Without cells then it would be impossible to mutate data inside of
+//! Without cells it would be impossible to mutate data inside of
 //! shared boxes at all!
 //!
 //! It's very common then to put a `RefCell` inside shared pointer
@@ -104,7 +104,7 @@
 //!             // Take a reference to the inside of cache cell
 //!             let mut cache = self.span_tree_cache.borrow_mut();
 //!             if cache.is_some() {
-//!                 return cache.take_unwrap().clone();
+//!                 return cache.get_ref().clone();
 //!             }
 //!
 //!             let span_tree = self.calc_span_tree();
@@ -118,14 +118,14 @@
 //!         // This is the major hazard of using `RefCell`.
 //!         self.minimum_spanning_tree()
 //!     }
-//! #   fn calc_span_tree(&self) -> Vec<(uint, uint)> { vec!() }
+//! #   fn calc_span_tree(&self) -> Vec<(uint, uint)> { vec![] }
 //! }
 //! # fn main() { }
 //! ```
 //!
 //! ## Mutating implementations of `clone`
 //!
-//! This is simply a special - bot common - case of the previous:
+//! This is simply a special - but common - case of the previous:
 //! hiding mutability for operations that appear to be immutable.
 //! The `clone` method is expected to not change the source value, and
 //! is declared to take `&self`, not `&mut self`. Therefore any

branches/dist-snap/src/libcore/lib.rs

@@ -14,11 +14,11 @@
 //! Rust Standard Library](../std/index.html). It is the portable glue
 //! between the language and its libraries, defining the intrinsic and
 //! primitive building blocks of all Rust code. It links to no
-//! upstream libraries, no system libraries, no libc.
+//! upstream libraries, no system libraries, and no libc.
 //!
 //! The core library is *minimal*: it isn't even aware of heap allocation,
 //! nor does it provide concurrency or I/O. These things require
-//! platform integration, and this library is platform-oblivious.
+//! platform integration, and this library is platform-agnostic.
 //!
 //! *It is not recommended to use the core library*. The stable
 //! functionality of libcore is reexported from the

branches/dist-snap/src/libstd/lib.rs

@@ -16,7 +16,7 @@
 //!
 //! ## Intrinsic types and operations
 //!
-//! The [`ptr`](../core/ptr/index.html), [`mem`](../core/mem/index.html),
+//! The [`ptr`](../core/ptr/index.html) and [`mem`](../core/mem/index.html)
 //! modules deal with unsafe pointers and memory manipulation.
 //! [`kinds`](../core/kinds/index.html) defines the special built-in traits,
 //! and [`raw`](../core/raw/index.html) the runtime representation of Rust types.