---

yaml
---
r: 75775
b: refs/heads/master
c: 00dd9e9
h: refs/heads/master
i:
  75773: 45bb3da
  75771: d4b2657
  75767: 511cd64
  75759: 7a1f493
  75743: 5ba28a0
  75711: 50e4b47
  75647: 81f4035
  75519: 44f5850
  75263: 293f921
  74751: 40c4c83
  73727: d50f3f3
v: v3

Author: bors

[refs]

@@ -1,5 +1,5 @@
 ---
-refs/heads/master: 0f6e90a5fd7a19382e3d3028bfcc36eb57135515
+refs/heads/master: 00dd9e9cc57d1925df8362d02c6504b01d8105e3
 refs/heads/snap-stage1: e33de59e47c5076a89eadeb38f4934f58a3618a6
 refs/heads/snap-stage3: 67c954e365970e4c2cd06f0c50724656d7010f45
 refs/heads/try: 10089455287dcc3652b984ab4bfd6971e1b5f302

trunk/configure

@@ -739,7 +739,6 @@ do
     make_dir $h/test/doc-tutorial-ffi
     make_dir $h/test/doc-tutorial-macros
     make_dir $h/test/doc-tutorial-borrowed-ptr
-    make_dir $h/test/doc-tutorial-container
     make_dir $h/test/doc-tutorial-tasks
     make_dir $h/test/doc-tutorial-conditions
     make_dir $h/test/doc-rust

trunk/doc/rust.md

@@ -2864,16 +2864,17 @@ the vtable pointer for the `T` implementation of `R`, and the pointer value of `
 An example of an object type:
 
 ~~~~~~~~
+# use std::int;
 trait Printable {
-  fn to_string(&self) -> ~str;
+  fn to_str(&self) -> ~str;
 }
 
 impl Printable for int {
-  fn to_string(&self) -> ~str { self.to_str() }
+  fn to_str(&self) -> ~str { int::to_str(*self) }
 }
 
 fn print(a: @Printable) {
-   println(a.to_string());
+   println(a.to_str());
 }
 
 fn main() {

trunk/doc/tutorial-container.md

@@ -163,7 +163,7 @@ assert_eq!(sum, 57);
 The `for` keyword can be used as sugar for iterating through any iterator:
 
 ~~~
-let xs = [2u, 3, 5, 7, 11, 13, 17];
+let xs = [2, 3, 5, 7, 11, 13, 17];
 
 // print out all the elements in the vector
 for x in xs.iter() {
@@ -219,7 +219,7 @@ Containers can provide conversion from iterators through `collect` by
 implementing the `FromIterator` trait. For example, the implementation for
 vectors is as follows:
 
-~~~ {.xfail-test}
+~~~
 impl<A> FromIterator<A> for ~[A] {
     pub fn from_iterator<T: Iterator<A>>(iterator: &mut T) -> ~[A] {
         let (lower, _) = iterator.size_hint();
@@ -237,7 +237,7 @@ impl<A> FromIterator<A> for ~[A] {
 The `Iterator` trait provides a `size_hint` default method, returning a lower
 bound and optionally on upper bound on the length of the iterator:
 
-~~~ {.xfail-test}
+~~~
 fn size_hint(&self) -> (uint, Option<uint>) { (0, None) }
 ~~~
 
@@ -319,16 +319,6 @@ for x in it.invert() {
 }
 ~~~
 
-The `reverse_` method is also available for any double-ended iterator yielding
-mutable references. It can be used to reverse a container in-place. Note that
-the trailing underscore is a workaround for issue #5898 and will be removed.
-
-~~~
-let mut ys = [1, 2, 3, 4, 5];
-ys.mut_iter().reverse_();
-assert_eq!(ys, [5, 4, 3, 2, 1]);
-~~~
-
 ## Random-access iterators
 
 The `RandomAccessIterator` trait represents an iterator offering random access

trunk/doc/tutorial.md

@@ -555,11 +555,12 @@ while cake_amount > 0 {
 `loop` denotes an infinite loop, and is the preferred way of writing `while true`:
 
 ~~~~
-let mut x = 5u;
+use std::int;
+let mut x = 5;
 loop {
     x += x - 3;
     if x % 5 == 0 { break; }
-    println(x.to_str());
+    println(int::to_str(x));
 }
 ~~~~
 

trunk/mk/tests.mk

@@ -20,7 +20,7 @@ TEST_CRATES = $(TEST_TARGET_CRATES) $(TEST_HOST_CRATES)
 
 # Markdown files under doc/ that should have their code extracted and run
 DOC_TEST_NAMES = tutorial tutorial-ffi tutorial-macros tutorial-borrowed-ptr \
-                 tutorial-tasks tutorial-conditions tutorial-container rust
+                 tutorial-tasks tutorial-conditions rust
 
 ######################################################################
 # Environment configuration

trunk/src/libextra/crypto/digest.rs

@@ -8,6 +8,7 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
+use std::uint;
 use std::vec;
 
 
@@ -70,7 +71,7 @@ pub trait Digest {
 fn to_hex(rr: &[u8]) -> ~str {
     let mut s = ~"";
     for b in rr.iter() {
-        let hex = (*b as uint).to_str_radix(16u);
+        let hex = uint::to_str_radix(*b as uint, 16u);
         if hex.len() == 1 {
             s.push_char('0');
         }

trunk/src/libextra/extra.rs

@@ -55,6 +55,7 @@ pub mod flatpipes;
 
 pub mod container;
 pub mod bitv;
+pub mod fun_treemap;
 pub mod list;
 pub mod ringbuf;
 pub mod priority_queue;

trunk/src/libextra/fun_treemap.rs

@@ -0,0 +1,84 @@
+// Copyright 2012 The Rust Project Developers. See the COPYRIGHT
+// file at the top-level directory of this distribution and at
+// http://rust-lang.org/COPYRIGHT.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+/*!
+ * A functional key,value store that works on anything.
+ *
+ * This works using a binary search tree. In the first version, it's a
+ * very naive algorithm, but it will probably be updated to be a
+ * red-black tree or something else.
+ *
+ * This is copied and modified from treemap right now. It's missing a lot
+ * of features.
+ */
+
+
+use std::cmp::{Eq, Ord};
+use std::option::{Some, None};
+
+pub type Treemap<K, V> = @TreeNode<K, V>;
+
+enum TreeNode<K, V> {
+    Empty,
+    Node(@K, @V, @TreeNode<K, V>, @TreeNode<K, V>)
+}
+
+/// Create a treemap
+pub fn init<K: 'static, V: 'static>() -> Treemap<K, V> {
+    @Empty
+}
+
+/// Insert a value into the map
+pub fn insert<K:Eq + Ord + 'static,
+              V:'static>(
+              m: Treemap<K, V>,
+              k: K,
+              v: V)
+              -> Treemap<K, V> {
+    @match m {
+        @Empty => Node(@k, @v, @Empty, @Empty),
+        @Node(kk, vv, left, right) => cond!(
+            (k <  *kk) { Node(kk, vv, insert(left, k, v), right) }
+            (k == *kk) { Node(kk, @v, left, right)               }
+            _          { Node(kk, vv, left, insert(right, k, v)) }
+        )
+    }
+}
+
+/// Find a value based on the key
+pub fn find<K:Eq + Ord + 'static,
+            V:Clone + 'static>(
+            m: Treemap<K, V>,
+            k: K)
+            -> Option<V> {
+    match *m {
+        Empty => None,
+        Node(kk, v, left, right) => cond!(
+            (k == *kk) { Some((*v).clone()) }
+            (k <  *kk) { find(left, k)  }
+            _          { find(right, k) }
+        )
+    }
+}
+
+/// Visit all pairs in the map in order.
+pub fn traverse<K, V>(m: Treemap<K, V>, f: &fn(&K, &V)) {
+    match *m {
+        Empty => (),
+        // Previously, this had what looked like redundant
+        // matches to me, so I changed it. but that may be a
+        // de-optimization -- tjc
+        Node(@ref k, @ref v, left, right) => {
+            traverse(left, |k,v| f(k,v));
+            f(k, v);
+            traverse(right, |k,v| f(k,v));
+        }
+    }
+}

trunk/src/libextra/md4.rs

@@ -9,6 +9,7 @@
 // except according to those terms.
 
 
+use std::uint;
 use std::vec;
 
 struct Quad {
@@ -120,7 +121,7 @@ pub fn md4_str(msg: &[u8]) -> ~str {
             if byte <= 16u8 {
                 result.push_char('0')
             }
-            result.push_str((byte as uint).to_str_radix(16u));
+            result.push_str(uint::to_str_radix(byte as uint, 16u));
             i += 1u32;
         }
     }

trunk/src/libextra/num/bigint.rs

@@ -525,7 +525,7 @@ impl ToStrRadix for BigUint {
             if v.is_empty() { return ~"0" }
             let mut s = str::with_capacity(v.len() * l);
             for n in v.rev_iter() {
-                let ss = (*n as uint).to_str_radix(radix);
+                let ss = uint::to_str_radix(*n as uint, radix);
                 s.push_str("0".repeat(l - ss.len()));
                 s.push_str(ss);
             }

trunk/src/libextra/time.rs

@@ -10,6 +10,8 @@
 
 #[allow(missing_doc)];
 
+
+use std::int;
 use std::io;
 use std::num;
 use std::str;
@@ -822,7 +824,7 @@ fn do_strftime(format: &str, tm: &Tm) -> ~str {
           //'U' {}
           'u' => {
             let i = tm.tm_wday as int;
-            (if i == 0 { 7 } else { i }).to_str()
+            int::to_str(if i == 0 { 7 } else { i })
           }
           //'V' {}
           'v' => {
@@ -832,10 +834,10 @@ fn do_strftime(format: &str, tm: &Tm) -> ~str {
                 parse_type('Y', tm))
           }
           //'W' {}
-          'w' => (tm.tm_wday as int).to_str(),
+          'w' => int::to_str(tm.tm_wday as int),
           //'X' {}
           //'x' {}
-          'Y' => (tm.tm_year as int + 1900).to_str(),
+          'Y' => int::to_str(tm.tm_year as int + 1900),
           'y' => fmt!("%02d", (tm.tm_year as int + 1900) % 100),
           'Z' => tm.tm_zone.clone(),
           'z' => {

trunk/src/librustc/driver/driver.rs

@@ -26,6 +26,7 @@ use util::common::time;
 use util::ppaux;
 
 use std::hashmap::{HashMap,HashSet};
+use std::int;
 use std::io;
 use std::os;
 use std::vec;
@@ -453,21 +454,21 @@ pub fn pretty_print_input(sess: Session, cfg: ast::CrateConfig, input: &input,
         match node {
           pprust::node_item(s, item) => {
             pp::space(s.s);
-            pprust::synth_comment(s, item.id.to_str());
+            pprust::synth_comment(s, int::to_str(item.id));
           }
           pprust::node_block(s, ref blk) => {
             pp::space(s.s);
             pprust::synth_comment(
-                s, ~"block " + blk.id.to_str());
+                s, ~"block " + int::to_str(blk.id));
           }
           pprust::node_expr(s, expr) => {
             pp::space(s.s);
-            pprust::synth_comment(s, expr.id.to_str());
+            pprust::synth_comment(s, int::to_str(expr.id));
             pprust::pclose(s);
           }
           pprust::node_pat(s, pat) => {
             pp::space(s.s);
-            pprust::synth_comment(s, ~"pat " + pat.id.to_str());
+            pprust::synth_comment(s, ~"pat " + int::to_str(pat.id));
           }
         }
     }

trunk/src/librustc/metadata/encoder.rs

@@ -25,6 +25,7 @@ use std::hash::HashUtil;
 use std::hashmap::{HashMap, HashSet};
 use std::io;
 use std::str;
+use std::uint;
 use std::vec;
 use extra::flate;
 use extra::serialize::Encodable;
@@ -302,7 +303,7 @@ fn encode_disr_val(_: &EncodeContext,
                    ebml_w: &mut writer::Encoder,
                    disr_val: uint) {
     ebml_w.start_tag(tag_disr_val);
-    let s = disr_val.to_str();
+    let s = uint::to_str(disr_val);
     ebml_w.writer.write(s.as_bytes());
     ebml_w.end_tag();
 }

trunk/src/librustc/metadata/tyencode.rs

@@ -17,6 +17,7 @@ use middle::ty;
 use std::hashmap::HashMap;
 use std::io::WriterUtil;
 use std::io;
+use std::uint;
 use syntax::abi::AbiSet;
 use syntax::ast;
 use syntax::ast::*;
@@ -323,7 +324,7 @@ fn enc_sty(w: @io::Writer, cx: @ctxt, st: &ty::sty) {
         w.write_char('p');
         w.write_str((cx.ds)(did));
         w.write_char('|');
-        w.write_str(id.to_str());
+        w.write_str(uint::to_str(id));
       }
       ty::ty_self(did) => {
         w.write_char('s');

trunk/src/librustc/middle/trans/base.rs

@@ -71,6 +71,7 @@ use std::hash;
 use std::hashmap::HashMap;
 use std::io;
 use std::libc::c_uint;
+use std::uint;
 use std::vec;
 use std::local_data;
 use extra::time;
@@ -718,7 +719,7 @@ pub fn iter_structural_ty(cx: @mut Block, av: ValueRef, t: ty::t,
                   for variant in (*variants).iter() {
                       let variant_cx =
                           sub_block(cx, ~"enum-iter-variant-" +
-                                    variant.disr_val.to_str());
+                                    uint::to_str(variant.disr_val));
                       let variant_cx =
                           iter_variant(variant_cx, repr, av, *variant,
                                        substs.tps, |x,y,z| f(x,y,z));

trunk/src/librustc/middle/ty.rs

@@ -33,6 +33,7 @@ use std::ops;
 use std::ptr::to_unsafe_ptr;
 use std::to_bytes;
 use std::to_str::ToStr;
+use std::u32;
 use std::vec;
 use syntax::ast::*;
 use syntax::ast_util::is_local;
@@ -1943,7 +1944,7 @@ impl ops::Sub<TypeContents,TypeContents> for TypeContents {
 
 impl ToStr for TypeContents {
     fn to_str(&self) -> ~str {
-        fmt!("TypeContents(%s)", self.bits.to_str_radix(2))
+        fmt!("TypeContents(%s)", u32::to_str_radix(self.bits, 2))
     }
 }
 

trunk/src/librustc/middle/typeck/infer/to_str.rs

@@ -17,6 +17,7 @@ use middle::typeck::infer::InferCtxt;
 use middle::typeck::infer::unify::{Redirect, Root, VarValue};
 use util::ppaux::{mt_to_str, ty_to_str, trait_ref_to_str};
 
+use std::uint;
 use syntax::ast;
 
 pub trait InferStr {
@@ -71,7 +72,7 @@ impl<V:Vid + ToStr,T:InferStr> InferStr for VarValue<V, T> {
         match *self {
           Redirect(ref vid) => fmt!("Redirect(%s)", vid.to_str()),
           Root(ref pt, rk) => fmt!("Root(%s, %s)", pt.inf_str(cx),
-                               rk.to_str_radix(10u))
+                               uint::to_str_radix(rk, 10u))
         }
     }
 }

trunk/src/libstd/container.rs

@@ -38,7 +38,6 @@ pub trait Map<K, V>: Container {
     fn find<'a>(&'a self, key: &K) -> Option<&'a V>;
 
     /// Return true if the map contains a value for the specified key
-    #[inline]
     fn contains_key(&self, key: &K) -> bool {
         self.find(key).is_some()
     }