---

yaml
---
r: 32975
b: refs/heads/dist-snap
c: 9ff95e2
h: refs/heads/master
i:
  32973: 606a1fb
  32971: b6505fd
  32967: 32cd8bf
  32959: bbf5541
v: v3

Author: catamorphism

[refs]

@@ -7,6 +7,6 @@ refs/tags/release-0.1: 1f5c5126e96c79d22cb7862f75304136e204f105
 refs/heads/ndm: f3868061cd7988080c30d6d5bf352a5a5fe2460b
 refs/heads/try2: d0c6ce338884ee21843f4b40bf6bf18d222ce5df
 refs/heads/incoming: d9317a174e434d4c99fc1a37fd7dc0d2f5328d37
-refs/heads/dist-snap: 314805d3aed2f534448e06bc9e4bff6007a0ef35
+refs/heads/dist-snap: 9ff95e29b3ae9e3de405680ddb6557da72cc25f7
 refs/tags/release-0.2: c870d2dffb391e14efb05aa27898f1f6333a9596
 refs/tags/release-0.3: b5f0d0f648d9a6153664837026ba1be43d3e2503

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

@@ -292,7 +292,7 @@ impl Writer {
         self.writer.write(b);
     }
 
-    fn wr_str(s: ~str) {
+    fn wr_str(s: &str) {
         debug!("Write str: %?", s);
         self.writer.write(str::to_bytes(s));
     }
@@ -418,7 +418,7 @@ fn ebml_deserializer(d: ebml::Doc) -> EbmlDeserializer {
 }
 
 priv impl EbmlDeserializer {
-    fn _check_label(lbl: ~str) {
+    fn _check_label(lbl: &str) {
         if self.pos < self.parent.end {
             let {tag: r_tag, doc: r_doc} =
                 ebml::doc_at(self.parent.data, self.pos);
@@ -516,7 +516,7 @@ impl EbmlDeserializer: serialization::Deserializer {
     fn read_str() -> ~str { ebml::doc_as_str(self.next_doc(EsStr)) }
 
     // Compound types:
-    fn read_enum<T>(name: ~str, f: fn() -> T) -> T {
+    fn read_enum<T>(name: &str, f: fn() -> T) -> T {
         debug!("read_enum(%s)", name);
         self._check_label(name);
         self.push_doc(self.next_doc(EsEnum), f)
@@ -565,7 +565,7 @@ impl EbmlDeserializer: serialization::Deserializer {
         f()
     }
 
-    fn read_rec_field<T>(f_name: ~str, f_idx: uint, f: fn() -> T) -> T {
+    fn read_rec_field<T>(f_name: &str, f_idx: uint, f: fn() -> T) -> T {
         debug!("read_rec_field(%s, idx=%u)", f_name, f_idx);
         self._check_label(f_name);
         f()

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

@@ -301,7 +301,7 @@ impl Serializer {
         self.writer.write(b);
     }
 
-    fn wr_str(s: ~str) {
+    fn wr_str(s: &str) {
         debug!("Write str: %?", s);
         self.writer.write(str::to_bytes(s));
     }
@@ -429,7 +429,7 @@ fn Deserializer(d: Doc) -> Deserializer {
 }
 
 priv impl Deserializer {
-    fn _check_label(lbl: ~str) {
+    fn _check_label(lbl: &str) {
         if self.pos < self.parent.end {
             let TaggedDoc { tag: r_tag, doc: r_doc } =
                 doc_at(self.parent.data, self.pos);
@@ -528,7 +528,7 @@ impl Deserializer: serialization2::Deserializer {
     fn read_str(&self) -> ~str { doc_as_str(self.next_doc(EsStr)) }
 
     // Compound types:
-    fn read_enum<T>(&self, name: ~str, f: fn() -> T) -> T {
+    fn read_enum<T>(&self, name: &str, f: fn() -> T) -> T {
         debug!("read_enum(%s)", name);
         self._check_label(name);
         self.push_doc(self.next_doc(EsEnum), f)
@@ -577,7 +577,7 @@ impl Deserializer: serialization2::Deserializer {
         f()
     }
 
-    fn read_rec_field<T>(&self, f_name: ~str, f_idx: uint,
+    fn read_rec_field<T>(&self, f_name: &str, f_idx: uint,
                          f: fn() -> T) -> T {
         debug!("read_rec_field(%s, idx=%u)", f_name, f_idx);
         self._check_label(f_name);

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

@@ -378,7 +378,7 @@ priv impl Parser {
         while char::is_whitespace(self.ch) { self.bump(); }
     }
 
-    fn parse_ident(ident: ~str, +value: Json) -> Result<Json, Error> {
+    fn parse_ident(ident: &str, +value: Json) -> Result<Json, Error> {
         if str::all(ident, |c| c == self.next_char()) {
             self.bump();
             Ok(move value)
@@ -747,7 +747,7 @@ pub impl Deserializer: serialization2::Deserializer {
         }
     }
 
-    fn read_enum<T>(&self, name: ~str, f: fn() -> T) -> T {
+    fn read_enum<T>(&self, name: &str, f: fn() -> T) -> T {
         debug!("read_enum(%s)", name);
         if name != ~"option" { fail ~"only supports the option enum" }
         f()
@@ -810,7 +810,7 @@ pub impl Deserializer: serialization2::Deserializer {
         value
     }
 
-    fn read_rec_field<T>(&self, f_name: ~str, f_idx: uint,
+    fn read_rec_field<T>(&self, f_name: &str, f_idx: uint,
                          f: fn() -> T) -> T {
         debug!("read_rec_field(%s, idx=%u)", f_name, f_idx);
         let top = self.peek();
@@ -819,7 +819,7 @@ pub impl Deserializer: serialization2::Deserializer {
                 // FIXME(#3148) This hint should not be necessary.
                 let obj: &self/~Object = obj;
 
-                match obj.find_ref(&f_name) {
+                match obj.find_ref(&(f_name.to_unique())) {
                     None => fail fmt!("no such field: %s", f_name),
                     Some(json) => {
                         self.stack.push(json);

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

@@ -72,7 +72,7 @@ fn map_slices<A: Copy Send, B: Copy Send>(
 }
 
 /// A parallel version of map.
-pub fn map<A: Copy Send, B: Copy Send>(xs: &[A], f: fn~((&A)) -> B) -> ~[B] {
+pub fn map<A: Copy Send, B: Copy Send>(xs: &[A], +f: fn~((&A)) -> B) -> ~[B] {
     vec::concat(map_slices(xs, || {
         fn~(_base: uint, slice : &[A], copy f) -> ~[B] {
             vec::map(slice, |x| f(x))
@@ -82,7 +82,7 @@ pub fn map<A: Copy Send, B: Copy Send>(xs: &[A], f: fn~((&A)) -> B) -> ~[B] {
 
 /// A parallel version of mapi.
 pub fn mapi<A: Copy Send, B: Copy Send>(xs: &[A],
-                                    f: fn~(uint, (&A)) -> B) -> ~[B] {
+                                    +f: fn~(uint, (&A)) -> B) -> ~[B] {
     let slices = map_slices(xs, || {
         fn~(base: uint, slice : &[A], copy f) -> ~[B] {
             vec::mapi(slice, |i, x| {
@@ -119,7 +119,7 @@ pub fn mapi_factory<A: Copy Send, B: Copy Send>(
 }
 
 /// Returns true if the function holds for all elements in the vector.
-pub fn alli<A: Copy Send>(xs: &[A], f: fn~(uint, (&A)) -> bool) -> bool {
+pub fn alli<A: Copy Send>(xs: &[A], +f: fn~(uint, (&A)) -> bool) -> bool {
     do vec::all(map_slices(xs, || {
         fn~(base: uint, slice : &[A], copy f) -> bool {
             vec::alli(slice, |i, x| {
@@ -130,7 +130,7 @@ pub fn alli<A: Copy Send>(xs: &[A], f: fn~(uint, (&A)) -> bool) -> bool {
 }
 
 /// Returns true if the function holds for any elements in the vector.
-pub fn any<A: Copy Send>(xs: &[A], f: fn~(&(A)) -> bool) -> bool {
+pub fn any<A: Copy Send>(xs: &[A], +f: fn~(&(A)) -> bool) -> bool {
     do vec::any(map_slices(xs, || {
         fn~(_base : uint, slice: &[A], copy f) -> bool {
             vec::any(slice, |x| f(x))

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

@@ -63,15 +63,15 @@ trait Deserializer {
     fn read_float() -> float;
 
     // Compound types:
-    fn read_enum<T>(name: ~str, f: fn() -> T) -> T;
+    fn read_enum<T>(name: &str, f: fn() -> T) -> T;
     fn read_enum_variant<T>(f: fn(uint) -> T) -> T;
     fn read_enum_variant_arg<T>(idx: uint, f: fn() -> T) -> T;
     fn read_vec<T>(f: fn(uint) -> T) -> T;
     fn read_vec_elt<T>(idx: uint, f: fn() -> T) -> T;
     fn read_box<T>(f: fn() -> T) -> T;
     fn read_uniq<T>(f: fn() -> T) -> T;
     fn read_rec<T>(f: fn() -> T) -> T;
-    fn read_rec_field<T>(f_name: ~str, f_idx: uint, f: fn() -> T) -> T;
+    fn read_rec_field<T>(f_name: &str, f_idx: uint, f: fn() -> T) -> T;
     fn read_tup<T>(sz: uint, f: fn() -> T) -> T;
     fn read_tup_elt<T>(idx: uint, f: fn() -> T) -> T;
 }

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

@@ -60,15 +60,15 @@ pub trait Deserializer {
     fn read_str(&self) -> ~str;
 
     // Compound types:
-    fn read_enum<T>(&self, name: ~str, f: fn() -> T) -> T;
+    fn read_enum<T>(&self, name: &str, f: fn() -> T) -> T;
     fn read_enum_variant<T>(&self, f: fn(uint) -> T) -> T;
     fn read_enum_variant_arg<T>(&self, idx: uint, f: fn() -> T) -> T;
     fn read_vec<T>(&self, f: fn(uint) -> T) -> T;
     fn read_vec_elt<T>(&self, idx: uint, f: fn() -> T) -> T;
     fn read_box<T>(&self, f: fn() -> T) -> T;
     fn read_uniq<T>(&self, f: fn() -> T) -> T;
     fn read_rec<T>(&self, f: fn() -> T) -> T;
-    fn read_rec_field<T>(&self, f_name: ~str, f_idx: uint, f: fn() -> T) -> T;
+    fn read_rec_field<T>(&self, f_name: &str, f_idx: uint, f: fn() -> T) -> T;
     fn read_tup<T>(&self, sz: uint, f: fn() -> T) -> T;
     fn read_tup_elt<T>(&self, idx: uint, f: fn() -> T) -> T;
 }