From 21a58e86e44c51f27bd6f95a4c07adea0979111a Mon Sep 17 00:00:00 2001
From: Erick Tryzelaar <erick.tryzelaar@gmail.com>
Date: Thu, 13 Nov 2014 07:54:44 -0800
Subject: [PATCH] Rename Serializable to Serialize, Deserializable to
 Deserialize

---
 benches/bench_enum.rs   |  10 +--
 benches/bench_log.rs    |  38 ++++-----
 benches/bench_map.rs    |   8 +-
 benches/bench_struct.rs |  14 ++--
 benches/bench_vec.rs    |  10 +--
 serde_macros/src/lib.rs |  60 +++++++-------
 src/de.rs               | 180 ++++++++++++++++++++--------------------
 src/json/mod.rs         | 142 +++++++++++++++----------------
 src/lib.rs              |   4 +-
 src/ser.rs              | 124 +++++++++++++--------------
 tests/json_struct.rs    |   4 +-
 11 files changed, 297 insertions(+), 297 deletions(-)

diff --git a/benches/bench_enum.rs b/benches/bench_enum.rs
index 62e02e42..7aa98712 100644
--- a/benches/bench_enum.rs
+++ b/benches/bench_enum.rs
@@ -11,12 +11,12 @@ use test::Bencher;
 
 use serialize::{Decoder, Decodable};
 
-use serde::de::{Deserializer, Deserializable};
+use serde::de::{Deserializer, Deserialize};
 
 //////////////////////////////////////////////////////////////////////////////
 
 #[deriving(Clone, PartialEq, Show, Decodable)]
-#[deriving_deserializable]
+#[deriving_deserialize]
 enum Animal {
     Dog,
     Frog(String, int)
@@ -260,7 +260,7 @@ mod deserializer {
 
         #[inline]
         fn missing_field<
-            T: de::Deserializable<AnimalDeserializer, Error>
+            T: de::Deserialize<AnimalDeserializer, Error>
         >(&mut self, _field: &'static str) -> Result<T, Error> {
             Err(SyntaxError)
         }
@@ -299,7 +299,7 @@ fn bench_deserializer_dog(b: &mut Bencher) {
         let animal = Dog;
 
         let mut d = deserializer::AnimalDeserializer::new(animal.clone());
-        let value: Animal = Deserializable::deserialize(&mut d).unwrap();
+        let value: Animal = Deserialize::deserialize(&mut d).unwrap();
 
         assert_eq!(value, animal);
     })
@@ -311,7 +311,7 @@ fn bench_deserializer_frog(b: &mut Bencher) {
         let animal = Frog("Henry".to_string(), 349);
 
         let mut d = deserializer::AnimalDeserializer::new(animal.clone());
-        let value: Animal = Deserializable::deserialize(&mut d).unwrap();
+        let value: Animal = Deserialize::deserialize(&mut d).unwrap();
 
         assert_eq!(value, animal);
     })
diff --git a/benches/bench_log.rs b/benches/bench_log.rs
index 09c50efb..7929c031 100644
--- a/benches/bench_log.rs
+++ b/benches/bench_log.rs
@@ -14,12 +14,12 @@ use test::Bencher;
 
 use serde::de;
 use serde::json;
-use serde::ser::Serializable;
+use serde::ser::Serialize;
 use serde::ser;
 
 #[deriving(Encodable, Decodable)]
-#[deriving_serializable]
-#[deriving_deserializable]
+#[deriving_serialize]
+#[deriving_deserialize]
 struct Http {
     protocol: HttpProtocol,
     status: u32,
@@ -39,14 +39,14 @@ enum HttpProtocol {
     HTTP11,
 }
 
-impl<S: ser::Serializer<E>, E> ser::Serializable<S, E> for HttpProtocol {
+impl<S: ser::Serializer<E>, E> ser::Serialize<S, E> for HttpProtocol {
     #[inline]
     fn serialize(&self, s: &mut S) -> Result<(), E> {
         s.serialize_uint(*self as uint)
     }
 }
 
-impl<D: de::Deserializer<E>, E> de::Deserializable<D, E> for HttpProtocol {
+impl<D: de::Deserializer<E>, E> de::Deserialize<D, E> for HttpProtocol {
     #[inline]
     fn deserialize_token(d: &mut D, token: de::Token) -> Result<HttpProtocol, E> {
         d.expect_from_primitive(token)
@@ -68,14 +68,14 @@ enum HttpMethod {
     PATCH,
 }
 
-impl<S: ser::Serializer<E>, E> ser::Serializable<S, E> for HttpMethod {
+impl<S: ser::Serializer<E>, E> ser::Serialize<S, E> for HttpMethod {
     #[inline]
     fn serialize(&self, s: &mut S) -> Result<(), E> {
         s.serialize_uint(*self as uint)
     }
 }
 
-impl<D: de::Deserializer<E>, E> de::Deserializable<D, E> for HttpMethod {
+impl<D: de::Deserializer<E>, E> de::Deserialize<D, E> for HttpMethod {
     #[inline]
     fn deserialize_token(d: &mut D, token: de::Token) -> Result<HttpMethod, E> {
         d.expect_from_primitive(token)
@@ -90,14 +90,14 @@ enum CacheStatus {
     Hit,
 }
 
-impl<S: ser::Serializer<E>, E> ser::Serializable<S, E> for CacheStatus {
+impl<S: ser::Serializer<E>, E> ser::Serialize<S, E> for CacheStatus {
     #[inline]
     fn serialize(&self, s: &mut S) -> Result<(), E> {
         s.serialize_uint(*self as uint)
     }
 }
 
-impl<D: de::Deserializer<E>, E> de::Deserializable<D, E> for CacheStatus {
+impl<D: de::Deserializer<E>, E> de::Deserialize<D, E> for CacheStatus {
     #[inline]
     fn deserialize_token(d: &mut D, token: de::Token) -> Result<CacheStatus, E> {
         d.expect_from_primitive(token)
@@ -105,8 +105,8 @@ impl<D: de::Deserializer<E>, E> de::Deserializable<D, E> for CacheStatus {
 }
 
 #[deriving(Encodable, Decodable)]
-#[deriving_serializable]
-#[deriving_deserializable]
+#[deriving_serialize]
+#[deriving_deserialize]
 struct Origin {
     ip: String,
     port: u32,
@@ -121,14 +121,14 @@ enum OriginProtocol {
     HTTPS,
 }
 
-impl<S: ser::Serializer<E>, E> ser::Serializable<S, E> for OriginProtocol {
+impl<S: ser::Serializer<E>, E> ser::Serialize<S, E> for OriginProtocol {
     #[inline]
     fn serialize(&self, s: &mut S) -> Result<(), E> {
         s.serialize_uint(*self as uint)
     }
 }
 
-impl<D: de::Deserializer<E>, E> de::Deserializable<D, E> for OriginProtocol {
+impl<D: de::Deserializer<E>, E> de::Deserialize<D, E> for OriginProtocol {
     #[inline]
     fn deserialize_token(d: &mut D, token: de::Token) -> Result<OriginProtocol, E> {
         d.expect_from_primitive(token)
@@ -144,14 +144,14 @@ enum ZonePlan {
     ENT,
 }
 
-impl<S: ser::Serializer<E>, E> ser::Serializable<S, E> for ZonePlan {
+impl<S: ser::Serializer<E>, E> ser::Serialize<S, E> for ZonePlan {
     #[inline]
     fn serialize(&self, s: &mut S) -> Result<(), E> {
         s.serialize_uint(*self as uint)
     }
 }
 
-impl<D: de::Deserializer<E>, E> de::Deserializable<D, E> for ZonePlan {
+impl<D: de::Deserializer<E>, E> de::Deserialize<D, E> for ZonePlan {
     #[inline]
     fn deserialize_token(d: &mut D, token: de::Token) -> Result<ZonePlan, E> {
         d.expect_from_primitive(token)
@@ -418,14 +418,14 @@ enum Country {
 	ZW,
 }
 
-impl<S: ser::Serializer<E>, E> ser::Serializable<S, E> for Country {
+impl<S: ser::Serializer<E>, E> ser::Serialize<S, E> for Country {
     #[inline]
     fn serialize(&self, s: &mut S) -> Result<(), E> {
         s.serialize_uint(*self as uint)
     }
 }
 
-impl<D: de::Deserializer<E>, E> de::Deserializable<D, E> for Country {
+impl<D: de::Deserializer<E>, E> de::Deserialize<D, E> for Country {
     #[inline]
     fn deserialize_token(d: &mut D, token: de::Token) -> Result<Country, E> {
         d.expect_from_primitive(token)
@@ -433,8 +433,8 @@ impl<D: de::Deserializer<E>, E> de::Deserializable<D, E> for Country {
 }
 
 #[deriving(Encodable, Decodable)]
-#[deriving_serializable]
-#[deriving_deserializable]
+#[deriving_serialize]
+#[deriving_deserialize]
 struct Log {
     timestamp: i64,
     zone_id: u32,
diff --git a/benches/bench_map.rs b/benches/bench_map.rs
index 82143989..c6674272 100644
--- a/benches/bench_map.rs
+++ b/benches/bench_map.rs
@@ -13,7 +13,7 @@ use test::Bencher;
 
 use serialize::{Decoder, Decodable};
 
-use serde::de::{Deserializer, Deserializable};
+use serde::de::{Deserializer, Deserialize};
 
 //////////////////////////////////////////////////////////////////////////////
 
@@ -258,7 +258,7 @@ mod deserializer {
 
         #[inline]
         fn missing_field<
-            T: de::Deserializable<IntDeserializer, Error>
+            T: de::Deserialize<IntDeserializer, Error>
         >(&mut self, _field: &'static str) -> Result<T, Error> {
             Err(SyntaxError)
         }
@@ -310,9 +310,9 @@ fn bench_decoder_100(b: &mut Bencher) {
 fn run_deserializer<
     D: Deserializer<E>,
     E: Show,
-    T: Clone + PartialEq + Show + Deserializable<D, E>
+    T: Clone + PartialEq + Show + Deserialize<D, E>
 >(mut d: D, value: T) {
-    let v: T = Deserializable::deserialize(&mut d).unwrap();
+    let v: T = Deserialize::deserialize(&mut d).unwrap();
 
     assert_eq!(value, v);
 }
diff --git a/benches/bench_struct.rs b/benches/bench_struct.rs
index 24a80412..cfdc2a1d 100644
--- a/benches/bench_struct.rs
+++ b/benches/bench_struct.rs
@@ -12,12 +12,12 @@ use test::Bencher;
 
 use serialize::{Decoder, Decodable};
 
-use serde::de::{Deserializer, Deserializable};
+use serde::de::{Deserializer, Deserialize};
 
 //////////////////////////////////////////////////////////////////////////////
 
 #[deriving(Clone, PartialEq, Show, Decodable)]
-#[deriving_deserializable]
+#[deriving_deserialize]
 struct Inner {
     a: (),
     b: uint,
@@ -27,7 +27,7 @@ struct Inner {
 //////////////////////////////////////////////////////////////////////////////
 
 #[deriving(Clone, PartialEq, Show, Decodable)]
-#[deriving_deserializable]
+#[deriving_deserialize]
 struct Outer {
     inner: Vec<Inner>,
 }
@@ -387,7 +387,7 @@ mod deserializer {
 
         #[inline]
         fn missing_field<
-            T: de::Deserializable<OuterDeserializer, Error>
+            T: de::Deserialize<OuterDeserializer, Error>
         >(&mut self, field: &'static str) -> Result<T, Error> {
             Err(MissingField(field))
         }
@@ -468,7 +468,7 @@ fn bench_deserializer_0_0(b: &mut Bencher) {
         };
 
         let mut d = deserializer::OuterDeserializer::new(outer.clone());
-        let value: Outer = Deserializable::deserialize(&mut d).unwrap();
+        let value: Outer = Deserialize::deserialize(&mut d).unwrap();
 
         assert_eq!(value, outer);
     })
@@ -490,7 +490,7 @@ fn bench_deserializer_1_0(b: &mut Bencher) {
         };
 
         let mut d = deserializer::OuterDeserializer::new(outer.clone());
-        let value: Outer = Deserializable::deserialize(&mut d).unwrap();
+        let value: Outer = Deserialize::deserialize(&mut d).unwrap();
 
         assert_eq!(value, outer);
     })
@@ -517,7 +517,7 @@ fn bench_deserializer_1_5(b: &mut Bencher) {
         };
 
         let mut d = deserializer::OuterDeserializer::new(outer.clone());
-        let value: Outer = Deserializable::deserialize(&mut d).unwrap();
+        let value: Outer = Deserialize::deserialize(&mut d).unwrap();
 
         assert_eq!(value, outer);
     })
diff --git a/benches/bench_vec.rs b/benches/bench_vec.rs
index f063c446..cd572f24 100644
--- a/benches/bench_vec.rs
+++ b/benches/bench_vec.rs
@@ -12,7 +12,7 @@ use test::Bencher;
 
 use serialize::{Decoder, Decodable};
 
-use serde::de::{Deserializer, Deserializable};
+use serde::de::{Deserializer, Deserialize};
 
 //////////////////////////////////////////////////////////////////////////////
 
@@ -327,7 +327,7 @@ mod deserializer {
 
         #[inline]
         fn missing_field<
-            T: de::Deserializable<IntDeserializer, Error>
+            T: de::Deserialize<IntDeserializer, Error>
         >(&mut self, _field: &'static str) -> Result<T, Error> {
             Err(SyntaxError)
         }
@@ -399,7 +399,7 @@ mod deserializer {
 
         #[inline]
         fn missing_field<
-            T: de::Deserializable<U8Deserializer, Error>
+            T: de::Deserialize<U8Deserializer, Error>
         >(&mut self, _field: &'static str) -> Result<T, Error> {
             Err(SyntaxError)
         }
@@ -421,9 +421,9 @@ fn run_decoder<
 fn run_deserializer<
     D: Deserializer<E>,
     E: Show,
-    T: Clone + PartialEq + Show + Deserializable<D, E>
+    T: Clone + PartialEq + Show + Deserialize<D, E>
 >(mut d: D, value: T) {
-    let v: T = Deserializable::deserialize(&mut d).unwrap();
+    let v: T = Deserialize::deserialize(&mut d).unwrap();
 
     assert_eq!(value, v);
 }
diff --git a/serde_macros/src/lib.rs b/serde_macros/src/lib.rs
index 876d5705..fd4ec19b 100644
--- a/serde_macros/src/lib.rs
+++ b/serde_macros/src/lib.rs
@@ -59,26 +59,26 @@ use rustc::plugin::Registry;
 #[doc(hidden)]
 pub fn plugin_registrar(reg: &mut Registry) {
     reg.register_syntax_extension(
-        token::intern("deriving_serializable"),
-        Decorator(box expand_deriving_serializable));
+        token::intern("deriving_serialize"),
+        Decorator(box expand_deriving_serialize));
 
     reg.register_syntax_extension(
-        token::intern("deriving_deserializable"),
-        Decorator(box expand_deriving_deserializable));
+        token::intern("deriving_deserialize"),
+        Decorator(box expand_deriving_deserialize));
 }
 
-fn expand_deriving_serializable(cx: &mut ExtCtxt,
-                                sp: Span,
-                                mitem: &MetaItem,
-                                item: &Item,
-                                push: |P<ast::Item>|) {
+fn expand_deriving_serialize(cx: &mut ExtCtxt,
+                             sp: Span,
+                             mitem: &MetaItem,
+                             item: &Item,
+                             push: |P<ast::Item>|) {
     let inline = cx.meta_word(sp, token::InternedString::new("inline"));
     let attrs = vec!(cx.attribute(sp, inline));
 
     let trait_def = TraitDef {
         span: sp,
         attributes: vec!(),
-        path: Path::new_(vec!("serde", "ser", "Serializable"), None,
+        path: Path::new_(vec!("serde", "ser", "Serialize"), None,
                          vec!(box Literal(Path::new_local("__S")),
                               box Literal(Path::new_local("__E"))), true),
         additional_bounds: Vec::new(),
@@ -109,7 +109,7 @@ fn expand_deriving_serializable(cx: &mut ExtCtxt,
                 ),
                 attributes: attrs,
                 combine_substructure: combine_substructure(|a, b, c| {
-                    serializable_substructure(a, b, c, item)
+                    serialize_substructure(a, b, c, item)
                 }),
             })
     };
@@ -117,11 +117,10 @@ fn expand_deriving_serializable(cx: &mut ExtCtxt,
     trait_def.expand(cx, mitem, item, push)
 }
 
-fn serializable_substructure(cx: &ExtCtxt,
-                             span: Span,
-                             substr: &Substructure,
-                             item: &Item
-                             ) -> P<Expr> {
+fn serialize_substructure(cx: &ExtCtxt,
+                          span: Span,
+                          substr: &Substructure,
+                          item: &Item) -> P<Expr> {
     let serializer = substr.nonself_args[0].clone();
 
     match (&item.node, substr.fields) {
@@ -193,19 +192,19 @@ fn serializable_substructure(cx: &ExtCtxt,
             })
         }
 
-        _ => cx.bug("expected Struct or EnumMatching in deriving_serializable")
+        _ => cx.bug("expected Struct or EnumMatching in deriving_serialize")
     }
 }
 
-pub fn expand_deriving_deserializable(cx: &mut ExtCtxt,
-                                      span: Span,
-                                      mitem: &MetaItem,
-                                      item: &Item,
-                                      push: |P<Item>|) {
+pub fn expand_deriving_deserialize(cx: &mut ExtCtxt,
+                                   span: Span,
+                                   mitem: &MetaItem,
+                                   item: &Item,
+                                   push: |P<Item>|) {
     let trait_def = TraitDef {
         span: span,
         attributes: Vec::new(),
-        path: Path::new_(vec!("serde", "de", "Deserializable"), None,
+        path: Path::new_(vec!("serde", "de", "Deserialize"), None,
                          vec!(box Literal(Path::new_local("__D")),
                               box Literal(Path::new_local("__E"))), true),
         additional_bounds: Vec::new(),
@@ -241,7 +240,7 @@ pub fn expand_deriving_deserializable(cx: &mut ExtCtxt,
                 ),
                 attributes: Vec::new(),
                 combine_substructure: combine_substructure(|a, b, c| {
-                    deserializable_substructure(a, b, c)
+                    deserialize_substructure(a, b, c)
                 }),
             })
     };
@@ -249,8 +248,9 @@ pub fn expand_deriving_deserializable(cx: &mut ExtCtxt,
     trait_def.expand(cx, mitem, item, push)
 }
 
-fn deserializable_substructure(cx: &mut ExtCtxt, span: Span,
-                               substr: &Substructure) -> P<Expr> {
+fn deserialize_substructure(cx: &mut ExtCtxt,
+                            span: Span,
+                            substr: &Substructure) -> P<Expr> {
     let deserializer = substr.nonself_args[0].clone();
     let token = substr.nonself_args[1].clone();
 
@@ -275,7 +275,7 @@ fn deserializable_substructure(cx: &mut ExtCtxt, span: Span,
                 deserializer,
                 token)
         }
-        _ => cx.bug("expected StaticEnum or StaticStruct in deriving(Deserializable)")
+        _ => cx.bug("expected StaticEnum or StaticStruct in deriving(Deserialize)")
     }
 }
 
@@ -372,7 +372,7 @@ fn deserialize_struct(
                 Some(_) => unreachable!(),
                 None => {
                     let _: ::serde::de::IgnoreTokens =
-                        try!(::serde::de::Deserializable::deserialize($deserializer));
+                        try!(::serde::de::Deserialize::deserialize($deserializer));
                 }
             }
             //try!($deserializer.ignore_field(token))
@@ -409,7 +409,7 @@ fn deserialize_enum(
     let arms: Vec<ast::Arm> = fields.iter()
         .enumerate()
         .map(|(i, &(name, span, ref parts))| {
-            let call = deserializable_static_fields(
+            let call = deserialize_static_fields(
                 cx,
                 span,
                 name,
@@ -441,7 +441,7 @@ fn deserialize_enum(
 /// Create a deserializer for a single enum variant/struct:
 /// - `outer_pat_ident` is the name of this enum variant/struct
 /// - `getarg` should retrieve the `uint`-th field with name `&str`.
-fn deserializable_static_fields(
+fn deserialize_static_fields(
     cx: &ExtCtxt,
     span: Span,
     outer_pat_ident: Ident,
diff --git a/src/de.rs b/src/de.rs
index 2fa78ae6..87e646df 100644
--- a/src/de.rs
+++ b/src/de.rs
@@ -177,7 +177,7 @@ macro_rules! to_result {
 }
 
 pub trait Deserializer<E>: Iterator<Result<Token, E>> {
-    /// Called when a `Deserializable` expected more tokens, but the
+    /// Called when a `Deserialize` expected more tokens, but the
     /// `Deserializer` was empty.
     fn end_of_stream_error(&mut self) -> E;
 
@@ -190,15 +190,15 @@ pub trait Deserializer<E>: Iterator<Result<Token, E>> {
     /// Called when a value was unable to be coerced into another value.
     fn conversion_error(&mut self, token: Token) -> E;
 
-    /// Called when a `Deserializable` structure did not deserialize a field
+    /// Called when a `Deserialize` structure did not deserialize a field
     /// named `field`.
     fn missing_field<
-        T: Deserializable<Self, E>
+        T: Deserialize<Self, E>
     >(&mut self, field: &'static str) -> Result<T, E>;
 
-    /// Called when a deserializable has decided to not consume this token.
+    /// Called when a `Deserialize` has decided to not consume this token.
     fn ignore_field(&mut self, _token: Token) -> Result<(), E> {
-        let _: IgnoreTokens = try!(Deserializable::deserialize(self));
+        let _: IgnoreTokens = try!(Deserialize::deserialize(self));
         Ok(())
     }
 
@@ -305,12 +305,12 @@ pub trait Deserializer<E>: Iterator<Result<Token, E>> {
 
     #[inline]
     fn expect_option<
-        T: Deserializable<Self, E>
+        T: Deserialize<Self, E>
     >(&mut self, token: Token) -> Result<option::Option<T>, E> {
         match token {
             Option(false) => Ok(None),
             Option(true) => {
-                let value: T = try!(Deserializable::deserialize(self));
+                let value: T = try!(Deserialize::deserialize(self));
                 Ok(Some(value))
             }
             token => Err(self.syntax_error(token, [OptionKind])),
@@ -328,9 +328,9 @@ pub trait Deserializer<E>: Iterator<Result<Token, E>> {
 
     #[inline]
     fn expect_tuple_elt<
-        T: Deserializable<Self, E>
+        T: Deserialize<Self, E>
     >(&mut self) -> Result<T, E> {
-        Deserializable::deserialize(self)
+        Deserialize::deserialize(self)
     }
 
     #[inline]
@@ -377,9 +377,9 @@ pub trait Deserializer<E>: Iterator<Result<Token, E>> {
 
     #[inline]
     fn expect_struct_value<
-        T: Deserializable<Self, E>
+        T: Deserialize<Self, E>
     >(&mut self) -> Result<T, E> {
-        Deserializable::deserialize(self)
+        Deserialize::deserialize(self)
     }
 
     #[inline]
@@ -409,9 +409,9 @@ pub trait Deserializer<E>: Iterator<Result<Token, E>> {
 
     #[inline]
     fn expect_enum_elt<
-        T: Deserializable<Self, E>
+        T: Deserialize<Self, E>
     >(&mut self) -> Result<T, E> {
-        Deserializable::deserialize(self)
+        Deserialize::deserialize(self)
     }
 
     #[inline]
@@ -433,12 +433,12 @@ pub trait Deserializer<E>: Iterator<Result<Token, E>> {
 
     #[inline]
     fn expect_seq_elt_or_end<
-        T: Deserializable<Self, E>
+        T: Deserialize<Self, E>
     >(&mut self) -> Result<option::Option<T>, E> {
         match try!(self.expect_token()) {
             End => Ok(None),
             token => {
-                let value = try!(Deserializable::deserialize_token(self, token));
+                let value = try!(Deserialize::deserialize_token(self, token));
                 Ok(Some(value))
             }
         }
@@ -447,7 +447,7 @@ pub trait Deserializer<E>: Iterator<Result<Token, E>> {
     #[inline]
     fn expect_seq<
         'a,
-        T: Deserializable<Self, E>,
+        T: Deserialize<Self, E>,
         C: FromIterator<T>
     >(&'a mut self, token: Token) -> Result<C, E> {
         let len = try!(self.expect_seq_start(token));
@@ -476,14 +476,14 @@ pub trait Deserializer<E>: Iterator<Result<Token, E>> {
 
     #[inline]
     fn expect_map_elt_or_end<
-        K: Deserializable<Self, E>,
-        V: Deserializable<Self, E>
+        K: Deserialize<Self, E>,
+        V: Deserialize<Self, E>
     >(&mut self) -> Result<option::Option<(K, V)>, E> {
         match try!(self.expect_token()) {
             End => Ok(None),
             token => {
-                let key = try!(Deserializable::deserialize_token(self, token));
-                let value = try!(Deserializable::deserialize(self));
+                let key = try!(Deserialize::deserialize_token(self, token));
+                let value = try!(Deserialize::deserialize(self));
                 Ok(Some((key, value)))
             }
         }
@@ -492,8 +492,8 @@ pub trait Deserializer<E>: Iterator<Result<Token, E>> {
     #[inline]
     fn expect_map<
         'a,
-        K: Deserializable<Self, E>,
-        V: Deserializable<Self, E>,
+        K: Deserialize<Self, E>,
+        V: Deserialize<Self, E>,
         C: FromIterator<(K, V)>
     >(&'a mut self, token: Token) -> Result<C, E> {
         let len = try!(self.expect_map_start(token));
@@ -525,7 +525,7 @@ impl<
     'a,
     D: Deserializer<E>,
     E,
-    T: Deserializable<D, E>
+    T: Deserialize<D, E>
 > Iterator<T> for SeqDeserializer<'a, D, E> {
     #[inline]
     fn next(&mut self) -> option::Option<T> {
@@ -556,8 +556,8 @@ impl<
     'a,
     D: Deserializer<E>,
     E,
-    K: Deserializable<D, E>,
-    V: Deserializable<D, E>
+    K: Deserialize<D, E>,
+    V: Deserialize<D, E>
 > Iterator<(K, V)> for MapDeserializer<'a, D, E> {
     #[inline]
     fn next(&mut self) -> option::Option<(K, V)> {
@@ -578,11 +578,11 @@ impl<
 
 //////////////////////////////////////////////////////////////////////////////
 
-pub trait Deserializable<D: Deserializer<E>, E> {
+pub trait Deserialize<D: Deserializer<E>, E> {
     #[inline]
     fn deserialize(d: &mut D) -> Result<Self, E> {
         let token = try!(d.expect_token());
-        Deserializable::deserialize_token(d, token)
+        Deserialize::deserialize_token(d, token)
     }
 
     fn deserialize_token(d: &mut D, token: Token) -> Result<Self, E>;
@@ -590,9 +590,9 @@ pub trait Deserializable<D: Deserializer<E>, E> {
 
 //////////////////////////////////////////////////////////////////////////////
 
-macro_rules! impl_deserializable {
+macro_rules! impl_deserialize {
     ($ty:ty, $method:ident) => {
-        impl<D: Deserializer<E>, E> Deserializable<D, E> for $ty {
+        impl<D: Deserializer<E>, E> Deserialize<D, E> for $ty {
             #[inline]
             fn deserialize_token(d: &mut D, token: Token) -> Result<$ty, E> {
                 d.$method(token)
@@ -601,55 +601,55 @@ macro_rules! impl_deserializable {
     }
 }
 
-impl_deserializable!(bool, expect_bool)
-impl_deserializable!(int, expect_num)
-impl_deserializable!(i8, expect_num)
-impl_deserializable!(i16, expect_num)
-impl_deserializable!(i32, expect_num)
-impl_deserializable!(i64, expect_num)
-impl_deserializable!(uint, expect_num)
-impl_deserializable!(u8, expect_num)
-impl_deserializable!(u16, expect_num)
-impl_deserializable!(u32, expect_num)
-impl_deserializable!(u64, expect_num)
-impl_deserializable!(f32, expect_num)
-impl_deserializable!(f64, expect_num)
-impl_deserializable!(char, expect_char)
-impl_deserializable!(&'static str, expect_str)
-impl_deserializable!(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)
 
 //////////////////////////////////////////////////////////////////////////////
 
 impl<
     D: Deserializer<E>,
     E,
-    T: Deserializable<D, E>
-> Deserializable<D, E> for Box<T> {
+    T: Deserialize<D, E>
+> Deserialize<D, E> for Box<T> {
     #[inline]
     fn deserialize_token(d: &mut D, token: Token) -> Result<Box<T>, E> {
-        Ok(box try!(Deserializable::deserialize_token(d, token)))
+        Ok(box try!(Deserialize::deserialize_token(d, token)))
     }
 }
 
 impl<
     D: Deserializer<E>,
     E,
-    T: Deserializable<D, E>
-> Deserializable<D, E> for Rc<T> {
+    T: Deserialize<D, E>
+> Deserialize<D, E> for Rc<T> {
     #[inline]
     fn deserialize_token(d: &mut D, token: Token) -> Result<Rc<T>, E> {
-        Ok(Rc::new(try!(Deserializable::deserialize_token(d, token))))
+        Ok(Rc::new(try!(Deserialize::deserialize_token(d, token))))
     }
 }
 
 impl<
     D: Deserializer<E>,
     E,
-    T: Deserializable<D, E> + Send + Sync
-> Deserializable<D, E> for Arc<T> {
+    T: Deserialize<D, E> + Send + Sync
+> Deserialize<D, E> for Arc<T> {
     #[inline]
     fn deserialize_token(d: &mut D, token: Token) -> Result<Arc<T>, E> {
-        Ok(Arc::new(try!(Deserializable::deserialize_token(d, token))))
+        Ok(Arc::new(try!(Deserialize::deserialize_token(d, token))))
     }
 }
 
@@ -658,8 +658,8 @@ impl<
 impl<
     D: Deserializer<E>,
     E,
-    T: Deserializable<D ,E>
-> Deserializable<D, E> for option::Option<T> {
+    T: Deserialize<D ,E>
+> Deserialize<D, E> for option::Option<T> {
     #[inline]
     fn deserialize_token(d: &mut D, token: Token) -> Result<option::Option<T>, E> {
         d.expect_option(token)
@@ -671,8 +671,8 @@ impl<
 impl<
     D: Deserializer<E>,
     E,
-    T: Deserializable<D ,E>
-> Deserializable<D, E> for Vec<T> {
+    T: Deserialize<D ,E>
+> Deserialize<D, E> for Vec<T> {
     #[inline]
     fn deserialize_token(d: &mut D, token: Token) -> Result<Vec<T>, E> {
         d.expect_seq(token)
@@ -684,9 +684,9 @@ impl<
 impl<
     D: Deserializer<E>,
     E,
-    K: Deserializable<D, E> + Eq + Hash,
-    V: Deserializable<D, E>
-> Deserializable<D, E> for HashMap<K, V> {
+    K: Deserialize<D, E> + Eq + Hash,
+    V: Deserialize<D, E>
+> Deserialize<D, E> for HashMap<K, V> {
     #[inline]
     fn deserialize_token(d: &mut D, token: Token) -> Result<HashMap<K, V>, E> {
         d.expect_map(token)
@@ -696,9 +696,9 @@ impl<
 impl<
     D: Deserializer<E>,
     E,
-    K: Deserializable<D, E> + Ord,
-    V: Deserializable<D, E>
-> Deserializable<D, E> for TreeMap<K, V> {
+    K: Deserialize<D, E> + Ord,
+    V: Deserialize<D, E>
+> Deserialize<D, E> for TreeMap<K, V> {
     #[inline]
     fn deserialize_token(d: &mut D, token: Token) -> Result<TreeMap<K, V>, E> {
         d.expect_map(token)
@@ -710,8 +710,8 @@ impl<
 impl<
     D: Deserializer<E>,
     E,
-    T: Deserializable<D, E> + Eq + Hash
-> Deserializable<D, E> for HashSet<T> {
+    T: Deserialize<D, E> + Eq + Hash
+> Deserialize<D, E> for HashSet<T> {
     #[inline]
     fn deserialize_token(d: &mut D, token: Token) -> Result<HashSet<T>, E> {
         d.expect_seq(token)
@@ -721,8 +721,8 @@ impl<
 impl<
     D: Deserializer<E>,
     E,
-    T: Deserializable<D, E> + Ord
-> Deserializable<D, E> for TreeSet<T> {
+    T: Deserialize<D, E> + Ord
+> Deserialize<D, E> for TreeSet<T> {
     #[inline]
     fn deserialize_token(d: &mut D, token: Token) -> Result<TreeSet<T>, E> {
         d.expect_seq(token)
@@ -740,7 +740,7 @@ macro_rules! impl_deserialize_tuple {
         impl<
             D: Deserializer<E>,
             E
-        > Deserializable<D, E> for () {
+        > Deserialize<D, E> for () {
             #[inline]
             fn deserialize_token(d: &mut D, token: Token) -> Result<(), E> {
                 d.expect_null(token)
@@ -751,8 +751,8 @@ macro_rules! impl_deserialize_tuple {
         impl<
             D: Deserializer<E>,
             E,
-            $($name: Deserializable<D, E>),*
-        > Deserializable<D, E> for ($($name,)*) {
+            $($name: Deserialize<D, E>),*
+        > Deserialize<D, E> for ($($name,)*) {
             #[inline]
             #[allow(non_snake_case)]
             fn deserialize_token(d: &mut D, token: Token) -> Result<($($name,)*), E> {
@@ -780,12 +780,12 @@ impl_deserialize_tuple! { T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, }
 /// recursive structures.
 pub struct IgnoreTokens;
 
-impl<D: Deserializer<E>, E> Deserializable<D, E> for IgnoreTokens {
+impl<D: Deserializer<E>, E> Deserialize<D, E> for IgnoreTokens {
     #[inline]
     fn deserialize_token(d: &mut D, token: Token) -> Result<IgnoreTokens, E> {
         match token {
             Option(true) => {
-                Deserializable::deserialize(d)
+                Deserialize::deserialize(d)
             }
 
             EnumStart(_, _, _) => {
@@ -793,7 +793,7 @@ impl<D: Deserializer<E>, E> Deserializable<D, E> for IgnoreTokens {
                     match try!(d.expect_token()) {
                         End => { return Ok(IgnoreTokens); }
                         token => {
-                            let _: IgnoreTokens = try!(Deserializable::deserialize_token(d, token));
+                            let _: IgnoreTokens = try!(Deserialize::deserialize_token(d, token));
                         }
                     }
                 }
@@ -804,7 +804,7 @@ impl<D: Deserializer<E>, E> Deserializable<D, E> for IgnoreTokens {
                     match try!(d.expect_token()) {
                         End => { return Ok(IgnoreTokens); }
                         Str(_) | String(_) => {
-                            let _: IgnoreTokens = try!(Deserializable::deserialize(d));
+                            let _: IgnoreTokens = try!(Deserialize::deserialize(d));
                         }
                         _token => { return Err(d.syntax_error(token, [EndKind, StrKind, StringKind])); }
                     }
@@ -816,7 +816,7 @@ impl<D: Deserializer<E>, E> Deserializable<D, E> for IgnoreTokens {
                     match try!(d.expect_token()) {
                         End => { return Ok(IgnoreTokens); }
                         token => {
-                            let _: IgnoreTokens = try!(Deserializable::deserialize_token(d, token));
+                            let _: IgnoreTokens = try!(Deserialize::deserialize_token(d, token));
                         }
                     }
                 }
@@ -827,7 +827,7 @@ impl<D: Deserializer<E>, E> Deserializable<D, E> for IgnoreTokens {
                     match try!(d.expect_token()) {
                         End => { return Ok(IgnoreTokens); }
                         token => {
-                            let _: IgnoreTokens = try!(Deserializable::deserialize_token(d, token));
+                            let _: IgnoreTokens = try!(Deserialize::deserialize_token(d, token));
                         }
                     }
                 }
@@ -838,8 +838,8 @@ impl<D: Deserializer<E>, E> Deserializable<D, E> for IgnoreTokens {
                     match try!(d.expect_token()) {
                         End => { return Ok(IgnoreTokens); }
                         token => {
-                            let _: IgnoreTokens = try!(Deserializable::deserialize_token(d, token));
-                            let _: IgnoreTokens = try!(Deserializable::deserialize(d));
+                            let _: IgnoreTokens = try!(Deserialize::deserialize_token(d, token));
+                            let _: IgnoreTokens = try!(Deserialize::deserialize(d));
                         }
                     }
                 }
@@ -967,7 +967,7 @@ impl GatherTokens {
     }
 }
 
-impl<D: Deserializer<E>, E> Deserializable<D, E> for GatherTokens {
+impl<D: Deserializer<E>, E> Deserialize<D, E> for GatherTokens {
     #[inline]
     fn deserialize_token(d: &mut D, token: Token) -> Result<GatherTokens, E> {
         let mut tokens = GatherTokens {
@@ -986,7 +986,7 @@ mod tests {
     use std::{option, string};
     use serialize::Decoder;
 
-    use super::{Deserializer, Deserializable, Token, TokenKind, IgnoreTokens};
+    use super::{Deserializer, Deserialize, Token, TokenKind, IgnoreTokens};
     use super::{
         Null,
         Bool,
@@ -1034,7 +1034,7 @@ mod tests {
     impl<
         D: Deserializer<E>,
         E
-    > Deserializable<D, E> for Inner {
+    > Deserialize<D, E> for Inner {
         #[inline]
         fn deserialize_token(d: &mut D, token: Token) -> Result<Inner, E> {
             try!(d.expect_struct_start(token, "Inner"));
@@ -1056,7 +1056,7 @@ mod tests {
                     Some(1) => { b = Some(try!(d.expect_struct_value())); }
                     Some(2) => { c = Some(try!(d.expect_struct_value())); }
                     Some(_) => unreachable!(),
-                    None => { let _: IgnoreTokens = try!(Deserializable::deserialize(d)); }
+                    None => { let _: IgnoreTokens = try!(Deserialize::deserialize(d)); }
                 }
             }
 
@@ -1071,7 +1071,7 @@ mod tests {
         inner: Vec<Inner>,
     }
 
-    impl<D: Deserializer<E>, E> Deserializable<D, E> for Outer {
+    impl<D: Deserializer<E>, E> Deserialize<D, E> for Outer {
         #[inline]
         fn deserialize_token(d: &mut D, token: Token) -> Result<Outer, E> {
             try!(d.expect_struct_start(token, "Outer"));
@@ -1089,7 +1089,7 @@ mod tests {
                 match idx {
                     Some(0) => { inner = Some(try!(d.expect_struct_value())); }
                     Some(_) => unreachable!(),
-                    None => { let _: IgnoreTokens = try!(Deserializable::deserialize(d)); }
+                    None => { let _: IgnoreTokens = try!(Deserialize::deserialize(d)); }
                 }
             }
 
@@ -1105,7 +1105,7 @@ mod tests {
         Frog(string::String, int)
     }
 
-    impl<D: Deserializer<E>, E> Deserializable<D, E> for Animal {
+    impl<D: Deserializer<E>, E> Deserialize<D, E> for Animal {
         #[inline]
         fn deserialize_token(d: &mut D, token: Token) -> Result<Animal, E> {
             match try!(d.expect_enum_start(token, "Animal", ["Dog", "Frog"])) {
@@ -1114,8 +1114,8 @@ mod tests {
                     Ok(Dog)
                 }
                 1 => {
-                    let x0 = try!(Deserializable::deserialize(d));
-                    let x1 = try!(Deserializable::deserialize(d));
+                    let x0 = try!(Deserialize::deserialize(d));
+                    let x1 = try!(Deserialize::deserialize(d));
                     try!(d.expect_enum_end());
                     Ok(Frog(x0, x1))
                 }
@@ -1179,7 +1179,7 @@ mod tests {
 
         #[inline]
         fn missing_field<
-            T: Deserializable<TokenDeserializer<Iter>, Error>
+            T: Deserialize<TokenDeserializer<Iter>, Error>
         >(&mut self, field: &'static str) -> Result<T, Error> {
             Err(MissingField(field))
         }
@@ -1193,7 +1193,7 @@ mod tests {
             fn $name() {
                 $(
                     let mut deserializer = TokenDeserializer::new($tokens.into_iter());
-                    let value: $ty = Deserializable::deserialize(&mut deserializer).unwrap();
+                    let value: $ty = Deserialize::deserialize(&mut deserializer).unwrap();
 
                     assert_eq!(value, $value);
                 )+
diff --git a/src/json/mod.rs b/src/json/mod.rs
index a89049a7..ccabaa1a 100644
--- a/src/json/mod.rs
+++ b/src/json/mod.rs
@@ -52,12 +52,12 @@ A simple JSON document serializing a person, his/her age, address and phone numb
 
 Rust provides a mechanism for low boilerplate serializing and deserializing
 of values to and from JSON via the serialization API.
-To be able to serialize a piece of data, it must implement the `serde::Serializable` trait.
-To be able to deserialize a piece of data, it must implement the `serde::Deserializable` trait.
+To be able to serialize a piece of data, it must implement the `serde::Serialize` trait.
+To be able to deserialize a piece of data, it must implement the `serde::Deserialize` trait.
 The Rust compiler provides an annotation to automatically generate
-the code for these traits: `#[deriving_serializable]` and `#[deriving_deserializable]`.
+the code for these traits: `#[deriving_serialize]` and `#[deriving_deserialize]`.
 
-To serialize using `Serializable`:
+To serialize using `Serialize`:
 
 ```rust
 #![feature(phase)]
@@ -67,9 +67,9 @@ extern crate serde;
 
 use std::io::{MemWriter, AsRefWriter};
 use serde::json;
-use serde::Serializable;
+use serde::Serialize;
 
-#[deriving_serializable]
+#[deriving_serialize]
 pub struct TestStruct   {
     data_str: String,
 }
@@ -90,7 +90,7 @@ fn main() {
 }
 ```
 
-Two wrapper functions are provided to serialize a Serializable object
+Two wrapper functions are provided to serialize a `Serialize` object
 into a string (String) or buffer (~[u8]): `json::to_string(value)` and
 `json::to_vec(value)`.
 
@@ -104,7 +104,7 @@ JSON API provide an enum `json::Json` and a trait `ToJson` to serialize object.
 The trait `ToJson` serialize object into a container `json::Json` and the API provide writer
 to serialize them into a stream or a string ...
 
-When using `ToJson` the `Serializable` trait implementation is not mandatory.
+When using `ToJson` the `Serialize` trait implementation is not mandatory.
 
 A basic `ToJson` example using a TreeMap of attribute name / attribute value:
 
@@ -140,7 +140,7 @@ fn main() {
 }
 ```
 
-To deserialize a JSON string using `Deserializable` trait :
+To deserialize a JSON string using `Deserialize` trait :
 
 ```rust
 #![feature(phase)]
@@ -149,9 +149,9 @@ extern crate serde_macros;
 extern crate serde;
 
 use serde::json;
-use serde::Deserializable;
+use serde::Deserialize;
 
-#[deriving_deserializable]
+#[deriving_deserialize]
 pub struct MyStruct  {
      attr1: u8,
      attr2: String,
@@ -160,7 +160,7 @@ pub struct MyStruct  {
 fn main() {
     let json_str_to_deserialize = "{ \"attr1\": 1, \"attr2\": \"toto\" }";
     let mut parser = json::Parser::new(json_str_to_deserialize.bytes());
-    let deserialized_object: MyStruct = match Deserializable::deserialize(&mut parser) {
+    let deserialized_object: MyStruct = match Deserialize::deserialize(&mut parser) {
         Ok(v) => v,
         Err(e) => panic!("Decoding error: {}", e)
     };
@@ -182,8 +182,8 @@ extern crate serde;
 
 use serde::json;
 
-#[deriving_serializable]
-#[deriving_deserializable]
+#[deriving_serialize]
+#[deriving_deserialize]
 pub struct TestStruct1  {
     data_int: u8,
     data_str: String,
@@ -191,7 +191,7 @@ pub struct TestStruct1  {
 }
 
 // To serialize use the `json::to_string` to serialize an object in a string.
-// It calls the generated `Serializable` impl.
+// It calls the generated `Serialize` impl.
 fn main() {
     let to_serialize_object = TestStruct1 {
         data_int: 1,
@@ -223,10 +223,10 @@ extern crate serde;
 use std::collections::TreeMap;
 use serde::json::ToJson;
 use serde::json;
-use serde::Deserializable;
+use serde::Deserialize;
 
-#[deriving_serializable]   // generate Serializable impl
-#[deriving_deserializable] // generate Deserializable impl
+#[deriving_serialize]   // generate Serialize impl
+#[deriving_deserialize] // generate Deserialize impl
 pub struct TestStruct1  {
     data_int: u8,
     data_str: String,
@@ -257,7 +257,7 @@ fn main() {
     // Deserialize like before.
 
     let mut parser = json::Parser::new(json_str.as_slice().bytes());
-    let deserialized: TestStruct1 = Deserializable::deserialize(&mut parser).unwrap();
+    let deserialized: TestStruct1 = Deserialize::deserialize(&mut parser).unwrap();
 }
 ```
 
@@ -279,7 +279,7 @@ use std::vec::Vec;
 use std::vec;
 
 use de;
-use ser::Serializable;
+use ser::Serialize;
 use ser;
 
 pub mod builder;
@@ -498,7 +498,7 @@ impl fmt::Show for Json {
     }
 }
 
-impl<S: ser::Serializer<E>, E> ser::Serializable<S, E> for Json {
+impl<S: ser::Serializer<E>, E> ser::Serialize<S, E> for Json {
     #[inline]
     fn serialize(&self, s: &mut S) -> Result<(), E> {
         match *self {
@@ -527,7 +527,7 @@ impl<S: ser::Serializer<E>, E> ser::Serializable<S, E> for Json {
     }
 }
 
-impl<D: de::Deserializer<E>, E> de::Deserializable<D, E> for Json {
+impl<D: de::Deserializer<E>, E> de::Deserialize<D, E> for Json {
     #[inline]
     fn deserialize_token(d: &mut D, token: de::Token) -> Result<Json, E> {
         match token {
@@ -549,18 +549,18 @@ impl<D: de::Deserializer<E>, E> de::Deserializable<D, E> for Json {
             de::Str(x) => Ok(String(x.to_string())),
             de::String(x) => Ok(String(x)),
             de::Option(false) => Ok(Null),
-            de::Option(true) => de::Deserializable::deserialize(d),
+            de::Option(true) => de::Deserialize::deserialize(d),
             de::TupleStart(_) | de::SeqStart(_) => {
-                let list = try!(de::Deserializable::deserialize_token(d, token));
+                let list = try!(de::Deserialize::deserialize_token(d, token));
                 Ok(List(list))
             }
             de::StructStart(_, _) | de::MapStart(_) => {
-                let object = try!(de::Deserializable::deserialize_token(d, token));
+                let object = try!(de::Deserialize::deserialize_token(d, token));
                 Ok(Object(object))
             }
             de::EnumStart(_, name, len) => {
                 let token = de::SeqStart(len);
-                let fields: Vec<Json> = try!(de::Deserializable::deserialize_token(d, token));
+                let fields: Vec<Json> = try!(de::Deserialize::deserialize_token(d, token));
                 let mut object = TreeMap::new();
                 object.insert(name.to_string(), List(fields));
                 Ok(Object(object))
@@ -668,22 +668,22 @@ impl de::Deserializer<ParserError> for JsonDeserializer {
 
     #[inline]
     fn missing_field<
-        T: de::Deserializable<JsonDeserializer, ParserError>
+        T: de::Deserialize<JsonDeserializer, ParserError>
     >(&mut self, _field: &'static str) -> Result<T, ParserError> {
         // JSON can represent `null` values as a missing value, so this isn't
         // necessarily an error.
-        de::Deserializable::deserialize_token(self, de::Null)
+        de::Deserialize::deserialize_token(self, de::Null)
     }
 
     // Special case treating options as a nullable value.
     #[inline]
     fn expect_option<
-        U: de::Deserializable<JsonDeserializer, ParserError>
+        U: de::Deserialize<JsonDeserializer, ParserError>
     >(&mut self, token: de::Token) -> Result<Option<U>, ParserError> {
         match token {
             de::Null => Ok(None),
             token => {
-                let value: U = try!(de::Deserializable::deserialize_token(self, token));
+                let value: U = try!(de::Deserialize::deserialize_token(self, token));
                 Ok(Some(value))
             }
         }
@@ -1054,7 +1054,7 @@ impl<W: Writer> ser::Serializer<io::IoError> for Serializer<W> {
 
     #[inline]
     fn serialize_tuple_elt<
-        T: Serializable<Serializer<W>, io::IoError>
+        T: Serialize<Serializer<W>, io::IoError>
     >(&mut self, value: &T) -> IoResult<()> {
         if self.first {
             self.first = false;
@@ -1077,7 +1077,7 @@ impl<W: Writer> ser::Serializer<io::IoError> for Serializer<W> {
 
     #[inline]
     fn serialize_struct_elt<
-        T: Serializable<Serializer<W>, io::IoError>
+        T: Serialize<Serializer<W>, io::IoError>
     >(&mut self, name: &str, value: &T) -> IoResult<()> {
         if self.first {
             self.first = false;
@@ -1104,7 +1104,7 @@ impl<W: Writer> ser::Serializer<io::IoError> for Serializer<W> {
 
     #[inline]
     fn serialize_enum_elt<
-        T: Serializable<Serializer<W>, io::IoError>
+        T: Serialize<Serializer<W>, io::IoError>
     >(&mut self, value: &T) -> IoResult<()> {
         if self.first {
             self.first = false;
@@ -1121,7 +1121,7 @@ impl<W: Writer> ser::Serializer<io::IoError> for Serializer<W> {
 
     #[inline]
     fn serialize_option<
-        T: Serializable<Serializer<W>, io::IoError>
+        T: Serialize<Serializer<W>, io::IoError>
     >(&mut self, v: &Option<T>) -> IoResult<()> {
         match *v {
             Some(ref v) => {
@@ -1135,7 +1135,7 @@ impl<W: Writer> ser::Serializer<io::IoError> for Serializer<W> {
 
     #[inline]
     fn serialize_seq<
-        T: Serializable<Serializer<W>, io::IoError>,
+        T: Serialize<Serializer<W>, io::IoError>,
         Iter: Iterator<T>
     >(&mut self, mut iter: Iter) -> IoResult<()> {
         try!(self.wr.write_str("["));
@@ -1154,8 +1154,8 @@ impl<W: Writer> ser::Serializer<io::IoError> for Serializer<W> {
 
     #[inline]
     fn serialize_map<
-        K: Serializable<Serializer<W>, io::IoError>,
-        V: Serializable<Serializer<W>, io::IoError>,
+        K: Serialize<Serializer<W>, io::IoError>,
+        V: Serialize<Serializer<W>, io::IoError>,
         Iter: Iterator<(K, V)>
     >(&mut self, mut iter: Iter) -> IoResult<()> {
         //Warning: WriterFormatter was added to work around
@@ -1319,7 +1319,7 @@ impl<W: Writer> ser::Serializer<io::IoError> for PrettySerializer<W> {
 
     #[inline]
     fn serialize_tuple_elt<
-        T: Serializable<PrettySerializer<W>, io::IoError>
+        T: Serialize<PrettySerializer<W>, io::IoError>
     >(&mut self, value: &T) -> IoResult<()> {
         try!(self.serialize_sep());
         value.serialize(self)
@@ -1338,7 +1338,7 @@ impl<W: Writer> ser::Serializer<io::IoError> for PrettySerializer<W> {
 
     #[inline]
     fn serialize_struct_elt<
-        T: Serializable<PrettySerializer<W>, io::IoError>
+        T: Serialize<PrettySerializer<W>, io::IoError>
     >(&mut self, name: &str, value: &T) -> IoResult<()> {
         try!(self.serialize_sep());
         try!(self.serialize_str(name));
@@ -1363,7 +1363,7 @@ impl<W: Writer> ser::Serializer<io::IoError> for PrettySerializer<W> {
 
     #[inline]
     fn serialize_enum_elt<
-        T: Serializable<PrettySerializer<W>, io::IoError>
+        T: Serialize<PrettySerializer<W>, io::IoError>
     >(&mut self, value: &T) -> IoResult<()> {
         try!(self.serialize_sep());
         value.serialize(self)
@@ -1377,7 +1377,7 @@ impl<W: Writer> ser::Serializer<io::IoError> for PrettySerializer<W> {
 
     #[inline]
     fn serialize_option<
-        T: Serializable<PrettySerializer<W>, io::IoError>
+        T: Serialize<PrettySerializer<W>, io::IoError>
     >(&mut self, v: &Option<T>) -> IoResult<()> {
         match *v {
             Some(ref v) => {
@@ -1391,7 +1391,7 @@ impl<W: Writer> ser::Serializer<io::IoError> for PrettySerializer<W> {
 
     #[inline]
     fn serialize_seq<
-        T: Serializable<PrettySerializer<W>, io::IoError>,
+        T: Serialize<PrettySerializer<W>, io::IoError>,
         Iter: Iterator<T>
     >(&mut self, mut iter: Iter) -> IoResult<()> {
         try!(self.wr.write_str("["));
@@ -1407,8 +1407,8 @@ impl<W: Writer> ser::Serializer<io::IoError> for PrettySerializer<W> {
 
     #[inline]
     fn serialize_map<
-        K: Serializable<PrettySerializer<W>, io::IoError>,
-        V: Serializable<PrettySerializer<W>, io::IoError>,
+        K: Serialize<PrettySerializer<W>, io::IoError>,
+        V: Serialize<PrettySerializer<W>, io::IoError>,
         Iter: Iterator<(K, V)>
     >(&mut self, mut iter: Iter) -> IoResult<()> {
         try!(self.wr.write_str("{"));
@@ -1428,7 +1428,7 @@ impl<W: Writer> ser::Serializer<io::IoError> for PrettySerializer<W> {
 /// Encode the specified struct into a json `[u8]` buffer.
 #[inline]
 pub fn to_vec<
-    T: ser::Serializable<Serializer<MemWriter>, io::IoError>
+    T: ser::Serialize<Serializer<MemWriter>, io::IoError>
 >(value: &T) -> Vec<u8> {
     let wr = MemWriter::with_capacity(1024);
     let mut serializer = Serializer::new(wr);
@@ -1441,7 +1441,7 @@ pub fn to_vec<
 /// Encode the specified struct into a json `String` buffer.
 #[inline]
 pub fn to_string<
-    T: ser::Serializable<Serializer<MemWriter>, io::IoError>
+    T: ser::Serialize<Serializer<MemWriter>, io::IoError>
 >(value: &T) -> Result<string::String, Vec<u8>> {
     let buf = to_vec(value);
     string::String::from_utf8(buf)
@@ -1449,7 +1449,7 @@ pub fn to_string<
 
 /// Encode the specified struct into a json `[u8]` buffer.
 pub fn to_pretty_vec<
-    T: ser::Serializable<PrettySerializer<MemWriter>, io::IoError>
+    T: ser::Serialize<PrettySerializer<MemWriter>, io::IoError>
 >(value: &T) -> Vec<u8> {
     let wr = MemWriter::new();
     let mut serializer = PrettySerializer::new(wr);
@@ -1459,7 +1459,7 @@ pub fn to_pretty_vec<
 
 /// Encode the specified struct into a json `String` buffer.
 pub fn to_pretty_string<
-    T: ser::Serializable<PrettySerializer<MemWriter>, io::IoError>
+    T: ser::Serialize<PrettySerializer<MemWriter>, io::IoError>
 >(value: &T) -> Result<string::String, Vec<u8>> {
     let buf = to_pretty_vec(value);
     string::String::from_utf8(buf)
@@ -2147,22 +2147,22 @@ impl<Iter: Iterator<u8>> de::Deserializer<ParserError> for Parser<Iter> {
 
     #[inline]
     fn missing_field<
-        T: de::Deserializable<Parser<Iter>, ParserError>
+        T: de::Deserialize<Parser<Iter>, ParserError>
     >(&mut self, _field: &'static str) -> Result<T, ParserError> {
         // JSON can represent `null` values as a missing value, so this isn't
         // necessarily an error.
-        de::Deserializable::deserialize_token(self, de::Null)
+        de::Deserialize::deserialize_token(self, de::Null)
     }
 
     // Special case treating options as a nullable value.
     #[inline]
     fn expect_option<
-        U: de::Deserializable<Parser<Iter>, ParserError>
+        U: de::Deserialize<Parser<Iter>, ParserError>
     >(&mut self, token: de::Token) -> Result<Option<U>, ParserError> {
         match token {
             de::Null => Ok(None),
             token => {
-                let value: U = try!(de::Deserializable::deserialize_token(self, token));
+                let value: U = try!(de::Deserialize::deserialize_token(self, token));
                 Ok(Some(value))
             }
         }
@@ -2244,10 +2244,10 @@ impl<Iter: Iterator<u8>> de::Deserializer<ParserError> for Parser<Iter> {
 /// Decodes a json value from an `Iterator<u8>`.
 pub fn from_iter<
     Iter: Iterator<u8>,
-    T: de::Deserializable<Parser<Iter>, ParserError>
+    T: de::Deserialize<Parser<Iter>, ParserError>
 >(iter: Iter) -> Result<T, ParserError> {
     let mut parser = Parser::new(iter);
-    let value = try!(de::Deserializable::deserialize(&mut parser));
+    let value = try!(de::Deserialize::deserialize(&mut parser));
 
     // Make sure the whole stream has been consumed.
     match parser.next() {
@@ -2260,17 +2260,17 @@ pub fn from_iter<
 /// Decodes a json value from a string
 pub fn from_str<
     'a,
-    T: de::Deserializable<Parser<str::Bytes<'a>>, ParserError>
+    T: de::Deserialize<Parser<str::Bytes<'a>>, ParserError>
 >(s: &'a str) -> Result<T, BuilderError> {
     from_iter(s.bytes())
 }
 
 /// Decodes a json value from a `Json`.
 pub fn from_json<
-    T: de::Deserializable<JsonDeserializer, ParserError>
+    T: de::Deserialize<JsonDeserializer, ParserError>
 >(json: Json) -> Result<T, ParserError> {
     let mut d = JsonDeserializer::new(json);
-    de::Deserializable::deserialize(&mut d)
+    de::Deserialize::deserialize(&mut d)
 }
 
 macro_rules! expect(
@@ -2461,7 +2461,7 @@ mod tests {
         ListCommaOrEnd,
     };
     use de;
-    use ser::{Serializable, Serializer};
+    use ser::{Serialize, Serializer};
     use ser;
 
     macro_rules! treemap {
@@ -2473,8 +2473,8 @@ mod tests {
     }
 
     #[deriving(PartialEq, Show)]
-    #[deriving_serializable]
-    #[deriving_deserializable]
+    #[deriving_serialize]
+    #[deriving_deserialize]
     enum Animal {
         Dog,
         Frog(string::String, Vec<int>)
@@ -2502,8 +2502,8 @@ mod tests {
     }
 
     #[deriving(PartialEq, Show)]
-    #[deriving_serializable]
-    #[deriving_deserializable]
+    #[deriving_serialize]
+    #[deriving_deserialize]
     struct Inner {
         a: (),
         b: uint,
@@ -2523,8 +2523,8 @@ mod tests {
     }
 
     #[deriving(PartialEq, Show)]
-    #[deriving_serializable]
-    #[deriving_deserializable]
+    #[deriving_serialize]
+    #[deriving_deserialize]
     struct Outer {
         inner: Vec<Inner>,
     }
@@ -2540,7 +2540,7 @@ mod tests {
     }
 
     fn test_encode_ok<
-        T: PartialEq + Show + ToJson + ser::Serializable<super::Serializer<io::MemWriter>, io::IoError>
+        T: PartialEq + Show + ToJson + ser::Serialize<super::Serializer<io::MemWriter>, io::IoError>
     >(errors: &[(T, &str)]) {
         for &(ref value, out) in errors.iter() {
             let out = out.to_string();
@@ -2554,7 +2554,7 @@ mod tests {
     }
 
     fn test_pretty_encode_ok<
-        T: PartialEq + Show + ToJson + ser::Serializable<super::PrettySerializer<io::MemWriter>, io::IoError>
+        T: PartialEq + Show + ToJson + ser::Serialize<super::PrettySerializer<io::MemWriter>, io::IoError>
     >(errors: &[(T, &str)]) {
         for &(ref value, out) in errors.iter() {
             let out = out.to_string();
@@ -2891,7 +2891,7 @@ mod tests {
     // FIXME (#5527): these could be merged once UFCS is finished.
     fn test_parse_err<
         'a,
-        T: Show + de::Deserializable<Parser<str::Bytes<'a>>, ParserError>
+        T: Show + de::Deserialize<Parser<str::Bytes<'a>>, ParserError>
     >(errors: &[(&'a str, ParserError)]) {
         for &(s, ref err) in errors.iter() {
             let v: Result<T, ParserError> = from_str(s);
@@ -2901,7 +2901,7 @@ mod tests {
 
     fn test_parse_ok<
         'a,
-        T: PartialEq + Show + ToJson + de::Deserializable<Parser<str::Bytes<'a>>, ParserError>
+        T: PartialEq + Show + ToJson + de::Deserialize<Parser<str::Bytes<'a>>, ParserError>
     >(errors: &[(&'a str, T)]) {
         for &(s, ref value) in errors.iter() {
             let v: T = from_str(s).unwrap();
@@ -2913,7 +2913,7 @@ mod tests {
     }
 
     fn test_json_deserialize_ok<
-        T: PartialEq + Show + ToJson + de::Deserializable<JsonDeserializer, ParserError>
+        T: PartialEq + Show + ToJson + de::Deserialize<JsonDeserializer, ParserError>
     >(errors: &[T]) {
         for value in errors.iter() {
             let v: T = from_json(value.to_json()).unwrap();
@@ -3219,8 +3219,8 @@ mod tests {
         ]);
 
         #[deriving(PartialEq, Show)]
-        #[deriving_serializable]
-        #[deriving_deserializable]
+        #[deriving_serialize]
+        #[deriving_deserialize]
         struct Foo {
             x: Option<int>,
         }
diff --git a/src/lib.rs b/src/lib.rs
index 41315e72..e2a61364 100644
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -12,8 +12,8 @@ extern crate serde_macros;
 #[cfg(test)]
 extern crate serialize;
 
-pub use ser::{Serializer, Serializable};
-pub use de::{Deserializer, Deserializable};
+pub use ser::{Serializer, Serialize};
+pub use de::{Deserializer, Deserialize};
 
 pub mod de;
 pub mod ser;
diff --git a/src/ser.rs b/src/ser.rs
index a4adce4f..b338bf06 100644
--- a/src/ser.rs
+++ b/src/ser.rs
@@ -79,49 +79,49 @@ pub trait Serializer<E> {
 
     fn serialize_tuple_start(&mut self, len: uint) -> Result<(), E>;
     fn serialize_tuple_elt<
-        T: Serializable<Self, E>
+        T: Serialize<Self, E>
     >(&mut self, v: &T) -> Result<(), E>;
     fn serialize_tuple_end(&mut self) -> Result<(), E>;
 
     fn serialize_struct_start(&mut self, name: &str, len: uint) -> Result<(), E>;
     fn serialize_struct_elt<
-        T: Serializable<Self, E>
+        T: Serialize<Self, E>
     >(&mut self, name: &str, v: &T) -> Result<(), E>;
     fn serialize_struct_end(&mut self) -> Result<(), E>;
 
     fn serialize_enum_start(&mut self, name: &str, variant: &str, len: uint) -> Result<(), E>;
     fn serialize_enum_elt<
-        T: Serializable<Self, E>
+        T: Serialize<Self, E>
     >(&mut self, v: &T) -> Result<(), E>;
     fn serialize_enum_end(&mut self) -> Result<(), E>;
 
     fn serialize_option<
-        T: Serializable<Self, E>
+        T: Serialize<Self, E>
     >(&mut self, v: &Option<T>) -> Result<(), E>;
 
     fn serialize_seq<
-        T: Serializable<Self, E>,
+        T: Serialize<Self, E>,
         Iter: Iterator<T>
     >(&mut self, iter: Iter) -> Result<(), E>;
 
     fn serialize_map<
-        K: Serializable<Self, E>,
-        V: Serializable<Self, E>,
+        K: Serialize<Self, E>,
+        V: Serialize<Self, E>,
         Iter: Iterator<(K, V)>
     >(&mut self, iter: Iter) -> Result<(), E>;
 }
 
 //////////////////////////////////////////////////////////////////////////////
 
-pub trait Serializable<S: Serializer<E>, E> {
+pub trait Serialize<S: Serializer<E>, E> {
     fn serialize(&self, s: &mut S) -> Result<(), E>;
 }
 
 //////////////////////////////////////////////////////////////////////////////
 
-macro_rules! impl_serializable {
+macro_rules! impl_serialize {
     ($ty:ty, $method:ident) => {
-        impl<S: Serializer<E>, E> Serializable<S, E> for $ty {
+        impl<S: Serializer<E>, E> Serialize<S, E> for $ty {
             #[inline]
             fn serialize(&self, s: &mut S) -> Result<(), E> {
                 s.$method(*self)
@@ -130,31 +130,31 @@ macro_rules! impl_serializable {
     }
 }
 
-impl_serializable!(bool, serialize_bool)
-impl_serializable!(int, serialize_int)
-impl_serializable!(i8, serialize_i8)
-impl_serializable!(i16, serialize_i16)
-impl_serializable!(i32, serialize_i32)
-impl_serializable!(i64, serialize_i64)
-impl_serializable!(uint, serialize_uint)
-impl_serializable!(u8, serialize_u8)
-impl_serializable!(u16, serialize_u16)
-impl_serializable!(u32, serialize_u32)
-impl_serializable!(u64, serialize_u64)
-impl_serializable!(f32, serialize_f32)
-impl_serializable!(f64, serialize_f64)
-impl_serializable!(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)
 
 //////////////////////////////////////////////////////////////////////////////
 
-impl<'a, S: Serializer<E>, E> Serializable<S, E> for &'a str {
+impl<'a, S: Serializer<E>, E> Serialize<S, E> for &'a str {
     #[inline]
     fn serialize(&self, s: &mut S) -> Result<(), E> {
         s.serialize_str(*self)
     }
 }
 
-impl<S: Serializer<E>, E> Serializable<S, E> for String {
+impl<S: Serializer<E>, E> Serialize<S, E> for String {
     #[inline]
     fn serialize(&self, s: &mut S) -> Result<(), E> {
         self.as_slice().serialize(s)
@@ -163,14 +163,14 @@ impl<S: Serializer<E>, E> Serializable<S, E> for String {
 
 //////////////////////////////////////////////////////////////////////////////
 
-macro_rules! impl_serializable_box {
+macro_rules! impl_serialize_box {
     ($ty:ty) => {
         impl<
             'a,
             S: Serializer<E>,
             E,
-            T: Serializable<S, E>
-        > Serializable<S, E> for $ty {
+            T: Serialize<S, E>
+        > Serialize<S, E> for $ty {
             #[inline]
             fn serialize(&self, s: &mut S) -> Result<(), E> {
                 (**self).serialize(s)
@@ -179,15 +179,15 @@ macro_rules! impl_serializable_box {
     }
 }
 
-impl_serializable_box!(&'a T)
-impl_serializable_box!(Box<T>)
-impl_serializable_box!(Rc<T>)
+impl_serialize_box!(&'a T)
+impl_serialize_box!(Box<T>)
+impl_serialize_box!(Rc<T>)
 
 impl<
     S: Serializer<E>,
     E,
-    T: Serializable<S, E> + Send + Sync
-> Serializable<S, E> for Arc<T> {
+    T: Serialize<S, E> + Send + Sync
+> Serialize<S, E> for Arc<T> {
     #[inline]
     fn serialize(&self, s: &mut S) -> Result<(), E> {
         (**self).serialize(s)
@@ -199,8 +199,8 @@ impl<
 impl<
     S: Serializer<E>,
     E,
-    T: Serializable<S, E>
-> Serializable<S, E> for Option<T> {
+    T: Serialize<S, E>
+> Serialize<S, E> for Option<T> {
     #[inline]
     fn serialize(&self, s: &mut S) -> Result<(), E> {
         s.serialize_option(self)
@@ -212,8 +212,8 @@ impl<
 impl<
     S: Serializer<E>,
     E,
-    T: Serializable<S, E>
-> Serializable<S, E> for Vec<T> {
+    T: Serialize<S, E>
+> Serialize<S, E> for Vec<T> {
     #[inline]
     fn serialize(&self, s: &mut S) -> Result<(), E> {
         s.serialize_seq(self.iter())
@@ -225,9 +225,9 @@ impl<
 impl<
     S: Serializer<E>,
     E,
-    K: Serializable<S, E> + Eq + Hash,
-    V: Serializable<S, E>
-> Serializable<S, E> for HashMap<K, V> {
+    K: Serialize<S, E> + Eq + Hash,
+    V: Serialize<S, E>
+> Serialize<S, E> for HashMap<K, V> {
     #[inline]
     fn serialize(&self, s: &mut S) -> Result<(), E> {
         s.serialize_map(self.iter())
@@ -237,9 +237,9 @@ impl<
 impl<
     S: Serializer<E>,
     E,
-    K: Serializable<S, E> + Ord,
-    V: Serializable<S, E>
-> Serializable<S, E> for TreeMap<K, V> {
+    K: Serialize<S, E> + Ord,
+    V: Serialize<S, E>
+> Serialize<S, E> for TreeMap<K, V> {
     #[inline]
     fn serialize(&self, s: &mut S) -> Result<(), E> {
         s.serialize_map(self.iter())
@@ -251,8 +251,8 @@ impl<
 impl<
     S: Serializer<E>,
     E,
-    T: Serializable<S, E> + Eq + Hash
-> Serializable<S, E> for HashSet<T> {
+    T: Serialize<S, E> + Eq + Hash
+> Serialize<S, E> for HashSet<T> {
     #[inline]
     fn serialize(&self, s: &mut S) -> Result<(), E> {
         s.serialize_seq(self.iter())
@@ -262,8 +262,8 @@ impl<
 impl<
     S: Serializer<E>,
     E,
-    T: Serializable<S, E> + Ord
-> Serializable<S, E> for TreeSet<T> {
+    T: Serialize<S, E> + Ord
+> Serialize<S, E> for TreeSet<T> {
     #[inline]
     fn serialize(&self, s: &mut S) -> Result<(), E> {
         s.serialize_seq(self.iter())
@@ -278,7 +278,7 @@ macro_rules! peel {
 
 macro_rules! impl_serialize_tuple {
     () => {
-        impl<S: Serializer<E>, E> Serializable<S, E> for () {
+        impl<S: Serializer<E>, E> Serialize<S, E> for () {
             #[inline]
             fn serialize(&self, s: &mut S) -> Result<(), E> {
                 s.serialize_null()
@@ -289,8 +289,8 @@ macro_rules! impl_serialize_tuple {
         impl<
             S: Serializer<E>,
             E,
-            $($name:Serializable<S, E>),+
-        > Serializable<S, E> for ($($name,)+) {
+            $($name:Serialize<S, E>),+
+        > Serialize<S, E> for ($($name,)+) {
             #[inline]
             #[allow(non_snake_case)]
             fn serialize(&self, s: &mut S) -> Result<(), E> {
@@ -323,12 +323,12 @@ mod tests {
 
     use serialize::Decoder;
 
-    use super::{Serializer, Serializable};
+    use super::{Serializer, Serialize};
 
     //////////////////////////////////////////////////////////////////////////////
 
     #[deriving(Clone, PartialEq, Show, Decodable)]
-    #[deriving_serializable]
+    #[deriving_serialize]
     struct Inner {
         a: (),
         b: uint,
@@ -338,7 +338,7 @@ mod tests {
     //////////////////////////////////////////////////////////////////////////////
 
     #[deriving(Clone, PartialEq, Show, Decodable)]
-    #[deriving_serializable]
+    #[deriving_serialize]
     struct Outer {
         inner: Vec<Inner>,
     }
@@ -346,7 +346,7 @@ mod tests {
     //////////////////////////////////////////////////////////////////////////////
 
     #[deriving(Clone, PartialEq, Show, Decodable)]
-    #[deriving_serializable]
+    #[deriving_serialize]
     enum Animal {
         Dog,
         Frog(String, int)
@@ -494,7 +494,7 @@ mod tests {
         }
 
         fn serialize_tuple_elt<
-            T: Serializable<AssertSerializer<Iter>, Error>
+            T: Serialize<AssertSerializer<Iter>, Error>
         >(&mut self, value: &T) -> Result<(), Error> {
             try!(self.serialize(TupleSep));
             value.serialize(self)
@@ -509,7 +509,7 @@ mod tests {
         }
 
         fn serialize_struct_elt<
-            T: Serializable<AssertSerializer<Iter>, Error>
+            T: Serialize<AssertSerializer<Iter>, Error>
         >(&mut self, name: &str, value: &T) -> Result<(), Error> {
             try!(self.serialize(StructSep(name)));
             value.serialize(self)
@@ -524,7 +524,7 @@ mod tests {
         }
 
         fn serialize_enum_elt<
-            T: Serializable<AssertSerializer<Iter>, Error>
+            T: Serialize<AssertSerializer<Iter>, Error>
         >(&mut self, value: &T) -> Result<(), Error> {
             try!(self.serialize(EnumSep));
             value.serialize(self)
@@ -535,7 +535,7 @@ mod tests {
         }
 
         fn serialize_option<
-            T: Serializable<AssertSerializer<Iter>, Error>
+            T: Serialize<AssertSerializer<Iter>, Error>
         >(&mut self, v: &option::Option<T>) -> Result<(), Error> {
             match *v {
                 Some(ref v) => {
@@ -549,7 +549,7 @@ mod tests {
         }
 
         fn serialize_seq<
-            T: Serializable<AssertSerializer<Iter>, Error>,
+            T: Serialize<AssertSerializer<Iter>, Error>,
             SeqIter: Iterator<T>
         >(&mut self, mut iter: SeqIter) -> Result<(), Error> {
             let (len, _) = iter.size_hint();
@@ -561,8 +561,8 @@ mod tests {
         }
 
         fn serialize_map<
-            K: Serializable<AssertSerializer<Iter>, Error>,
-            V: Serializable<AssertSerializer<Iter>, Error>,
+            K: Serialize<AssertSerializer<Iter>, Error>,
+            V: Serialize<AssertSerializer<Iter>, Error>,
             MapIter: Iterator<(K, V)>
         >(&mut self, mut iter: MapIter) -> Result<(), Error> {
             let (len, _) = iter.size_hint();
diff --git a/tests/json_struct.rs b/tests/json_struct.rs
index ce53cedc..90469953 100644
--- a/tests/json_struct.rs
+++ b/tests/json_struct.rs
@@ -5,8 +5,8 @@ extern crate serde;
 extern crate serde_macros;
 
 #[deriving(PartialEq, Show)]
-#[deriving_serializable]
-#[deriving_deserializable]
+#[deriving_serialize]
+#[deriving_deserialize]
 struct Test {
     #[serial_name = "$schema"]
     schema: String,