---

yaml
---
r: 102129
b: refs/heads/master
c: 768b96e
h: refs/heads/master
i:
  102127: 1297c67
v: v3

Author: huonw

[refs]

@@ -1,5 +1,5 @@
 ---
-refs/heads/master: 68a4f7d9babb0c638f3425ced08e13f9fbfdcf56
+refs/heads/master: 768b96e8b14b58f9450cdf02199149a8a7b255b4
 refs/heads/snap-stage1: e33de59e47c5076a89eadeb38f4934f58a3618a6
 refs/heads/snap-stage3: 6e7f170fedd3c526a643c0b2d13863acd982be02
 refs/heads/try: a97642026c18a624ff6ea01075dd9550f8ed07ff

trunk/src/compiletest/procsrv.rs

@@ -9,8 +9,9 @@
 // except according to those terms.
 
 use std::os;
+use std::run;
 use std::str;
-use std::io::process::{ProcessExit, Process, ProcessConfig, ProcessOutput};
+use std::io::process::ProcessExit;
 
 #[cfg(target_os = "win32")]
 fn target_env(lib_path: &str, prog: &str) -> ~[(~str,~str)] {
@@ -48,19 +49,17 @@ pub fn run(lib_path: &str,
            input: Option<~str>) -> Option<Result> {
 
     let env = env + target_env(lib_path, prog);
-    let mut opt_process = Process::configure(ProcessConfig {
-        program: prog,
-        args: args,
-        env: Some(env.as_slice()),
-        .. ProcessConfig::new()
+    let mut opt_process = run::Process::new(prog, args, run::ProcessOptions {
+        env: Some(env),
+        .. run::ProcessOptions::new()
     });
 
     match opt_process {
         Ok(ref mut process) => {
             for input in input.iter() {
-                process.stdin.get_mut_ref().write(input.as_bytes()).unwrap();
+                process.input().write(input.as_bytes()).unwrap();
             }
-            let ProcessOutput { status, output, error } = process.wait_with_output();
+            let run::ProcessOutput { status, output, error } = process.finish_with_output();
 
             Some(Result {
                 status: status,
@@ -76,20 +75,18 @@ pub fn run_background(lib_path: &str,
            prog: &str,
            args: &[~str],
            env: ~[(~str, ~str)],
-           input: Option<~str>) -> Option<Process> {
+           input: Option<~str>) -> Option<run::Process> {
 
     let env = env + target_env(lib_path, prog);
-    let opt_process = Process::configure(ProcessConfig {
-        program: prog,
-        args: args,
-        env: Some(env.as_slice()),
-        .. ProcessConfig::new()
+    let opt_process = run::Process::new(prog, args, run::ProcessOptions {
+        env: Some(env),
+        .. run::ProcessOptions::new()
     });
 
     match opt_process {
         Ok(mut process) => {
             for input in input.iter() {
-                process.stdin.get_mut_ref().write(input.as_bytes()).unwrap();
+                process.input().write(input.as_bytes()).unwrap();
             }
 
             Some(process)

trunk/src/compiletest/runtest.rs

@@ -360,7 +360,7 @@ fn run_debuginfo_test(config: &config, props: &TestProps, testfile: &Path) {
                                stdout: out,
                                stderr: err,
                                cmdline: cmdline};
-            process.signal_kill().unwrap();
+            process.force_destroy().unwrap();
         }
 
         _=> {

trunk/src/doc/complement-cheatsheet.md

@@ -211,7 +211,7 @@ Description            C signature                                    Equivalent
 ---------------------- ---------------------------------------------- ------------------------------------------
 no parameters          `void foo(void);`                              `fn foo();`
 return value           `int foo(void);`                               `fn foo() -> c_int;`
-function parameters    `void foo(int x, int y);`                      `fn foo(x: c_int, y: c_int);`
+function parameters    `void foo(int x, int y);`                      `fn foo(x: int, y: int);`
 in-out pointers        `void foo(const int* in_ptr, int* out_ptr);`   `fn foo(in_ptr: *c_int, out_ptr: *mut c_int);`
 
 Note: The Rust signatures should be wrapped in an `extern "ABI" { ... }` block.

trunk/src/doc/guide-container.md

@@ -38,7 +38,7 @@ order.
 Each `HashMap` instance has a random 128-bit key to use with a keyed hash,
 making the order of a set of keys in a given hash table randomized. Rust
 provides a [SipHash](https://131002.net/siphash/) implementation for any type
-implementing the `Hash` trait.
+implementing the `IterBytes` trait.
 
 ## Double-ended queues
 
@@ -186,12 +186,12 @@ let mut calls = 0;
     let it = xs.iter().scan((), |_, x| {
         calls += 1;
         if *x < 3 { Some(x) } else { None }});
-
+        
     // the iterator will only yield 1 and 2 before returning None
     // If we were to call it 5 times, calls would end up as 5, despite
     // only 2 values being yielded (and therefore 3 unique calls being
     // made). The fuse() adaptor can fix this.
-
+    
     let mut it = it.fuse();
     it.next();
     it.next();

trunk/src/doc/po/ja/tutorial.md.po

@@ -4421,15 +4421,15 @@ msgstr ""
 #, fuzzy
 #| msgid ""
 #| "The full list of derivable traits is `Eq`, `TotalEq`, `Ord`, `TotalOrd`, "
-#| "`Encodable` `Decodable`, `Clone`, `DeepClone`, `Hash`, `Rand`, "
+#| "`Encodable` `Decodable`, `Clone`, `DeepClone`, `IterBytes`, `Rand`, "
 #| "`Zero`, and `ToStr`."
 msgid ""
 "The full list of derivable traits is `Eq`, `TotalEq`, `Ord`, `TotalOrd`, "
-"`Encodable` `Decodable`, `Clone`, `DeepClone`, `Hash`, `Rand`, "
+"`Encodable` `Decodable`, `Clone`, `DeepClone`, `IterBytes`, `Rand`, "
 "`Default`, `Zero`, and `ToStr`."
 msgstr ""
 "実装を自動的に導出可能なトレイトは、 `Eq`, `TotalEq`, `Ord`, `TotalOrd`, "
-"`Encodable` `Decodable`, `Clone`, `DeepClone`, `Hash`, `Rand`, `Zero`, "
+"`Encodable` `Decodable`, `Clone`, `DeepClone`, `IterBytes`, `Rand`, `Zero`, "
 "および `ToStr` です。."
 
 #. type: Plain text

trunk/src/doc/rust.md

@@ -2035,7 +2035,7 @@ Supported traits for `deriving` are:
 * Comparison traits: `Eq`, `TotalEq`, `Ord`, `TotalOrd`.
 * Serialization: `Encodable`, `Decodable`. These require `serialize`.
 * `Clone` and `DeepClone`, to perform (deep) copies.
-* `Hash`, to iterate over the bytes in a data type.
+* `IterBytes`, to iterate over the bytes in a data type.
 * `Rand`, to create a random instance of a data type.
 * `Default`, to create an empty instance of a data type.
 * `Zero`, to create an zero instance of a numeric data type.

trunk/src/doc/tutorial.md

@@ -1026,7 +1026,7 @@ type was invalid because the size was infinite!
 
 An *owned box* (`~`) uses a dynamic memory allocation to provide the invariant
 of always being the size of a pointer, regardless of the contained type. This
-can be leveraged to create a valid `List` definition:
+can be leverage to create a valid `List` definition:
 
 ~~~
 enum List {
@@ -2519,13 +2519,13 @@ of type `ABC` can be randomly generated and converted to a string:
 #[deriving(Eq)]
 struct Circle { radius: f64 }
 
-#[deriving(Rand, Show)]
+#[deriving(Rand, ToStr)]
 enum ABC { A, B, C }
 ~~~
 
 The full list of derivable traits is `Eq`, `TotalEq`, `Ord`,
 `TotalOrd`, `Encodable` `Decodable`, `Clone`, `DeepClone`,
-`Hash`, `Rand`, `Default`, `Zero`, `FromPrimitive` and `Show`.
+`IterBytes`, `Rand`, `Default`, `Zero`, `FromPrimitive` and `Show`.
 
 # Crates and the module system
 

trunk/src/etc/vim/syntax/rust.vim

@@ -93,6 +93,7 @@ syn keyword rustTrait GenericPath Path PosixPath WindowsPath
 syn keyword rustTrait RawPtr
 syn keyword rustTrait Buffer Writer Reader Seek
 syn keyword rustTrait Str StrVector StrSlice OwnedStr IntoMaybeOwned
+syn keyword rustTrait IterBytes
 syn keyword rustTrait ToStr IntoStr
 syn keyword rustTrait Tuple1 Tuple2 Tuple3 Tuple4
 syn keyword rustTrait Tuple5 Tuple6 Tuple7 Tuple8

trunk/src/libcollections/btree.rs

@@ -18,8 +18,7 @@
 ///a length (the height of the tree), and lower and upper bounds on the
 ///number of elements that a given node can contain.
 
-use std::fmt;
-use std::fmt::Show;
+use std::vec::OwnedVector;
 
 #[allow(missing_doc)]
 pub struct BTree<K, V> {
@@ -107,10 +106,11 @@ impl<K: TotalOrd, V: TotalEq> TotalOrd for BTree<K, V> {
     }
 }
 
-impl<K: fmt::Show + TotalOrd, V: fmt::Show> fmt::Show for BTree<K, V> {
+impl<K: ToStr + TotalOrd, V: ToStr> ToStr for BTree<K, V> {
     ///Returns a string representation of the BTree
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        self.root.fmt(f)
+    fn to_str(&self) -> ~str {
+        let ret = self.root.to_str();
+        ret
     }
 }
 
@@ -235,15 +235,15 @@ impl<K: TotalOrd, V: TotalEq> TotalOrd for Node<K, V> {
     }
 }
 
-impl<K: fmt::Show + TotalOrd, V: fmt::Show> fmt::Show for Node<K, V> {
+impl<K: ToStr + TotalOrd, V: ToStr> ToStr for Node<K, V> {
     ///Returns a string representation of a Node.
     ///Will iterate over the Node and show "Key: x, value: y, child: () // "
     ///for all elements in the Node. "Child" only exists if the Node contains
     ///a branch.
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+    fn to_str(&self) -> ~str {
         match *self {
-            LeafNode(ref leaf) => leaf.fmt(f),
-            BranchNode(ref branch) => branch.fmt(f),
+            LeafNode(ref leaf) => leaf.to_str(),
+            BranchNode(ref branch) => branch.to_str()
         }
     }
 }
@@ -401,14 +401,10 @@ impl<K: TotalOrd, V: TotalEq> TotalOrd for Leaf<K, V> {
 }
 
 
-impl<K: fmt::Show + TotalOrd, V: fmt::Show> fmt::Show for Leaf<K, V> {
+impl<K: ToStr + TotalOrd, V: ToStr> ToStr for Leaf<K, V> {
     ///Returns a string representation of a Leaf.
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        for (i, s) in self.elts.iter().enumerate() {
-            if i != 0 { try!(write!(f.buf, " // ")) }
-            try!(write!(f.buf, "{}", *s))
-        }
-        Ok(())
+    fn to_str(&self) -> ~str {
+        self.elts.iter().map(|s| s.to_str()).to_owned_vec().connect(" // ")
     }
 }
 
@@ -622,14 +618,13 @@ impl<K: TotalOrd, V: TotalEq> TotalOrd for Branch<K, V> {
     }
 }
 
-impl<K: fmt::Show + TotalOrd, V: fmt::Show> fmt::Show for Branch<K, V> {
+impl<K: ToStr + TotalOrd, V: ToStr> ToStr for Branch<K, V> {
     ///Returns a string representation of a Branch.
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        for (i, s) in self.elts.iter().enumerate() {
-            if i != 0 { try!(write!(f.buf, " // ")) }
-            try!(write!(f.buf, "{}", *s))
-        }
-        write!(f.buf, " // rightmost child: ({}) ", *self.rightmost_child)
+    fn to_str(&self) -> ~str {
+        let mut ret = self.elts.iter().map(|s| s.to_str()).to_owned_vec().connect(" // ");
+        ret.push_str(" // ");
+        ret.push_str("rightmost child: ("+ self.rightmost_child.to_str() +") ");
+        ret
     }
 }
 
@@ -677,10 +672,11 @@ impl<K: TotalOrd, V: TotalEq> TotalOrd for LeafElt<K, V> {
     }
 }
 
-impl<K: fmt::Show + TotalOrd, V: fmt::Show> fmt::Show for LeafElt<K, V> {
+impl<K: ToStr + TotalOrd, V: ToStr> ToStr for LeafElt<K, V> {
     ///Returns a string representation of a LeafElt.
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        write!(f.buf, "Key: {}, value: {};", self.key, self.value)
+    fn to_str(&self) -> ~str {
+        format!("Key: {}, value: {};",
+            self.key.to_str(), self.value.to_str())
     }
 }
 
@@ -719,12 +715,12 @@ impl<K: TotalOrd, V: TotalEq> TotalOrd for BranchElt<K, V> {
     }
 }
 
-impl<K: fmt::Show + TotalOrd, V: fmt::Show> fmt::Show for BranchElt<K, V> {
-    /// Returns string containing key, value, and child (which should recur to a
-    /// leaf) Consider changing in future to be more readable.
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        write!(f.buf, "Key: {}, value: {}, (child: {})",
-               self.key, self.value, *self.left)
+impl<K: ToStr + TotalOrd, V: ToStr> ToStr for BranchElt<K, V> {
+    ///Returns string containing key, value, and child (which should recur to a leaf)
+    ///Consider changing in future to be more readable.
+    fn to_str(&self) -> ~str {
+        format!("Key: {}, value: {}, (child: {})",
+            self.key.to_str(), self.value.to_str(), self.left.to_str())
     }
 }
 

trunk/src/libcollections/enum_set.rs

@@ -15,7 +15,7 @@
 
 use std::num::Bitwise;
 
-#[deriving(Clone, Eq, Hash, Show, Encodable, Decodable)]
+#[deriving(Clone, Eq, IterBytes, ToStr, Encodable, Decodable)]
 /// A specialized Set implementation to use enum types.
 pub struct EnumSet<E> {
     // We must maintain the invariant that no bits are set