diff --git a/benches/bench_log.rs b/benches/bench_log.rs
index 709c9554..7fd3aadc 100644
--- a/benches/bench_log.rs
+++ b/benches/bench_log.rs
@@ -589,7 +589,7 @@ macro_rules! likely(
             unsafe { expect(x as u8, 1) != 0 }
         }
     }
-)
+);
 
 macro_rules! unlikely(
     ($val:expr) => {
@@ -602,7 +602,7 @@ macro_rules! unlikely(
             unsafe { expect(x as u8, 0) != 0 }
         }
     }
-)
+);
 
 struct MyMemWriter0 {
     buf: Vec<u8>,
diff --git a/benches/bench_map.rs b/benches/bench_map.rs
index e17e80f7..ad6ddd09 100644
--- a/benches/bench_map.rs
+++ b/benches/bench_map.rs
@@ -28,7 +28,7 @@ pub enum Error {
 
 mod decoder {
     use std::collections::HashMap;
-    use std::collections::hash_map::MoveEntries;
+    use std::collections::hash_map::IntoIter;
     use serialize;
 
     use super::Error;
@@ -42,7 +42,7 @@ mod decoder {
 
     pub struct IntDecoder {
         len: uint,
-        iter: MoveEntries<String, int>,
+        iter: IntoIter<String, int>,
         stack: Vec<Value>,
     }
 
@@ -216,7 +216,7 @@ mod decoder {
 
 mod deserializer {
     use std::collections::HashMap;
-    use std::collections::hash_map::MoveEntries;
+    use std::collections::hash_map::IntoIter;
 
     use super::Error;
     use super::Error::{EndOfStream, SyntaxError};
@@ -235,7 +235,7 @@ mod deserializer {
     pub struct IntDeserializer {
         stack: Vec<State>,
         len: uint,
-        iter: MoveEntries<String, int>,
+        iter: IntoIter<String, int>,
     }
 
     impl IntDeserializer {
diff --git a/benches/bench_vec.rs b/benches/bench_vec.rs
index 6af27b25..a06f651c 100644
--- a/benches/bench_vec.rs
+++ b/benches/bench_vec.rs
@@ -34,7 +34,7 @@ mod decoder {
 
     pub struct IntDecoder {
         len: uint,
-        iter: vec::MoveItems<int>,
+        iter: vec::IntoIter<int>,
     }
 
     impl IntDecoder {
@@ -186,7 +186,7 @@ mod decoder {
 
     pub struct U8Decoder {
         len: uint,
-        iter: vec::MoveItems<u8>,
+        iter: vec::IntoIter<u8>,
     }
 
     impl U8Decoder {
@@ -359,7 +359,7 @@ mod deserializer {
     pub struct IntDeserializer {
         state: State,
         len: uint,
-        iter: vec::MoveItems<int>,
+        iter: vec::IntoIter<int>,
     }
 
     impl IntDeserializer {
@@ -431,7 +431,7 @@ mod deserializer {
     pub struct U8Deserializer {
         state: State,
         len: uint,
-        iter: vec::MoveItems<u8>,
+        iter: vec::IntoIter<u8>,
     }
 
     impl U8Deserializer {
diff --git a/serde2/benches/bench_log.rs b/serde2/benches/bench_log.rs
index 1617ea6d..c55f89c7 100644
--- a/serde2/benches/bench_log.rs
+++ b/serde2/benches/bench_log.rs
@@ -932,7 +932,7 @@ macro_rules! likely(
             unsafe { expect(x as u8, 1) != 0 }
         }
     }
-)
+);
 
 macro_rules! unlikely(
     ($val:expr) => {
@@ -945,7 +945,7 @@ macro_rules! unlikely(
             unsafe { expect(x as u8, 0) != 0 }
         }
     }
-)
+);
 
 struct MyMemWriter0 {
     buf: Vec<u8>,
diff --git a/serde2/src/bin.rs b/serde2/src/bin.rs
index 8653afe8..c844bcb6 100644
--- a/serde2/src/bin.rs
+++ b/serde2/src/bin.rs
@@ -253,7 +253,7 @@ impl<
 ///////////////////////////////////////////////////////////////////////////////
 
 mod json {
-    use std::collections::TreeMap;
+    use std::collections::BTreeMap;
     use serde2::de;
 
     #[deriving(Show)]
@@ -263,7 +263,7 @@ mod json {
         Int(int),
         //String(String),
         List(Vec<Value>),
-        Map(TreeMap<String, Value>),
+        Map(BTreeMap<String, Value>),
     }
 
     impl<
@@ -323,7 +323,7 @@ mod json {
                 fn visit_map<
                     Visitor: de::MapVisitor<D, E>,
                 >(&mut self, mut visitor: Visitor) -> Result<Value, E> {
-                    let mut values = TreeMap::new();
+                    let mut values = BTreeMap::new();
 
                     loop {
                         match try!(visitor.visit()) {
@@ -500,7 +500,7 @@ pub fn main() {
 
 
 /*
-use std::collections::TreeMap;
+use std::collections::BTreeMap;
 use serde::{Serialize, GatherTokens};
 use serde::json;
 
@@ -578,7 +578,7 @@ fn main() {
 
     ////
 
-    let mut value = TreeMap::new();
+    let mut value = BTreeMap::new();
     value.insert("a", 1i);
     value.insert("b", 2);
     value.insert("c", 3);
diff --git a/serde2/src/de.rs b/serde2/src/de.rs
index c7f7ecd4..17ce0904 100644
--- a/serde2/src/de.rs
+++ b/serde2/src/de.rs
@@ -1,4 +1,4 @@
-use std::collections::{HashMap, TreeMap};
+use std::collections::{HashMap, BTreeMap};
 use std::hash::Hash;
 
 ///////////////////////////////////////////////////////////////////////////////
@@ -237,18 +237,18 @@ pub fn deserialize_from_primitive<
         E: Error,
         T: Deserialize<S, E> + FromPrimitive
     > self::Visitor<S, T, E> for Visitor {
-        impl_deserialize_num_method!(int, visit_int, from_int)
-        impl_deserialize_num_method!(i8, visit_i8, from_i8)
-        impl_deserialize_num_method!(i16, visit_i16, from_i16)
-        impl_deserialize_num_method!(i32, visit_i32, from_i32)
-        impl_deserialize_num_method!(i64, visit_i64, from_i64)
-        impl_deserialize_num_method!(uint, visit_uint, from_uint)
-        impl_deserialize_num_method!(u8, visit_u8, from_u8)
-        impl_deserialize_num_method!(u16, visit_u16, from_u16)
-        impl_deserialize_num_method!(u32, visit_u32, from_u32)
-        impl_deserialize_num_method!(u64, visit_u64, from_u64)
-        impl_deserialize_num_method!(f32, visit_f32, from_f32)
-        impl_deserialize_num_method!(f64, visit_f64, from_f64)
+        impl_deserialize_num_method!(int, visit_int, from_int);
+        impl_deserialize_num_method!(i8, visit_i8, from_i8);
+        impl_deserialize_num_method!(i16, visit_i16, from_i16);
+        impl_deserialize_num_method!(i32, visit_i32, from_i32);
+        impl_deserialize_num_method!(i64, visit_i64, from_i64);
+        impl_deserialize_num_method!(uint, visit_uint, from_uint);
+        impl_deserialize_num_method!(u8, visit_u8, from_u8);
+        impl_deserialize_num_method!(u16, visit_u16, from_u16);
+        impl_deserialize_num_method!(u32, visit_u32, from_u32);
+        impl_deserialize_num_method!(u64, visit_u64, from_u64);
+        impl_deserialize_num_method!(f32, visit_f32, from_f32);
+        impl_deserialize_num_method!(f64, visit_f64, from_f64);
     }
 
     state.visit(&mut Visitor)
@@ -268,18 +268,18 @@ macro_rules! impl_deserialize_num {
     }
 }
 
-impl_deserialize_num!(int)
-impl_deserialize_num!(i8)
-impl_deserialize_num!(i16)
-impl_deserialize_num!(i32)
-impl_deserialize_num!(i64)
-impl_deserialize_num!(uint)
-impl_deserialize_num!(u8)
-impl_deserialize_num!(u16)
-impl_deserialize_num!(u32)
-impl_deserialize_num!(u64)
-impl_deserialize_num!(f32)
-impl_deserialize_num!(f64)
+impl_deserialize_num!(int);
+impl_deserialize_num!(i8);
+impl_deserialize_num!(i16);
+impl_deserialize_num!(i32);
+impl_deserialize_num!(i64);
+impl_deserialize_num!(uint);
+impl_deserialize_num!(u8);
+impl_deserialize_num!(u16);
+impl_deserialize_num!(u32);
+impl_deserialize_num!(u64);
+impl_deserialize_num!(f32);
+impl_deserialize_num!(f64);
 
 ///////////////////////////////////////////////////////////////////////////////
 
@@ -377,14 +377,14 @@ impl<
 
 macro_rules! peel {
     ($name:ident, $($other:ident,)*) => {
-        impl_deserialize_tuple!($($other,)*)
+        impl_deserialize_tuple!($($other,)*);
     }
 }
 
 macro_rules! impl_deserialize_tuple {
     () => {};
     ( $($name:ident,)+ ) => {
-        peel!($($name,)*)
+        peel!($($name,)*);
 
         impl<
             S: Deserializer<E>,
@@ -472,8 +472,8 @@ impl<
     V: Deserialize<S, E>,
     S: Deserializer<E>,
     E: Error,
-> Deserialize<S, E> for TreeMap<K, V> {
-    fn deserialize(state: &mut S) -> Result<TreeMap<K, V>, E> {
+> Deserialize<S, E> for BTreeMap<K, V> {
+    fn deserialize(state: &mut S) -> Result<BTreeMap<K, V>, E> {
         struct Visitor;
 
         impl<
@@ -481,11 +481,11 @@ impl<
             V: Deserialize<S, E>,
             S: Deserializer<E>,
             E: Error,
-        > self::Visitor<S, TreeMap<K, V>, E> for Visitor {
+        > self::Visitor<S, BTreeMap<K, V>, E> for Visitor {
             fn visit_map<
                 Visitor: MapVisitor<S, E>,
-            >(&mut self, mut visitor: Visitor) -> Result<TreeMap<K, V>, E> {
-                let mut values = TreeMap::new();
+            >(&mut self, mut visitor: Visitor) -> Result<BTreeMap<K, V>, E> {
+                let mut values = BTreeMap::new();
 
                 loop {
                     match try!(visitor.visit()) {
diff --git a/serde2/src/json/builder.rs b/serde2/src/json/builder.rs
index c66b63bc..a495eeaa 100644
--- a/serde2/src/json/builder.rs
+++ b/serde2/src/json/builder.rs
@@ -8,8 +8,7 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-use std::collections::TreeMap;
-use std::str::StrAllocating;
+use std::collections::BTreeMap;
 
 use ser::{mod, Serialize};
 use json::value::{mod, Value};
@@ -46,39 +45,39 @@ impl ArrayBuilder {
 }
 
 pub struct ObjectBuilder {
-    object: TreeMap<String, Value>,
+    object: BTreeMap<String, Value>,
 }
 
 impl ObjectBuilder {
     pub fn new() -> ObjectBuilder {
-        ObjectBuilder { object: TreeMap::new() }
+        ObjectBuilder { object: BTreeMap::new() }
     }
 
     pub fn unwrap(self) -> Value {
         Value::Object(self.object)
     }
 
-    pub fn insert<K: StrAllocating, V: ser::Serialize>(mut self, k: K, v: V) -> ObjectBuilder {
-        self.object.insert(k.into_string(), value::to_value(&v));
+    pub fn insert<V: ser::Serialize>(mut self, k: String, v: V) -> ObjectBuilder {
+        self.object.insert(k, value::to_value(&v));
         self
     }
 
-    pub fn insert_array<S: StrAllocating>(mut self, key: S, f: |ArrayBuilder| -> ArrayBuilder) -> ObjectBuilder {
+    pub fn insert_array(mut self, key: String, f: |ArrayBuilder| -> ArrayBuilder) -> ObjectBuilder {
         let builder = ArrayBuilder::new();
-        self.object.insert(key.into_string(), f(builder).unwrap());
+        self.object.insert(key, f(builder).unwrap());
         self
     }
 
-    pub fn insert_object<S: StrAllocating>(mut self, key: S, f: |ObjectBuilder| -> ObjectBuilder) -> ObjectBuilder {
+    pub fn insert_object(mut self, key: String, f: |ObjectBuilder| -> ObjectBuilder) -> ObjectBuilder {
         let builder = ObjectBuilder::new();
-        self.object.insert(key.into_string(), f(builder).unwrap());
+        self.object.insert(key, f(builder).unwrap());
         self
     }
 }
 
 #[cfg(test)]
 mod tests {
-    use std::collections::TreeMap;
+    use std::collections::BTreeMap;
 
     use json::value::Value;
     use super::{ArrayBuilder, ObjectBuilder};
@@ -107,7 +106,7 @@ mod tests {
                     .insert("b".to_string(), 2i))
             .unwrap();
 
-        let mut map = TreeMap::new();
+        let mut map = BTreeMap::new();
         map.insert("a".to_string(), Value::I64(1));
         map.insert("b".to_string(), Value::I64(2));
         assert_eq!(value, Value::Array(vec!(Value::Object(map))));
@@ -116,14 +115,14 @@ mod tests {
     #[test]
     fn test_object_builder() {
         let value = ObjectBuilder::new().unwrap();
-        assert_eq!(value, Value::Object(TreeMap::new()));
+        assert_eq!(value, Value::Object(BTreeMap::new()));
 
         let value = ObjectBuilder::new()
             .insert("a".to_string(), 1i)
             .insert("b".to_string(), 2i)
             .unwrap();
 
-        let mut map = TreeMap::new();
+        let mut map = BTreeMap::new();
         map.insert("a".to_string(), Value::I64(1));
         map.insert("b".to_string(), Value::I64(2));
         assert_eq!(value, Value::Object(map));
diff --git a/serde2/src/json/de.rs b/serde2/src/json/de.rs
index f2625072..8e38eeb9 100644
--- a/serde2/src/json/de.rs
+++ b/serde2/src/json/de.rs
@@ -1,6 +1,6 @@
 use std::char;
 use std::num::Float;
-use std::str::ScalarValue;
+use unicode::str::Utf16Item;
 use std::str;
 
 use de;
@@ -337,8 +337,8 @@ impl<Iter: Iterator<u8>> Parser<Iter> {
                                 }
 
                                 let buf = &[n1, try!(self.decode_hex_escape())];
-                                match str::utf16_items(buf.as_slice()).next() {
-                                    Some(ScalarValue(c)) => c,
+                                match ::unicode::str::utf16_items(buf.as_slice()).next() {
+                                    Some(Utf16Item::ScalarValue(c)) => c,
                                     _ => {
                                         return Err(self.error(ErrorCode::LoneLeadingSurrogateInHexEscape));
                                     }
@@ -529,7 +529,7 @@ pub fn from_str<
 mod tests {
     use std::str;
     use std::fmt::Show;
-    use std::collections::TreeMap;
+    use std::collections::BTreeMap;
 
     use de::Deserialize;
     use super::{Parser, from_str};
@@ -537,7 +537,7 @@ mod tests {
 
     macro_rules! treemap {
         ($($k:expr => $v:expr),*) => ({
-            let mut _m = TreeMap::new();
+            let mut _m = BTreeMap::new();
             $(_m.insert($k, $v);)*
             _m
         })
@@ -694,7 +694,7 @@ mod tests {
 
     #[test]
     fn test_parse_object() {
-        test_parse_err::<TreeMap<String, int>>(vec![
+        test_parse_err::<BTreeMap<String, int>>(vec![
             ("{", Error::SyntaxError(ErrorCode::EOFWhileParsingValue, 1, 2)),
             ("{ ", Error::SyntaxError(ErrorCode::EOFWhileParsingValue, 1, 3)),
             ("{1", Error::SyntaxError(ErrorCode::KeyMustBeAString, 1, 2)),
diff --git a/serde2/src/json/ser.rs b/serde2/src/json/ser.rs
index e7817eb6..57fa3c3e 100644
--- a/serde2/src/json/ser.rs
+++ b/serde2/src/json/ser.rs
@@ -1,6 +1,7 @@
 use std::f64;
 use std::io::{mod, ByRefWriter, IoError};
 use std::num::{Float, FPNaN, FPInfinite};
+use std::str::Utf8Error;
 
 use ser;
 use ser::Serializer;
@@ -251,7 +252,7 @@ pub fn to_vec<
 #[inline]
 pub fn to_string<
     T: ser::Serialize,
->(value: &T) -> Result<Result<String, Vec<u8>>, IoError> {
+>(value: &T) -> Result<Result<String, (Vec<u8>, Utf8Error)>, IoError> {
     let vec = try!(to_vec(value));
     Ok(String::from_utf8(vec))
 }
diff --git a/serde2/src/json/value.rs b/serde2/src/json/value.rs
index 821dcca8..ea700dff 100644
--- a/serde2/src/json/value.rs
+++ b/serde2/src/json/value.rs
@@ -1,4 +1,4 @@
-use std::collections::TreeMap;
+use std::collections::BTreeMap;
 use std::fmt;
 use std::io;
 
@@ -12,7 +12,7 @@ pub enum Value {
     F64(f64),
     String(String),
     Array(Vec<Value>),
-    Object(TreeMap<String, Value>),
+    Object(BTreeMap<String, Value>),
 }
 
 impl ser::Serialize for Value {
@@ -77,7 +77,7 @@ pub fn to_value<
 enum State {
     Value(Value),
     Array(Vec<Value>),
-    Object(TreeMap<String, Value>),
+    Object(BTreeMap<String, Value>),
 }
 
 pub struct Writer {
@@ -203,7 +203,7 @@ impl ser::Visitor<Writer, (), ()> for Visitor {
     fn visit_map<
         V: ser::MapVisitor<Writer, (), ()>
     >(&self, state: &mut Writer, mut visitor: V) -> Result<(), ()> {
-        let values = TreeMap::new();
+        let values = BTreeMap::new();
 
         state.state.push(State::Object(values));
 
diff --git a/serde2/src/lib.rs b/serde2/src/lib.rs
index 655d4798..b8a5da00 100644
--- a/serde2/src/lib.rs
+++ b/serde2/src/lib.rs
@@ -1,5 +1,7 @@
 #![feature(macro_rules)]
 
+extern crate unicode;
+
 pub use ser::{Serialize, Serializer};
 //pub use ser::{Visitor, VisitorState};
 //pub use ser::GatherTokens;
diff --git a/serde2/src/ser.rs b/serde2/src/ser.rs
index 9af4e80f..6a97a1f9 100644
--- a/serde2/src/ser.rs
+++ b/serde2/src/ser.rs
@@ -1,4 +1,4 @@
-use std::collections::TreeMap;
+use std::collections::BTreeMap;
 
 ///////////////////////////////////////////////////////////////////////////////
 
@@ -176,20 +176,20 @@ macro_rules! impl_visit {
     }
 }
 
-impl_visit!(bool, visit_bool)
-impl_visit!(int, visit_int)
-impl_visit!(i8, visit_i8)
-impl_visit!(i16, visit_i16)
-impl_visit!(i32, visit_i32)
-impl_visit!(i64, visit_i64)
-impl_visit!(uint, visit_uint)
-impl_visit!(u8, visit_u8)
-impl_visit!(u16, visit_u16)
-impl_visit!(u32, visit_u32)
-impl_visit!(u64, visit_u64)
-impl_visit!(f32, visit_f32)
-impl_visit!(f64, visit_f64)
-impl_visit!(char, visit_char)
+impl_visit!(bool, visit_bool);
+impl_visit!(int, visit_int);
+impl_visit!(i8, visit_i8);
+impl_visit!(i16, visit_i16);
+impl_visit!(i32, visit_i32);
+impl_visit!(i64, visit_i64);
+impl_visit!(uint, visit_uint);
+impl_visit!(u8, visit_u8);
+impl_visit!(u16, visit_u16);
+impl_visit!(u32, visit_u32);
+impl_visit!(u64, visit_u64);
+impl_visit!(f32, visit_f32);
+impl_visit!(f64, visit_f64);
+impl_visit!(char, visit_char);
 
 ///////////////////////////////////////////////////////////////////////////////
 
@@ -491,7 +491,7 @@ impl<
 impl<
     K: Serialize + Ord,
     V: Serialize,
-> Serialize for TreeMap<K, V> {
+> Serialize for BTreeMap<K, V> {
     #[inline]
     fn visit<
         S,
diff --git a/src/de.rs b/src/de.rs
index f608a788..d436b82d 100644
--- a/src/de.rs
+++ b/src/de.rs
@@ -8,7 +8,7 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-use std::collections::{HashMap, HashSet, TreeMap, TreeSet};
+use std::collections::{HashMap, HashSet, BTreeMap, BTreeSet};
 use std::hash::Hash;
 use std::num;
 use std::rc::Rc;
@@ -288,10 +288,10 @@ pub trait Deserializer<E>: Iterator<Result<Token, E>> {
     fn expect_char(&mut self, token: Token) -> Result<char, E> {
         match token {
             Token::Char(value) => Ok(value),
-            Token::Str(value) if value.char_len() == 1 => {
+            Token::Str(value) if value.chars().count() == 1 => {
                 Ok(value.char_at(0))
             }
-            Token::String(ref value) if value.as_slice().char_len() == 1 => {
+            Token::String(ref value) if value.as_slice().chars().count() == 1 => {
                 Ok(value.as_slice().char_at(0))
             }
             token => {
@@ -673,22 +673,22 @@ macro_rules! impl_deserialize {
     }
 }
 
-impl_deserialize!(bool, expect_bool)
-impl_deserialize!(int, expect_num)
-impl_deserialize!(i8, expect_num)
-impl_deserialize!(i16, expect_num)
-impl_deserialize!(i32, expect_num)
-impl_deserialize!(i64, expect_num)
-impl_deserialize!(uint, expect_num)
-impl_deserialize!(u8, expect_num)
-impl_deserialize!(u16, expect_num)
-impl_deserialize!(u32, expect_num)
-impl_deserialize!(u64, expect_num)
-impl_deserialize!(f32, expect_num)
-impl_deserialize!(f64, expect_num)
-impl_deserialize!(char, expect_char)
-impl_deserialize!(&'static str, expect_str)
-impl_deserialize!(string::String, expect_string)
+impl_deserialize!(bool, expect_bool);
+impl_deserialize!(int, expect_num);
+impl_deserialize!(i8, expect_num);
+impl_deserialize!(i16, expect_num);
+impl_deserialize!(i32, expect_num);
+impl_deserialize!(i64, expect_num);
+impl_deserialize!(uint, expect_num);
+impl_deserialize!(u8, expect_num);
+impl_deserialize!(u16, expect_num);
+impl_deserialize!(u32, expect_num);
+impl_deserialize!(u64, expect_num);
+impl_deserialize!(f32, expect_num);
+impl_deserialize!(f64, expect_num);
+impl_deserialize!(char, expect_char);
+impl_deserialize!(&'static str, expect_str);
+impl_deserialize!(string::String, expect_string);
 
 //////////////////////////////////////////////////////////////////////////////
 
@@ -770,9 +770,9 @@ impl<
     E,
     K: Deserialize<D, E> + Ord,
     V: Deserialize<D, E>
-> Deserialize<D, E> for TreeMap<K, V> {
+> Deserialize<D, E> for BTreeMap<K, V> {
     #[inline]
-    fn deserialize_token(d: &mut D, token: Token) -> Result<TreeMap<K, V>, E> {
+    fn deserialize_token(d: &mut D, token: Token) -> Result<BTreeMap<K, V>, E> {
         d.expect_map(token)
     }
 }
@@ -794,9 +794,9 @@ impl<
     D: Deserializer<E>,
     E,
     T: Deserialize<D, E> + Ord
-> Deserialize<D, E> for TreeSet<T> {
+> Deserialize<D, E> for BTreeSet<T> {
     #[inline]
-    fn deserialize_token(d: &mut D, token: Token) -> Result<TreeSet<T>, E> {
+    fn deserialize_token(d: &mut D, token: Token) -> Result<BTreeSet<T>, E> {
         d.expect_seq(token)
     }
 }
@@ -804,7 +804,7 @@ impl<
 //////////////////////////////////////////////////////////////////////////////
 
 macro_rules! peel {
-    ($name:ident, $($other:ident,)*) => (impl_deserialize_tuple!($($other,)*))
+    ($name:ident, $($other:ident,)*) => ( impl_deserialize_tuple!($($other,)*); )
 }
 
 macro_rules! impl_deserialize_tuple {
@@ -840,7 +840,7 @@ macro_rules! impl_deserialize_tuple {
                 Ok(result)
             }
         }
-        peel!($($name,)*)
+        peel!($($name,)*);
     }
 }
 
@@ -1067,7 +1067,7 @@ impl<D: Deserializer<E>, E> Deserialize<D, E> for GatherTokens {
 
 #[cfg(test)]
 mod tests {
-    use std::collections::TreeMap;
+    use std::collections::BTreeMap;
     use std::{option, string};
     use serialize::Decoder;
 
@@ -1075,7 +1075,7 @@ mod tests {
 
     macro_rules! treemap {
         ($($k:expr => $v:expr),*) => ({
-            let mut _m = ::std::collections::TreeMap::new();
+            let mut _m = ::std::collections::BTreeMap::new();
             $(_m.insert($k, $v);)*
             _m
         })
@@ -1087,7 +1087,7 @@ mod tests {
     struct Inner {
         a: (),
         b: uint,
-        c: TreeMap<string::String, option::Option<char>>,
+        c: BTreeMap<string::String, option::Option<char>>,
     }
 
     impl<
@@ -1276,7 +1276,7 @@ mod tests {
         vec!(Token::Char('c')) => 'c': char,
         vec!(Token::Str("abc")) => "abc": &str,
         vec!(Token::String("abc".to_string())) => "abc".to_string(): string::String
-    ])
+    ]);
 
     test_value!(test_tuples, [
         vec!(
@@ -1306,7 +1306,7 @@ mod tests {
                 Token::End,
             Token::End,
         ) => ((), (), (5, "a")): ((), (), (int, &'static str))
-    ])
+    ]);
 
     test_value!(test_options, [
         vec!(Token::Option(false)) => None: option::Option<int>,
@@ -1315,7 +1315,7 @@ mod tests {
             Token::Option(true),
             Token::Int(5),
         ) => Some(5): option::Option<int>
-    ])
+    ]);
 
     test_value!(test_structs, [
         vec!(
@@ -1356,7 +1356,7 @@ mod tests {
                 },
             ),
         }: Outer
-    ])
+    ]);
 
     test_value!(test_enums, [
         vec!(
@@ -1370,7 +1370,7 @@ mod tests {
                 Token::Int(349),
             Token::End,
         ) => Animal::Frog("Henry".to_string(), 349): Animal
-    ])
+    ]);
 
     test_value!(test_vecs, [
         vec!(
@@ -1410,13 +1410,13 @@ mod tests {
                 Token::End,
             Token::End,
         ) => vec!(vec!(1), vec!(2, 3), vec!(4, 5, 6)): Vec<Vec<int>>
-    ])
+    ]);
 
     test_value!(test_treemaps, [
         vec!(
             Token::MapStart(0),
             Token::End,
-        ) => treemap!(): TreeMap<int, string::String>,
+        ) => treemap!(): BTreeMap<int, string::String>,
 
         vec!(
             Token::MapStart(2),
@@ -1426,7 +1426,7 @@ mod tests {
                 Token::Int(6),
                 Token::String("b".to_string()),
             Token::End,
-        ) => treemap!(5i => "a".to_string(), 6i => "b".to_string()): TreeMap<int, string::
+        ) => treemap!(5i => "a".to_string(), 6i => "b".to_string()): BTreeMap<int, string::
         String>
-    ])
+    ]);
 }
diff --git a/src/json/builder.rs b/src/json/builder.rs
index 65b14154..3bba0ab8 100644
--- a/src/json/builder.rs
+++ b/src/json/builder.rs
@@ -8,8 +8,7 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-use std::collections::TreeMap;
-use std::str::StrAllocating;
+use std::collections::BTreeMap;
 
 use json::value::{ToJson, Value};
 
@@ -44,38 +43,38 @@ impl ArrayBuilder {
 }
 
 pub struct ObjectBuilder {
-    object: TreeMap<String, Value>,
+    object: BTreeMap<String, Value>,
 }
 
 impl ObjectBuilder {
     pub fn new() -> ObjectBuilder {
-        ObjectBuilder { object: TreeMap::new() }
+        ObjectBuilder { object: BTreeMap::new() }
     }
 
     pub fn unwrap(self) -> Value {
         Value::Object(self.object)
     }
 
-    pub fn insert<K: StrAllocating, V: ToJson>(self, key: K, value: V) -> ObjectBuilder {
+    pub fn insert<V: ToJson>(self, key: String, value: V) -> ObjectBuilder {
         let mut builder = self;
-        builder.object.insert(key.into_string(), value.to_json());
+        builder.object.insert(key, value.to_json());
         builder
     }
 
-    pub fn insert_array<S: StrAllocating>(self, key: S, f: |ArrayBuilder| -> ArrayBuilder) -> ObjectBuilder {
+    pub fn insert_array(self, key: String, f: |ArrayBuilder| -> ArrayBuilder) -> ObjectBuilder {
         let builder = ArrayBuilder::new();
-        self.insert(key.into_string(), f(builder).unwrap())
+        self.insert(key, f(builder).unwrap())
     }
 
-    pub fn insert_object<S: StrAllocating>(self, key: S, f: |ObjectBuilder| -> ObjectBuilder) -> ObjectBuilder {
+    pub fn insert_object(self, key: String, f: |ObjectBuilder| -> ObjectBuilder) -> ObjectBuilder {
         let builder = ObjectBuilder::new();
-        self.insert(key.into_string(), f(builder).unwrap())
+        self.insert(key, f(builder).unwrap())
     }
 }
 
 #[cfg(test)]
 mod tests {
-    use std::collections::TreeMap;
+    use std::collections::BTreeMap;
 
     use json::value::Value;
     use super::{ArrayBuilder, ObjectBuilder};
@@ -104,7 +103,7 @@ mod tests {
                     .insert("b".to_string(), 2i))
             .unwrap();
 
-        let mut map = TreeMap::new();
+        let mut map = BTreeMap::new();
         map.insert("a".to_string(), Value::Integer(1));
         map.insert("b".to_string(), Value::Integer(2));
         assert_eq!(value, Value::Array(vec!(Value::Object(map))));
@@ -113,14 +112,14 @@ mod tests {
     #[test]
     fn test_object_builder() {
         let value = ObjectBuilder::new().unwrap();
-        assert_eq!(value, Value::Object(TreeMap::new()));
+        assert_eq!(value, Value::Object(BTreeMap::new()));
 
         let value = ObjectBuilder::new()
             .insert("a".to_string(), 1i)
             .insert("b".to_string(), 2i)
             .unwrap();
 
-        let mut map = TreeMap::new();
+        let mut map = BTreeMap::new();
         map.insert("a".to_string(), Value::Integer(1));
         map.insert("b".to_string(), Value::Integer(2));
         assert_eq!(value, Value::Object(map));
diff --git a/src/json/de.rs b/src/json/de.rs
index a0be628b..33eac20a 100644
--- a/src/json/de.rs
+++ b/src/json/de.rs
@@ -1,6 +1,6 @@
 use std::str;
 use std::num::Float;
-use std::str::ScalarValue;
+use unicode::str::Utf16Item;
 use std::char;
 
 use de;
@@ -379,8 +379,8 @@ impl<Iter: Iterator<u8>> Parser<Iter> {
                                 }
 
                                 let buf = &[n1, try!(self.decode_hex_escape())];
-                                match str::utf16_items(buf.as_slice()).next() {
-                                    Some(ScalarValue(c)) => c,
+                                match ::unicode::str::utf16_items(buf.as_slice()).next() {
+                                    Some(Utf16Item::ScalarValue(c)) => c,
                                     _ => {
                                         return Err(self.error(ErrorCode::LoneLeadingSurrogateInHexEscape));
                                     }
diff --git a/src/json/mod.rs b/src/json/mod.rs
index ca6f14be..feca55f6 100644
--- a/src/json/mod.rs
+++ b/src/json/mod.rs
@@ -106,7 +106,7 @@ the API provide writer to serialize them into a stream or a string ...
 
 When using `ToJson` the `Serialize` trait implementation is not mandatory.
 
-A basic `ToJson` example using a TreeMap of attribute name / attribute value:
+A basic `ToJson` example using a BTreeMap of attribute name / attribute value:
 
 
 ```rust
@@ -115,7 +115,7 @@ A basic `ToJson` example using a TreeMap of attribute name / attribute value:
 extern crate serde_macros;
 extern crate serde;
 
-use std::collections::TreeMap;
+use std::collections::BTreeMap;
 use serde::json::{ToJson, Value};
 
 pub struct MyStruct  {
@@ -125,7 +125,7 @@ pub struct MyStruct  {
 
 impl ToJson for MyStruct {
     fn to_json( &self ) -> Value {
-        let mut d = TreeMap::new();
+        let mut d = BTreeMap::new();
         d.insert("attr1".to_string(), self.attr1.to_json());
         d.insert("attr2".to_string(), self.attr2.to_json());
         d.to_json()
@@ -157,8 +157,8 @@ pub struct MyStruct  {
 impl ToJson for MyStruct {
     fn to_json( &self ) -> Value {
         ObjectBuilder::new()
-            .insert("attr1", &self.attr1)
-            .insert("attr2", &self.attr2)
+            .insert("attr1".to_string(), &self.attr1)
+            .insert("attr2".to_string(), &self.attr2)
             .unwrap()
     }
 }
@@ -265,9 +265,9 @@ pub struct TestStruct1  {
 impl ToJson for TestStruct1 {
     fn to_json( &self ) -> json::Value {
         json::builder::ObjectBuilder::new()
-            .insert("data_int", &self.data_int)
-            .insert("data_str", &self.data_str)
-            .insert("data_vector", &self.data_vector)
+            .insert("data_int".to_string(), &self.data_int)
+            .insert("data_str".to_string(), &self.data_str)
+            .insert("data_vector".to_string(), &self.data_vector)
             .unwrap()
     }
 }
@@ -281,7 +281,7 @@ fn main() {
         data_vector: vec![2,3,4,5],
     };
     let json: json::Value = test.to_json();
-    let json_str: String = json.to_string().into_string();
+    let json_str: String = json.to_string();
 
     // Deserialize like before.
 
@@ -322,7 +322,7 @@ mod tests {
     use std::io;
     use std::str;
     use std::string;
-    use std::collections::TreeMap;
+    use std::collections::BTreeMap;
 
     use de;
     use ser::{Serialize, Serializer};
@@ -351,7 +351,7 @@ mod tests {
 
     macro_rules! treemap {
         ($($k:expr => $v:expr),*) => ({
-            let mut _m = ::std::collections::TreeMap::new();
+            let mut _m = ::std::collections::BTreeMap::new();
             $(_m.insert($k, $v);)*
             _m
         })
@@ -1002,7 +1002,7 @@ mod tests {
 
     #[test]
     fn test_parse_object() {
-        test_parse_err::<TreeMap<string::String, int>>(&[
+        test_parse_err::<BTreeMap<string::String, int>>(&[
             ("{", SyntaxError(EOFWhileParsingString, 1, 2)),
             ("{ ", SyntaxError(EOFWhileParsingString, 1, 3)),
             ("{1", SyntaxError(KeyMustBeAString, 1, 2)),
@@ -1171,7 +1171,7 @@ mod tests {
 
     #[test]
     fn test_multiline_errors() {
-        test_parse_err::<TreeMap<string::String, string::String>>(&[
+        test_parse_err::<BTreeMap<string::String, string::String>>(&[
             ("{\n  \"foo\":\n \"bar\"", SyntaxError(EOFWhileParsingObject, 3u, 8u)),
         ]);
     }
@@ -1267,7 +1267,7 @@ mod tests {
     fn test_as_object() {
         let json_value: Value = from_str("{}").unwrap();
         let json_object = json_value.as_object();
-        let map = TreeMap::<string::String, Value>::new();
+        let map = BTreeMap::<string::String, Value>::new();
         assert_eq!(json_object, Some(&map));
     }
 
@@ -1698,7 +1698,7 @@ mod tests {
 
 #[cfg(test)]
 mod bench {
-    use std::collections::TreeMap;
+    use std::collections::BTreeMap;
     use std::string;
     use serialize;
     use test::Bencher;
@@ -1709,7 +1709,7 @@ mod bench {
 
     macro_rules! treemap {
         ($($k:expr => $v:expr),*) => ({
-            let mut _m = ::std::collections::TreeMap::new();
+            let mut _m = ::std::collections::BTreeMap::new();
             $(_m.insert($k, $v);)*
             _m
         })
@@ -1764,7 +1764,7 @@ mod bench {
                 ))
             )));
         }
-        list.push(Json::Object(TreeMap::new()));
+        list.push(Json::Object(BTreeMap::new()));
         Json::Array(list)
     }
 
@@ -1783,7 +1783,7 @@ mod bench {
                 ))
             )));
         }
-        list.push(Value::Object(TreeMap::new()));
+        list.push(Value::Object(BTreeMap::new()));
         Value::Array(list)
     }
 
diff --git a/src/json/ser.rs b/src/json/ser.rs
index 65414929..ac07b677 100644
--- a/src/json/ser.rs
+++ b/src/json/ser.rs
@@ -2,6 +2,7 @@ use std::f32;
 use std::f64;
 use std::num::{Float, FPNaN, FPInfinite};
 use std::io::{IoError, IoResult};
+use std::str::Utf8Error;
 
 use ser::Serialize;
 use ser;
@@ -599,7 +600,7 @@ pub fn to_vec<
 #[inline]
 pub fn to_string<
     T: Serialize<Serializer<Vec<u8>>, IoError>
->(value: &T) -> Result<String, Vec<u8>> {
+>(value: &T) -> Result<String, (Vec<u8>, Utf8Error)> {
     let buf = to_vec(value);
     String::from_utf8(buf)
 }
@@ -628,7 +629,7 @@ pub fn to_pretty_vec<
 /// Encode the specified struct into a json `String` buffer.
 pub fn to_pretty_string<
     T: Serialize<PrettySerializer<Vec<u8>>, IoError>
->(value: &T) -> Result<String, Vec<u8>> {
+>(value: &T) -> Result<String, (Vec<u8>, Utf8Error)> {
     let buf = to_pretty_vec(value);
     String::from_utf8(buf)
 }
diff --git a/src/json/value.rs b/src/json/value.rs
index 7e31b063..70ac4733 100644
--- a/src/json/value.rs
+++ b/src/json/value.rs
@@ -1,4 +1,4 @@
-use std::collections::{HashMap, TreeMap, tree_map};
+use std::collections::{HashMap, BTreeMap, btree_map};
 use std::fmt;
 use std::io::{ByRefWriter, IoResult};
 use std::io;
@@ -21,7 +21,7 @@ pub enum Value {
     Floating(f64),
     String(String),
     Array(Vec<Value>),
-    Object(TreeMap<String, Value>),
+    Object(BTreeMap<String, Value>),
 }
 
 impl Value {
@@ -99,7 +99,7 @@ impl Value {
 
     /// If the Json value is an Object, returns the associated TreeMap.
     /// Returns None otherwise.
-    pub fn as_object<'a>(&'a self) -> Option<&'a TreeMap<String, Value>> {
+    pub fn as_object<'a>(&'a self) -> Option<&'a BTreeMap<String, Value>> {
         match *self {
             Value::Object(ref map) => Some(map),
             _ => None
@@ -286,7 +286,7 @@ impl<D: de::Deserializer<E>, E> de::Deserialize<D, E> for Value {
             Token::EnumStart(_, name, len) => {
                 let token = Token::SeqStart(len);
                 let fields: Vec<Value> = try!(de::Deserialize::deserialize_token(d, token));
-                let mut object = TreeMap::new();
+                let mut object = BTreeMap::new();
                 object.insert(name.to_string(), Value::Array(fields));
                 Ok(Value::Object(object))
             }
@@ -302,8 +302,8 @@ impl<D: de::Deserializer<E>, E> de::Deserialize<D, E> for Value {
 
 enum State {
     Value(Value),
-    Array(vec::MoveItems<Value>),
-    Object(tree_map::MoveEntries<String, Value>),
+    Array(vec::IntoIter<Value>),
+    Object(btree_map::IntoIter<String, Value>),
     End,
 }
 
@@ -584,7 +584,7 @@ impl ToJson for String {
 }
 
 macro_rules! peel_to_json_tuple {
-    ($name:ident, $($other:ident,)*) => (impl_to_json_tuple!($($other,)*))
+    ($name:ident, $($other:ident,)*) => ( impl_to_json_tuple!($($other,)*); )
 }
 
 macro_rules! impl_to_json_tuple {
@@ -615,7 +615,7 @@ macro_rules! impl_to_json_tuple {
                 Value::Array(array)
             }
         }
-        peel_to_json_tuple!($($name,)*)
+        peel_to_json_tuple!($($name,)*);
     }
 }
 
@@ -627,9 +627,9 @@ impl<A:ToJson> ToJson for Vec<A> {
     }
 }
 
-impl<A:ToJson> ToJson for TreeMap<String, A> {
+impl<A:ToJson> ToJson for BTreeMap<String, A> {
     fn to_json(&self) -> Value {
-        let mut d = TreeMap::new();
+        let mut d = BTreeMap::new();
         for (key, value) in self.iter() {
             d.insert((*key).clone(), value.to_json());
         }
@@ -639,7 +639,7 @@ impl<A:ToJson> ToJson for TreeMap<String, A> {
 
 impl<A:ToJson> ToJson for HashMap<String, A> {
     fn to_json(&self) -> Value {
-        let mut d = TreeMap::new();
+        let mut d = BTreeMap::new();
         for (key, value) in self.iter() {
             d.insert((*key).clone(), value.to_json());
         }
diff --git a/src/lib.rs b/src/lib.rs
index 60602976..c4df6b91 100644
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -12,6 +12,8 @@ extern crate serde_macros;
 #[cfg(test)]
 extern crate serialize;
 
+extern crate unicode;
+
 pub use de::{Deserializer, Deserialize};
 pub use ser::{Serializer, Serialize};
 
diff --git a/src/ser.rs b/src/ser.rs
index 4f467674..61fd7395 100644
--- a/src/ser.rs
+++ b/src/ser.rs
@@ -8,7 +8,7 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-use std::collections::{HashMap, HashSet, TreeMap, TreeSet};
+use std::collections::{HashMap, HashSet, BTreeMap, BTreeSet};
 use std::hash::Hash;
 use std::rc::Rc;
 use std::sync::Arc;
@@ -130,20 +130,20 @@ macro_rules! impl_serialize {
     }
 }
 
-impl_serialize!(bool, serialize_bool)
-impl_serialize!(int, serialize_int)
-impl_serialize!(i8, serialize_i8)
-impl_serialize!(i16, serialize_i16)
-impl_serialize!(i32, serialize_i32)
-impl_serialize!(i64, serialize_i64)
-impl_serialize!(uint, serialize_uint)
-impl_serialize!(u8, serialize_u8)
-impl_serialize!(u16, serialize_u16)
-impl_serialize!(u32, serialize_u32)
-impl_serialize!(u64, serialize_u64)
-impl_serialize!(f32, serialize_f32)
-impl_serialize!(f64, serialize_f64)
-impl_serialize!(char, serialize_char)
+impl_serialize!(bool, serialize_bool);
+impl_serialize!(int, serialize_int);
+impl_serialize!(i8, serialize_i8);
+impl_serialize!(i16, serialize_i16);
+impl_serialize!(i32, serialize_i32);
+impl_serialize!(i64, serialize_i64);
+impl_serialize!(uint, serialize_uint);
+impl_serialize!(u8, serialize_u8);
+impl_serialize!(u16, serialize_u16);
+impl_serialize!(u32, serialize_u32);
+impl_serialize!(u64, serialize_u64);
+impl_serialize!(f32, serialize_f32);
+impl_serialize!(f64, serialize_f64);
+impl_serialize!(char, serialize_char);
 
 //////////////////////////////////////////////////////////////////////////////
 
@@ -179,9 +179,9 @@ macro_rules! impl_serialize_box {
     }
 }
 
-impl_serialize_box!(&'a T)
-impl_serialize_box!(Box<T>)
-impl_serialize_box!(Rc<T>)
+impl_serialize_box!(&'a T);
+impl_serialize_box!(Box<T>);
+impl_serialize_box!(Rc<T>);
 
 impl<
     S: Serializer<E>,
@@ -239,7 +239,7 @@ impl<
     E,
     K: Serialize<S, E> + Ord,
     V: Serialize<S, E>
-> Serialize<S, E> for TreeMap<K, V> {
+> Serialize<S, E> for BTreeMap<K, V> {
     #[inline]
     fn serialize(&self, s: &mut S) -> Result<(), E> {
         s.serialize_map(self.iter())
@@ -263,7 +263,7 @@ impl<
     S: Serializer<E>,
     E,
     T: Serialize<S, E> + Ord
-> Serialize<S, E> for TreeSet<T> {
+> Serialize<S, E> for BTreeSet<T> {
     #[inline]
     fn serialize(&self, s: &mut S) -> Result<(), E> {
         s.serialize_seq(self.iter())
@@ -273,7 +273,7 @@ impl<
 //////////////////////////////////////////////////////////////////////////////
 
 macro_rules! peel {
-    ($name:ident, $($other:ident,)*) => (impl_serialize_tuple!($($other,)*))
+    ($name:ident, $($other:ident,)*) => ( impl_serialize_tuple!($($other,)*);  )
 }
 
 macro_rules! impl_serialize_tuple {
@@ -307,7 +307,7 @@ macro_rules! impl_serialize_tuple {
                 s.serialize_tuple_end()
             }
         }
-        peel!($($name,)*)
+        peel!($($name,)*);
     }
 }
 
@@ -317,7 +317,7 @@ impl_serialize_tuple! { T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, }
 
 #[cfg(test)]
 mod tests {
-    use std::collections::{HashMap, TreeMap};
+    use std::collections::{HashMap, BTreeMap};
 
     use std::{option, string};
 
@@ -825,7 +825,7 @@ mod tests {
 
         let mut serializer = AssertSerializer::new(tokens.into_iter());
 
-        let mut map = TreeMap::new();
+        let mut map = BTreeMap::new();
         map.insert(5i, "a".to_string());
         map.insert(6i, "b".to_string());