Move off unstable APIs where possible

Author: alexcrichton

src/base64.rs

@@ -113,7 +113,7 @@ impl ToBase64 for [u8] {
             let (first, second, third) = (self[i], self[i + 1], self[i + 2]);
             if let Some(line_length) = config.line_length {
                 if cur_length >= line_length {
-                    v.push_all(newline);
+                    v.extend(newline.iter().map(|x| *x));
                     cur_length = 0;
                 }
             }
@@ -135,7 +135,7 @@ impl ToBase64 for [u8] {
         if mod_len != 0 {
             if let Some(line_length) = config.line_length {
                 if cur_length >= line_length {
-                    v.push_all(newline);
+                    v.extend(newline.iter().map(|x| *x));
                 }
             }
         }
@@ -230,7 +230,7 @@ impl FromBase64 for str {
     /// fn main () {
     ///     let hello_str = b"Hello, World".to_base64(STANDARD);
     ///     println!("base64 output: {}", hello_str);
-    ///     let res = hello_str.as_slice().from_base64();
+    ///     let res = hello_str.from_base64();
     ///     if res.is_ok() {
     ///       let opt_bytes = String::from_utf8(res.unwrap());
     ///       if opt_bytes.is_ok() {
@@ -330,7 +330,6 @@ mod tests {
         assert!(![08; 1000].to_base64(Config {line_length: None,
                                                  newline: Newline::LF,
                                                  ..STANDARD})
-                              .as_slice()
                               .contains("\n"));
         assert_eq!(b"foobar".to_base64(Config {line_length: Some(4),
                                                newline: Newline::LF,
@@ -398,7 +397,7 @@ mod tests {
     fn test_base64_random() {
         use rand::{thread_rng, Rng};
 
-        for _ in range(0, 1000) {
+        for _ in 0..1000 {
             let times = thread_rng().gen_range(1, 100);
             let v = thread_rng().gen_iter::<u8>().take(times)
                                 .collect::<Vec<_>>();

src/collection_impls.rs

@@ -34,7 +34,7 @@ impl<T:Decodable> Decodable for DList<T> {
     fn decode<D: Decoder>(d: &mut D) -> Result<DList<T>, D::Error> {
         d.read_seq(|d, len| {
             let mut list = DList::new();
-            for i in range(0, len) {
+            for i in 0..len {
                 list.push_back(try!(d.read_seq_elt(i, |d| Decodable::decode(d))));
             }
             Ok(list)
@@ -57,7 +57,7 @@ impl<T:Decodable> Decodable for RingBuf<T> {
     fn decode<D: Decoder>(d: &mut D) -> Result<RingBuf<T>, D::Error> {
         d.read_seq(|d, len| {
             let mut deque: RingBuf<T> = RingBuf::new();
-            for i in range(0, len) {
+            for i in 0..len {
                 deque.push_back(try!(d.read_seq_elt(i, |d| Decodable::decode(d))));
             }
             Ok(deque)
@@ -89,7 +89,7 @@ impl<
     fn decode<D: Decoder>(d: &mut D) -> Result<BTreeMap<K, V>, D::Error> {
         d.read_map(|d, len| {
             let mut map = BTreeMap::new();
-            for i in range(0, len) {
+            for i in 0..len {
                 let key = try!(d.read_map_elt_key(i, |d| Decodable::decode(d)));
                 let val = try!(d.read_map_elt_val(i, |d| Decodable::decode(d)));
                 map.insert(key, val);
@@ -120,7 +120,7 @@ impl<
     fn decode<D: Decoder>(d: &mut D) -> Result<BTreeSet<T>, D::Error> {
         d.read_seq(|d, len| {
             let mut set = BTreeSet::new();
-            for i in range(0, len) {
+            for i in 0..len {
                 set.insert(try!(d.read_seq_elt(i, |d| Decodable::decode(d))));
             }
             Ok(set)
@@ -157,7 +157,7 @@ impl<K, V, S> Decodable for HashMap<K, V, S>
         d.read_map(|d, len| {
             let state = Default::default();
             let mut map = HashMap::with_capacity_and_hash_state(len, state);
-            for i in range(0, len) {
+            for i in 0..len {
                 let key = try!(d.read_map_elt_key(i, |d| Decodable::decode(d)));
                 let val = try!(d.read_map_elt_val(i, |d| Decodable::decode(d)));
                 map.insert(key, val);
@@ -193,7 +193,7 @@ impl<T, S> Decodable for HashSet<T, S>
         d.read_seq(|d, len| {
             let state = Default::default();
             let mut set = HashSet::with_capacity_and_hash_state(len, state);
-            for i in range(0, len) {
+            for i in 0..len {
                 set.insert(try!(d.read_seq_elt(i, |d| Decodable::decode(d))));
             }
             Ok(set)
@@ -216,7 +216,7 @@ impl<V: Decodable> Decodable for VecMap<V> {
     fn decode<D: Decoder>(d: &mut D) -> Result<VecMap<V>, D::Error> {
         d.read_map(|d, len| {
             let mut map = VecMap::new();
-            for i in range(0, len) {
+            for i in 0..len {
                 let key = try!(d.read_map_elt_key(i, |d| Decodable::decode(d)));
                 let val = try!(d.read_map_elt_val(i, |d| Decodable::decode(d)));
                 map.insert(key, val);

src/hex.rs

@@ -192,14 +192,14 @@ mod tests {
 
     #[test]
     pub fn test_to_hex_all_bytes() {
-        for i in range(0, 256) {
+        for i in 0..256 {
             assert_eq!([i as u8].to_hex(), format!("{:02x}", i));
         }
     }
 
     #[test]
     pub fn test_from_hex_all_bytes() {
-        for i in range(0, 256) {
+        for i in 0..256 {
             let ii: &[u8] = &[i as u8];
             assert_eq!(format!("{:02x}", i).from_hex().unwrap(),
                        ii);

src/json.rs

@@ -108,7 +108,7 @@
 //!     let encoded = json::encode(&object).unwrap();
 //!
 //!     // Deserialize using `json::decode`
-//!     let decoded: TestStruct = json::decode(encoded.as_slice()).unwrap();
+//!     let decoded: TestStruct = json::decode(&encoded).unwrap();
 //! }
 //! ```
 //!
@@ -196,7 +196,7 @@
 //!     let json_str: String = json_obj.to_string();
 //!
 //!     // Deserialize like before
-//!     let decoded: TestStruct = json::decode(json_str.as_slice()).unwrap();
+//!     let decoded: TestStruct = json::decode(&json_str).unwrap();
 //! }
 //! ```
 //!
@@ -508,7 +508,7 @@ fn fmt_number_or_null(v: f64) -> string::String {
     use std::num::FpCategory::{Nan, Infinite};
 
     match v.classify() {
-        Nan | Infinite => string::String::from_str("null"),
+        Nan | Infinite => "null".to_string(),
         _ if v.fract() != 0f64 => f64::to_str_digits(v, 6),
         _ => f64::to_str_digits(v, 6) + ".0",
     }
@@ -922,7 +922,7 @@ impl Json {
             Ok(c)  => c,
             Err(e) => return Err(io_error_to_error(e))
         };
-        let s = match str::from_utf8(contents.as_slice()).ok() {
+        let s = match str::from_utf8(&contents).ok() {
             Some(s) => s,
             _       => return Err(SyntaxError(NotUtf8, 0, 0))
         };
@@ -1245,7 +1245,7 @@ impl Stack {
     /// Compares this stack with an array of StackElements.
     pub fn is_equal_to(&self, rhs: &[StackElement]) -> bool {
         if self.stack.len() != rhs.len() { return false; }
-        for i in range(0, rhs.len()) {
+        for i in 0..rhs.len() {
             if self.get(i) != rhs[i] { return false; }
         }
         return true;
@@ -1255,7 +1255,7 @@ impl Stack {
     /// the ones passed as parameter.
     pub fn starts_with(&self, rhs: &[StackElement]) -> bool {
         if self.stack.len() < rhs.len() { return false; }
-        for i in range(0, rhs.len()) {
+        for i in 0..rhs.len() {
             if self.get(i) != rhs[i] { return false; }
         }
         return true;
@@ -1266,7 +1266,7 @@ impl Stack {
     pub fn ends_with(&self, rhs: &[StackElement]) -> bool {
         if self.stack.len() < rhs.len() { return false; }
         let offset = self.stack.len() - rhs.len();
-        for i in range(0, rhs.len()) {
+        for i in 0..rhs.len() {
             if self.get(i + offset) != rhs[i] { return false; }
         }
         return true;
@@ -3415,7 +3415,7 @@ mod tests {
         }
 
         // Test up to 4 spaces of indents (more?)
-        for i in range(0, 4us) {
+        for i in 0..4 {
             let mut writer = Vec::new();
             write!(&mut writer, "{}",
                    super::as_pretty_json(&json).indent(i as u32)).unwrap();
@@ -3466,7 +3466,7 @@ mod tests {
         map.insert(Enum::Foo, 0);
         let result = json::encode(&map).unwrap();
         assert_eq!(&result[], r#"{"Foo":0}"#);
-        let decoded: HashMap<Enum, _> = json::decode(result.as_slice()).unwrap();
+        let decoded: HashMap<Enum, _> = json::decode(&result).unwrap();
         assert_eq!(map, decoded);
     }
 
@@ -3494,7 +3494,7 @@ mod tests {
                 None => { break; }
             };
             let (ref expected_evt, ref expected_stack) = expected[i];
-            if !parser.stack().is_equal_to(expected_stack.as_slice()) {
+            if !parser.stack().is_equal_to(&expected_stack) {
                 panic!("Parser stack is not equal to {:?}", expected_stack);
             }
             assert_eq!(&evt, expected_evt);
@@ -3881,7 +3881,7 @@ mod tests {
 
     fn big_json() -> string::String {
         let mut src = "[\n".to_string();
-        for _ in range(0, 500) {
+        for _ in 0..500 {
             src.push_str(r#"{ "a": true, "b": null, "c":3.1415, "d": "Hello world", "e": \
                             [1,2,3]},"#);
         }
@@ -3905,6 +3905,6 @@ mod tests {
     #[bench]
     fn bench_large(b: &mut Bencher) {
         let src = big_json();
-        b.iter( || { let _ = Json::from_str(src.as_slice()); });
+        b.iter( || { let _ = Json::from_str(&src); });
     }
 }

src/serialize.rs

@@ -463,7 +463,7 @@ impl<T:Decodable> Decodable for Vec<T> {
     fn decode<D: Decoder>(d: &mut D) -> Result<Vec<T>, D::Error> {
         d.read_seq(|d, len| {
             let mut v = Vec::with_capacity(len);
-            for i in range(0, len) {
+            for i in 0..len {
                 v.push(try!(d.read_seq_elt(i, |d| Decodable::decode(d))));
             }
             Ok(v)
@@ -680,7 +680,7 @@ impl<D: Decoder> DecoderHelpers for D {
     {
         self.read_seq(|this, len| {
             let mut v = Vec::with_capacity(len);
-            for i in range(0, len) {
+            for i in 0..len {
                 v.push(try!(this.read_seq_elt(i, |this| f(this))));
             }
             Ok(v)