---

yaml
---
r: 31004
b: refs/heads/incoming
c: a06b903
h: refs/heads/master
v: v3

Author: graydon

[refs]

@@ -6,7 +6,7 @@ refs/heads/try: d324a424d8f84b1eb049b12cf34182bda91b0024
 refs/tags/release-0.1: 1f5c5126e96c79d22cb7862f75304136e204f105
 refs/heads/ndm: f3868061cd7988080c30d6d5bf352a5a5fe2460b
 refs/heads/try2: d0c6ce338884ee21843f4b40bf6bf18d222ce5df
-refs/heads/incoming: 0eb9d41454083d2e9cb11859669f35c25c0f3347
+refs/heads/incoming: a06b90322cb4b61a3a20e12ab3406cff809c586c
 refs/heads/dist-snap: 2f32a1581f522e524009138b33b1c7049ced668d
 refs/tags/release-0.2: c870d2dffb391e14efb05aa27898f1f6333a9596
 refs/tags/release-0.3: b5f0d0f648d9a6153664837026ba1be43d3e2503

branches/incoming/doc/tutorial-macros.md

@@ -65,7 +65,7 @@ forbidden.
 To take as an argument a fragment of Rust code, write `$` followed by a name
  (for use on the right-hand side), followed by a `:`, followed by the sort of
 fragment to match (the most common ones are `ident`, `expr`, `ty`, `pat`, and
-`block`). Anything not preceded by a `$` is taken literally. The standard
+`block`). Anything not preceeded by a `$` is taken literally. The standard
 rules of tokenization apply,
 
 So `($x:ident => (($e:expr)))`, though excessively fancy, would create a macro
@@ -88,7 +88,7 @@ position).
 
 Going back to the motivating example, suppose that we wanted each invocation
 of `early_return` to potentially accept multiple "special" identifiers. The
-syntax `$(...)*` accepts zero or more occurrences of its contents, much like
+syntax `$(...)*` accepts zero or more occurences of its contents, much like
 the Kleene star operator in regular expressions. It also supports a separator
 token (a comma-separated list could be written `$(...),*`), and `+` instead of
 `*` to mean "at least one".

branches/incoming/doc/tutorial-tasks.md

@@ -47,7 +47,7 @@ In particular, there are currently two independent modules that provide
 a message passing interface to Rust code: `core::comm` and `core::pipes`.
 `core::comm` is an older, less efficient system that is being phased out
 in favor of `pipes`. At some point the existing `core::comm` API will
-be removed and the user-facing portions of `core::pipes` will be moved
+be romoved and the user-facing portions of `core::pipes` will be moved
 to `core::comm`. In this tutorial we will discuss `pipes` and ignore
 the `comm` API.
 
@@ -58,7 +58,7 @@ concurrency at the moment.
 * [`core::comm`] - The deprecated message passing API
 * [`core::pipes`] - The new message passing infrastructure and API
 * [`std::comm`] - Higher level messaging types based on `core::pipes`
-* [`std::sync`] - More exotic synchronization tools, including locks
+* [`std::sync`] - More exotic synchronization tools, including locks 
 * [`std::arc`] - The ARC type, for safely sharing immutable data
 * [`std::par`] - Some basic tools for implementing parallel algorithms
 
@@ -151,7 +151,7 @@ commonly used, which we will cover presently.
 
 The simplest way to create a pipe is to use the `pipes::stream`
 function to create a `(Chan, Port)` pair. In Rust parlance a 'channel'
-is a sending endpoint of a pipe, and a 'port' is the receiving
+is a sending endpoint of a pipe, and a 'port' is the recieving
 endpoint. Consider the following example of performing two calculations
 concurrently.
 
@@ -183,7 +183,7 @@ let (chan, port): (Chan<int>, Port<int>) = stream();
 ~~~~
 
 The channel will be used by the child task to send data to the parent task,
-which will wait to receive the data on the port. The next statement
+which will wait to recieve the data on the port. The next statement
 spawns the child task.
 
 ~~~~
@@ -307,7 +307,7 @@ unrecoverable within a single task - once a task fails there is no way
 to "catch" the exception.
 
 All tasks are, by default, _linked_ to each other, meaning their fate
-is intertwined, and if one fails so do all of them.
+is interwined, and if one fails so do all of them.
 
 ~~~
 # use task::spawn;

branches/incoming/src/libstd/serialization.rs

@@ -4,7 +4,7 @@
 Core serialization interfaces.
 */
 
-trait Serializer {
+pub trait Serializer {
     // Primitive types:
     fn emit_nil();
     fn emit_uint(v: uint);
@@ -37,7 +37,7 @@ trait Serializer {
     fn emit_tup_elt(idx: uint, f: fn());
 }
 
-trait Deserializer {
+pub trait Deserializer {
     // Primitive types:
     fn read_nil() -> ();
 
@@ -81,7 +81,7 @@ trait Deserializer {
 //
 // In some cases, these should eventually be coded as traits.
 
-fn emit_from_vec<S: Serializer, T>(&&s: S, &&v: ~[T], f: fn(&&x: T)) {
+pub fn emit_from_vec<S: Serializer, T>(&&s: S, &&v: ~[T], f: fn(&&x: T)) {
     do s.emit_vec(vec::len(v)) {
         for vec::eachi(v) |i,e| {
             do s.emit_vec_elt(i) {
@@ -91,15 +91,15 @@ fn emit_from_vec<S: Serializer, T>(&&s: S, &&v: ~[T], f: fn(&&x: T)) {
     }
 }
 
-fn read_to_vec<D: Deserializer, T: Copy>(&&d: D, f: fn() -> T) -> ~[T] {
+pub fn read_to_vec<D: Deserializer, T: Copy>(&&d: D, f: fn() -> T) -> ~[T] {
     do d.read_vec |len| {
         do vec::from_fn(len) |i| {
             d.read_vec_elt(i, || f())
         }
     }
 }
 
-trait SerializerHelpers {
+pub trait SerializerHelpers {
     fn emit_from_vec<T>(&&v: ~[T], f: fn(&&x: T));
 }
 
@@ -109,7 +109,7 @@ impl<S: Serializer> S: SerializerHelpers {
     }
 }
 
-trait DeserializerHelpers {
+pub trait DeserializerHelpers {
     fn read_to_vec<T: Copy>(f: fn() -> T) -> ~[T];
 }
 
@@ -119,127 +119,127 @@ impl<D: Deserializer> D: DeserializerHelpers {
     }
 }
 
-fn serialize_uint<S: Serializer>(&&s: S, v: uint) {
+pub fn serialize_uint<S: Serializer>(&&s: S, v: uint) {
     s.emit_uint(v);
 }
 
-fn deserialize_uint<D: Deserializer>(&&d: D) -> uint {
+pub fn deserialize_uint<D: Deserializer>(&&d: D) -> uint {
     d.read_uint()
 }
 
-fn serialize_u8<S: Serializer>(&&s: S, v: u8) {
+pub fn serialize_u8<S: Serializer>(&&s: S, v: u8) {
     s.emit_u8(v);
 }
 
-fn deserialize_u8<D: Deserializer>(&&d: D) -> u8 {
+pub fn deserialize_u8<D: Deserializer>(&&d: D) -> u8 {
     d.read_u8()
 }
 
-fn serialize_u16<S: Serializer>(&&s: S, v: u16) {
+pub fn serialize_u16<S: Serializer>(&&s: S, v: u16) {
     s.emit_u16(v);
 }
 
-fn deserialize_u16<D: Deserializer>(&&d: D) -> u16 {
+pub fn deserialize_u16<D: Deserializer>(&&d: D) -> u16 {
     d.read_u16()
 }
 
-fn serialize_u32<S: Serializer>(&&s: S, v: u32) {
+pub fn serialize_u32<S: Serializer>(&&s: S, v: u32) {
     s.emit_u32(v);
 }
 
-fn deserialize_u32<D: Deserializer>(&&d: D) -> u32 {
+pub fn deserialize_u32<D: Deserializer>(&&d: D) -> u32 {
     d.read_u32()
 }
 
-fn serialize_u64<S: Serializer>(&&s: S, v: u64) {
+pub fn serialize_u64<S: Serializer>(&&s: S, v: u64) {
     s.emit_u64(v);
 }
 
-fn deserialize_u64<D: Deserializer>(&&d: D) -> u64 {
+pub fn deserialize_u64<D: Deserializer>(&&d: D) -> u64 {
     d.read_u64()
 }
 
-fn serialize_int<S: Serializer>(&&s: S, v: int) {
+pub fn serialize_int<S: Serializer>(&&s: S, v: int) {
     s.emit_int(v);
 }
 
-fn deserialize_int<D: Deserializer>(&&d: D) -> int {
+pub fn deserialize_int<D: Deserializer>(&&d: D) -> int {
     d.read_int()
 }
 
-fn serialize_i8<S: Serializer>(&&s: S, v: i8) {
+pub fn serialize_i8<S: Serializer>(&&s: S, v: i8) {
     s.emit_i8(v);
 }
 
-fn deserialize_i8<D: Deserializer>(&&d: D) -> i8 {
+pub fn deserialize_i8<D: Deserializer>(&&d: D) -> i8 {
     d.read_i8()
 }
 
-fn serialize_i16<S: Serializer>(&&s: S, v: i16) {
+pub fn serialize_i16<S: Serializer>(&&s: S, v: i16) {
     s.emit_i16(v);
 }
 
-fn deserialize_i16<D: Deserializer>(&&d: D) -> i16 {
+pub fn deserialize_i16<D: Deserializer>(&&d: D) -> i16 {
     d.read_i16()
 }
 
-fn serialize_i32<S: Serializer>(&&s: S, v: i32) {
+pub fn serialize_i32<S: Serializer>(&&s: S, v: i32) {
     s.emit_i32(v);
 }
 
-fn deserialize_i32<D: Deserializer>(&&d: D) -> i32 {
+pub fn deserialize_i32<D: Deserializer>(&&d: D) -> i32 {
     d.read_i32()
 }
 
-fn serialize_i64<S: Serializer>(&&s: S, v: i64) {
+pub fn serialize_i64<S: Serializer>(&&s: S, v: i64) {
     s.emit_i64(v);
 }
 
-fn deserialize_i64<D: Deserializer>(&&d: D) -> i64 {
+pub fn deserialize_i64<D: Deserializer>(&&d: D) -> i64 {
     d.read_i64()
 }
 
-fn serialize_str<S: Serializer>(&&s: S, v: &str) {
+pub fn serialize_str<S: Serializer>(&&s: S, v: &str) {
     s.emit_str(v);
 }
 
-fn deserialize_str<D: Deserializer>(&&d: D) -> ~str {
+pub fn deserialize_str<D: Deserializer>(&&d: D) -> ~str {
     d.read_str()
 }
 
-fn serialize_float<S: Serializer>(&&s: S, v: float) {
+pub fn serialize_float<S: Serializer>(&&s: S, v: float) {
     s.emit_float(v);
 }
 
-fn deserialize_float<D: Deserializer>(&&d: D) -> float {
+pub fn deserialize_float<D: Deserializer>(&&d: D) -> float {
     d.read_float()
 }
 
-fn serialize_f32<S: Serializer>(&&s: S, v: f32) {
+pub fn serialize_f32<S: Serializer>(&&s: S, v: f32) {
     s.emit_f32(v);
 }
 
-fn deserialize_f32<D: Deserializer>(&&d: D) -> f32 {
+pub fn deserialize_f32<D: Deserializer>(&&d: D) -> f32 {
     d.read_f32()
 }
 
-fn serialize_f64<S: Serializer>(&&s: S, v: f64) {
+pub fn serialize_f64<S: Serializer>(&&s: S, v: f64) {
     s.emit_f64(v);
 }
 
-fn deserialize_f64<D: Deserializer>(&&d: D) -> f64 {
+pub fn deserialize_f64<D: Deserializer>(&&d: D) -> f64 {
     d.read_f64()
 }
 
-fn serialize_bool<S: Serializer>(&&s: S, v: bool) {
+pub fn serialize_bool<S: Serializer>(&&s: S, v: bool) {
     s.emit_bool(v);
 }
 
-fn deserialize_bool<D: Deserializer>(&&d: D) -> bool {
+pub fn deserialize_bool<D: Deserializer>(&&d: D) -> bool {
     d.read_bool()
 }
 
-fn serialize_Option<S: Serializer,T>(&&s: S, &&v: Option<T>, st: fn(&&x: T)) {
+pub fn serialize_Option<S: Serializer,T>(&&s: S, &&v: Option<T>, st: fn(&&x: T)) {
     do s.emit_enum(~"option") {
         match v {
           None => do s.emit_enum_variant(~"none", 0u, 0u) {
@@ -254,7 +254,7 @@ fn serialize_Option<S: Serializer,T>(&&s: S, &&v: Option<T>, st: fn(&&x: T)) {
     }
 }
 
-fn deserialize_Option<D: Deserializer,T: Copy>(&&d: D, st: fn() -> T)
+pub fn deserialize_Option<D: Deserializer,T: Copy>(&&d: D, st: fn() -> T)
     -> Option<T> {
     do d.read_enum(~"option") {
         do d.read_enum_variant |i| {