Auto merge of #153 - erickt:doc, r=erickt

Start documenting everything
Bump version
2026-04-23 01:18:02 +00:00 · 2015-09-03 00:54:55 +09:00 · 2015-09-02 08:54:01 -07:00 · 2015-09-02 08:36:14 -07:00 · 2015-09-02 08:36:14 -07:00 · 2015-09-02 08:36:14 -07:00
42 changed files with 3508 additions and 7317 deletions
@@ -1,34 +1,41 @@
 language: rust
+sudo: false
+
 rust:
  - stable
  - beta
  - nightly
+
+addons:
+  apt:
+    packages:
+    - libcurl4-openssl-dev
+    - libelf-dev
+    - libdw-dev
+
+before_script:
+- |
+    pip install 'travis-cargo<0.2' --user &&
+    export PATH=$HOME/.local/bin:$PATH
+
+script:
+- |
+    (cd serde && travis-cargo build) &&
+    (cd serde && travis-cargo test) &&
+    (cd serde_tests && travis-cargo test) &&
+    (cd serde_macros && travis-cargo --only nightly test) &&
+    (cd serde_macros && travis-cargo --only nightly bench) &&
+    (cd serde && travis-cargo --only stable doc) &&
+    (cd serde_codegen && travis-cargo --only stable doc)
+
+after_success:
+- (cd serde && travis-cargo --only stable doc-upload)
+- (cd serde_tests && travis-cargo coveralls --no-sudo)
+
 env:
  global:
-    secure: HO41LMpMXkF2In9+1sxWVu7fgolL+y9+4Q5PI6wZX2L5pDwpPJCjxaQarQXCEnoIxED1PlP03JuF7ULNz0zw1ylYhAOfOSdkxFZRnE2wMZqq6qvXBHwyMiDrAociIzoPKSGv7JVrKPsjsnd+96K6xxueIodQZrmAdyq7N/M82Mc=
-  matrix:
-    - CRATE=serde_tests TARGET=test
-matrix:
-  include:
-    - rust: nightly
-      env: CRATE=serde_macros TARGET=test
-    - rust: nightly
-      env: CRATE=serde_macros TARGET=bench
-    - rust: nightly
-      env: CRATE=serde_tests TARGET=bench
-script:
-  - (cd $CRATE && cargo $TARGET)
-after_success: |
-  [ $TRAVIS_BRANCH = "master" ] &&
-  [ $TRAVIS_PULL_REQUEST  = false ] &&
-  mkdir -p target/doc &&
-  (cd serde && cargo doc --no-deps) &&
-  (cd serde_codegen && cargo doc --no-deps) &&
-  (cd serde_macros && cargo doc --no-deps) &&
-  cp -r serde/target/doc target/doc/serde &&
-  cp -r serde_codegen/target/doc target/doc/serde_codegen &&
-  cp -r serde_macros/target/doc target/doc/serde_macros &&
-  echo "<meta http-equiv=refresh content=0;url=`echo $TRAVIS_REPO_SLUG | cut -d '/' -f 2`/index.html>" > target/doc/index.html &&
-  sudo pip install ghp-import &&
-  ghp-import -n target/doc &&
-  git push -fq https://${GH_TOKEN}@github.com/${TRAVIS_REPO_SLUG}.git gh-pages
+    # override the default `--features unstable` used for the nightly branch (optional)
+    - TRAVIS_CARGO_NIGHTLY_FEATURE=""
+
+    # encrypted github token for doc upload (see `GH_TOKEN` link above)
+    - secure: HO41LMpMXkF2In9+1sxWVu7fgolL+y9+4Q5PI6wZX2L5pDwpPJCjxaQarQXCEnoIxED1PlP03JuF7ULNz0zw1ylYhAOfOSdkxFZRnE2wMZqq6qvXBHwyMiDrAociIzoPKSGv7JVrKPsjsnd+96K6xxueIodQZrmAdyq7N/M82Mc=
@@ -2,6 +2,7 @@ Serde Rust Serialization Framework
 ==================================

 [![Build Status](https://api.travis-ci.org/serde-rs/serde.png?branch=master)](https://travis-ci.org/serde-rs/serde)
+[![Coverage Status](https://coveralls.io/repos/serde-rs/serde/badge.svg?branch=master&service=github)](https://coveralls.io/github/serde-rs/serde?branch=master)
 [![Latest Version](https://img.shields.io/crates/v/serde.svg)](https://crates.io/crates/serde)

 Serde is a powerful framework that enables serialization libraries to
@@ -10,78 +11,210 @@ information. In many situations, the handshake protocol between serializers and
 serializees can be completely optimized away, leaving Serde to perform roughly
 the same speed as a hand written serializer for a specific type.

-Documentation is available at http://serde-rs.github.io/serde/serde
+Documentation is available at:

-Making a Type Serializable
-==========================
+* [serde](https://serde-rs.github.io/serde/serde/serde/index.html)
+* [serde\_json](https://serde-rs.github.io/serde/serde_json/serde_json/index.html)
+* [serde\_codegen](https://serde-rs.github.io/serde/serde_codegen/serde_codegen/index.html)

-The simplest way to make a type serializable is to use the `serde_macros`
-syntax extension, which comes with a `#[derive(Serialize, Deserialize)]`
-annotation, which automatically generates implementations of 
-[Serialize](http://serde-rs.github.io/serde/serde/ser/trait.Serialize.html)
-and
-[Deserialize](http://serde-rs.github.io/serde/serde/de/trait.Deserialize.html)
-for the annotated type:
+Using Serde
+===========
+
+Here is a simple example that demonstrates how to use Serde by serializing and
+deserializing to JSON. Serde comes with some powerful code generation libraries
+that work with Stable and Nightly Rust that eliminate much of the complexity of
+hand rolling serialization and deserialization for a given type. First lets see
+how we would use Nightly Rust, which is currently a bit simpler than Stable
+Rust:
+
+`Cargo.toml`:
+
+```toml
+[package]
+name = "serde_example_nightly"
+version = "0.1.0"
+authors = ["Erick Tryzelaar <erick.tryzelaar@gmail.com>"]
+
+[dependencies]
+serde = "*"
+serde_json = "*"
+serde_macros = "*"
+```
+
+`src/main.rs`

 ```rust
 #![feature(custom_derive, plugin)]
 #![plugin(serde_macros)]

 extern crate serde;
+extern crate serde_json;

-...
-
-#[derive(Serialize, Deserialize)]
+#[derive(Serialize, Deserialize, Debug)]
 struct Point {
    x: i32,
    y: i32,
 }
+
+fn main() {
+    let point = Point { x: 1, y: 2 };
+    let serialized = serde_json::to_string(&point).unwrap();
+
+    println!("{}", serialized);
+
+    let deserialized: Point = serde_json::from_str(&serialized).unwrap();
+
+    println!("{:?}", deserialized);
+}
 ```

-Serde bundles a high performance JSON serializer and deserializer,
-[serde::json](http://serde-rs.github.io/serde/serde/json/index.html),
-which comes with the helper functions
-[to_string](http://serde-rs.github.io/serde/serde/json/ser/fn.to_string.html)
-and
-[from_str](http://serde-rs.github.io/serde/serde/json/de/fn.from_str.html)
-that make it easy to go to and from JSON:
+When run, it produces:
+
+```
+% cargo run
+{"x":1,"y":2}
+Point { x: 1, y: 2 }
+```
+
+Stable Rust is a little more complicated because it does not yet support
+compiler plugins. Instead we need to use the code generation library
+[syntex](https://github.com/erickt/rust-syntex) for this:
+
+```toml
+[package]
+name = "serde_example"
+version = "0.1.0"
+authors = ["Erick Tryzelaar <erick.tryzelaar@gmail.com>"]
+build = "build.rs"
+
+[build-dependencies]
+serde_codegen = "*"
+syntex = "*"
+
+[dependencies]
+serde = "*"
+serde_json = "*"
+```
+
+`src/main.rs`:

 ```rust
-use serde::json;
+extern crate serde;
+extern crate serde_json;

-...
-
-let point = Point { x: 1, y: 2 };
-let serialized_point = json::to_string(&point).unwrap();
-
-println!("{}", serialized_point); // prints: {"x":1,"y":2}
-
-let deserialize_point: Point = json::from_str(&serialized_point).unwrap();
+include!(concat!(env!("OUT_DIR"), "/main.rs"));
 ```

-[serde::json](http://serde-rs.github.io/serde/serde/json/index.html) also
-supports a generic
-[Value](http://serde-rs.github.io/serde/serde/json/value/enum.Value.html)
-type, which can represent any JSON value. Also, any
-[Serialize](http://serde-rs.github.io/serde/serde/ser/trait.Serialize.html)
-and
-[Deserialize](http://serde-rs.github.io/serde/serde/de/trait.Deserialize.html)
-can be converted into a 
-[Value](http://serde-rs.github.io/serde/serde/json/value/enum.Value.html)
-with the methods
-[to_value](http://serde-rs.github.io/serde/serde/json/value/fn.to_value.html)
-and
-[from_value](http://serde-rs.github.io/serde/serde/json/value/fn.from_value.html):
+`src/main.rs.in`:

 ```rust
-let point = Point { x: 1, y: 2 };
-let point_value = json::to_value(&point).unwrap();
+#[derive(Serialize, Deserialize, Debug)]
+struct Point {
+    x: i32,
+    y: i32,
+}

-println!("{}", point_value.find("x")); // prints: Some(1)
+fn main() {
+    let point = Point { x: 1, y: 2 };
+    let serialized = serde_json::to_string(&point).unwrap();

-let deserialize_point: Point = json::from_value(point_value).unwrap();
+    println!("{}", serialized);
+
+    let deserialized: Point = serde_json::from_str(&serialized).unwrap();
+
+    println!("{:?}", deserialized);
+}
 ```

+This also produces:
+
+```
+% cargo run
+{"x":1,"y":2}
+Point { x: 1, y: 2 }
+```
+
+While this works well with Stable Rust, be aware that the error locations
+currently are reported in the generated file instead of in the source file. You
+may find it easier to develop with Nightly Rust and `serde\_macros`, then
+deploy with Stable Rust and `serde_codegen`. It's possible to combine both
+approaches in one setup:
+
+`Cargo.toml`:
+
+```toml
+[package]
+name = "serde_example"
+version = "0.1.0"
+authors = ["Erick Tryzelaar <erick.tryzelaar@gmail.com>"]
+build = "build.rs"
+
+[features]
+default = ["serde_codegen"]
+nightly = ["serde_macros"]
+
+[build-dependencies]
+serde_codegen = { version = "*", optional = true }
+syntex = "*"
+
+[dependencies]
+serde = "*"
+serde_json = "*"
+serde_macros = { version = "*", optional = true }
+```
+
+`build.rs`:
+
+```rust
+#[cfg(not(feature = "serde_macros"))]
+mod inner {
+    extern crate syntex;
+    extern crate serde_codegen;
+
+    use std::env;
+    use std::path::Path;
+
+    pub fn main() {
+        let out_dir = env::var_os("OUT_DIR").unwrap();
+
+        let src = Path::new("src/main.rs.in");
+        let dst = Path::new(&out_dir).join("main.rs");
+
+        let mut registry = syntex::Registry::new();
+
+        serde_codegen::register(&mut registry);
+        registry.expand("", &src, &dst).unwrap();
+    }
+}
+
+#[cfg(feature = "serde_macros")]
+mod inner {
+    pub fn main() {}
+}
+
+fn main() {
+    inner::main();
+}
+```
+
+`src/main.rs`:
+
+```rust
+#![cfg_attr(feature = "serde_macros", feature(custom_derive, plugin))]
+#![cfg_attr(feature = "serde_macros", plugin(serde_macros))]
+
+extern crate serde;
+extern crate serde_json;
+
+#[cfg(feature = "serde_macros")]
+include!("main.rs.in");
+
+#[cfg(not(feature = "serde_macros"))]
+include!(concat!(env!("OUT_DIR"), "/main.rs"));
+```
+
+The `src/main.rs.in` is the same as before.
+
 Serialization without Macros
 ============================

@@ -174,7 +307,7 @@ impl<K, V, I> MapVisitor for MapIteratorVisitor<I>
 ```

 Serializing structs follow this same pattern. In fact, structs are represented
-as a named map. It's visitor uses a simple state machine to iterate through all
+as a named map. Its visitor uses a simple state machine to iterate through all
 the fields:

 ```rust
@@ -187,7 +320,7 @@ impl serde::Serialize for Point {
    fn serialize<S>(&self, serializer: &mut S) -> Result<(), S::Error>
        where S: serde::Serializer
    {
-        serializer.visit_named_map("Point", PointMapVisitor {
+        serializer.visit_struct("Point", PointMapVisitor {
            value: self,
            state: 0,
        })
@@ -206,11 +339,11 @@ impl<'a> serde::ser::MapVisitor for PointMapVisitor<'a> {
        match self.state {
            0 => {
                self.state += 1;
-                Ok(Some(try!(serializer.visit_map_elt("x", &self.value.x))))
+                Ok(Some(try!(serializer.visit_struct_elt("x", &self.value.x))))
            }
            1 => {
                self.state += 1;
-                Ok(Some(try!(serializer.visit_map_elt("y", &self.value.y))))
+                Ok(Some(try!(serializer.visit_struct_elt("y", &self.value.y))))
            }
            _ => {
                Ok(None)
@@ -275,7 +408,7 @@ to generate an error for a few common error conditions. Here's how it could be u
    fn visit_string<E>(&mut self, _: String) -> Result<i32, E>
        where E: Error,
    {
-        Err(serde::de::Error::syntax_error())
+        Err(serde::de::Error::syntax("expect a string"))
    }

    ...
@@ -355,23 +488,23 @@ impl serde::Deserialize for PointField {
    fn deserialize<D>(deserializer: &mut D) -> Result<PointField, D::Error>
        where D: serde::de::Deserializer
    {
-        struct FieldVisitor;
+        struct PointFieldVisitor;

-        impl serde::de::Visitor for FieldVisitor {
-            type Value = Field;
+        impl serde::de::Visitor for PointFieldVisitor {
+            type Value = PointField;

            fn visit_str<E>(&mut self, value: &str) -> Result<PointField, E>
                where E: serde::de::Error
            {
                match value {
-                    "x" => Ok(Field::X),
-                    "y" => Ok(Field::Y),
-                    _ => Err(serde::de::Error::syntax_error()),
+                    "x" => Ok(PointField::X),
+                    "y" => Ok(PointField::Y),
+                    _ => Err(serde::de::Error::syntax("expected x or y")),
                }
            }
        }

-        deserializer.visit(FieldVisitor)
+        deserializer.visit(PointFieldVisitor)
    }
 }
 ```
@@ -383,7 +516,8 @@ impl serde::Deserialize for Point {
    fn deserialize<D>(deserializer: &mut D) -> Result<Point, D::Error>
        where D: serde::de::Deserializer
    {
-        deserializer.visit_named_map("Point", PointVisitor)
+        static FIELDS: &'static [&'static str] = &["x", "y"];
+        deserializer.visit_struct("Point", FIELDS, PointVisitor)
    }
 }

@@ -400,8 +534,8 @@ impl serde::de::Visitor for PointVisitor {

        loop {
            match try!(visitor.visit_key()) {
-                Some(Field::X) => { x = Some(try!(visitor.visit_value())); }
-                Some(Field::Y) => { y = Some(try!(visitor.visit_value())); }
+                Some(PointField::X) => { x = Some(try!(visitor.visit_value())); }
+                Some(PointField::Y) => { y = Some(try!(visitor.visit_value())); }
                None => { break; }
            }
        }
@@ -422,3 +556,14 @@ impl serde::de::Visitor for PointVisitor {
    }
 }
 ```
+
+Serialization Formats Using Serde
+=================================
+
+| Format      | Name                                               |
+| ------      | ----                                               |
+| Bincode     | [bincode](https://crates.io/crates/bincode)        |
+| JSON        | [serde\_json](https://crates.io/crates/serde_json) |
+| MessagePack | [rmp](https://crates.io/crates/rmp)                |
+| XML         | [serde\_xml](https://github.com/serde-rs/xml)      |
+| YAML        | [serde\_yaml](https://github.com/serde-rs/yaml/)   |
@@ -1,13 +1,17 @@
 [package]
 name = "serde"
-version = "0.4.1"
+version = "0.6.0"
 authors = ["Erick Tryzelaar <erick.tryzelaar@gmail.com>"]
 license = "MIT/Apache-2.0"
 description = "A generic serialization/deserialization framework"
 repository = "https://github.com/serde-rs/serde"
-documentation = "http://serde-rs.github.io/serde/serde"
+documentation = "https://serde-rs.github.io/serde/serde/serde/index.html"
 readme = "../README.md"
-keywords = ["serialization"]
+keywords = ["serde", "serialization"]

 [dependencies]
 num = "*"
+
+[features]
+nightly = []
+
@@ -1,94 +0,0 @@
-use std::cmp;
-use std::io;
-use std::slice;
-
-trait IntoBufRead {
-    type IntoBuf: io::BufRead + BufReadExt;
-
-    fn into_buf_read(self) -> Self::IntoBuf;
-}
-
-trait BufReadExt {
-    fn get_buf(&self) -> &[u8];
-    fn read_u8(&mut self) -> io::Result<Option<u8>>;
-}
-
-struct SliceReader<'a> {
-    buf: &'a [u8],
-}
-
-impl<'a> io::Read for SliceReader<'a> {
-    #[inline]
-    fn read(&mut self, buf: &mut [u8]) -> io::Result<usize> {
-        let amt = cmp::min(buf.len(), self.buf.len());
-        let (a, b) = self.buf.split_at(amt);
-        slice::bytes::copy_memory(buf, a);
-        *self.buf = b;
-        Ok(amt)
-    }
-}
-
-impl<'a> io::BufRead for SliceReader<'a> {
-    fn fill_buf(&mut self) -> io::Result<&[u8]> { Ok(*self) }
-    fn consume(&mut self, amt: usize) { *self.buf = &self.buf[amt..]; }
-}
-
-impl<'a> BufReadExt for SliceReader<'a> {
-    fn get_buf(&self) -> &[u8] { self.buf }
-    fn read_u8(&mut self) -> io::Result<Option<u8>> {
-        let byte = self.buf.get(0);
-        *self.buf = &self.buf[1..];
-        byte
-    }
-}
-
-struct BufReader<R> {
-    inner: R,
-    buf: io::Cursor<Vec<u8>>,
-}
-
-impl<R> BufReader<R> where R: io::Read {
-    fn new(inner: R) -> Self {
-        BufferedReader::with_capacity(io::DEFAULT_BUF_SIZE, inner)
-    }
-
-    fn new(cap: usize, inner: R) -> Self {
-        BufferedReader {
-            inner: inner,
-            buf: io::Cursor::new(Vec::with_capacity(cap)),
-        }
-    }
-
-    fn into_inner(self) -> R {
-        self.inner
-    }
-}
-
-impl<R> Read for BufReader<R> where R: io::Read {
-    fn read(&mut self, buf: &mut [u8]) -> io::Result<usize> {
-        // If we don't have any buffered data and we're doing a massive read
-        // (larger than our internal buffer), bypass our internal buffer
-        // entirely.
-        if self.buf.get_ref().len() == self.buf.position() as usize &&
-            buf.len() >= self.buf.get_ref().capacity() {
-            return self.inner.read(buf);
-        }
-        try!(self.fill_buf());
-        self.buf.read(buf)
-    }
-}
-
-impl<R> BufReadExt for BufReader<R> {
-    fn get_buf(&self) -> &[u8] {
-        self.buf.get_ref()
-    }
-
-    fn read_u8(&mut self) -> io::Result<Option<u8>> {
-        if self.buf.get_ref().len() == self.buf.position() as usize {
-
-        }
-        let byte = self.buf.get(0);
-        *self.buf = &self.buf[1..];
-        byte
-    }
-}
@@ -60,19 +60,21 @@ impl<'a> ser::Serialize for Bytes<'a> {

 ///////////////////////////////////////////////////////////////////////////////

-/// `ByteBuf` wraps a `Vec<u8>` in order to hook into serialize and from deserialize a byte array.
+/// `ByteBuf` wraps a `Vec<u8>` and serializes as a byte array.
 #[derive(Clone, Eq, Hash, PartialEq, PartialOrd, Ord)]
 pub struct ByteBuf {
    bytes: Vec<u8>,
 }

 impl ByteBuf {
+    /// Construct a new, empty `ByteBuf`.
    pub fn new() -> Self {
        ByteBuf {
            bytes: Vec::new(),
        }
    }

+    /// Construct a new, empty `ByteBuf` with the specified capacity.
    pub fn with_capacity(cap: usize) -> Self {
        ByteBuf {
            bytes: Vec::with_capacity(cap)
@@ -142,6 +144,7 @@ impl ser::Serialize for ByteBuf {
    }
 }

+/// This type implements the `serde::de::Visitor` trait for a `ByteBuf`.
 pub struct ByteBufVisitor;

 impl de::Visitor for ByteBufVisitor {
@@ -1,4 +1,17 @@
-use std::collections::{BTreeMap, BTreeSet, HashMap, HashSet};
+//! This module contains `Deserialize` and `Visitor` implementations.
+
+use std::borrow::Cow;
+use std::collections::{
+    BinaryHeap,
+    BTreeMap,
+    BTreeSet,
+    LinkedList,
+    HashMap,
+    HashSet,
+    VecDeque,
+};
+#[cfg(feature = "nightly")]
+use collections::enum_set::{CLike, EnumSet};
 use std::hash::Hash;
 use std::marker::PhantomData;
 use std::path;
@@ -8,17 +21,27 @@ use std::sync::Arc;

 use num::FromPrimitive;

+#[cfg(feature = "nightly")]
+use core::nonzero::{NonZero, Zeroable};
+
+#[cfg(feature = "nightly")]
+use std::num::Zero;
+
 use de::{
    Deserialize,
    Deserializer,
+    EnumVisitor,
    Error,
    MapVisitor,
    SeqVisitor,
+    Type,
+    VariantVisitor,
    Visitor,
 };

 ///////////////////////////////////////////////////////////////////////////////

+/// A visitor that produces a `()`.
 pub struct UnitVisitor;

 impl Visitor for UnitVisitor {
@@ -41,13 +64,14 @@ impl Deserialize for () {
    fn deserialize<D>(deserializer: &mut D) -> Result<(), D::Error>
        where D: Deserializer,
    {
-        deserializer.visit(UnitVisitor)
+        deserializer.visit_unit(UnitVisitor)
    }
 }

 ///////////////////////////////////////////////////////////////////////////////

-struct BoolVisitor;
+/// A visitor that produces a `bool`.
+pub struct BoolVisitor;

 impl Visitor for BoolVisitor {
    type Value = bool;
@@ -64,7 +88,7 @@ impl Visitor for BoolVisitor {
        match s.trim() {
            "true" => Ok(true),
            "false" => Ok(false),
-            _ => Err(Error::syntax_error()),
+            _ => Err(Error::type_mismatch(Type::Bool)),
        }
    }
 }
@@ -73,31 +97,33 @@ impl Deserialize for bool {
    fn deserialize<D>(deserializer: &mut D) -> Result<bool, D::Error>
        where D: Deserializer,
    {
-        deserializer.visit(BoolVisitor)
+        deserializer.visit_bool(BoolVisitor)
    }
 }

 ///////////////////////////////////////////////////////////////////////////////

 macro_rules! impl_deserialize_num_method {
-    ($src_ty:ty, $method:ident, $from_method:ident) => {
+    ($src_ty:ty, $method:ident, $from_method:ident, $ty:expr) => {
        #[inline]
        fn $method<E>(&mut self, v: $src_ty) -> Result<T, E>
            where E: Error,
        {
            match FromPrimitive::$from_method(v) {
                Some(v) => Ok(v),
-                None => Err(Error::syntax_error()),
+                None => Err(Error::type_mismatch($ty)),
            }
        }
    }
 }

+/// A visitor that produces a primitive type.
 pub struct PrimitiveVisitor<T> {
    marker: PhantomData<T>,
 }

 impl<T> PrimitiveVisitor<T> {
+    /// Construct a new `PrimitiveVisitor`.
    #[inline]
    pub fn new() -> Self {
        PrimitiveVisitor {
@@ -111,52 +137,52 @@ impl<
 > Visitor for PrimitiveVisitor<T> {
    type Value = T;

-    impl_deserialize_num_method!(isize, visit_isize, from_isize);
-    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!(usize, visit_usize, from_usize);
-    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!(isize, visit_isize, from_isize, Type::Isize);
+    impl_deserialize_num_method!(i8, visit_i8, from_i8, Type::I8);
+    impl_deserialize_num_method!(i16, visit_i16, from_i16, Type::I16);
+    impl_deserialize_num_method!(i32, visit_i32, from_i32, Type::I32);
+    impl_deserialize_num_method!(i64, visit_i64, from_i64, Type::I64);
+    impl_deserialize_num_method!(usize, visit_usize, from_usize, Type::Usize);
+    impl_deserialize_num_method!(u8, visit_u8, from_u8, Type::U8);
+    impl_deserialize_num_method!(u16, visit_u16, from_u16, Type::U16);
+    impl_deserialize_num_method!(u32, visit_u32, from_u32, Type::U32);
+    impl_deserialize_num_method!(u64, visit_u64, from_u64, Type::U64);
+    impl_deserialize_num_method!(f32, visit_f32, from_f32, Type::F32);
+    impl_deserialize_num_method!(f64, visit_f64, from_f64, Type::F64);

    #[inline]
    fn visit_str<E>(&mut self, v: &str) -> Result<T, E>
        where E: Error,
    {
-        str::FromStr::from_str(v.trim()).or(Err(Error::syntax_error()))
+        str::FromStr::from_str(v.trim()).or(Err(Error::type_mismatch(Type::Str)))
    }
 }

 macro_rules! impl_deserialize_num {
-    ($ty:ty) => {
+    ($ty:ty, $method:ident) => {
        impl Deserialize for $ty {
            #[inline]
            fn deserialize<D>(deserializer: &mut D) -> Result<$ty, D::Error>
                where D: Deserializer,
            {
-                deserializer.visit(PrimitiveVisitor::new())
+                deserializer.$method(PrimitiveVisitor::new())
            }
        }
    }
 }

-impl_deserialize_num!(isize);
-impl_deserialize_num!(i8);
-impl_deserialize_num!(i16);
-impl_deserialize_num!(i32);
-impl_deserialize_num!(i64);
-impl_deserialize_num!(usize);
-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!(isize, visit_isize);
+impl_deserialize_num!(i8, visit_i8);
+impl_deserialize_num!(i16, visit_i16);
+impl_deserialize_num!(i32, visit_i32);
+impl_deserialize_num!(i64, visit_i64);
+impl_deserialize_num!(usize, visit_usize);
+impl_deserialize_num!(u8, visit_u8);
+impl_deserialize_num!(u16, visit_u16);
+impl_deserialize_num!(u32, visit_u32);
+impl_deserialize_num!(u64, visit_u64);
+impl_deserialize_num!(f32, visit_f32);
+impl_deserialize_num!(f64, visit_f64);

 ///////////////////////////////////////////////////////////////////////////////

@@ -179,12 +205,12 @@ impl Visitor for CharVisitor {
        let mut iter = v.chars();
        if let Some(v) = iter.next() {
            if iter.next().is_some() {
-                Err(Error::syntax_error())
+                Err(Error::type_mismatch(Type::Char))
            } else {
                Ok(v)
            }
        } else {
-            Err(Error::end_of_stream_error())
+            Err(Error::end_of_stream())
        }
    }
 }
@@ -194,7 +220,7 @@ impl Deserialize for char {
    fn deserialize<D>(deserializer: &mut D) -> Result<char, D::Error>
        where D: Deserializer,
    {
-        deserializer.visit(CharVisitor)
+        deserializer.visit_char(CharVisitor)
    }
 }

@@ -222,7 +248,7 @@ impl Visitor for StringVisitor {
    {
        match str::from_utf8(v) {
            Ok(s) => Ok(s.to_string()),
-            Err(_) => Err(Error::syntax_error()),
+            Err(_) => Err(Error::type_mismatch(Type::String)),
        }
    }

@@ -231,7 +257,7 @@ impl Visitor for StringVisitor {
    {
        match String::from_utf8(v) {
            Ok(s) => Ok(s),
-            Err(_) => Err(Error::syntax_error()),
+            Err(_) => Err(Error::type_mismatch(Type::String)),
        }
    }
 }
@@ -240,7 +266,7 @@ impl Deserialize for String {
    fn deserialize<D>(deserializer: &mut D) -> Result<String, D::Error>
        where D: Deserializer,
    {
-        deserializer.visit(StringVisitor)
+        deserializer.visit_string(StringVisitor)
    }
 }

@@ -280,159 +306,133 @@ impl<T> Deserialize for Option<T> where T: Deserialize {

 ///////////////////////////////////////////////////////////////////////////////

-pub struct BTreeSetVisitor<T> {
-    marker: PhantomData<T>,
-}
+macro_rules! seq_impl {
+    (
+        $ty:ty,
+        < $($constraints:ident),* >,
+        $visitor_name:ident,
+        $visitor:ident,
+        $ctor:expr,
+        $with_capacity:expr,
+        $insert:expr
+    ) => {
+        /// A visitor that produces a sequence.
+        pub struct $visitor_name<T> {
+            marker: PhantomData<T>,
+        }

-impl<T> BTreeSetVisitor<T> {
-    pub fn new() -> Self {
-        BTreeSetVisitor {
-            marker: PhantomData,
+        impl<T> $visitor_name<T> {
+            /// Construct a new sequence visitor.
+            pub fn new() -> Self {
+                $visitor_name {
+                    marker: PhantomData,
+                }
+            }
+        }
+
+        impl<T> Visitor for $visitor_name<T>
+            where T: $($constraints +)*,
+        {
+            type Value = $ty;
+
+            #[inline]
+            fn visit_unit<E>(&mut self) -> Result<$ty, E>
+                where E: Error,
+            {
+                Ok($ctor)
+            }
+
+            #[inline]
+            fn visit_seq<V>(&mut self, mut $visitor: V) -> Result<$ty, V::Error>
+                where V: SeqVisitor,
+            {
+                let mut values = $with_capacity;
+
+                while let Some(value) = try!($visitor.visit()) {
+                    $insert(&mut values, value);
+                }
+
+                try!($visitor.end());
+
+                Ok(values)
+            }
+        }
+
+        impl<T> Deserialize for $ty
+            where T: $($constraints +)*,
+        {
+            fn deserialize<D>(deserializer: &mut D) -> Result<$ty, D::Error>
+                where D: Deserializer,
+            {
+                deserializer.visit_seq($visitor_name::new())
+            }
        }
    }
 }

-impl<T> Visitor for BTreeSetVisitor<T>
-    where T: Deserialize + Eq + Ord,
-{
-    type Value = BTreeSet<T>;
+seq_impl!(
+    BinaryHeap<T>,
+    <Deserialize, Ord>,
+    BinaryHeapVisitor,
+    visitor,
+    BinaryHeap::new(),
+    BinaryHeap::with_capacity(visitor.size_hint().0),
+    BinaryHeap::push);

-    #[inline]
-    fn visit_unit<E>(&mut self) -> Result<BTreeSet<T>, E>
-        where E: Error,
-    {
-        Ok(BTreeSet::new())
-    }
+seq_impl!(
+    BTreeSet<T>,
+    <Deserialize, Eq, Ord>,
+    BTreeSetVisitor,
+    visitor,
+    BTreeSet::new(),
+    BTreeSet::new(),
+    BTreeSet::insert);

-    #[inline]
-    fn visit_seq<V>(&mut self, mut visitor: V) -> Result<BTreeSet<T>, V::Error>
-        where V: SeqVisitor,
-    {
-        let mut values = BTreeSet::new();
+#[cfg(feature = "nightly")]
+seq_impl!(
+    EnumSet<T>,
+    <Deserialize, CLike>,
+    EnumSetVisitor,
+    visitor,
+    EnumSet::new(),
+    EnumSet::new(),
+    EnumSet::insert);

-        while let Some(value) = try!(visitor.visit()) {
-            values.insert(value);
-        }
+seq_impl!(
+    LinkedList<T>,
+    <Deserialize>,
+    LinkedListVisitor,
+    visitor,
+    LinkedList::new(),
+    LinkedList::new(),
+    LinkedList::push_back);

-        try!(visitor.end());
+seq_impl!(
+    HashSet<T>,
+    <Deserialize, Eq, Hash>,
+    HashSetVisitor,
+    visitor,
+    HashSet::new(),
+    HashSet::with_capacity(visitor.size_hint().0),
+    HashSet::insert);

-        Ok(values)
-    }
-}
+seq_impl!(
+    Vec<T>,
+    <Deserialize>,
+    VecVisitor,
+    visitor,
+    Vec::new(),
+    Vec::with_capacity(visitor.size_hint().0),
+    Vec::push);

-impl<T> Deserialize for BTreeSet<T>
-    where T: Deserialize + Eq + Ord,
-{
-    fn deserialize<D>(deserializer: &mut D) -> Result<BTreeSet<T>, D::Error>
-        where D: Deserializer,
-    {
-        deserializer.visit(BTreeSetVisitor::new())
-    }
-}
-
-///////////////////////////////////////////////////////////////////////////////
-
-pub struct HashSetVisitor<T> {
-    marker: PhantomData<T>,
-}
-
-impl<T> HashSetVisitor<T> {
-    pub fn new() -> Self {
-        HashSetVisitor {
-            marker: PhantomData,
-        }
-    }
-}
-
-impl<T> Visitor for HashSetVisitor<T>
-    where T: Deserialize + Eq + Hash,
-{
-    type Value = HashSet<T>;
-
-    #[inline]
-    fn visit_unit<E>(&mut self) -> Result<HashSet<T>, E>
-        where E: Error,
-    {
-        Ok(HashSet::new())
-    }
-
-    #[inline]
-    fn visit_seq<V>(&mut self, mut visitor: V) -> Result<HashSet<T>, V::Error>
-        where V: SeqVisitor,
-    {
-        let (len, _) = visitor.size_hint();
-        let mut values = HashSet::with_capacity(len);
-
-        while let Some(value) = try!(visitor.visit()) {
-            values.insert(value);
-        }
-
-        try!(visitor.end());
-
-        Ok(values)
-    }
-}
-
-impl<T> Deserialize for HashSet<T>
-    where T: Deserialize + Eq + Hash,
-{
-    fn deserialize<D>(deserializer: &mut D) -> Result<HashSet<T>, D::Error>
-        where D: Deserializer,
-    {
-        deserializer.visit(HashSetVisitor::new())
-    }
-}
-
-///////////////////////////////////////////////////////////////////////////////
-
-pub struct VecVisitor<T> {
-    marker: PhantomData<T>,
-}
-
-impl<T> VecVisitor<T> {
-    pub fn new() -> Self {
-        VecVisitor {
-            marker: PhantomData,
-        }
-    }
-}
-
-impl<T> Visitor for VecVisitor<T> where T: Deserialize {
-    type Value = Vec<T>;
-
-    #[inline]
-    fn visit_unit<E>(&mut self) -> Result<Vec<T>, E>
-        where E: Error,
-    {
-        Ok(Vec::new())
-    }
-
-    #[inline]
-    fn visit_seq<V>(&mut self, mut visitor: V) -> Result<Vec<T>, V::Error>
-        where V: SeqVisitor,
-    {
-        let (len, _) = visitor.size_hint();
-        let mut values = Vec::with_capacity(len);
-
-        while let Some(value) = try!(visitor.visit()) {
-            values.push(value);
-        }
-
-        try!(visitor.end());
-
-        Ok(values)
-    }
-}
-
-impl<T> Deserialize for Vec<T>
-    where T: Deserialize,
-{
-    fn deserialize<D>(deserializer: &mut D) -> Result<Vec<T>, D::Error>
-        where D: Deserializer,
-    {
-        deserializer.visit_seq(VecVisitor::new())
-    }
-}
+seq_impl!(
+    VecDeque<T>,
+    <Deserialize>,
+    VecDequeVisitor,
+    visitor,
+    VecDeque::new(),
+    VecDeque::with_capacity(visitor.size_hint().0),
+    VecDeque::push_back);

 ///////////////////////////////////////////////////////////////////////////////

@@ -441,6 +441,7 @@ struct ArrayVisitor0<T> {
 }

 impl<T> ArrayVisitor0<T> {
+    /// Construct a `ArrayVisitor0<T>`.
    pub fn new() -> Self {
        ArrayVisitor0 {
            marker: PhantomData,
@@ -473,7 +474,7 @@ impl<T> Deserialize for [T; 0]
    fn deserialize<D>(deserializer: &mut D) -> Result<[T; 0], D::Error>
        where D: Deserializer,
    {
-        deserializer.visit(ArrayVisitor0::new())
+        deserializer.visit_seq(ArrayVisitor0::new())
    }
 }

@@ -485,6 +486,7 @@ macro_rules! array_impls {
            }

            impl<T> $visitor<T> {
+                /// Construct a `ArrayVisitor*<T>`.
                pub fn new() -> Self {
                    $visitor {
                        marker: PhantomData
@@ -502,7 +504,7 @@ macro_rules! array_impls {
                    $(
                        let $name = match try!(visitor.visit()) {
                            Some(val) => val,
-                            None => { return Err(Error::end_of_stream_error()); }
+                            None => { return Err(Error::end_of_stream()); }
                        };
                    )+;

@@ -518,7 +520,7 @@ macro_rules! array_impls {
                fn deserialize<D>(deserializer: &mut D) -> Result<[T; $len], D::Error>
                    where D: Deserializer,
                {
-                    deserializer.visit($visitor::new())
+                    deserializer.visit_seq($visitor::new())
                }
            }
        )+
@@ -572,12 +574,23 @@ array_impls! {

 macro_rules! tuple_impls {
    () => {};
-    ($($visitor:ident => ($($name:ident),+),)+) => {
+    ($($len:expr => $visitor:ident => ($($name:ident),+),)+) => {
        $(
-            struct $visitor<$($name,)+> {
+            /// Construct a tuple visitor.
+            pub struct $visitor<$($name,)+> {
                marker: PhantomData<($($name,)+)>,
            }

+            impl<
+                $($name: Deserialize,)+
+            > $visitor<$($name,)+> {
+                /// Construct a `TupleVisitor*<T>`.
+                pub fn new() -> Self {
+                    $visitor { marker: PhantomData }
+                }
+            }
+
+
            impl<
                $($name: Deserialize,)+
            > Visitor for $visitor<$($name,)+> {
@@ -591,7 +604,7 @@ macro_rules! tuple_impls {
                    $(
                        let $name = match try!(visitor.visit()) {
                            Some(value) => value,
-                            None => { return Err(Error::end_of_stream_error()); }
+                            None => { return Err(Error::end_of_stream()); }
                        };
                     )+;

@@ -608,7 +621,7 @@ macro_rules! tuple_impls {
                fn deserialize<D>(deserializer: &mut D) -> Result<($($name,)+), D::Error>
                    where D: Deserializer,
                {
-                    deserializer.visit_seq($visitor { marker: PhantomData })
+                    deserializer.visit_tuple($len, $visitor::new())
                }
            }
        )+
@@ -616,187 +629,105 @@ macro_rules! tuple_impls {
 }

 tuple_impls! {
-    TupleVisitor1 => (T0),
-    TupleVisitor2 => (T0, T1),
-    TupleVisitor3 => (T0, T1, T2),
-    TupleVisitor4 => (T0, T1, T2, T3),
-    TupleVisitor5 => (T0, T1, T2, T3, T4),
-    TupleVisitor6 => (T0, T1, T2, T3, T4, T5),
-    TupleVisitor7 => (T0, T1, T2, T3, T4, T5, T6),
-    TupleVisitor8 => (T0, T1, T2, T3, T4, T5, T6, T7),
-    TupleVisitor9 => (T0, T1, T2, T3, T4, T5, T6, T7, T8),
-    TupleVisitor10 => (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9),
-    TupleVisitor11 => (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10),
-    TupleVisitor12 => (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11),
+    1 => TupleVisitor1 => (T0),
+    2 => TupleVisitor2 => (T0, T1),
+    3 => TupleVisitor3 => (T0, T1, T2),
+    4 => TupleVisitor4 => (T0, T1, T2, T3),
+    5 => TupleVisitor5 => (T0, T1, T2, T3, T4),
+    6 => TupleVisitor6 => (T0, T1, T2, T3, T4, T5),
+    7 => TupleVisitor7 => (T0, T1, T2, T3, T4, T5, T6),
+    8 => TupleVisitor8 => (T0, T1, T2, T3, T4, T5, T6, T7),
+    9 => TupleVisitor9 => (T0, T1, T2, T3, T4, T5, T6, T7, T8),
+    10 => TupleVisitor10 => (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9),
+    11 => TupleVisitor11 => (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10),
+    12 => TupleVisitor12 => (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11),
 }

 ///////////////////////////////////////////////////////////////////////////////

-pub struct BTreeMapVisitor<K, V> {
-    marker: PhantomData<BTreeMap<K, V>>,
-}
+macro_rules! map_impl {
+    (
+        $ty:ty,
+        < $($constraints:ident),* >,
+        $visitor_name:ident,
+        $visitor:ident,
+        $ctor:expr,
+        $with_capacity:expr,
+        $insert:expr
+    ) => {
+        /// A visitor that produces a map.
+        pub struct $visitor_name<K, V> {
+            marker: PhantomData<$ty>,
+        }

-impl<K, V> BTreeMapVisitor<K, V> {
-    #[inline]
-    pub fn new() -> Self {
-        BTreeMapVisitor {
-            marker: PhantomData,
+        impl<K, V> $visitor_name<K, V> {
+            /// Construct a `MapVisitor*<T>`.
+            pub fn new() -> Self {
+                $visitor_name {
+                    marker: PhantomData,
+                }
+            }
+        }
+
+        impl<K, V> Visitor for $visitor_name<K, V>
+            where K: $($constraints +)*,
+                  V: Deserialize,
+        {
+            type Value = $ty;
+
+            #[inline]
+            fn visit_unit<E>(&mut self) -> Result<$ty, E>
+                where E: Error,
+            {
+                Ok($ctor)
+            }
+
+            #[inline]
+            fn visit_map<Visitor>(&mut self, mut $visitor: Visitor) -> Result<$ty, Visitor::Error>
+                where Visitor: MapVisitor,
+            {
+                let mut values = $with_capacity;
+
+                while let Some((key, value)) = try!($visitor.visit()) {
+                    $insert(&mut values, key, value);
+                }
+
+                try!($visitor.end());
+
+                Ok(values)
+            }
+        }
+
+        impl<K, V> Deserialize for $ty
+            where K: $($constraints +)*,
+                  V: Deserialize,
+        {
+            fn deserialize<D>(deserializer: &mut D) -> Result<$ty, D::Error>
+                where D: Deserializer,
+            {
+                deserializer.visit_map($visitor_name::new())
+            }
        }
    }
 }

-impl<K, V> Visitor for BTreeMapVisitor<K, V>
-    where K: Deserialize + Ord,
-          V: Deserialize
-{
-    type Value = BTreeMap<K, V>;
+map_impl!(
+    BTreeMap<K, V>,
+    <Deserialize, Eq, Ord>,
+    BTreeMapVisitor,
+    visitor,
+    BTreeMap::new(),
+    BTreeMap::new(),
+    BTreeMap::insert);

-    #[inline]
-    fn visit_unit<E>(&mut self) -> Result<BTreeMap<K, V>, E>
-        where E: Error,
-    {
-        Ok(BTreeMap::new())
-    }
-
-    #[inline]
-    fn visit_map<Visitor>(&mut self, mut visitor: Visitor) -> Result<BTreeMap<K, V>, Visitor::Error>
-        where Visitor: MapVisitor,
-    {
-        let mut values = BTreeMap::new();
-
-        while let Some((key, value)) = try!(visitor.visit()) {
-            values.insert(key, value);
-        }
-
-        try!(visitor.end());
-
-        Ok(values)
-    }
-}
-
-impl<K, V> Deserialize for BTreeMap<K, V>
-    where K: Deserialize + Eq + Ord,
-          V: Deserialize,
-{
-    fn deserialize<D>(deserializer: &mut D) -> Result<BTreeMap<K, V>, D::Error>
-        where D: Deserializer,
-    {
-        deserializer.visit(BTreeMapVisitor::new())
-    }
-}
-
-///////////////////////////////////////////////////////////////////////////////
-
-pub struct HashMapVisitor<K, V> {
-    marker: PhantomData<HashMap<K, V>>,
-}
-
-impl<K, V> HashMapVisitor<K, V> {
-    #[inline]
-    pub fn new() -> Self {
-        HashMapVisitor {
-            marker: PhantomData,
-        }
-    }
-}
-
-impl<K, V> Visitor for HashMapVisitor<K, V>
-    where K: Deserialize + Eq + Hash,
-          V: Deserialize,
-{
-    type Value = HashMap<K, V>;
-
-    #[inline]
-    fn visit_unit<E>(&mut self) -> Result<HashMap<K, V>, E>
-        where E: Error,
-    {
-        Ok(HashMap::new())
-    }
-
-    #[inline]
-    fn visit_map<V_>(&mut self, mut visitor: V_) -> Result<HashMap<K, V>, V_::Error>
-        where V_: MapVisitor,
-    {
-        let (len, _) = visitor.size_hint();
-        let mut values = HashMap::with_capacity(len);
-
-        while let Some((key, value)) = try!(visitor.visit()) {
-            values.insert(key, value);
-        }
-
-        try!(visitor.end());
-
-        Ok(values)
-    }
-}
-
-impl<K, V> Deserialize for HashMap<K, V>
-    where K: Deserialize + Eq + Hash,
-          V: Deserialize,
-{
-    fn deserialize<D>(deserializer: &mut D) -> Result<HashMap<K, V>, D::Error>
-        where D: Deserializer,
-    {
-        deserializer.visit(HashMapVisitor::new())
-    }
-}
-
-///////////////////////////////////////////////////////////////////////////////
-
-// FIXME: `VecMap` is unstable.
-/*
-pub struct VecMapVisitor<V> {
-    marker: PhantomData<VecMap<V>>,
-}
-
-impl<V> VecMapVisitor<V> {
-    #[inline]
-    pub fn new() -> Self {
-        VecMapVisitor {
-            marker: PhantomData,
-        }
-    }
-}
-
-impl<V> Visitor for VecMapVisitor<V>
-    where V: Deserialize,
-{
-    type Value = VecMap<V>;
-
-    #[inline]
-    fn visit_unit<E>(&mut self) -> Result<VecMap<V>, E>
-        where E: Error,
-    {
-        Ok(VecMap::new())
-    }
-
-    #[inline]
-    fn visit_map<V_>(&mut self, mut visitor: V_) -> Result<VecMap<V>, V_::Error>
-        where V_: MapVisitor,
-    {
-        let (len, _) = visitor.size_hint();
-        let mut values = VecMap::with_capacity(len);
-
-        while let Some((key, value)) = try!(visitor.visit()) {
-            values.insert(key, value);
-        }
-
-        try!(visitor.end());
-
-        Ok(values)
-    }
-}
-
-impl<V> Deserialize for VecMap<V>
-    where V: Deserialize,
-{
-    fn deserialize<D>(deserializer: &mut D) -> Result<VecMap<V>, D::Error>
-        where D: Deserializer,
-    {
-        deserializer.visit(VecMapVisitor::new())
-    }
-}
-*/
+map_impl!(
+    HashMap<K, V>,
+    <Deserialize, Eq, Hash>,
+    HashMapVisitor,
+    visitor,
+    HashMap::new(),
+    HashMap::with_capacity(visitor.size_hint().0),
+    HashMap::insert);

 ///////////////////////////////////////////////////////////////////////////////

@@ -854,3 +785,113 @@ impl<T: Deserialize> Deserialize for Rc<T> {
        Ok(Rc::new(val))
    }
 }
+
+impl<'a, T: ?Sized> Deserialize for Cow<'a, T> where T: ToOwned, T::Owned: Deserialize, {
+    #[inline]
+    fn deserialize<D>(deserializer: &mut D) -> Result<Cow<'a, T>, D::Error>
+        where D: Deserializer,
+    {
+        let val = try!(Deserialize::deserialize(deserializer));
+        Ok(Cow::Owned(val))
+    }
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+#[cfg(feature = "nightly")]
+impl<T> Deserialize for NonZero<T> where T: Deserialize + PartialEq + Zeroable + Zero {
+    fn deserialize<D>(deserializer: &mut D) -> Result<NonZero<T>, D::Error> where D: Deserializer {
+        let value = try!(Deserialize::deserialize(deserializer));
+        if value == Zero::zero() {
+            return Err(Error::syntax("expected a non-zero value"))
+        }
+        unsafe {
+            Ok(NonZero::new(value))
+        }
+    }
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+
+impl<T, E> Deserialize for Result<T, E> where T: Deserialize, E: Deserialize {
+    fn deserialize<D>(deserializer: &mut D) -> Result<Result<T, E>, D::Error>
+                      where D: Deserializer {
+        enum Field {
+            Ok,
+            Err,
+        }
+
+        impl Deserialize for Field {
+            #[inline]
+            fn deserialize<D>(deserializer: &mut D) -> Result<Field, D::Error>
+                where D: Deserializer
+            {
+                struct FieldVisitor;
+
+                impl ::de::Visitor for FieldVisitor {
+                    type Value = Field;
+
+                    fn visit_usize<E>(&mut self, value: usize) -> Result<Field, E> where E: Error {
+                        match value {
+                            0 => Ok(Field::Ok),
+                            1 => Ok(Field::Err),
+                            _ => Err(Error::unknown_field(&value.to_string())),
+                        }
+                    }
+
+                    fn visit_str<E>(&mut self, value: &str) -> Result<Field, E> where E: Error {
+                        match value {
+                            "Ok" => Ok(Field::Ok),
+                            "Err" => Ok(Field::Err),
+                            _ => Err(Error::unknown_field(value)),
+                        }
+                    }
+
+                    fn visit_bytes<E>(&mut self, value: &[u8]) -> Result<Field, E> where E: Error {
+                        match value {
+                            b"Ok" => Ok(Field::Ok),
+                            b"Err" => Ok(Field::Err),
+                            _ => {
+                                match str::from_utf8(value) {
+                                    Ok(value) => Err(Error::unknown_field(value)),
+                                    Err(_) => Err(Error::type_mismatch(Type::String)),
+                                }
+                            }
+                        }
+                    }
+                }
+
+                deserializer.visit(FieldVisitor)
+            }
+        }
+
+        struct Visitor<T, E>(PhantomData<Result<T, E>>);
+
+        impl<T, E> EnumVisitor for Visitor<T, E>
+            where T: Deserialize,
+                  E: Deserialize
+        {
+            type Value = Result<T, E>;
+
+            fn visit<V>(&mut self, mut visitor: V) -> Result<Result<T, E>, V::Error>
+                where V: VariantVisitor
+            {
+                match try!(visitor.visit_variant()) {
+                    Field::Ok => {
+                        let value = try!(visitor.visit_newtype());
+                        Ok(Ok(value))
+                    }
+                    Field::Err => {
+                        let value = try!(visitor.visit_newtype());
+                        Ok(Err(value))
+                    }
+                }
+            }
+        }
+
+        const VARIANTS: &'static [&'static str] = &["Ok", "Err"];
+
+        deserializer.visit_enum("Result", VARIANTS, Visitor(PhantomData))
+    }
+}
@@ -5,19 +5,130 @@ pub mod value;

 ///////////////////////////////////////////////////////////////////////////////

-pub trait Error {
-    fn syntax_error() -> Self;
+/// `Error` is a trait that allows a `Deserialize` to generically create a
+/// `Deserializer` error.
+pub trait Error: Sized {
+    /// Raised when there is general error when deserializing a type.
+    fn syntax(msg: &str) -> Self;

-    fn end_of_stream_error() -> Self;
+    /// Raised when a fixed sized sequence or map was passed in the wrong amount of arguments.
+    fn length_mismatch(_len: usize) -> Self {
+        Error::syntax("incorrect length")
+    }

-    fn unknown_field_error(field: &str) -> Self;
+    /// Raised when a `Deserialize` was passed an incorrect type.
+    fn type_mismatch(_type: Type) -> Self {
+        Error::syntax("incorrect type")
+    }

-    fn missing_field_error(field: &'static str) -> Self;
+    /// Raised when a `Deserialize` type unexpectedly hit the end of the stream.
+    fn end_of_stream() -> Self;
+
+    /// Raised when a `Deserialize` struct type received an unexpected struct field.
+    fn unknown_field(field: &str) -> Self;
+
+    /// Raised when a `Deserialize` struct type did not receive a field.
+    fn missing_field(field: &'static str) -> Self;
+}
+
+/// `Type` represents all the primitive types that can be deserialized. This is used by
+/// `Error::kind_mismatch`.
+pub enum Type {
+    /// Represents a `bool` type.
+    Bool,
+
+    /// Represents a `usize` type.
+    Usize,
+
+    /// Represents a `u8` type.
+    U8,
+
+    /// Represents a `u16` type.
+    U16,
+
+    /// Represents a `u32` type.
+    U32,
+
+    /// Represents a `u64` type.
+    U64,
+
+    /// Represents a `isize` type.
+    Isize,
+
+    /// Represents a `i8` type.
+    I8,
+
+    /// Represents a `i16` type.
+    I16,
+
+    /// Represents a `i32` type.
+    I32,
+
+    /// Represents a `i64` type.
+    I64,
+
+    /// Represents a `f32` type.
+    F32,
+
+    /// Represents a `f64` type.
+    F64,
+
+    /// Represents a `char` type.
+    Char,
+
+    /// Represents a `&str` type.
+    Str,
+
+    /// Represents a `String` type.
+    String,
+
+    /// Represents a `()` type.
+    Unit,
+
+    /// Represents an `Option<T>` type.
+    Option,
+
+    /// Represents a sequence type.
+    Seq,
+
+    /// Represents a map type.
+    Map,
+
+    /// Represents a unit struct type.
+    UnitStruct,
+
+    /// Represents a newtype type.
+    NewtypeStruct,
+
+    /// Represents a tuple struct type.
+    TupleStruct,
+
+    /// Represents a struct type.
+    Struct,
+
+    /// Represents a tuple type.
+    Tuple,
+
+    /// Represents an `enum` type.
+    Enum,
+
+    /// Represents a struct variant.
+    StructVariant,
+
+    /// Represents a tuple variant.
+    TupleVariant,
+
+    /// Represents a unit variant.
+    UnitVariant,
+
+    /// Represents a `&[u8]` type.
+    Bytes,
 }

 ///////////////////////////////////////////////////////////////////////////////

-pub trait Deserialize {
+/// `Deserialize` represents a type that can be deserialized.
+pub trait Deserialize: Sized {
    /// Deserialize this value given this `Deserializer`.
    fn deserialize<D>(deserializer: &mut D) -> Result<Self, D::Error>
        where D: Deserializer;
@@ -25,18 +136,165 @@ pub trait Deserialize {

 ///////////////////////////////////////////////////////////////////////////////

-/// `Deserializer` is an abstract trait that can deserialize values into a `Visitor`.
+/// `Deserializer` is a trait that can deserialize values by threading a `Visitor` trait through a
+/// value. It supports two entry point styles which enables different kinds of deserialization.
+///
+/// 1) The `visit` method. File formats like JSON embed the type of it's construct in it's file
+///    format. This allows the `Deserializer` to deserialize into a generic type like
+///    `json::Value`, which can represent all JSON types.
+///
+/// 2) The `visit_*` methods. File formats like bincode do not embed in it's format how to decode
+///    it's values. It relies instead on the `Deserialize` type to hint to the `Deserializer` with
+///    the `visit_*` methods how it should parse the next value. One downside though to only
+///    supporting the `visit_*` types is that it does not allow for deserializing into a generic
+///    `json::Value`-esque type.
 pub trait Deserializer {
+    /// The error type that can be returned if some error occurs during deserialization.
    type Error: Error;

-    /// The `visit` method walks a visitor through a value as it is being deserialized.
+    /// This method walks a visitor through a value as it is being deserialized.
    fn visit<V>(&mut self, visitor: V) -> Result<V::Value, Self::Error>
        where V: Visitor;

-    /// The `visit_option` method allows a `Deserialize` type to inform the `Deserializer` that
-    /// it's expecting an optional value. This allows deserializers that encode an optional value
-    /// as a nullable value to convert the null value into a `None`, and a regular value as
-    /// `Some(value)`.
+    /// This method hints that the `Deserialize` type is expecting a `bool` value.
+    #[inline]
+    fn visit_bool<V>(&mut self, visitor: V) -> Result<V::Value, Self::Error>
+        where V: Visitor,
+    {
+        self.visit(visitor)
+    }
+
+    /// This method hints that the `Deserialize` type is expecting an `usize` value.
+    #[inline]
+    fn visit_usize<V>(&mut self, visitor: V) -> Result<V::Value, Self::Error>
+        where V: Visitor,
+    {
+        self.visit_u64(visitor)
+    }
+
+    /// This method hints that the `Deserialize` type is expecting an `u8` value.
+    #[inline]
+    fn visit_u8<V>(&mut self, visitor: V) -> Result<V::Value, Self::Error>
+        where V: Visitor,
+    {
+        self.visit_u64(visitor)
+    }
+
+    /// This method hints that the `Deserialize` type is expecting an `u16` value.
+    #[inline]
+    fn visit_u16<V>(&mut self, visitor: V) -> Result<V::Value, Self::Error>
+        where V: Visitor,
+    {
+        self.visit_u64(visitor)
+    }
+
+    /// This method hints that the `Deserialize` type is expecting an `u32` value.
+    #[inline]
+    fn visit_u32<V>(&mut self, visitor: V) -> Result<V::Value, Self::Error>
+        where V: Visitor,
+    {
+        self.visit_u64(visitor)
+    }
+
+    /// This method hints that the `Deserialize` type is expecting an `u64` value.
+    #[inline]
+    fn visit_u64<V>(&mut self, visitor: V) -> Result<V::Value, Self::Error>
+        where V: Visitor,
+    {
+        self.visit(visitor)
+    }
+
+    /// This method hints that the `Deserialize` type is expecting an `isize` value.
+    #[inline]
+    fn visit_isize<V>(&mut self, visitor: V) -> Result<V::Value, Self::Error>
+        where V: Visitor,
+    {
+        self.visit_i64(visitor)
+    }
+
+    /// This method hints that the `Deserialize` type is expecting an `i8` value.
+    #[inline]
+    fn visit_i8<V>(&mut self, visitor: V) -> Result<V::Value, Self::Error>
+        where V: Visitor,
+    {
+        self.visit_i64(visitor)
+    }
+
+    /// This method hints that the `Deserialize` type is expecting an `i16` value.
+    #[inline]
+    fn visit_i16<V>(&mut self, visitor: V) -> Result<V::Value, Self::Error>
+        where V: Visitor,
+    {
+        self.visit_i64(visitor)
+    }
+
+    /// This method hints that the `Deserialize` type is expecting an `i32` value.
+    #[inline]
+    fn visit_i32<V>(&mut self, visitor: V) -> Result<V::Value, Self::Error>
+        where V: Visitor,
+    {
+        self.visit_i64(visitor)
+    }
+
+    /// This method hints that the `Deserialize` type is expecting an `i64` value.
+    #[inline]
+    fn visit_i64<V>(&mut self, visitor: V) -> Result<V::Value, Self::Error>
+        where V: Visitor,
+    {
+        self.visit(visitor)
+    }
+
+    /// This method hints that the `Deserialize` type is expecting a `f32` value.
+    #[inline]
+    fn visit_f32<V>(&mut self, visitor: V) -> Result<V::Value, Self::Error>
+        where V: Visitor,
+    {
+        self.visit_f64(visitor)
+    }
+
+    /// This method hints that the `Deserialize` type is expecting a `f64` value.
+    #[inline]
+    fn visit_f64<V>(&mut self, visitor: V) -> Result<V::Value, Self::Error>
+        where V: Visitor,
+    {
+        self.visit(visitor)
+    }
+
+    /// This method hints that the `Deserialize` type is expecting a `char` value.
+    #[inline]
+    fn visit_char<V>(&mut self, visitor: V) -> Result<V::Value, Self::Error>
+        where V: Visitor,
+    {
+        self.visit(visitor)
+    }
+
+    /// This method hints that the `Deserialize` type is expecting a `&str` value.
+    #[inline]
+    fn visit_str<V>(&mut self, visitor: V) -> Result<V::Value, Self::Error>
+        where V: Visitor,
+    {
+        self.visit(visitor)
+    }
+
+    /// This method hints that the `Deserialize` type is expecting a `String` value.
+    #[inline]
+    fn visit_string<V>(&mut self, visitor: V) -> Result<V::Value, Self::Error>
+        where V: Visitor,
+    {
+        self.visit_str(visitor)
+    }
+
+    /// This method hints that the `Deserialize` type is expecting an `unit` value.
+    #[inline]
+    fn visit_unit<V>(&mut self, visitor: V) -> Result<V::Value, Self::Error>
+        where V: Visitor,
+    {
+        self.visit(visitor)
+    }
+
+    /// This method hints that the `Deserialize` type is expecting an `Option` value. This allows
+    /// deserializers that encode an optional value as a nullable value to convert the null value
+    /// into a `None`, and a regular value as `Some(value)`.
    #[inline]
    fn visit_option<V>(&mut self, visitor: V) -> Result<V::Value, Self::Error>
        where V: Visitor,
@@ -44,9 +302,8 @@ pub trait Deserializer {
        self.visit(visitor)
    }

-    /// The `visit_seq` method allows a `Deserialize` type to inform the `Deserializer` that it's
-    /// expecting a sequence of values. This allows deserializers to parse sequences that aren't
-    /// tagged as sequences.
+    /// This method hints that the `Deserialize` type is expecting a sequence value. This allows
+    /// deserializers to parse sequences that aren't tagged as sequences.
    #[inline]
    fn visit_seq<V>(&mut self, visitor: V) -> Result<V::Value, Self::Error>
        where V: Visitor,
@@ -54,9 +311,8 @@ pub trait Deserializer {
        self.visit(visitor)
    }

-    /// The `visit_map` method allows a `Deserialize` type to inform the `Deserializer` that it's
-    /// expecting a map of values. This allows deserializers to parse sequences that aren't tagged
-    /// as maps.
+    /// This method hints that the `Deserialize` type is expecting a map of values. This allows
+    /// deserializers to parse sequences that aren't tagged as maps.
    #[inline]
    fn visit_map<V>(&mut self, visitor: V) -> Result<V::Value, Self::Error>
        where V: Visitor,
@@ -64,54 +320,82 @@ pub trait Deserializer {
        self.visit(visitor)
    }

-    /// The `visit_named_unit` method allows a `Deserialize` type to inform the `Deserializer` that
-    /// it's expecting a named unit. This allows deserializers to a named unit that aren't tagged
-    /// as a named unit.
+    /// This method hints that the `Deserialize` type is expecting a unit struct. This allows
+    /// deserializers to a unit struct that aren't tagged as a unit struct.
    #[inline]
-    fn visit_named_unit<V>(&mut self, _name: &str, visitor: V) -> Result<V::Value, Self::Error>
+    fn visit_unit_struct<V>(&mut self,
+                            _name: &'static str,
+                            visitor: V) -> Result<V::Value, Self::Error>
        where V: Visitor,
    {
-        self.visit(visitor)
+        self.visit_unit(visitor)
    }

-    /// The `visit_named_seq` method allows a `Deserialize` type to inform the `Deserializer` that
-    /// it's expecting a named sequence of values. This allows deserializers to parse sequences
-    /// that aren't tagged as sequences.
+    /// This method hints that the `Deserialize` type is expecting a newtype struct. This allows
+    /// deserializers to a newtype struct that aren't tagged as a newtype struct.
    #[inline]
-    fn visit_named_seq<V>(&mut self, _name: &str, visitor: V) -> Result<V::Value, Self::Error>
+    fn visit_newtype_struct<V>(&mut self,
+                               name: &'static str,
+                               visitor: V) -> Result<V::Value, Self::Error>
        where V: Visitor,
    {
-        self.visit_seq(visitor)
+        self.visit_tuple_struct(name, 1, visitor)
    }

-    /// The `visit_named_map` method allows a `Deserialize` type to inform the `Deserializer` that
-    /// it's expecting a map of values. This allows deserializers to parse sequences that aren't
-    /// tagged as maps.
+    /// This method hints that the `Deserialize` type is expecting a tuple struct. This allows
+    /// deserializers to parse sequences that aren't tagged as sequences.
    #[inline]
-    fn visit_named_map<V>(&mut self, _name: &str, visitor: V) -> Result<V::Value, Self::Error>
+    fn visit_tuple_struct<V>(&mut self,
+                             _name: &'static str,
+                             len: usize,
+                             visitor: V) -> Result<V::Value, Self::Error>
+        where V: Visitor,
+    {
+        self.visit_tuple(len, visitor)
+    }
+
+    /// This method hints that the `Deserialize` type is expecting a struct. This allows
+    /// deserializers to parse sequences that aren't tagged as maps.
+    #[inline]
+    fn visit_struct<V>(&mut self,
+                       _name: &'static str,
+                       _fields: &'static [&'static str],
+                       visitor: V) -> Result<V::Value, Self::Error>
        where V: Visitor,
    {
        self.visit_map(visitor)
    }

-    /// The `visit_enum` method allows a `Deserialize` type to inform the `Deserializer` that it's
-    /// expecting an enum value. This allows deserializers that provide a custom enumeration
-    /// serialization to properly deserialize the type.
+    /// This method hints that the `Deserialize` type is expecting a tuple value. This allows
+    /// deserializers that provide a custom tuple serialization to properly deserialize the type.
    #[inline]
-    fn visit_enum<V>(&mut self, _enum: &str, _visitor: V) -> Result<V::Value, Self::Error>
-        where V: EnumVisitor,
+    fn visit_tuple<V>(&mut self, _len: usize, visitor: V) -> Result<V::Value, Self::Error>
+        where V: Visitor,
    {
-        Err(Error::syntax_error())
+        self.visit_seq(visitor)
    }

-    /// The `visit_bytes` method allows a `Deserialize` type to inform the `Deserializer` that it's
-    /// expecting a `Vec<u8>`. This allows deserializers that provide a custom byte vector
-    /// serialization to properly deserialize the type.
+    /// This method hints that the `Deserialize` type is expecting an enum value. This allows
+    /// deserializers that provide a custom enumeration serialization to properly deserialize the
+    /// type.
+    #[inline]
+    fn visit_enum<V>(&mut self,
+                     _enum: &'static str,
+                     _variants: &'static [&'static str],
+                     _visitor: V) -> Result<V::Value, Self::Error>
+        where V: EnumVisitor,
+    {
+        Err(Error::syntax("expected an enum"))
+    }
+
+    /// This method hints that the `Deserialize` type is expecting a `Vec<u8>`. This allows
+    /// deserializers that provide a custom byte vector serialization to properly deserialize the
+    /// type.
    #[inline]
    fn visit_bytes<V>(&mut self, visitor: V) -> Result<V::Value, Self::Error>
        where V: Visitor,
    {
-        self.visit(visitor)
+        self.visit_seq(visitor)
    }

    /// Specify a format string for the deserializer.
@@ -126,87 +410,103 @@ pub trait Deserializer {

 ///////////////////////////////////////////////////////////////////////////////

+/// This trait represents a visitor that walks through a deserializer.
 pub trait Visitor {
+    /// The value produced by this visitor.
    type Value: Deserialize;

+    /// `visit_bool` deserializes a `bool` into a `Value`.
    fn visit_bool<E>(&mut self, _v: bool) -> Result<Self::Value, E>
        where E: Error,
    {
-        Err(Error::syntax_error())
+        Err(Error::type_mismatch(Type::Bool))
    }

+    /// `visit_isize` deserializes a `isize` into a `Value`.
    fn visit_isize<E>(&mut self, v: isize) -> Result<Self::Value, E>
        where E: Error,
    {
        self.visit_i64(v as i64)
    }

+    /// `visit_i8` deserializes a `i8` into a `Value`.
    fn visit_i8<E>(&mut self, v: i8) -> Result<Self::Value, E>
        where E: Error,
    {
        self.visit_i64(v as i64)
    }

+    /// `visit_i16` deserializes a `i16` into a `Value`.
    fn visit_i16<E>(&mut self, v: i16) -> Result<Self::Value, E>
        where E: Error,
    {
        self.visit_i64(v as i64)
    }

+    /// `visit_i32` deserializes a `i32` into a `Value`.
    fn visit_i32<E>(&mut self, v: i32) -> Result<Self::Value, E>
        where E: Error,
    {
        self.visit_i64(v as i64)
    }

+    /// `visit_i64` deserializes a `i64` into a `Value`.
    fn visit_i64<E>(&mut self, _v: i64) -> Result<Self::Value, E>
        where E: Error,
    {
-        Err(Error::syntax_error())
+        Err(Error::type_mismatch(Type::I64))
    }

+    /// `visit_usize` deserializes a `usize` into a `Value`.
    fn visit_usize<E>(&mut self, v: usize) -> Result<Self::Value, E>
        where E: Error,
    {
        self.visit_u64(v as u64)
    }

+    /// `visit_u8` deserializes a `u8` into a `Value`.
    fn visit_u8<E>(&mut self, v: u8) -> Result<Self::Value, E>
        where E: Error,
    {
        self.visit_u64(v as u64)
    }

+    /// `visit_u16` deserializes a `u16` into a `Value`.
    fn visit_u16<E>(&mut self, v: u16) -> Result<Self::Value, E>
        where E: Error,
    {
        self.visit_u64(v as u64)
    }

+    /// `visit_u32` deserializes a `u32` into a `Value`.
    fn visit_u32<E>(&mut self, v: u32) -> Result<Self::Value, E>
        where E: Error,
    {
        self.visit_u64(v as u64)
    }

+    /// `visit_u64` deserializes a `u64` into a `Value`.
    fn visit_u64<E>(&mut self, _v: u64) -> Result<Self::Value, E>
        where E: Error,
    {
-        Err(Error::syntax_error())
+        Err(Error::type_mismatch(Type::U64))
    }

+    /// `visit_f32` deserializes a `f32` into a `Value`.
    fn visit_f32<E>(&mut self, v: f32) -> Result<Self::Value, E>
        where E: Error,
    {
        self.visit_f64(v as f64)
    }

+    /// `visit_f64` deserializes a `f64` into a `Value`.
    fn visit_f64<E>(&mut self, _v: f64) -> Result<Self::Value, E>
        where E: Error,
    {
-        Err(Error::syntax_error())
+        Err(Error::type_mismatch(Type::F64))
    }

+    /// `visit_char` deserializes a `char` into a `Value`.
    #[inline]
    fn visit_char<E>(&mut self, v: char) -> Result<Self::Value, E>
        where E: Error,
@@ -216,12 +516,14 @@ pub trait Visitor {
        self.visit_string(v.to_string())
    }

+    /// `visit_str` deserializes a `&str` into a `Value`.
    fn visit_str<E>(&mut self, _v: &str) -> Result<Self::Value, E>
        where E: Error,
    {
-        Err(Error::syntax_error())
+        Err(Error::type_mismatch(Type::Str))
    }

+    /// `visit_string` deserializes a `String` into a `Value`.
    #[inline]
    fn visit_string<E>(&mut self, v: String) -> Result<Self::Value, E>
        where E: Error,
@@ -229,49 +531,64 @@ pub trait Visitor {
        self.visit_str(&v)
    }

+    /// `visit_unit` deserializes a `()` into a `Value`.
    fn visit_unit<E>(&mut self) -> Result<Self::Value, E>
        where E: Error,
    {
-        Err(Error::syntax_error())
+        Err(Error::type_mismatch(Type::Unit))
    }

+    /// `visit_unit_struct` deserializes a unit struct into a `Value`.
    #[inline]
-    fn visit_named_unit<E>(&mut self, _name: &str) -> Result<Self::Value, E>
+    fn visit_unit_struct<E>(&mut self, _name: &'static str) -> Result<Self::Value, E>
        where E: Error,
    {
        self.visit_unit()
    }

+    /// `visit_none` deserializes a none value into a `Value`.
    fn visit_none<E>(&mut self) -> Result<Self::Value, E>
        where E: Error,
    {
-        Err(Error::syntax_error())
+        Err(Error::type_mismatch(Type::Option))
    }

+    /// `visit_some` deserializes a value into a `Value`.
    fn visit_some<D>(&mut self, _deserializer: &mut D) -> Result<Self::Value, D::Error>
        where D: Deserializer,
    {
-        Err(Error::syntax_error())
+        Err(Error::type_mismatch(Type::Option))
    }

+    /// `visit_newtype_struct` deserializes a value into a `Value`.
+    fn visit_newtype_struct<D>(&mut self, _deserializer: &mut D) -> Result<Self::Value, D::Error>
+        where D: Deserializer,
+    {
+        Err(Error::type_mismatch(Type::NewtypeStruct))
+    }
+
+    /// `visit_bool` deserializes a `SeqVisitor` into a `Value`.
    fn visit_seq<V>(&mut self, _visitor: V) -> Result<Self::Value, V::Error>
        where V: SeqVisitor,
    {
-        Err(Error::syntax_error())
+        Err(Error::type_mismatch(Type::Seq))
    }

+    /// `visit_map` deserializes a `MapVisitor` into a `Value`.
    fn visit_map<V>(&mut self, _visitor: V) -> Result<Self::Value, V::Error>
        where V: MapVisitor,
    {
-        Err(Error::syntax_error())
+        Err(Error::type_mismatch(Type::Map))
    }

+    /// `visit_bytes` deserializes a `&[u8]` into a `Value`.
    fn visit_bytes<E>(&mut self, _v: &[u8]) -> Result<Self::Value, E>
        where E: Error,
    {
-        Err(Error::syntax_error())
+        Err(Error::type_mismatch(Type::Bytes))
    }

+    /// `visit_byte_buf` deserializes a `Vec<u8>` into a `Value`.
    fn visit_byte_buf<E>(&mut self, v: Vec<u8>) -> Result<Self::Value, E>
        where E: Error,
    {
@@ -281,14 +598,23 @@ pub trait Visitor {

 ///////////////////////////////////////////////////////////////////////////////

+/// `SeqVisitor` visits each item in a sequence.
+///
+/// This is a trait that a `Deserializer` passes to a `Visitor` implementation, which deserializes
+/// each item in a sequence.
 pub trait SeqVisitor {
+    /// The error type that can be returned if some error occurs during deserialization.
    type Error: Error;

+    /// This returns a `Ok(Some(value))` for the next value in the sequence, or `Ok(None)` if there
+    /// are no more remaining items.
    fn visit<T>(&mut self) -> Result<Option<T>, Self::Error>
        where T: Deserialize;

+    /// This signals to the `SeqVisitor` that the `Visitor` does not expect any more items.
    fn end(&mut self) -> Result<(), Self::Error>;

+    /// Return the lower and upper bound of items remaining in the sequence.
    #[inline]
    fn size_hint(&self) -> (usize, Option<usize>) {
        (0, None)
@@ -318,9 +644,15 @@ impl<'a, V> SeqVisitor for &'a mut V where V: SeqVisitor {

 ///////////////////////////////////////////////////////////////////////////////

+/// `MapVisitor` visits each item in a sequence.
+///
+/// This is a trait that a `Deserializer` passes to a `Visitor` implementation.
 pub trait MapVisitor {
+    /// The error type that can be returned if some error occurs during deserialization.
    type Error: Error;

+    /// This returns a `Ok(Some((key, value)))` for the next (key-value) pair in the map, or
+    /// `Ok(None)` if there are no more remaining items.
    #[inline]
    fn visit<K, V>(&mut self) -> Result<Option<(K, V)>, Self::Error>
        where K: Deserialize,
@@ -335,23 +667,29 @@ pub trait MapVisitor {
        }
    }

+    /// This returns a `Ok(Some(key))` for the next key in the map, or `Ok(None)` if there are no
+    /// more remaining items.
    fn visit_key<K>(&mut self) -> Result<Option<K>, Self::Error>
        where K: Deserialize;

+    /// This returns a `Ok(value)` for the next value in the map.
    fn visit_value<V>(&mut self) -> Result<V, Self::Error>
        where V: Deserialize;

+    /// This signals to the `MapVisitor` that the `Visitor` does not expect any more items.
    fn end(&mut self) -> Result<(), Self::Error>;

+    /// Return the lower and upper bound of items remaining in the sequence.
    #[inline]
    fn size_hint(&self) -> (usize, Option<usize>) {
        (0, None)
    }

+    /// Report that there 
    fn missing_field<V>(&mut self, field: &'static str) -> Result<V, Self::Error>
        where V: Deserialize,
    {
-        Err(Error::missing_field_error(field))
+        Err(Error::missing_field(field))
    }
 }

@@ -396,8 +734,10 @@ impl<'a, V_> MapVisitor for &'a mut V_ where V_: MapVisitor {
 /// `EnumVisitor` is a visitor that is created by the `Deserialize` and passed to the
 /// `Deserializer` in order to deserialize enums.
 pub trait EnumVisitor {
+    /// The value produced by this visitor.
    type Value;

+    /// Visit the specific variant with the `VariantVisitor`.
    fn visit<V>(&mut self, visitor: V) -> Result<Self::Value, V::Error>
        where V: VariantVisitor;
 }
@@ -407,6 +747,7 @@ pub trait EnumVisitor {
 /// `VariantVisitor` is a visitor that is created by the `Deserializer` and passed to the
 /// `Deserialize` in order to deserialize a specific enum variant.
 pub trait VariantVisitor {
+    /// The error type that can be returned if some error occurs during deserialization.
    type Error: Error;

    /// `visit_variant` is called to identify which variant to deserialize.
@@ -415,21 +756,35 @@ pub trait VariantVisitor {

    /// `visit_unit` is called when deserializing a variant with no values.
    fn visit_unit(&mut self) -> Result<(), Self::Error> {
-        Err(Error::syntax_error())
+        Err(Error::type_mismatch(Type::UnitVariant))
    }

-    /// `visit_seq` is called when deserializing a tuple-like variant.
-    fn visit_seq<V>(&mut self, _visitor: V) -> Result<V::Value, Self::Error>
-        where V: Visitor
+    /// `visit_newtype` is called when deserializing a variant with a single value. By default this
+    /// uses the `visit_tuple` method to deserialize the value.
+    #[inline]
+    fn visit_newtype<T>(&mut self) -> Result<T, Self::Error>
+        where T: Deserialize,
    {
-        Err(Error::syntax_error())
+        let (value,) = try!(self.visit_tuple(1, impls::TupleVisitor1::new()));
+        Ok(value)
    }

-    /// `visit_map` is called when deserializing a struct-like variant.
-    fn visit_map<V>(&mut self, _visitor: V) -> Result<V::Value, Self::Error>
+    /// `visit_tuple` is called when deserializing a tuple-like variant.
+    fn visit_tuple<V>(&mut self,
+                      _len: usize,
+                      _visitor: V) -> Result<V::Value, Self::Error>
        where V: Visitor
    {
-        Err(Error::syntax_error())
+        Err(Error::type_mismatch(Type::TupleVariant))
+    }
+
+    /// `visit_struct` is called when deserializing a struct-like variant.
+    fn visit_struct<V>(&mut self,
+                       _fields: &'static [&'static str],
+                       _visitor: V) -> Result<V::Value, Self::Error>
+        where V: Visitor
+    {
+        Err(Error::type_mismatch(Type::StructVariant))
    }
 }

@@ -446,33 +801,25 @@ impl<'a, T> VariantVisitor for &'a mut T where T: VariantVisitor {
        (**self).visit_unit()
    }

-    fn visit_seq<V>(&mut self, visitor: V) -> Result<V::Value, T::Error>
-        where V: Visitor,
+    fn visit_newtype<D>(&mut self) -> Result<D, T::Error>
+        where D: Deserialize,
    {
-        (**self).visit_seq(visitor)
+        (**self).visit_newtype()
    }

-    fn visit_map<V>(&mut self, visitor: V) -> Result<V::Value, T::Error>
+    fn visit_tuple<V>(&mut self,
+                      len: usize,
+                      visitor: V) -> Result<V::Value, T::Error>
        where V: Visitor,
    {
-        (**self).visit_map(visitor)
+        (**self).visit_tuple(len, visitor)
+    }
+
+    fn visit_struct<V>(&mut self,
+                    fields: &'static [&'static str],
+                    visitor: V) -> Result<V::Value, T::Error>
+        where V: Visitor,
+    {
+        (**self).visit_struct(fields, visitor)
    }
 }
-
-///////////////////////////////////////////////////////////////////////////////
-
-pub trait EnumSeqVisitor {
-    type Value;
-
-    fn visit<V>(&mut self, visitor: V) -> Result<Self::Value, V::Error>
-        where V: SeqVisitor;
-}
-
-///////////////////////////////////////////////////////////////////////////////
-
-pub trait EnumMapVisitor {
-    type Value;
-
-    fn visit<V>(&mut self, visitor: V) -> Result<Self::Value, V::Error>
-        where V: MapVisitor;
-}
@@ -1,3 +1,5 @@
+//! This module supports deserializing from primitives with the `ValueDeserializer` trait.
+
 use std::collections::{
    BTreeMap,
    BTreeSet,
@@ -16,25 +18,37 @@ use bytes;

 ///////////////////////////////////////////////////////////////////////////////

+/// This represents all the possible errors that can occur using the `ValueDeserializer`.
+#[derive(Clone, Debug, PartialEq)]
 pub enum Error {
+    /// The value had some syntatic error.
    SyntaxError,
+
+    /// EOF while deserializing a value.
    EndOfStreamError,
+
+    /// Unknown field in struct.
    UnknownFieldError(String),
+
+    /// Struct is missing a field.
    MissingFieldError(&'static str),
 }

 impl de::Error for Error {
-    fn syntax_error() -> Self { Error::SyntaxError }
-    fn end_of_stream_error() -> Self { Error::EndOfStreamError }
-    fn unknown_field_error(field: &str) -> Self { Error::UnknownFieldError(field.to_string()) }
-    fn missing_field_error(field: &'static str) -> Self { Error::MissingFieldError(field) }
+    fn syntax(_: &str) -> Self { Error::SyntaxError }
+    fn end_of_stream() -> Self { Error::EndOfStreamError }
+    fn unknown_field(field: &str) -> Self { Error::UnknownFieldError(String::from(field)) }
+    fn missing_field(field: &'static str) -> Self { Error::MissingFieldError(field) }
 }

 ///////////////////////////////////////////////////////////////////////////////

+/// This trait converts primitive types into a deserializer.
 pub trait ValueDeserializer {
+    /// The actual deserializer type.
    type Deserializer: de::Deserializer<Error=Error>;

+    /// Convert this value into a deserializer.
    fn into_deserializer(self) -> Self::Deserializer;
 }

@@ -71,6 +85,7 @@ impl de::Deserializer for UnitDeserializer {

 macro_rules! primitive_deserializer {
    ($ty:ty, $name:ident, $method:ident) => {
+        /// A helper deserializer that deserializes a number.
        pub struct $name(Option<$ty>);

        impl ValueDeserializer for $ty {
@@ -89,7 +104,7 @@ macro_rules! primitive_deserializer {
            {
                match self.0.take() {
                    Some(v) => visitor.$method(v),
-                    None => Err(de::Error::end_of_stream_error()),
+                    None => Err(de::Error::end_of_stream()),
                }
            }
        }
@@ -132,11 +147,14 @@ impl<'a> de::Deserializer for StrDeserializer<'a> {
    {
        match self.0.take() {
            Some(v) => visitor.visit_str(v),
-            None => Err(de::Error::end_of_stream_error()),
+            None => Err(de::Error::end_of_stream()),
        }
    }

-    fn visit_enum<V>(&mut self, _name: &str, mut visitor: V) -> Result<V::Value, Error>
+    fn visit_enum<V>(&mut self,
+                     _name: &str,
+                     _variants: &'static [&'static str],
+                     mut visitor: V) -> Result<V::Value, Error>
        where V: de::EnumVisitor,
    {
        visitor.visit(self)
@@ -178,11 +196,14 @@ impl de::Deserializer for StringDeserializer {
    {
        match self.0.take() {
            Some(string) => visitor.visit_string(string),
-            None => Err(de::Error::end_of_stream_error()),
+            None => Err(de::Error::end_of_stream()),
        }
    }

-    fn visit_enum<V>(&mut self, _name: &str, mut visitor: V) -> Result<V::Value, Error>
+    fn visit_enum<V>(&mut self,
+                     _name: &str,
+                     _variants: &'static [&'static str],
+                     mut visitor: V) -> Result<V::Value, Error>
        where V: de::EnumVisitor,
    {
        visitor.visit(self)
@@ -205,12 +226,14 @@ impl<'a> de::VariantVisitor for StringDeserializer {

 ///////////////////////////////////////////////////////////////////////////////

+/// A helper deserializer that deserializes a sequence.
 pub struct SeqDeserializer<I> {
    iter: I,
    len: usize,
 }

 impl<I> SeqDeserializer<I> {
+    /// Construct a new `SeqDeserializer<I>`.
    pub fn new(iter: I, len: usize) -> Self {
        SeqDeserializer {
            iter: iter,
@@ -255,7 +278,7 @@ impl<I, T> de::SeqVisitor for SeqDeserializer<I>
        if self.len == 0 {
            Ok(())
        } else {
-            Err(de::Error::end_of_stream_error())
+            Err(de::Error::length_mismatch(self.len))
        }
    }

@@ -301,6 +324,7 @@ impl<T> ValueDeserializer for HashSet<T>

 ///////////////////////////////////////////////////////////////////////////////

+/// A helper deserializer that deserializes a map.
 pub struct MapDeserializer<I, K, V>
    where I: Iterator<Item=(K, V)>,
          K: ValueDeserializer,
@@ -316,6 +340,7 @@ impl<I, K, V> MapDeserializer<I, K, V>
          K: ValueDeserializer,
          V: ValueDeserializer,
 {
+    /// Construct a new `MapDeserializer<I, K, V>`.
    pub fn new(iter: I, len: usize) -> Self {
        MapDeserializer {
            iter: iter,
@@ -368,7 +393,7 @@ impl<I, K, V> de::MapVisitor for MapDeserializer<I, K, V>
                let mut de = value.into_deserializer();
                de::Deserialize::deserialize(&mut de)
            }
-            None => Err(de::Error::syntax_error())
+            None => Err(de::Error::syntax("expected a map value"))
        }
    }

@@ -376,7 +401,7 @@ impl<I, K, V> de::MapVisitor for MapDeserializer<I, K, V>
        if self.len == 0 {
            Ok(())
        } else {
-            Err(de::Error::end_of_stream_error())
+            Err(de::Error::length_mismatch(self.len))
        }
    }

@@ -422,6 +447,7 @@ impl<'a> ValueDeserializer for bytes::Bytes<'a>
    }
 }

+/// A helper deserializer that deserializes a `&[u8]`.
 pub struct BytesDeserializer<'a> (Option<&'a [u8]>);

 impl<'a> de::Deserializer for BytesDeserializer<'a> {
@@ -432,7 +458,7 @@ impl<'a> de::Deserializer for BytesDeserializer<'a> {
    {
        match self.0.take() {
            Some(bytes) => visitor.visit_bytes(bytes),
-            None => Err(de::Error::end_of_stream_error()),
+            None => Err(de::Error::end_of_stream()),
        }
    }
 }
@@ -449,6 +475,7 @@ impl ValueDeserializer for bytes::ByteBuf
    }
 }

+/// A helper deserializer that deserializes a `Vec<u8>`.
 pub struct ByteBufDeserializer(Option<Vec<u8>>);

 impl de::Deserializer for ByteBufDeserializer {
@@ -459,7 +486,7 @@ impl de::Deserializer for ByteBufDeserializer {
    {
        match self.0.take() {
            Some(bytes) => visitor.visit_byte_buf(bytes),
-            None => Err(de::Error::end_of_stream_error()),
+            None => Err(de::Error::end_of_stream()),
        }
    }
 }
@@ -1,6 +1,9 @@
+//! Module that contains helper iterators.
+
 use std::io;
 use std::iter::Peekable;

+/// Iterator over a byte stream that tracks the current position's line and column.
 pub struct LineColIterator<Iter: Iterator<Item=io::Result<u8>>> {
    iter: Iter,
    line: usize,
@@ -8,6 +11,7 @@ pub struct LineColIterator<Iter: Iterator<Item=io::Result<u8>>> {
 }

 impl<Iter: Iterator<Item=io::Result<u8>>> LineColIterator<Iter> {
+    /// Construct a new `LineColIterator<Iter>`.
    pub fn new(iter: Iter) -> LineColIterator<Iter> {
        LineColIterator {
            iter: iter,
@@ -1,84 +0,0 @@
-// Copyright 2012-2014 The Rust Project Developers. See the COPYRIGHT
-// file at the top-level directory of this distribution and at
-// http://rust-lang.org/COPYRIGHT.
-//
-// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
-// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
-// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
-// option. This file may not be copied, modified, or distributed
-// except according to those terms.
-
-use std::collections::BTreeMap;
-
-use ser::{self, Serialize};
-use json::value::{self, Value};
-
-pub struct ArrayBuilder {
-    array: Vec<Value>,
-}
-
-impl ArrayBuilder {
-    pub fn new() -> ArrayBuilder {
-        ArrayBuilder { array: Vec::new() }
-    }
-
-    pub fn unwrap(self) -> Value {
-        Value::Array(self.array)
-    }
-
-    pub fn push<T: ser::Serialize>(mut self, v: T) -> ArrayBuilder {
-        self.array.push(value::to_value(&v));
-        self
-    }
-
-    pub fn push_array<F>(mut self, f: F) -> ArrayBuilder where
-        F: FnOnce(ArrayBuilder) -> ArrayBuilder
-    {
-        let builder = ArrayBuilder::new();
-        self.array.push(f(builder).unwrap());
-        self
-    }
-
-    pub fn push_object<F>(mut self, f: F) -> ArrayBuilder where
-        F: FnOnce(ObjectBuilder) -> ObjectBuilder
-    {
-        let builder = ObjectBuilder::new();
-        self.array.push(f(builder).unwrap());
-        self
-    }
-}
-
-pub struct ObjectBuilder {
-    object: BTreeMap<String, Value>,
-}
-
-impl ObjectBuilder {
-    pub fn new() -> ObjectBuilder {
-        ObjectBuilder { object: BTreeMap::new() }
-    }
-
-    pub fn unwrap(self) -> Value {
-        Value::Object(self.object)
-    }
-
-    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<F>(mut self, key: String, f: F) -> ObjectBuilder where
-        F: FnOnce(ArrayBuilder) -> ArrayBuilder
-    {
-        let builder = ArrayBuilder::new();
-        self.object.insert(key, f(builder).unwrap());
-        self
-    }
-
-    pub fn insert_object<F>(mut self, key: String, f: F) -> ObjectBuilder where
-        F: FnOnce(ObjectBuilder) -> ObjectBuilder
-    {
-        let builder = ObjectBuilder::new();
-        self.object.insert(key, f(builder).unwrap());
-        self
-    }
-}
@@ -1,694 +0,0 @@
-use std::char;
-use std::i32;
-use std::io;
-use std::str;
-
-use de;
-use iter::LineColIterator;
-
-use super::error::{Error, ErrorCode};
-
-pub struct Deserializer<Iter: Iterator<Item=io::Result<u8>>> {
-    rdr: LineColIterator<Iter>,
-    ch: Option<u8>,
-    str_buf: Vec<u8>,
-}
-
-macro_rules! try_or_invalid {
-    ($self_:expr, $e:expr) => {
-        match $e {
-            Some(v) => v,
-            None => { return Err($self_.error(ErrorCode::InvalidNumber)); }
-        }
-    }
-}
-
-impl<Iter> Deserializer<Iter>
-    where Iter: Iterator<Item=io::Result<u8>>,
-{
-    /// Creates the JSON parser from an `std::iter::Iterator`.
-    #[inline]
-    pub fn new(rdr: Iter) -> Result<Deserializer<Iter>, Error> {
-        let mut deserializer = Deserializer {
-            rdr: LineColIterator::new(rdr),
-            ch: None,
-            str_buf: Vec::with_capacity(128),
-        };
-
-        try!(deserializer.bump());
-
-        Ok(deserializer)
-    }
-
-    #[inline]
-    pub fn end(&mut self) -> Result<(), Error> {
-        try!(self.parse_whitespace());
-        if self.eof() {
-            Ok(())
-        } else {
-            Err(self.error(ErrorCode::TrailingCharacters))
-        }
-    }
-
-    fn eof(&self) -> bool { self.ch.is_none() }
-
-    fn ch_or_null(&self) -> u8 { self.ch.unwrap_or(b'\x00') }
-
-    fn bump(&mut self) -> Result<(), Error> {
-        self.ch = match self.rdr.next() {
-            Some(Err(err)) => { return Err(Error::IoError(err)); }
-            Some(Ok(ch)) => Some(ch),
-            None => None,
-        };
-
-        Ok(())
-    }
-
-    fn next_char(&mut self) -> Result<Option<u8>, Error> {
-        try!(self.bump());
-        Ok(self.ch)
-    }
-
-    fn ch_is(&self, c: u8) -> bool {
-        self.ch == Some(c)
-    }
-
-    fn error(&mut self, reason: ErrorCode) -> Error {
-        Error::SyntaxError(reason, self.rdr.line(), self.rdr.col())
-    }
-
-    fn parse_whitespace(&mut self) -> Result<(), Error> {
-        while self.ch_is(b' ') ||
-              self.ch_is(b'\n') ||
-              self.ch_is(b'\t') ||
-              self.ch_is(b'\r') { try!(self.bump()); }
-
-        Ok(())
-    }
-
-    fn parse_value<V>(&mut self, mut visitor: V) -> Result<V::Value, Error>
-        where V: de::Visitor,
-    {
-        try!(self.parse_whitespace());
-
-        if self.eof() {
-            return Err(self.error(ErrorCode::EOFWhileParsingValue));
-        }
-
-        let value = match self.ch_or_null() {
-            b'n' => {
-                try!(self.parse_ident(b"ull"));
-                visitor.visit_unit()
-            }
-            b't' => {
-                try!(self.parse_ident(b"rue"));
-                visitor.visit_bool(true)
-            }
-            b'f' => {
-                try!(self.parse_ident(b"alse"));
-                visitor.visit_bool(false)
-            }
-            b'0' ... b'9' | b'-' => self.parse_number(visitor),
-            b'"' => {
-                try!(self.parse_string());
-                let s = str::from_utf8(&self.str_buf).unwrap();
-                visitor.visit_str(s)
-            }
-            b'[' => {
-                try!(self.bump());
-                visitor.visit_seq(SeqVisitor::new(self))
-            }
-            b'{' => {
-                try!(self.bump());
-                visitor.visit_map(MapVisitor::new(self))
-            }
-            _ => {
-                Err(self.error(ErrorCode::ExpectedSomeValue))
-            }
-        };
-
-        match value {
-            Ok(value) => Ok(value),
-            Err(Error::SyntaxError(code, _, _)) => Err(self.error(code)),
-            Err(err) => Err(err),
-        }
-    }
-
-    fn parse_ident(&mut self, ident: &[u8]) -> Result<(), Error> {
-        for c in ident {
-            if Some(*c) != try!(self.next_char()) {
-                return Err(self.error(ErrorCode::ExpectedSomeIdent));
-            }
-        }
-
-        try!(self.bump());
-        Ok(())
-    }
-
-    fn parse_number<V>(&mut self, mut visitor: V) -> Result<V::Value, Error>
-        where V: de::Visitor,
-    {
-        let mut neg = false;
-
-        if self.ch_is(b'-') {
-            try!(self.bump());
-            neg = true;
-        }
-
-        let res = try!(self.parse_integer());
-
-        if self.ch_is(b'.') || self.ch_is(b'e') || self.ch_is(b'E') {
-            let mut res = res as f64;
-
-            if self.ch_is(b'.') {
-                res = try!(self.parse_decimal(res));
-            }
-
-            if self.ch_is(b'e') || self.ch_is(b'E') {
-                res = try!(self.parse_exponent(res));
-            }
-
-            if neg {
-                visitor.visit_f64(-res)
-            } else {
-                visitor.visit_f64(res)
-            }
-        } else {
-            if neg {
-                let res = -(res as i64);
-
-                // Make sure we didn't underflow.
-                if res > 0 {
-                    Err(self.error(ErrorCode::InvalidNumber))
-                } else {
-                    visitor.visit_i64(res)
-                }
-            } else {
-                visitor.visit_u64(res)
-            }
-        }
-    }
-
-    fn parse_integer(&mut self) -> Result<u64, Error> {
-        let mut accum: u64 = 0;
-
-        match self.ch_or_null() {
-            b'0' => {
-                try!(self.bump());
-
-                // There can be only one leading '0'.
-                match self.ch_or_null() {
-                    b'0' ... b'9' => {
-                        return Err(self.error(ErrorCode::InvalidNumber));
-                    }
-                    _ => ()
-                }
-            },
-            b'1' ... b'9' => {
-                while !self.eof() {
-                    match self.ch_or_null() {
-                        c @ b'0' ... b'9' => {
-                            accum = try_or_invalid!(self, accum.checked_mul(10));
-                            accum = try_or_invalid!(self, accum.checked_add((c as u64) - ('0' as u64)));
-
-                            try!(self.bump());
-                        }
-                        _ => break,
-                    }
-                }
-            }
-            _ => { return Err(self.error(ErrorCode::InvalidNumber)); }
-        }
-
-        Ok(accum)
-    }
-
-    fn parse_decimal(&mut self, res: f64) -> Result<f64, Error> {
-        try!(self.bump());
-
-        // Make sure a digit follows the decimal place.
-        match self.ch_or_null() {
-            b'0' ... b'9' => (),
-             _ => { return Err(self.error(ErrorCode::InvalidNumber)); }
-        }
-
-        let mut res = res;
-        let mut dec = 1.0;
-        while !self.eof() {
-            match self.ch_or_null() {
-                c @ b'0' ... b'9' => {
-                    dec /= 10.0;
-                    res += (((c as u64) - (b'0' as u64)) as f64) * dec;
-                    try!(self.bump());
-                }
-                _ => break,
-            }
-        }
-
-        Ok(res)
-    }
-
-    fn parse_exponent(&mut self, mut res: f64) -> Result<f64, Error> {
-        try!(self.bump());
-
-        let mut exp: u64 = 0;
-        let mut neg_exp = false;
-
-        if self.ch_is(b'+') {
-            try!(self.bump());
-        } else if self.ch_is(b'-') {
-            try!(self.bump());
-            neg_exp = true;
-        }
-
-        // Make sure a digit follows the exponent place.
-        match self.ch_or_null() {
-            b'0' ... b'9' => (),
-            _ => { return Err(self.error(ErrorCode::InvalidNumber)); }
-        }
-        while !self.eof() {
-            match self.ch_or_null() {
-                c @ b'0' ... b'9' => {
-                    exp = try_or_invalid!(self, exp.checked_mul(10));
-                    exp = try_or_invalid!(self, exp.checked_add((c as u64) - (b'0' as u64)));
-
-                    try!(self.bump());
-                }
-                _ => break
-            }
-        }
-
-        let exp = if exp <= i32::MAX as u64 {
-            10_f64.powi(exp as i32)
-        } else {
-            return Err(self.error(ErrorCode::InvalidNumber));
-        };
-
-        if neg_exp {
-            res /= exp;
-        } else {
-            res *= exp;
-        }
-
-        Ok(res)
-    }
-
-    fn decode_hex_escape(&mut self) -> Result<u16, Error> {
-        let mut i = 0;
-        let mut n = 0u16;
-        while i < 4 && !self.eof() {
-            try!(self.bump());
-            n = match self.ch_or_null() {
-                c @ b'0' ... b'9' => n * 16_u16 + ((c as u16) - (b'0' as u16)),
-                b'a' | b'A' => n * 16_u16 + 10_u16,
-                b'b' | b'B' => n * 16_u16 + 11_u16,
-                b'c' | b'C' => n * 16_u16 + 12_u16,
-                b'd' | b'D' => n * 16_u16 + 13_u16,
-                b'e' | b'E' => n * 16_u16 + 14_u16,
-                b'f' | b'F' => n * 16_u16 + 15_u16,
-                _ => { return Err(self.error(ErrorCode::InvalidEscape)); }
-            };
-
-            i += 1;
-        }
-
-        // Error out if we didn't parse 4 digits.
-        if i != 4 {
-            return Err(self.error(ErrorCode::InvalidEscape));
-        }
-
-        Ok(n)
-    }
-
-    fn parse_string(&mut self) -> Result<(), Error> {
-        self.str_buf.clear();
-
-        loop {
-            let ch = match try!(self.next_char()) {
-                Some(ch) => ch,
-                None => { return Err(self.error(ErrorCode::EOFWhileParsingString)); }
-            };
-
-            match ch {
-                b'"' => {
-                    try!(self.bump());
-                    return Ok(());
-                }
-                b'\\' => {
-                    let ch = match try!(self.next_char()) {
-                        Some(ch) => ch,
-                        None => { return Err(self.error(ErrorCode::EOFWhileParsingString)); }
-                    };
-
-                    match ch {
-                        b'"' => self.str_buf.push(b'"'),
-                        b'\\' => self.str_buf.push(b'\\'),
-                        b'/' => self.str_buf.push(b'/'),
-                        b'b' => self.str_buf.push(b'\x08'),
-                        b'f' => self.str_buf.push(b'\x0c'),
-                        b'n' => self.str_buf.push(b'\n'),
-                        b'r' => self.str_buf.push(b'\r'),
-                        b't' => self.str_buf.push(b'\t'),
-                        b'u' => {
-                            let c = match try!(self.decode_hex_escape()) {
-                                0xDC00 ... 0xDFFF => {
-                                    return Err(self.error(ErrorCode::LoneLeadingSurrogateInHexEscape));
-                                }
-
-                                // Non-BMP characters are encoded as a sequence of
-                                // two hex escapes, representing UTF-16 surrogates.
-                                n1 @ 0xD800 ... 0xDBFF => {
-                                    match (try!(self.next_char()), try!(self.next_char())) {
-                                        (Some(b'\\'), Some(b'u')) => (),
-                                        _ => {
-                                            return Err(self.error(ErrorCode::UnexpectedEndOfHexEscape));
-                                        }
-                                    }
-
-                                    let n2 = try!(self.decode_hex_escape());
-
-                                    if n2 < 0xDC00 || n2 > 0xDFFF {
-                                        return Err(self.error(ErrorCode::LoneLeadingSurrogateInHexEscape));
-                                    }
-
-                                    let n = (((n1 - 0xD800) as u32) << 10 |
-                                              (n2 - 0xDC00) as u32) + 0x1_0000;
-
-                                    match char::from_u32(n as u32) {
-                                        Some(c) => c,
-                                        None => {
-                                            return Err(self.error(ErrorCode::InvalidUnicodeCodePoint));
-                                        }
-                                    }
-                                }
-
-                                n => {
-                                    match char::from_u32(n as u32) {
-                                        Some(c) => c,
-                                        None => {
-                                            return Err(self.error(ErrorCode::InvalidUnicodeCodePoint));
-                                        }
-                                    }
-                                }
-                            };
-
-                            // FIXME: this allocation is required in order to be compatible with stable
-                            // rust, which doesn't support encoding a `char` into a stack buffer.
-                            let buf = c.to_string();
-                            self.str_buf.extend(buf.bytes());
-                        }
-                        _ => {
-                            return Err(self.error(ErrorCode::InvalidEscape));
-                        }
-                    }
-                }
-                ch => {
-                    self.str_buf.push(ch);
-                }
-            }
-        }
-    }
-
-    fn parse_object_colon(&mut self) -> Result<(), Error> {
-        try!(self.parse_whitespace());
-
-        if self.ch_is(b':') {
-            try!(self.bump());
-            Ok(())
-        } else if self.eof() {
-            Err(self.error(ErrorCode::EOFWhileParsingObject))
-        } else {
-            Err(self.error(ErrorCode::ExpectedColon))
-        }
-    }
-}
-
-impl<Iter> de::Deserializer for Deserializer<Iter>
-    where Iter: Iterator<Item=io::Result<u8>>,
-{
-    type Error = Error;
-
-    #[inline]
-    fn visit<V>(&mut self, visitor: V) -> Result<V::Value, Error>
-        where V: de::Visitor,
-    {
-        self.parse_value(visitor)
-    }
-
-    #[inline]
-    fn visit_option<V>(&mut self, mut visitor: V) -> Result<V::Value, Error>
-        where V: de::Visitor,
-    {
-        try!(self.parse_whitespace());
-
-        if self.eof() {
-            return Err(self.error(ErrorCode::EOFWhileParsingValue));
-        }
-
-        if self.ch_is(b'n') {
-            try!(self.parse_ident(b"ull"));
-            visitor.visit_none()
-        } else {
-            visitor.visit_some(self)
-        }
-    }
-
-    #[inline]
-    fn visit_enum<V>(&mut self, _name: &str, mut visitor: V) -> Result<V::Value, Error>
-        where V: de::EnumVisitor,
-    {
-        try!(self.parse_whitespace());
-
-        if self.ch_is(b'{') {
-            try!(self.bump());
-            try!(self.parse_whitespace());
-
-            let value = {
-                try!(visitor.visit(&mut *self))
-            };
-
-            try!(self.parse_whitespace());
-
-            if self.ch_is(b'}') {
-                try!(self.bump());
-                Ok(value)
-            } else {
-                Err(self.error(ErrorCode::ExpectedSomeValue))
-            }
-        } else {
-            Err(self.error(ErrorCode::ExpectedSomeValue))
-        }
-    }
-
-    #[inline]
-    fn format() -> &'static str {
-        "json"
-    }
-}
-
-struct SeqVisitor<'a, Iter: 'a + Iterator<Item=io::Result<u8>>> {
-    de: &'a mut Deserializer<Iter>,
-    first: bool,
-}
-
-impl<'a, Iter: Iterator<Item=io::Result<u8>>> SeqVisitor<'a, Iter> {
-    fn new(de: &'a mut Deserializer<Iter>) -> Self {
-        SeqVisitor {
-            de: de,
-            first: true,
-        }
-    }
-}
-
-impl<'a, Iter> de::SeqVisitor for SeqVisitor<'a, Iter>
-    where Iter: Iterator<Item=io::Result<u8>>,
-{
-    type Error = Error;
-
-    fn visit<T>(&mut self) -> Result<Option<T>, Error>
-        where T: de::Deserialize,
-    {
-        try!(self.de.parse_whitespace());
-
-        if self.de.ch_is(b']') {
-            return Ok(None);
-        }
-
-        if self.first {
-            self.first = false;
-        } else {
-            if self.de.ch_is(b',') {
-                try!(self.de.bump());
-            } else if self.de.eof() {
-                return Err(self.de.error(ErrorCode::EOFWhileParsingList));
-            } else {
-                return Err(self.de.error(ErrorCode::ExpectedListCommaOrEnd));
-            }
-        }
-
-        let value = try!(de::Deserialize::deserialize(self.de));
-        Ok(Some(value))
-    }
-
-    fn end(&mut self) -> Result<(), Error> {
-        try!(self.de.parse_whitespace());
-
-        if self.de.ch_is(b']') {
-            self.de.bump()
-        } else if self.de.eof() {
-            Err(self.de.error(ErrorCode::EOFWhileParsingList))
-        } else {
-            Err(self.de.error(ErrorCode::TrailingCharacters))
-        }
-    }
-}
-
-struct MapVisitor<'a, Iter: 'a + Iterator<Item=io::Result<u8>>> {
-    de: &'a mut Deserializer<Iter>,
-    first: bool,
-}
-
-impl<'a, Iter: Iterator<Item=io::Result<u8>>> MapVisitor<'a, Iter> {
-    fn new(de: &'a mut Deserializer<Iter>) -> Self {
-        MapVisitor {
-            de: de,
-            first: true,
-        }
-    }
-}
-
-impl<'a, Iter> de::MapVisitor for MapVisitor<'a, Iter>
-    where Iter: Iterator<Item=io::Result<u8>>
-{
-    type Error = Error;
-
-    fn visit_key<K>(&mut self) -> Result<Option<K>, Error>
-        where K: de::Deserialize,
-    {
-        try!(self.de.parse_whitespace());
-
-        if self.de.ch_is(b'}') {
-            return Ok(None);
-        }
-
-        if self.first {
-            self.first = false;
-        } else {
-            if self.de.ch_is(b',') {
-                try!(self.de.bump());
-                try!(self.de.parse_whitespace());
-            } else if self.de.eof() {
-                return Err(self.de.error(ErrorCode::EOFWhileParsingObject));
-            } else {
-                return Err(self.de.error(ErrorCode::ExpectedObjectCommaOrEnd));
-            }
-        }
-
-        if self.de.eof() {
-            return Err(self.de.error(ErrorCode::EOFWhileParsingValue));
-        }
-
-        if !self.de.ch_is(b'"') {
-            return Err(self.de.error(ErrorCode::KeyMustBeAString));
-        }
-
-        Ok(Some(try!(de::Deserialize::deserialize(self.de))))
-    }
-
-    fn visit_value<V>(&mut self) -> Result<V, Error>
-        where V: de::Deserialize,
-    {
-        try!(self.de.parse_object_colon());
-
-        Ok(try!(de::Deserialize::deserialize(self.de)))
-    }
-
-    fn end(&mut self) -> Result<(), Error> {
-        try!(self.de.parse_whitespace());
-
-        if self.de.ch_is(b'}') {
-            try!(self.de.bump());
-            Ok(())
-        } else if self.de.eof() {
-            Err(self.de.error(ErrorCode::EOFWhileParsingObject))
-        } else {
-            Err(self.de.error(ErrorCode::TrailingCharacters))
-        }
-    }
-
-    fn missing_field<V>(&mut self, _field: &'static str) -> Result<V, Error>
-        where V: de::Deserialize,
-    {
-        let mut de = de::value::ValueDeserializer::into_deserializer(());
-        Ok(try!(de::Deserialize::deserialize(&mut de)))
-    }
-}
-
-impl<Iter> de::VariantVisitor for Deserializer<Iter>
-    where Iter: Iterator<Item=io::Result<u8>>,
-{
-    type Error = Error;
-
-    fn visit_variant<V>(&mut self) -> Result<V, Error>
-        where V: de::Deserialize
-    {
-        de::Deserialize::deserialize(self)
-    }
-
-    fn visit_unit(&mut self) -> Result<(), Error> {
-        try!(self.parse_object_colon());
-
-        de::Deserialize::deserialize(self)
-    }
-
-    fn visit_seq<V>(&mut self, visitor: V) -> Result<V::Value, Error>
-        where V: de::Visitor,
-    {
-        try!(self.parse_object_colon());
-
-        de::Deserializer::visit(self, visitor)
-    }
-
-    fn visit_map<V>(&mut self, visitor: V) -> Result<V::Value, Error>
-        where V: de::Visitor,
-    {
-        try!(self.parse_object_colon());
-
-        de::Deserializer::visit(self, visitor)
-    }
-}
-
-/// Decodes a json value from a `std::io::Read`.
-pub fn from_iter<I, T>(iter: I) -> Result<T, Error>
-    where I: Iterator<Item=io::Result<u8>>,
-          T: de::Deserialize,
-{
-    let mut de = try!(Deserializer::new(iter));
-    let value = try!(de::Deserialize::deserialize(&mut de));
-
-    // Make sure the whole stream has been consumed.
-    try!(de.end());
-    Ok(value)
-}
-
-/// Decodes a json value from a `std::io::Read`.
-pub fn from_reader<R, T>(rdr: R) -> Result<T, Error>
-    where R: io::Read,
-          T: de::Deserialize,
-{
-    from_iter(rdr.bytes())
-}
-
-/// Decodes a json value from a `&str`.
-pub fn from_slice<T>(v: &[u8]) -> Result<T, Error>
-    where T: de::Deserialize
-{
-    from_iter(v.iter().map(|byte| Ok(*byte)))
-}
-
-/// Decodes a json value from a `&str`.
-pub fn from_str<T>(s: &str) -> Result<T, Error>
-    where T: de::Deserialize
-{
-    from_slice(s.as_bytes())
-}
@@ -1,185 +0,0 @@
-use std::error;
-use std::fmt;
-use std::io;
-
-use de;
-
-/// The errors that can arise while parsing a JSON stream.
-#[derive(Clone, PartialEq)]
-pub enum ErrorCode {
-    EOFWhileParsingList,
-    EOFWhileParsingObject,
-    EOFWhileParsingString,
-    EOFWhileParsingValue,
-    ExpectedColon,
-    ExpectedConversion,
-    ExpectedEnumEnd,
-    ExpectedEnumEndToken,
-    ExpectedEnumMapStart,
-    ExpectedEnumToken,
-    ExpectedEnumVariantString,
-    ExpectedListCommaOrEnd,
-    ExpectedName,
-    ExpectedObjectCommaOrEnd,
-    ExpectedSomeIdent,
-    ExpectedSomeValue,
-    InvalidEscape,
-    InvalidNumber,
-    InvalidUnicodeCodePoint,
-    KeyMustBeAString,
-    LoneLeadingSurrogateInHexEscape,
-    UnknownField(String),
-    MissingField(&'static str),
-    NotFourDigit,
-    NotUtf8,
-    TrailingCharacters,
-    UnexpectedEndOfHexEscape,
-    UnknownVariant,
-    UnrecognizedHex,
-}
-
-impl fmt::Debug for ErrorCode {
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        use std::fmt::Debug;
-
-        match *self {
-            //ErrorCode::ConversionError(ref token) => write!(f, "failed to convert {}", token),
-            ErrorCode::EOFWhileParsingList => "EOF While parsing list".fmt(f),
-            ErrorCode::EOFWhileParsingObject => "EOF While parsing object".fmt(f),
-            ErrorCode::EOFWhileParsingString => "EOF While parsing string".fmt(f),
-            ErrorCode::EOFWhileParsingValue => "EOF While parsing value".fmt(f),
-            ErrorCode::ExpectedColon => "expected `:`".fmt(f),
-            ErrorCode::ExpectedConversion => "expected conversion".fmt(f),
-            ErrorCode::ExpectedEnumEnd => "expected enum end".fmt(f),
-            ErrorCode::ExpectedEnumEndToken => "expected enum map end".fmt(f),
-            ErrorCode::ExpectedEnumMapStart => "expected enum map start".fmt(f),
-            ErrorCode::ExpectedEnumToken => "expected enum token".fmt(f),
-            ErrorCode::ExpectedEnumVariantString => "expected variant".fmt(f),
-            ErrorCode::ExpectedListCommaOrEnd => "expected `,` or `]`".fmt(f),
-            ErrorCode::ExpectedName => "expected name".fmt(f),
-            ErrorCode::ExpectedObjectCommaOrEnd => "expected `,` or `}`".fmt(f),
-            ErrorCode::ExpectedSomeIdent => "expected ident".fmt(f),
-            ErrorCode::ExpectedSomeValue => "expected value".fmt(f),
-            //ErrorCode::ExpectedTokens(ref token, tokens) => write!(f, "expected {}, found {}", tokens, token),
-            ErrorCode::InvalidEscape => "invalid escape".fmt(f),
-            ErrorCode::InvalidNumber => "invalid number".fmt(f),
-            ErrorCode::InvalidUnicodeCodePoint => "invalid unicode code point".fmt(f),
-            ErrorCode::KeyMustBeAString => "key must be a string".fmt(f),
-            ErrorCode::LoneLeadingSurrogateInHexEscape => "lone leading surrogate in hex escape".fmt(f),
-            ErrorCode::UnknownField(ref field) => write!(f, "unknown field \"{}\"", field),
-            ErrorCode::MissingField(ref field) => write!(f, "missing field \"{}\"", field),
-            ErrorCode::NotFourDigit => "invalid \\u escape (not four digits)".fmt(f),
-            ErrorCode::NotUtf8 => "contents not utf-8".fmt(f),
-            ErrorCode::TrailingCharacters => "trailing characters".fmt(f),
-            ErrorCode::UnexpectedEndOfHexEscape => "unexpected end of hex escape".fmt(f),
-            //ErrorCode::UnexpectedName(ref name) => write!(f, "unexpected name {}", name),
-            ErrorCode::UnknownVariant => "unknown variant".fmt(f),
-            ErrorCode::UnrecognizedHex => "invalid \\u escape (unrecognized hex)".fmt(f),
-        }
-    }
-}
-
-#[derive(Debug)]
-pub enum Error {
-    /// msg, line, col
-    SyntaxError(ErrorCode, usize, usize),
-    IoError(io::Error),
-    /*
-    ExpectedError(String, String),
-    */
-    MissingFieldError(&'static str),
-    /*
-    UnknownVariantError(String),
-    */
-}
-
-impl error::Error for Error {
-    fn description(&self) -> &str {
-        match *self {
-            Error::SyntaxError(..) => "syntax error",
-            Error::IoError(ref error) => error::Error::description(error),
-            /*
-            Error::ExpectedError(ref expected, _) => &expected,
-            */
-            Error::MissingFieldError(_) => "missing field",
-            /*
-            Error::UnknownVariantError(_) => "unknown variant",
-            */
-        }
-    }
-
-    fn cause(&self) -> Option<&error::Error> {
-        match *self {
-            Error::IoError(ref error) => Some(error),
-            _ => None,
-        }
-    }
-
-}
-
-impl fmt::Display for Error {
-    fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
-        match *self {
-            Error::SyntaxError(ref code, line, col) => {
-                write!(fmt, "{:?} at line {} column {}", code, line, col)
-            }
-            Error::IoError(ref error) => fmt::Display::fmt(error, fmt),
-            /*
-            Error::ExpectedError(ref expected, ref found) => {
-                Some(format!("expected {}, found {}", expected, found))
-            }
-            */
-            Error::MissingFieldError(ref field) => {
-                write!(fmt, "missing field {}", field)
-            }
-            /*
-            Error::UnknownVariantError(ref variant) => {
-                Some(format!("unknown variant {}", variant))
-            }
-            */
-        }
-    }
-}
-
-impl From<io::Error> for Error {
-    fn from(error: io::Error) -> Error {
-        Error::IoError(error)
-    }
-}
-
-impl From<de::value::Error> for Error {
-    fn from(error: de::value::Error) -> Error {
-        match error {
-            de::value::Error::SyntaxError => {
-                de::Error::syntax_error()
-            }
-            de::value::Error::EndOfStreamError => {
-                de::Error::end_of_stream_error()
-            }
-            de::value::Error::UnknownFieldError(field) => {
-                Error::SyntaxError(ErrorCode::UnknownField(field), 0, 0)
-            }
-            de::value::Error::MissingFieldError(field) => {
-                de::Error::missing_field_error(field)
-            }
-        }
-    }
-}
-
-impl de::Error for Error {
-    fn syntax_error() -> Error {
-        Error::SyntaxError(ErrorCode::ExpectedSomeValue, 0, 0)
-    }
-
-    fn end_of_stream_error() -> Error {
-        Error::SyntaxError(ErrorCode::EOFWhileParsingValue, 0, 0)
-    }
-
-    fn unknown_field_error(field: &str) -> Error {
-        Error::SyntaxError(ErrorCode::UnknownField(field.to_string()), 0, 0)
-    }
-
-    fn missing_field_error(field: &'static str) -> Error {
-        Error::MissingFieldError(field)
-    }
-}
@@ -1,113 +0,0 @@
-//! JSON and serialization
-//!
-//! # What is JSON?
-//!
-//! JSON (JavaScript Object Notation) is a way to write data in JavaScript.  Like XML, it allows to
-//! encode structured data in a text format that can be easily read by humans.  Its simple syntax
-//! and native compatibility with JavaScript have made it a widely used format.
-//!
-//! Data types that can be encoded are JavaScript types (see the `serde::json:Value` enum for more
-//! details):
-//!
-//! * `Boolean`: equivalent to rust's `bool`
-//! * `I64`: equivalent to rust's `i64`
-//! * `U64`: equivalent to rust's `u64`
-//! * `F64`: equivalent to rust's `i64`
-//! * `String`: equivalent to rust's `String`
-//! * `Array`: equivalent to rust's `Vec<T>`, but also allowing objects of different types in the
-//!    same array
-//! * `Object`: equivalent to rust's `BTreeMap<String, serde::json::Value>`
-//! * `Null`
-//!
-//! An object is a series of string keys mapping to values, in `"key": value` format.  Arrays are
-//! enclosed in square brackets ([ ... ]) and objects in curly brackets ({ ... }).  A simple JSON
-//! document encoding a person, his/her age, address and phone numbers could look like
-//!
-//! ```ignore
-//! {
-//!     "FirstName": "John",
-//!     "LastName": "Doe",
-//!     "Age": 43,
-//!     "Address": {
-//!         "Street": "Downing Street 10",
-//!         "City": "London",
-//!         "Country": "Great Britain"
-//!     },
-//!     "PhoneNumbers": [
-//!         "+44 1234567",
-//!         "+44 2345678"
-//!     ]
-//! }
-//! ```
-//!
-//! # Type-based Serialization and Deserialization
-//!
-//! Serde provides a mechanism for low boilerplate serialization & deserialization of values to and
-//! from JSON via the serialization API.  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.  Serde provides provides an annotation to automatically generate
-//! the code for these traits: `#[derive(Serialize, Deserialize)]`.
-//!
-//! The JSON API also provides an enum `serde::json::Value` and a method `to_value` to serialize
-//! objects.  A `serde::json::Value` value can be serialized as a string or buffer using the
-//! functions described above.  You can also use the `json::Serializer` object, which implements the
-//! `Serializer` trait.
-//!
-//! # Examples of use
-//!
-//! ## Parsing a `str` to `Value` and reading the result
-//!
-//! ```rust
-//! //#![feature(custom_derive, plugin)]
-//! //#![plugin(serde_macros)]
-//!
-//! extern crate serde;
-//!
-//! use serde::json::{self, Value};
-//!
-//! fn main() {
-//!     let data: Value = json::from_str("{\"foo\": 13, \"bar\": \"baz\"}").unwrap();
-//!     println!("data: {:?}", data);
-//!     // data: {"bar":"baz","foo":13}
-//!     println!("object? {}", data.is_object());
-//!     // object? true
-//!
-//!     let obj = data.as_object().unwrap();
-//!     let foo = obj.get("foo").unwrap();
-//!
-//!     println!("array? {:?}", foo.as_array());
-//!     // array? None
-//!     println!("u64? {:?}", foo.as_u64());
-//!     // u64? Some(13u64)
-//!
-//!     for (key, value) in obj.iter() {
-//!         println!("{}: {}", key, match *value {
-//!             Value::U64(v) => format!("{} (u64)", v),
-//!             Value::String(ref v) => format!("{} (string)", v),
-//!             _ => format!("other")
-//!         });
-//!     }
-//!     // bar: baz (string)
-//!     // foo: 13 (u64)
-//! }
-//! ```
-
-pub use self::de::{Deserializer, from_str};
-pub use self::error::{Error, ErrorCode};
-pub use self::ser::{
-    Serializer,
-    to_writer,
-    to_writer_pretty,
-    to_vec,
-    to_vec_pretty,
-    to_string,
-    to_string_pretty,
-    escape_str,
-};
-pub use self::value::{Value, to_value, from_value};
-
-pub mod builder;
-pub mod de;
-pub mod error;
-pub mod ser;
-pub mod value;
@@ -1,524 +0,0 @@
-use std::io;
-use std::num::FpCategory;
-use std::string::FromUtf8Error;
-
-use ser;
-
-/// A structure for implementing serialization to JSON.
-pub struct Serializer<W, F=CompactFormatter> {
-    writer: W,
-    formatter: F,
-
-    /// `first` is used to signify if we should print a comma when we are walking through a
-    /// sequence.
-    first: bool,
-}
-
-impl<W> Serializer<W>
-    where W: io::Write,
-{
-    /// Creates a new JSON serializer.
-    #[inline]
-    pub fn new(writer: W) -> Self {
-        Serializer::with_formatter(writer, CompactFormatter)
-    }
-}
-
-impl<'a, W> Serializer<W, PrettyFormatter<'a>>
-    where W: io::Write,
-{
-    /// Creates a new JSON pretty print serializer.
-    #[inline]
-    pub fn pretty(writer: W) -> Self {
-        Serializer::with_formatter(writer, PrettyFormatter::new())
-    }
-}
-
-impl<W, F> Serializer<W, F>
-    where W: io::Write,
-          F: Formatter,
-{
-    /// Creates a new JSON visitor whose output will be written to the writer
-    /// specified.
-    #[inline]
-    pub fn with_formatter(writer: W, formatter: F) -> Self {
-        Serializer {
-            writer: writer,
-            formatter: formatter,
-            first: false,
-        }
-    }
-
-    /// Unwrap the `Writer` from the `Serializer`.
-    #[inline]
-    pub fn into_inner(self) -> W {
-        self.writer
-    }
-}
-
-impl<W, F> ser::Serializer for Serializer<W, F>
-    where W: io::Write,
-          F: Formatter,
-{
-    type Error = io::Error;
-
-    #[inline]
-    fn visit_bool(&mut self, value: bool) -> io::Result<()> {
-        if value {
-            self.writer.write_all(b"true")
-        } else {
-            self.writer.write_all(b"false")
-        }
-    }
-
-    #[inline]
-    fn visit_isize(&mut self, value: isize) -> io::Result<()> {
-        write!(&mut self.writer, "{}", value)
-    }
-
-    #[inline]
-    fn visit_i8(&mut self, value: i8) -> io::Result<()> {
-        write!(&mut self.writer, "{}", value)
-    }
-
-    #[inline]
-    fn visit_i16(&mut self, value: i16) -> io::Result<()> {
-        write!(&mut self.writer, "{}", value)
-    }
-
-    #[inline]
-    fn visit_i32(&mut self, value: i32) -> io::Result<()> {
-        write!(&mut self.writer, "{}", value)
-    }
-
-    #[inline]
-    fn visit_i64(&mut self, value: i64) -> io::Result<()> {
-        write!(&mut self.writer, "{}", value)
-    }
-
-    #[inline]
-    fn visit_usize(&mut self, value: usize) -> io::Result<()> {
-        write!(&mut self.writer, "{}", value)
-    }
-
-    #[inline]
-    fn visit_u8(&mut self, value: u8) -> io::Result<()> {
-        write!(&mut self.writer, "{}", value)
-    }
-
-    #[inline]
-    fn visit_u16(&mut self, value: u16) -> io::Result<()> {
-        write!(&mut self.writer, "{}", value)
-    }
-
-    #[inline]
-    fn visit_u32(&mut self, value: u32) -> io::Result<()> {
-        write!(&mut self.writer, "{}", value)
-    }
-
-    #[inline]
-    fn visit_u64(&mut self, value: u64) -> io::Result<()> {
-        write!(&mut self.writer, "{}", value)
-    }
-
-    #[inline]
-    fn visit_f32(&mut self, value: f32) -> io::Result<()> {
-        fmt_f32_or_null(&mut self.writer, value)
-    }
-
-    #[inline]
-    fn visit_f64(&mut self, value: f64) -> io::Result<()> {
-        fmt_f64_or_null(&mut self.writer, value)
-    }
-
-    #[inline]
-    fn visit_char(&mut self, value: char) -> io::Result<()> {
-        escape_char(&mut self.writer, value)
-    }
-
-    #[inline]
-    fn visit_str(&mut self, value: &str) -> io::Result<()> {
-        escape_str(&mut self.writer, value)
-    }
-
-    #[inline]
-    fn visit_none(&mut self) -> io::Result<()> {
-        self.visit_unit()
-    }
-
-    #[inline]
-    fn visit_some<V>(&mut self, value: V) -> io::Result<()>
-        where V: ser::Serialize
-    {
-        value.serialize(self)
-    }
-
-    #[inline]
-    fn visit_unit(&mut self) -> io::Result<()> {
-        self.writer.write_all(b"null")
-    }
-
-    #[inline]
-    fn visit_enum_unit(&mut self, _name: &str, variant: &str) -> io::Result<()> {
-        try!(self.formatter.open(&mut self.writer, b'{'));
-        try!(self.formatter.comma(&mut self.writer, true));
-        try!(self.visit_str(variant));
-        try!(self.formatter.colon(&mut self.writer));
-        try!(self.writer.write_all(b"[]"));
-        self.formatter.close(&mut self.writer, b'}')
-    }
-
-    #[inline]
-    fn visit_seq<V>(&mut self, mut visitor: V) -> io::Result<()>
-        where V: ser::SeqVisitor,
-    {
-        match visitor.len() {
-            Some(len) if len == 0 => {
-                self.writer.write_all(b"[]")
-            }
-            _ => {
-                try!(self.formatter.open(&mut self.writer, b'['));
-
-                self.first = true;
-
-                while let Some(()) = try!(visitor.visit(self)) { }
-
-                self.formatter.close(&mut self.writer, b']')
-            }
-        }
-
-    }
-
-    #[inline]
-    fn visit_enum_seq<V>(&mut self, _name: &str, variant: &str, visitor: V) -> io::Result<()>
-        where V: ser::SeqVisitor,
-    {
-        try!(self.formatter.open(&mut self.writer, b'{'));
-        try!(self.formatter.comma(&mut self.writer, true));
-        try!(self.visit_str(variant));
-        try!(self.formatter.colon(&mut self.writer));
-        try!(self.visit_seq(visitor));
-        self.formatter.close(&mut self.writer, b'}')
-    }
-
-    #[inline]
-    fn visit_seq_elt<T>(&mut self, value: T) -> io::Result<()>
-        where T: ser::Serialize,
-    {
-        try!(self.formatter.comma(&mut self.writer, self.first));
-        self.first = false;
-
-        value.serialize(self)
-    }
-
-    #[inline]
-    fn visit_map<V>(&mut self, mut visitor: V) -> io::Result<()>
-        where V: ser::MapVisitor,
-    {
-        match visitor.len() {
-            Some(len) if len == 0 => {
-                self.writer.write_all(b"{}")
-            }
-            _ => {
-                try!(self.formatter.open(&mut self.writer, b'{'));
-
-                self.first = true;
-
-                while let Some(()) = try!(visitor.visit(self)) { }
-
-                self.formatter.close(&mut self.writer, b'}')
-            }
-        }
-    }
-
-    #[inline]
-    fn visit_enum_map<V>(&mut self, _name: &str, variant: &str, visitor: V) -> io::Result<()>
-        where V: ser::MapVisitor,
-    {
-        try!(self.formatter.open(&mut self.writer, b'{'));
-        try!(self.formatter.comma(&mut self.writer, true));
-        try!(self.visit_str(variant));
-        try!(self.formatter.colon(&mut self.writer));
-        try!(self.visit_map(visitor));
-
-        self.formatter.close(&mut self.writer, b'}')
-    }
-
-    #[inline]
-    fn visit_map_elt<K, V>(&mut self, key: K, value: V) -> io::Result<()>
-        where K: ser::Serialize,
-              V: ser::Serialize,
-    {
-        try!(self.formatter.comma(&mut self.writer, self.first));
-        self.first = false;
-
-        try!(key.serialize(self));
-        try!(self.formatter.colon(&mut self.writer));
-        value.serialize(self)
-    }
-
-    #[inline]
-    fn format() -> &'static str {
-        "json"
-    }
-}
-
-pub trait Formatter {
-    fn open<W>(&mut self, writer: &mut W, ch: u8) -> io::Result<()>
-        where W: io::Write;
-
-    fn comma<W>(&mut self, writer: &mut W, first: bool) -> io::Result<()>
-        where W: io::Write;
-
-    fn colon<W>(&mut self, writer: &mut W) -> io::Result<()>
-        where W: io::Write;
-
-    fn close<W>(&mut self, writer: &mut W, ch: u8) -> io::Result<()>
-        where W: io::Write;
-}
-
-pub struct CompactFormatter;
-
-impl Formatter for CompactFormatter {
-    fn open<W>(&mut self, writer: &mut W, ch: u8) -> io::Result<()>
-        where W: io::Write,
-    {
-        writer.write_all(&[ch])
-    }
-
-    fn comma<W>(&mut self, writer: &mut W, first: bool) -> io::Result<()>
-        where W: io::Write,
-    {
-        if first {
-            Ok(())
-        } else {
-            writer.write_all(b",")
-        }
-    }
-
-    fn colon<W>(&mut self, writer: &mut W) -> io::Result<()>
-        where W: io::Write,
-    {
-        writer.write_all(b":")
-    }
-
-    fn close<W>(&mut self, writer: &mut W, ch: u8) -> io::Result<()>
-        where W: io::Write,
-    {
-        writer.write_all(&[ch])
-    }
-}
-
-pub struct PrettyFormatter<'a> {
-    current_indent: usize,
-    indent: &'a [u8],
-}
-
-impl<'a> PrettyFormatter<'a> {
-    fn new() -> Self {
-        PrettyFormatter::with_indent(b"  ")
-    }
-
-    fn with_indent(indent: &'a [u8]) -> Self {
-        PrettyFormatter {
-            current_indent: 0,
-            indent: indent,
-        }
-    }
-}
-
-impl<'a> Formatter for PrettyFormatter<'a> {
-    fn open<W>(&mut self, writer: &mut W, ch: u8) -> io::Result<()>
-        where W: io::Write,
-    {
-        self.current_indent += 1;
-        writer.write_all(&[ch])
-    }
-
-    fn comma<W>(&mut self, writer: &mut W, first: bool) -> io::Result<()>
-        where W: io::Write,
-    {
-        if first {
-            try!(writer.write_all(b"\n"));
-        } else {
-            try!(writer.write_all(b",\n"));
-        }
-
-        indent(writer, self.current_indent, self.indent)
-    }
-
-    fn colon<W>(&mut self, writer: &mut W) -> io::Result<()>
-        where W: io::Write,
-    {
-        writer.write_all(b": ")
-    }
-
-    fn close<W>(&mut self, writer: &mut W, ch: u8) -> io::Result<()>
-        where W: io::Write,
-    {
-        self.current_indent -= 1;
-        try!(writer.write(b"\n"));
-        try!(indent(writer, self.current_indent, self.indent));
-
-        writer.write_all(&[ch])
-    }
-}
-
-#[inline]
-pub fn escape_bytes<W>(wr: &mut W, bytes: &[u8]) -> io::Result<()>
-    where W: io::Write
-{
-    try!(wr.write_all(b"\""));
-
-    let mut start = 0;
-
-    for (i, byte) in bytes.iter().enumerate() {
-        let escaped = match *byte {
-            b'"' => b"\\\"",
-            b'\\' => b"\\\\",
-            b'\x08' => b"\\b",
-            b'\x0c' => b"\\f",
-            b'\n' => b"\\n",
-            b'\r' => b"\\r",
-            b'\t' => b"\\t",
-            _ => { continue; }
-        };
-
-        if start < i {
-            try!(wr.write_all(&bytes[start..i]));
-        }
-
-        try!(wr.write_all(escaped));
-
-        start = i + 1;
-    }
-
-    if start != bytes.len() {
-        try!(wr.write_all(&bytes[start..]));
-    }
-
-    try!(wr.write_all(b"\""));
-    Ok(())
-}
-
-#[inline]
-pub fn escape_str<W>(wr: &mut W, value: &str) -> io::Result<()>
-    where W: io::Write
-{
-    escape_bytes(wr, value.as_bytes())
-}
-
-#[inline]
-fn escape_char<W>(wr: &mut W, value: char) -> io::Result<()>
-    where W: io::Write
-{
-    // FIXME: this allocation is required in order to be compatible with stable
-    // rust, which doesn't support encoding a `char` into a stack buffer.
-    escape_bytes(wr, value.to_string().as_bytes())
-}
-
-fn fmt_f32_or_null<W>(wr: &mut W, value: f32) -> io::Result<()>
-    where W: io::Write
-{
-    match value.classify() {
-        FpCategory::Nan | FpCategory::Infinite => wr.write_all(b"null"),
-        _ => {
-            let s = format!("{:?}", value);
-            try!(wr.write_all(s.as_bytes()));
-            if !s.contains('.') {
-                try!(wr.write_all(b".0"))
-            }
-            Ok(())
-        }
-    }
-}
-
-fn fmt_f64_or_null<W>(wr: &mut W, value: f64) -> io::Result<()>
-    where W: io::Write
-{
-    match value.classify() {
-        FpCategory::Nan | FpCategory::Infinite => wr.write_all(b"null"),
-        _ => {
-            let s = format!("{:?}", value);
-            try!(wr.write_all(s.as_bytes()));
-            if !s.contains('.') {
-                try!(wr.write_all(b".0"))
-            }
-            Ok(())
-        }
-    }
-}
-
-/// Encode the specified struct into a json `[u8]` writer.
-#[inline]
-pub fn to_writer<W, T>(writer: &mut W, value: &T) -> io::Result<()>
-    where W: io::Write,
-          T: ser::Serialize,
-{
-    let mut ser = Serializer::new(writer);
-    try!(value.serialize(&mut ser));
-    Ok(())
-}
-
-/// Encode the specified struct into a json `[u8]` writer.
-#[inline]
-pub fn to_writer_pretty<W, T>(writer: &mut W, value: &T) -> io::Result<()>
-    where W: io::Write,
-          T: ser::Serialize,
-{
-    let mut ser = Serializer::pretty(writer);
-    try!(value.serialize(&mut ser));
-    Ok(())
-}
-
-/// Encode the specified struct into a json `[u8]` buffer.
-#[inline]
-pub fn to_vec<T>(value: &T) -> Vec<u8>
-    where T: ser::Serialize,
-{
-    // We are writing to a Vec, which doesn't fail. So we can ignore
-    // the error.
-    let mut writer = Vec::with_capacity(128);
-    to_writer(&mut writer, value).unwrap();
-    writer
-}
-
-/// Encode the specified struct into a json `[u8]` buffer.
-#[inline]
-pub fn to_vec_pretty<T>(value: &T) -> Vec<u8>
-    where T: ser::Serialize,
-{
-    // We are writing to a Vec, which doesn't fail. So we can ignore
-    // the error.
-    let mut writer = Vec::with_capacity(128);
-    to_writer_pretty(&mut writer, value).unwrap();
-    writer
-}
-
-/// Encode the specified struct into a json `String` buffer.
-#[inline]
-pub fn to_string<T>(value: &T) -> Result<String, FromUtf8Error>
-    where T: ser::Serialize
-{
-    let vec = to_vec(value);
-    String::from_utf8(vec)
-}
-
-/// Encode the specified struct into a json `String` buffer.
-#[inline]
-pub fn to_string_pretty<T>(value: &T) -> Result<String, FromUtf8Error>
-    where T: ser::Serialize
-{
-    let vec = to_vec_pretty(value);
-    String::from_utf8(vec)
-}
-
-fn indent<W>(wr: &mut W, n: usize, s: &[u8]) -> io::Result<()>
-    where W: io::Write,
-{
-    for _ in 0 .. n {
-        try!(wr.write_all(s));
-    }
-
-    Ok(())
-}
@@ -1,915 +0,0 @@
-use std::collections::{BTreeMap, btree_map};
-use std::fmt;
-use std::io;
-use std::str;
-use std::vec;
-
-use num::NumCast;
-
-use de;
-use ser;
-use super::error::Error;
-
-#[derive(Clone, PartialEq)]
-pub enum Value {
-    Null,
-    Bool(bool),
-    I64(i64),
-    U64(u64),
-    F64(f64),
-    String(String),
-    Array(Vec<Value>),
-    Object(BTreeMap<String, Value>),
-}
-
-impl Value {
-    /// If the `Value` is an Object, returns the value associated with the provided key.
-    /// Otherwise, returns None.
-    pub fn find<'a>(&'a self, key: &str) -> Option<&'a Value>{
-        match self {
-            &Value::Object(ref map) => map.get(key),
-            _ => None
-        }
-    }
-
-    /// Attempts to get a nested Value Object for each key in `keys`.
-    /// If any key is found not to exist, find_path will return None.
-    /// Otherwise, it will return the `Value` associated with the final key.
-    pub fn find_path<'a>(&'a self, keys: &[&str]) -> Option<&'a Value>{
-        let mut target = self;
-        for key in keys {
-            match target.find(key) {
-                Some(t) => { target = t; },
-                None => return None
-            }
-        }
-        Some(target)
-    }
-
-    /// Looks up a value by path.
-    ///
-    /// This is a convenience method that splits the path by `'.'`
-    /// and then feeds the sequence of keys into the `find_path`
-    /// method.
-    ///
-    /// ``` ignore
-    /// let obj: Value = json::from_str(r#"{"x": {"a": 1}}"#).unwrap();
-    ///
-    /// assert!(obj.lookup("x.a").unwrap() == &Value::U64(1));
-    /// ```
-    pub fn lookup<'a>(&'a self, path: &str) -> Option<&'a Value> {
-        let mut target = self;
-        for key in path.split('.') {
-            match target.find(key) {
-                Some(t) => { target = t; },
-                None => return None
-            }
-        }
-        Some(target)
-    }
-
-    /// If the `Value` is an Object, performs a depth-first search until
-    /// a value associated with the provided key is found. If no value is found
-    /// or the `Value` is not an Object, returns None.
-    pub fn search<'a>(&'a self, key: &str) -> Option<&'a Value> {
-        match self {
-            &Value::Object(ref map) => {
-                match map.get(key) {
-                    Some(json_value) => Some(json_value),
-                    None => {
-                        for (_, v) in map.iter() {
-                            match v.search(key) {
-                                x if x.is_some() => return x,
-                                _ => ()
-                            }
-                        }
-                        None
-                    }
-                }
-            },
-            _ => None
-        }
-    }
-
-    /// Returns true if the `Value` is an Object. Returns false otherwise.
-    pub fn is_object<'a>(&'a self) -> bool {
-        self.as_object().is_some()
-    }
-
-    /// If the `Value` is an Object, returns the associated BTreeMap.
-    /// Returns None otherwise.
-    pub fn as_object<'a>(&'a self) -> Option<&'a BTreeMap<String, Value>> {
-        match self {
-            &Value::Object(ref map) => Some(map),
-            _ => None
-        }
-    }
-
-    /// If the `Value` is an Object, returns the associated mutable BTreeMap.
-    /// Returns None otherwise.
-    pub fn as_object_mut<'a>(&'a mut self) -> Option<&'a mut BTreeMap<String, Value>> {
-        match self {
-            &mut Value::Object(ref mut map) => Some(map),
-            _ => None
-        }
-    }
-
-    /// Returns true if the `Value` is an Array. Returns false otherwise.
-    pub fn is_array<'a>(&'a self) -> bool {
-        self.as_array().is_some()
-    }
-
-    /// If the `Value` is an Array, returns the associated vector.
-    /// Returns None otherwise.
-    pub fn as_array<'a>(&'a self) -> Option<&'a Vec<Value>> {
-        match self {
-            &Value::Array(ref array) => Some(&*array),
-            _ => None
-        }
-    }
-
-    /// If the `Value` is an Array, returns the associated mutable vector.
-    /// Returns None otherwise.
-    pub fn as_array_mut<'a>(&'a mut self) -> Option<&'a mut Vec<Value>> {
-        match self {
-            &mut Value::Array(ref mut list) => Some(list),
-            _ => None
-        }
-    }
-
-    /// Returns true if the `Value` is a String. Returns false otherwise.
-    pub fn is_string<'a>(&'a self) -> bool {
-        self.as_string().is_some()
-    }
-
-    /// If the `Value` is a String, returns the associated str.
-    /// Returns None otherwise.
-    pub fn as_string<'a>(&'a self) -> Option<&'a str> {
-        match *self {
-            Value::String(ref s) => Some(&s),
-            _ => None
-        }
-    }
-
-    /// Returns true if the `Value` is a Number. Returns false otherwise.
-    pub fn is_number(&self) -> bool {
-        match *self {
-            Value::I64(_) | Value::U64(_) | Value::F64(_) => true,
-            _ => false,
-        }
-    }
-
-    /// Returns true if the `Value` is a i64. Returns false otherwise.
-    pub fn is_i64(&self) -> bool {
-        match *self {
-            Value::I64(_) => true,
-            _ => false,
-        }
-    }
-
-    /// Returns true if the `Value` is a u64. Returns false otherwise.
-    pub fn is_u64(&self) -> bool {
-        match *self {
-            Value::U64(_) => true,
-            _ => false,
-        }
-    }
-
-    /// Returns true if the `Value` is a f64. Returns false otherwise.
-    pub fn is_f64(&self) -> bool {
-        match *self {
-            Value::F64(_) => true,
-            _ => false,
-        }
-    }
-
-    /// If the `Value` is a number, return or cast it to a i64.
-    /// Returns None otherwise.
-    pub fn as_i64(&self) -> Option<i64> {
-        match *self {
-            Value::I64(n) => Some(n),
-            Value::U64(n) => NumCast::from(n),
-            _ => None
-        }
-    }
-
-    /// If the `Value` is a number, return or cast it to a u64.
-    /// Returns None otherwise.
-    pub fn as_u64(&self) -> Option<u64> {
-        match *self {
-            Value::I64(n) => NumCast::from(n),
-            Value::U64(n) => Some(n),
-            _ => None
-        }
-    }
-
-    /// If the `Value` is a number, return or cast it to a f64.
-    /// Returns None otherwise.
-    pub fn as_f64(&self) -> Option<f64> {
-        match *self {
-            Value::I64(n) => NumCast::from(n),
-            Value::U64(n) => NumCast::from(n),
-            Value::F64(n) => Some(n),
-            _ => None
-        }
-    }
-
-    /// Returns true if the `Value` is a Boolean. Returns false otherwise.
-    pub fn is_boolean(&self) -> bool {
-        self.as_boolean().is_some()
-    }
-
-    /// If the `Value` is a Boolean, returns the associated bool.
-    /// Returns None otherwise.
-    pub fn as_boolean(&self) -> Option<bool> {
-        match self {
-            &Value::Bool(b) => Some(b),
-            _ => None
-        }
-    }
-
-    /// Returns true if the `Value` is a Null. Returns false otherwise.
-    pub fn is_null(&self) -> bool {
-        self.as_null().is_some()
-    }
-
-    /// If the `Value` is a Null, returns ().
-    /// Returns None otherwise.
-    pub fn as_null(&self) -> Option<()> {
-        match self {
-            &Value::Null => Some(()),
-            _ => None
-        }
-    }
-}
-
-impl ser::Serialize for Value {
-    #[inline]
-    fn serialize<S>(&self, serializer: &mut S) -> Result<(), S::Error>
-        where S: ser::Serializer,
-    {
-        match *self {
-            Value::Null => serializer.visit_unit(),
-            Value::Bool(v) => serializer.visit_bool(v),
-            Value::I64(v) => serializer.visit_i64(v),
-            Value::U64(v) => serializer.visit_u64(v),
-            Value::F64(v) => serializer.visit_f64(v),
-            Value::String(ref v) => serializer.visit_str(&v),
-            Value::Array(ref v) => v.serialize(serializer),
-            Value::Object(ref v) => v.serialize(serializer),
-        }
-    }
-}
-
-impl de::Deserialize for Value {
-    #[inline]
-    fn deserialize<D>(deserializer: &mut D) -> Result<Value, D::Error>
-        where D: de::Deserializer,
-    {
-        struct ValueVisitor;
-
-        impl de::Visitor for ValueVisitor {
-            type Value = Value;
-
-            #[inline]
-            fn visit_bool<E>(&mut self, value: bool) -> Result<Value, E> {
-                Ok(Value::Bool(value))
-            }
-
-            #[inline]
-            fn visit_i64<E>(&mut self, value: i64) -> Result<Value, E> {
-                if value < 0 {
-                    Ok(Value::I64(value))
-                } else {
-                    Ok(Value::U64(value as u64))
-                }
-            }
-
-            #[inline]
-            fn visit_u64<E>(&mut self, value: u64) -> Result<Value, E> {
-                Ok(Value::U64(value))
-            }
-
-            #[inline]
-            fn visit_f64<E>(&mut self, value: f64) -> Result<Value, E> {
-                Ok(Value::F64(value))
-            }
-
-            #[inline]
-            fn visit_str<E>(&mut self, value: &str) -> Result<Value, E>
-                where E: de::Error,
-            {
-                self.visit_string(value.to_string())
-            }
-
-            #[inline]
-            fn visit_string<E>(&mut self, value: String) -> Result<Value, E> {
-                Ok(Value::String(value))
-            }
-
-            #[inline]
-            fn visit_none<E>(&mut self) -> Result<Value, E> {
-                Ok(Value::Null)
-            }
-
-            #[inline]
-            fn visit_some<D>(&mut self, deserializer: &mut D) -> Result<Value, D::Error>
-                where D: de::Deserializer,
-            {
-                de::Deserialize::deserialize(deserializer)
-            }
-
-            #[inline]
-            fn visit_unit<E>(&mut self) -> Result<Value, E> {
-                Ok(Value::Null)
-            }
-
-            #[inline]
-            fn visit_seq<V>(&mut self, visitor: V) -> Result<Value, V::Error>
-                where V: de::SeqVisitor,
-            {
-                let values = try!(de::impls::VecVisitor::new().visit_seq(visitor));
-                Ok(Value::Array(values))
-            }
-
-            #[inline]
-            fn visit_map<V>(&mut self, visitor: V) -> Result<Value, V::Error>
-                where V: de::MapVisitor,
-            {
-                let values = try!(de::impls::BTreeMapVisitor::new().visit_map(visitor));
-                Ok(Value::Object(values))
-            }
-        }
-
-        deserializer.visit(ValueVisitor)
-    }
-}
-
-struct WriterFormatter<'a, 'b: 'a> {
-    inner: &'a mut fmt::Formatter<'b>,
-}
-
-impl<'a, 'b> io::Write for WriterFormatter<'a, 'b> {
-    fn write(&mut self, buf: &[u8]) -> io::Result<usize> {
-        match self.inner.write_str(str::from_utf8(buf).unwrap()) {
-            Ok(_) => Ok(buf.len()),
-            Err(_) => Err(io::Error::last_os_error()),
-        }
-    }
-
-    fn flush(&mut self) -> io::Result<()> {
-        Ok(())
-    }
-}
-
-impl fmt::Debug for Value {
-    /// Serializes a json value into a string
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        let mut wr = WriterFormatter { inner: f };
-        super::ser::to_writer(&mut wr, self).map_err(|_| fmt::Error)
-    }
-}
-
-#[derive(Debug)]
-enum State {
-    Value(Value),
-    Array(Vec<Value>),
-    Object(BTreeMap<String, Value>),
-}
-
-pub struct Serializer {
-    state: Vec<State>,
-}
-
-impl Serializer {
-    pub fn new() -> Serializer {
-        Serializer {
-            state: Vec::with_capacity(4),
-        }
-    }
-
-    pub fn unwrap(mut self) -> Value {
-        match self.state.pop().unwrap() {
-            State::Value(value) => value,
-            state => panic!("expected value, found {:?}", state),
-        }
-    }
-}
-
-impl ser::Serializer for Serializer {
-    type Error = ();
-
-    #[inline]
-    fn visit_bool(&mut self, value: bool) -> Result<(), ()> {
-        self.state.push(State::Value(Value::Bool(value)));
-        Ok(())
-    }
-
-    #[inline]
-    fn visit_i64(&mut self, value: i64) -> Result<(), ()> {
-        if value < 0 {
-            self.state.push(State::Value(Value::I64(value)));
-        } else {
-            self.state.push(State::Value(Value::U64(value as u64)));
-        }
-        Ok(())
-    }
-
-    #[inline]
-    fn visit_u64(&mut self, value: u64) -> Result<(), ()> {
-        self.state.push(State::Value(Value::U64(value)));
-        Ok(())
-    }
-
-    #[inline]
-    fn visit_f64(&mut self, value: f64) -> Result<(), ()> {
-        self.state.push(State::Value(Value::F64(value as f64)));
-        Ok(())
-    }
-
-    #[inline]
-    fn visit_char(&mut self, value: char) -> Result<(), ()> {
-        self.state.push(State::Value(Value::String(value.to_string())));
-        Ok(())
-    }
-
-    #[inline]
-    fn visit_str(&mut self, value: &str) -> Result<(), ()> {
-        self.state.push(State::Value(Value::String(value.to_string())));
-        Ok(())
-    }
-
-    #[inline]
-    fn visit_none(&mut self) -> Result<(), ()> {
-        self.visit_unit()
-    }
-
-    #[inline]
-    fn visit_some<V>(&mut self, value: V) -> Result<(), ()>
-        where V: ser::Serialize,
-    {
-        value.serialize(self)
-    }
-
-    #[inline]
-    fn visit_unit(&mut self) -> Result<(), ()> {
-        self.state.push(State::Value(Value::Null));
-        Ok(())
-    }
-
-    #[inline]
-    fn visit_enum_unit(&mut self, _name: &str, variant: &str) -> Result<(), ()> {
-        let mut values = BTreeMap::new();
-        values.insert(variant.to_string(), Value::Array(vec![]));
-
-        self.state.push(State::Value(Value::Object(values)));
-
-        Ok(())
-    }
-
-    #[inline]
-    fn visit_seq<V>(&mut self, mut visitor: V) -> Result<(), ()>
-        where V: ser::SeqVisitor,
-    {
-        let len = visitor.len().unwrap_or(0);
-        let values = Vec::with_capacity(len);
-
-        self.state.push(State::Array(values));
-
-        while let Some(()) = try!(visitor.visit(self)) { }
-
-        let values = match self.state.pop().unwrap() {
-            State::Array(values) => values,
-            state => panic!("Expected array, found {:?}", state),
-        };
-
-        self.state.push(State::Value(Value::Array(values)));
-
-        Ok(())
-    }
-
-    #[inline]
-    fn visit_enum_seq<V>(&mut self, _name: &str, variant: &str, visitor: V) -> Result<(), ()>
-        where V: ser::SeqVisitor,
-    {
-        try!(self.visit_seq(visitor));
-
-        let value = match self.state.pop().unwrap() {
-            State::Value(value) => value,
-            state => panic!("expected value, found {:?}", state),
-        };
-
-        let mut object = BTreeMap::new();
-
-        object.insert(variant.to_string(), value);
-
-        self.state.push(State::Value(Value::Object(object)));
-
-        Ok(())
-    }
-
-    #[inline]
-    fn visit_seq_elt<T>(&mut self, value: T) -> Result<(), ()>
-        where T: ser::Serialize,
-    {
-        try!(value.serialize(self));
-
-        let value = match self.state.pop().unwrap() {
-            State::Value(value) => value,
-            state => panic!("expected value, found {:?}", state),
-        };
-
-        match *self.state.last_mut().unwrap() {
-            State::Array(ref mut values) => { values.push(value); }
-            ref state => panic!("expected array, found {:?}", state),
-        }
-
-        Ok(())
-    }
-
-    #[inline]
-    fn visit_map<V>(&mut self, mut visitor: V) -> Result<(), ()>
-        where V: ser::MapVisitor,
-    {
-        let values = BTreeMap::new();
-
-        self.state.push(State::Object(values));
-
-        while let Some(()) = try!(visitor.visit(self)) { }
-
-        let values = match self.state.pop().unwrap() {
-            State::Object(values) => values,
-            state => panic!("expected object, found {:?}", state),
-        };
-
-        self.state.push(State::Value(Value::Object(values)));
-
-        Ok(())
-    }
-
-    #[inline]
-    fn visit_enum_map<V>(&mut self, _name: &str, variant: &str, visitor: V) -> Result<(), ()>
-        where V: ser::MapVisitor,
-    {
-        try!(self.visit_map(visitor));
-
-        let value = match self.state.pop().unwrap() {
-            State::Value(value) => value,
-            state => panic!("expected value, found {:?}", state),
-        };
-
-        let mut object = BTreeMap::new();
-
-        object.insert(variant.to_string(), value);
-
-        self.state.push(State::Value(Value::Object(object)));
-
-        Ok(())
-    }
-
-    #[inline]
-    fn visit_map_elt<K, V>(&mut self, key: K, value: V) -> Result<(), ()>
-        where K: ser::Serialize,
-              V: ser::Serialize,
-    {
-        try!(key.serialize(self));
-
-        let key = match self.state.pop().unwrap() {
-            State::Value(Value::String(value)) => value,
-            state => panic!("expected key, found {:?}", state),
-        };
-
-        try!(value.serialize(self));
-
-        let value = match self.state.pop().unwrap() {
-            State::Value(value) => value,
-            state => panic!("expected value, found {:?}", state),
-        };
-
-        match *self.state.last_mut().unwrap() {
-            State::Object(ref mut values) => { values.insert(key, value); }
-            ref state => panic!("expected object, found {:?}", state),
-        }
-
-        Ok(())
-    }
-
-    #[inline]
-    fn format() -> &'static str {
-        "json"
-    }
-}
-
-pub struct Deserializer {
-    value: Option<Value>,
-}
-
-impl Deserializer {
-    /// Creates a new deserializer instance for deserializing the specified JSON value.
-    pub fn new(value: Value) -> Deserializer {
-        Deserializer {
-            value: Some(value),
-        }
-    }
-}
-
-impl de::Deserializer for Deserializer {
-    type Error = Error;
-
-    #[inline]
-    fn visit<V>(&mut self, mut visitor: V) -> Result<V::Value, Error>
-        where V: de::Visitor,
-    {
-        let value = match self.value.take() {
-            Some(value) => value,
-            None => { return Err(de::Error::end_of_stream_error()); }
-        };
-
-        match value {
-            Value::Null => visitor.visit_unit(),
-            Value::Bool(v) => visitor.visit_bool(v),
-            Value::I64(v) => visitor.visit_i64(v),
-            Value::U64(v) => visitor.visit_u64(v),
-            Value::F64(v) => visitor.visit_f64(v),
-            Value::String(v) => visitor.visit_string(v),
-            Value::Array(v) => {
-                let len = v.len();
-                visitor.visit_seq(SeqDeserializer {
-                    de: self,
-                    iter: v.into_iter(),
-                    len: len,
-                })
-            }
-            Value::Object(v) => {
-                let len = v.len();
-                visitor.visit_map(MapDeserializer {
-                    de: self,
-                    iter: v.into_iter(),
-                    value: None,
-                    len: len,
-                })
-            }
-        }
-    }
-
-    #[inline]
-    fn visit_option<V>(&mut self, mut visitor: V) -> Result<V::Value, Error>
-        where V: de::Visitor,
-    {
-        match self.value {
-            Some(Value::Null) => visitor.visit_none(),
-            Some(_) => visitor.visit_some(self),
-            None => Err(de::Error::end_of_stream_error()),
-        }
-    }
-
-    #[inline]
-    fn visit_enum<V>(&mut self, _name: &str, mut visitor: V) -> Result<V::Value, Error>
-        where V: de::EnumVisitor,
-    {
-        let value = match self.value.take() {
-            Some(Value::Object(value)) => value,
-            Some(_) => { return Err(de::Error::syntax_error()); }
-            None => { return Err(de::Error::end_of_stream_error()); }
-        };
-
-        let mut iter = value.into_iter();
-
-        let value = match iter.next() {
-            Some((variant, Value::Array(fields))) => {
-                self.value = Some(Value::String(variant));
-
-                let len = fields.len();
-                try!(visitor.visit(SeqDeserializer {
-                    de: self,
-                    iter: fields.into_iter(),
-                    len: len,
-                }))
-            }
-            Some((variant, Value::Object(fields))) => {
-                let len = fields.len();
-                try!(visitor.visit(MapDeserializer {
-                    de: self,
-                    iter: fields.into_iter(),
-                    value: Some(Value::String(variant)),
-                    len: len,
-                }))
-            }
-            Some(_) => { return Err(de::Error::syntax_error()); }
-            None => { return Err(de::Error::syntax_error()); }
-        };
-
-        match iter.next() {
-            Some(_) => Err(de::Error::syntax_error()),
-            None => Ok(value)
-        }
-    }
-
-    #[inline]
-    fn format() -> &'static str {
-        "json"
-    }
-}
-
-struct SeqDeserializer<'a> {
-    de: &'a mut Deserializer,
-    iter: vec::IntoIter<Value>,
-    len: usize,
-}
-
-impl<'a> de::Deserializer for SeqDeserializer<'a> {
-    type Error = Error;
-
-    #[inline]
-    fn visit<V>(&mut self, mut visitor: V) -> Result<V::Value, Error>
-        where V: de::Visitor,
-    {
-        if self.len == 0 {
-            visitor.visit_unit()
-        } else {
-            visitor.visit_seq(self)
-        }
-    }
-}
-
-impl<'a> de::SeqVisitor for SeqDeserializer<'a> {
-    type Error = Error;
-
-    fn visit<T>(&mut self) -> Result<Option<T>, Error>
-        where T: de::Deserialize
-    {
-        match self.iter.next() {
-            Some(value) => {
-                self.len -= 1;
-                self.de.value = Some(value);
-                Ok(Some(try!(de::Deserialize::deserialize(self.de))))
-            }
-            None => Ok(None),
-        }
-    }
-
-    fn end(&mut self) -> Result<(), Error> {
-        if self.len == 0 {
-            Ok(())
-        } else {
-            Err(de::Error::end_of_stream_error())
-        }
-    }
-
-    fn size_hint(&self) -> (usize, Option<usize>) {
-        (self.len, Some(self.len))
-    }
-}
-
-impl<'a> de::VariantVisitor for SeqDeserializer<'a> {
-    type Error = Error;
-
-    fn visit_variant<V>(&mut self) -> Result<V, Error>
-        where V: de::Deserialize,
-    {
-        de::Deserialize::deserialize(self.de)
-    }
-
-    fn visit_unit(&mut self) -> Result<(), Error>
-    {
-        de::Deserialize::deserialize(self)
-    }
-
-    fn visit_seq<V>(&mut self, visitor: V) -> Result<V::Value, Error>
-        where V: de::Visitor,
-    {
-        de::Deserializer::visit(self, visitor)
-    }
-
-    fn visit_map<V>(&mut self, visitor: V) -> Result<V::Value, Error>
-        where V: de::Visitor,
-    {
-        de::Deserializer::visit(self, visitor)
-    }
-}
-
-struct MapDeserializer<'a> {
-    de: &'a mut Deserializer,
-    iter: btree_map::IntoIter<String, Value>,
-    value: Option<Value>,
-    len: usize,
-}
-
-impl<'a> de::MapVisitor for MapDeserializer<'a> {
-    type Error = Error;
-
-    fn visit_key<T>(&mut self) -> Result<Option<T>, Error>
-        where T: de::Deserialize
-    {
-        match self.iter.next() {
-            Some((key, value)) => {
-                self.len -= 1;
-                self.value = Some(value);
-                self.de.value = Some(Value::String(key));
-                Ok(Some(try!(de::Deserialize::deserialize(self.de))))
-            }
-            None => Ok(None),
-        }
-    }
-
-    fn visit_value<T>(&mut self) -> Result<T, Error>
-        where T: de::Deserialize
-    {
-        let value = self.value.take().unwrap();
-        self.de.value = Some(value);
-        Ok(try!(de::Deserialize::deserialize(self.de)))
-    }
-
-    fn end(&mut self) -> Result<(), Error> {
-        if self.len == 0 {
-            Ok(())
-        } else {
-            Err(de::Error::end_of_stream_error())
-        }
-    }
-
-    fn missing_field<V>(&mut self, _field: &'static str) -> Result<V, Error>
-        where V: de::Deserialize,
-    {
-        // See if the type can deserialize from a unit.
-        struct UnitDeserializer;
-
-        impl de::Deserializer for UnitDeserializer {
-            type Error = Error;
-
-            fn visit<V>(&mut self, mut visitor: V) -> Result<V::Value, Error>
-                where V: de::Visitor,
-            {
-                visitor.visit_unit()
-            }
-
-            fn visit_option<V>(&mut self, mut visitor: V) -> Result<V::Value, Error>
-                where V: de::Visitor,
-            {
-                visitor.visit_none()
-            }
-        }
-
-        Ok(try!(de::Deserialize::deserialize(&mut UnitDeserializer)))
-    }
-
-    fn size_hint(&self) -> (usize, Option<usize>) {
-        (self.len, Some(self.len))
-    }
-}
-
-impl<'a> de::Deserializer for MapDeserializer<'a> {
-    type Error = Error;
-
-    #[inline]
-    fn visit<V>(&mut self, mut visitor: V) -> Result<V::Value, Error>
-        where V: de::Visitor,
-    {
-        println!("MapDeserializer!");
-        visitor.visit_map(self)
-    }
-}
-
-impl<'a> de::VariantVisitor for MapDeserializer<'a> {
-    type Error = Error;
-
-    fn visit_variant<V>(&mut self) -> Result<V, Error>
-        where V: de::Deserialize,
-    {
-        self.de.value = self.value.take();
-        de::Deserialize::deserialize(self.de)
-    }
-
-    fn visit_unit(&mut self) -> Result<(), Error> {
-        de::Deserialize::deserialize(self)
-    }
-
-    fn visit_seq<V>(&mut self, visitor: V) -> Result<V::Value, Error>
-        where V: de::Visitor,
-    {
-        de::Deserializer::visit(self, visitor)
-    }
-
-    fn visit_map<V>(&mut self, visitor: V) -> Result<V::Value, Error>
-        where V: de::Visitor,
-    {
-        de::Deserializer::visit(self, visitor)
-    }
-}
-
-/// Shortcut function to encode a `T` into a JSON `Value`
-pub fn to_value<T>(value: &T) -> Value
-    where T: ser::Serialize
-{
-    let mut ser = Serializer::new();
-    value.serialize(&mut ser).ok().unwrap();
-    ser.unwrap()
-}
-
-/// Shortcut function to decode a JSON `Value` into a `T`
-pub fn from_value<T>(value: Value) -> Result<T, Error>
-    where T: de::Deserialize
-{
-    let mut de = Deserializer::new(value);
-    de::Deserialize::deserialize(&mut de)
-}
@@ -5,15 +5,24 @@
 //! handshake protocol between serializers and serializees can be completely optimized away,
 //! leaving serde to perform roughly the same speed as a hand written serializer for a specific
 //! type.
-#![doc(html_root_url="http://erickt.github.io/rust-serde")]
+
+#![doc(html_root_url="https://serde-rs.github.io/serde/serde")]
+#![cfg_attr(feature = "nightly", feature(collections, core, enumset, nonzero, step_trait, zero_one))]
+
+#![deny(missing_docs)]

 extern crate num;

+#[cfg(feature = "nightly")]
+extern crate collections;
+
+#[cfg(feature = "nightly")]
+extern crate core;
+
 pub use ser::{Serialize, Serializer};
 pub use de::{Deserialize, Deserializer, Error};

 pub mod bytes;
 pub mod de;
 pub mod iter;
-pub mod json;
 pub mod ser;
@@ -1,9 +1,31 @@
-use std::collections::{BTreeMap, BTreeSet, HashMap, HashSet};
+//! Implementations for all of Rust's builtin types.
+
+use std::borrow::Cow;
+use std::collections::{
+    BinaryHeap,
+    BTreeMap,
+    BTreeSet,
+    LinkedList,
+    HashMap,
+    HashSet,
+    VecDeque,
+};
+#[cfg(feature = "nightly")]
+use collections::enum_set::{CLike, EnumSet};
 use std::hash::Hash;
+#[cfg(feature = "nightly")]
+use std::iter;
+#[cfg(feature = "nightly")]
+use std::num;
+#[cfg(feature = "nightly")]
+use std::ops;
 use std::path;
 use std::rc::Rc;
 use std::sync::Arc;

+#[cfg(feature = "nightly")]
+use core::nonzero::{NonZero, Zeroable};
+
 use super::{
    Serialize,
    Serializer,
@@ -75,8 +97,49 @@ impl<T> Serialize for Option<T> where T: Serialize {
    }
 }

+impl<T> SeqVisitor for Option<T> where T: Serialize {
+    #[inline]
+    fn visit<S>(&mut self, serializer: &mut S) -> Result<Option<()>, S::Error>
+        where S: Serializer,
+    {
+        match self.take() {
+            Some(value) => {
+                try!(serializer.visit_seq_elt(value));
+                Ok(Some(()))
+            }
+            None => Ok(None),
+        }
+    }
+
+    #[inline]
+    fn len(&self) -> Option<usize> {
+        Some(if self.is_some() { 1 } else { 0 })
+    }
+}
+
 ///////////////////////////////////////////////////////////////////////////////

+/// A `serde::Visitor` for sequence iterators.
+///
+/// # Examples
+///
+/// ```
+/// use serde::{Serialize, Serializer};
+/// use serde::ser::impls::SeqIteratorVisitor;
+///
+/// struct Seq(Vec<u32>);
+///
+/// impl Serialize for Seq {
+///     fn serialize<S>(&self, ser: &mut S) -> Result<(), S::Error>
+///         where S: Serializer,
+///     {
+///         ser.visit_seq(SeqIteratorVisitor::new(
+///             self.0.iter(),
+///             Some(self.0.len()),
+///         ))
+///     }
+/// }
+/// ```
 pub struct SeqIteratorVisitor<Iter> {
    iter: Iter,
    len: Option<usize>,
@@ -85,6 +148,7 @@ pub struct SeqIteratorVisitor<Iter> {
 impl<T, Iter> SeqIteratorVisitor<Iter>
    where Iter: Iterator<Item=T>
 {
+    /// Construct a new `SeqIteratorVisitor<Iter>`.
    #[inline]
    pub fn new(iter: Iter, len: Option<usize>) -> SeqIteratorVisitor<Iter> {
        SeqIteratorVisitor {
@@ -104,8 +168,8 @@ impl<T, Iter> SeqVisitor for SeqIteratorVisitor<Iter>
    {
        match self.iter.next() {
            Some(value) => {
-                let value = try!(serializer.visit_seq_elt(value));
-                Ok(Some(value))
+                try!(serializer.visit_seq_elt(value));
+                Ok(Some(()))
            }
            None => Ok(None),
        }
@@ -119,7 +183,7 @@ impl<T, Iter> SeqVisitor for SeqIteratorVisitor<Iter>

 ///////////////////////////////////////////////////////////////////////////////

-impl<'a, T> Serialize for &'a [T]
+impl<T> Serialize for [T]
    where T: Serialize,
 {
    #[inline]
@@ -177,12 +241,16 @@ array_impls!(30);
 array_impls!(31);
 array_impls!(32);

-impl<T> Serialize for Vec<T> where T: Serialize {
+///////////////////////////////////////////////////////////////////////////////
+
+impl<T> Serialize for BinaryHeap<T>
+    where T: Serialize + Ord
+{
    #[inline]
    fn serialize<S>(&self, serializer: &mut S) -> Result<(), S::Error>
        where S: Serializer,
    {
-        (&self[..]).serialize(serializer)
+        serializer.visit_seq(SeqIteratorVisitor::new(self.iter(), Some(self.len())))
    }
 }

@@ -197,6 +265,18 @@ impl<T> Serialize for BTreeSet<T>
    }
 }

+#[cfg(feature = "nightly")]
+impl<T> Serialize for EnumSet<T>
+    where T: Serialize + CLike
+{
+    #[inline]
+    fn serialize<S>(&self, serializer: &mut S) -> Result<(), S::Error>
+        where S: Serializer,
+    {
+        serializer.visit_seq(SeqIteratorVisitor::new(self.iter(), Some(self.len())))
+    }
+}
+
 impl<T> Serialize for HashSet<T>
    where T: Serialize + Eq + Hash,
 {
@@ -208,6 +288,49 @@ impl<T> Serialize for HashSet<T>
    }
 }

+impl<T> Serialize for LinkedList<T>
+    where T: Serialize,
+{
+    #[inline]
+    fn serialize<S>(&self, serializer: &mut S) -> Result<(), S::Error>
+        where S: Serializer,
+    {
+        serializer.visit_seq(SeqIteratorVisitor::new(self.iter(), Some(self.len())))
+    }
+}
+
+#[cfg(feature = "nightly")]
+impl<A> Serialize for ops::Range<A>
+    where A: Serialize + Clone + iter::Step + num::One,
+          for<'a> &'a A: ops::Add<&'a A, Output = A>,
+{
+    #[inline]
+    fn serialize<S>(&self, serializer: &mut S) -> Result<(), S::Error>
+        where S: Serializer,
+    {
+        let len = iter::Step::steps_between(&self.start, &self.end, &A::one());
+        serializer.visit_seq(SeqIteratorVisitor::new(self.clone(), len))
+    }
+}
+
+impl<T> Serialize for Vec<T> where T: Serialize {
+    #[inline]
+    fn serialize<S>(&self, serializer: &mut S) -> Result<(), S::Error>
+        where S: Serializer,
+    {
+        (&self[..]).serialize(serializer)
+    }
+}
+
+impl<T> Serialize for VecDeque<T> where T: Serialize {
+    #[inline]
+    fn serialize<S>(&self, serializer: &mut S) -> Result<(), S::Error>
+        where S: Serializer,
+    {
+        serializer.visit_seq(SeqIteratorVisitor::new(self.iter(), Some(self.len())))
+    }
+}
+
 ///////////////////////////////////////////////////////////////////////////////

 impl Serialize for () {
@@ -233,12 +356,14 @@ macro_rules! tuple_impls {
        }
    )+) => {
        $(
+            /// A tuple visitor.
            pub struct $TupleVisitor<'a, $($T: 'a),+> {
                tuple: &'a ($($T,)+),
                state: u8,
            }

            impl<'a, $($T: 'a),+> $TupleVisitor<'a, $($T),+> {
+                /// Construct a new, empty `TupleVisitor`.
                pub fn new(tuple: &'a ($($T,)+)) -> $TupleVisitor<'a, $($T),+> {
                    $TupleVisitor {
                        tuple: tuple,
@@ -257,7 +382,7 @@ macro_rules! tuple_impls {
                        $(
                            $state => {
                                self.state += 1;
-                                Ok(Some(try!(serializer.visit_seq_elt(&e!(self.tuple.$idx)))))
+                                Ok(Some(try!(serializer.visit_tuple_elt(&e!(self.tuple.$idx)))))
                            }
                        )+
                        _ => {
@@ -276,7 +401,7 @@ macro_rules! tuple_impls {
            {
                #[inline]
                fn serialize<S: Serializer>(&self, serializer: &mut S) -> Result<(), S::Error> {
-                    serializer.visit_seq($TupleVisitor::new(self))
+                    serializer.visit_tuple($TupleVisitor::new(self))
                }
            }
        )+
@@ -390,6 +515,28 @@ tuple_impls! {

 ///////////////////////////////////////////////////////////////////////////////

+/// A `serde::Visitor` for (key, value) map iterators.
+///
+/// # Examples
+///
+/// ```
+/// use std::collections::HashMap;
+/// use serde::{Serialize, Serializer};
+/// use serde::ser::impls::MapIteratorVisitor;
+///
+/// struct Map(HashMap<u32, u32>);
+///
+/// impl Serialize for Map {
+///     fn serialize<S>(&self, ser: &mut S) -> Result<(), S::Error>
+///         where S: Serializer,
+///     {
+///         ser.visit_map(MapIteratorVisitor::new(
+///             self.0.iter(),
+///             Some(self.0.len()),
+///         ))
+///     }
+/// }
+/// ```
 pub struct MapIteratorVisitor<Iter> {
    iter: Iter,
    len: Option<usize>,
@@ -398,6 +545,7 @@ pub struct MapIteratorVisitor<Iter> {
 impl<K, V, Iter> MapIteratorVisitor<Iter>
    where Iter: Iterator<Item=(K, V)>
 {
+    /// Construct a new `MapIteratorVisitor<Iter>`.
    #[inline]
    pub fn new(iter: Iter, len: Option<usize>) -> MapIteratorVisitor<Iter> {
        MapIteratorVisitor {
@@ -457,20 +605,6 @@ impl<K, V> Serialize for HashMap<K, V>
    }
 }

-// FIXME: `VecMap` is unstable.
-/*
-impl<V> Serialize for VecMap<V>
-    where V: Serialize,
-{
-    #[inline]
-    fn serialize<S>(&self, serializer: &mut S) -> Result<(), S::Error>
-        where S: Serializer,
-    {
-        serializer.visit_map(MapIteratorVisitor::new(self.iter(), Some(self.len())))
-    }
-}
-*/
-
 ///////////////////////////////////////////////////////////////////////////////

 impl<'a, T: ?Sized> Serialize for &'a T where T: Serialize {
@@ -518,6 +652,30 @@ impl<T> Serialize for Arc<T> where T: Serialize, {
    }
 }

+impl<'a, T: ?Sized> Serialize for Cow<'a, T> where T: Serialize + ToOwned, {
+    #[inline]
+    fn serialize<S>(&self, serializer: &mut S) -> Result<(), S::Error>
+        where S: Serializer,
+    {
+        (**self).serialize(serializer)
+    }
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+impl<T, E> Serialize for Result<T, E> where T: Serialize, E: Serialize {
+    fn serialize<S>(&self, serializer: &mut S) -> Result<(), S::Error> where S: Serializer {
+        match *self {
+            Result::Ok(ref value) => {
+                serializer.visit_newtype_variant("Result", 0, "Ok", value)
+            }
+            Result::Err(ref value) => {
+                serializer.visit_newtype_variant("Result", 1, "Err", value)
+            }
+        }
+    }
+}
+
 ///////////////////////////////////////////////////////////////////////////////

 impl Serialize for path::Path {
@@ -535,3 +693,10 @@ impl Serialize for path::PathBuf {
        self.to_str().unwrap().serialize(serializer)
    }
 }
+
+#[cfg(feature = "nightly")]
+impl<T> Serialize for NonZero<T> where T: Serialize + Zeroable {
+    fn serialize<S>(&self, serializer: &mut S) -> Result<(), S::Error> where S: Serializer {
+        (**self).serialize(serializer)
+    }
+}
@@ -4,14 +4,18 @@ pub mod impls;

 ///////////////////////////////////////////////////////////////////////////////

+/// A trait that describes a type that can be serialized by a `Serializer`.
 pub trait Serialize {
+    /// Serializes this value into this serializer.
    fn serialize<S>(&self, serializer: &mut S) -> Result<(), S::Error>
        where S: Serializer;
 }

 ///////////////////////////////////////////////////////////////////////////////

+/// A trait that describes a type that can serialize a stream of values into the underlying format.
 pub trait Serializer {
+    /// The error type that can be returned if some error occurs during serialization.
    type Error;

    /// `visit_bool` serializes a `bool` value.
@@ -110,76 +114,204 @@ pub trait Serializer {
        self.visit_seq(impls::SeqIteratorVisitor::new(value.iter(), Some(value.len())))
    }

+    /// Serializes a `()` value.
    fn visit_unit(&mut self) -> Result<(), Self::Error>;

+    /// Serializes a unit struct value.
+    ///
+    /// By default, unit structs are serialized as a `()`.
    #[inline]
-    fn visit_named_unit(&mut self, _name: &str) -> Result<(), Self::Error> {
+    fn visit_unit_struct(&mut self, _name: &'static str) -> Result<(), Self::Error> {
        self.visit_unit()
    }

+    /// Serializes a unit variant, otherwise known as a variant with no arguments.
+    ///
+    /// By default, unit variants are serialized as a `()`.
    #[inline]
-    fn visit_enum_unit(&mut self,
-                       _name: &str,
-                       _variant: &str) -> Result<(), Self::Error> {
+    fn visit_unit_variant(&mut self,
+                          _name: &'static str,
+                          _variant_index: usize,
+                          _variant: &'static str) -> Result<(), Self::Error> {
        self.visit_unit()
    }

+    /// The `visit_newtype_struct` allows a tuple struct with a single element, also known as a
+    /// newtyped value, to be more efficiently serialized than a tuple struct with multiple items.
+    /// By default it just serializes the value as a tuple struct sequence.
+    #[inline]
+    fn visit_newtype_struct<T>(&mut self,
+                               name: &'static str,
+                               value: T) -> Result<(), Self::Error>
+        where T: Serialize,
+    {
+        self.visit_tuple_struct(name, Some(value))
+    }
+
+    /// The `visit_newtype_variant` allows a variant with a single item to be more efficiently
+    /// serialized than a variant with multiple items. By default it just serializes the value as a
+    /// tuple variant sequence.
+    #[inline]
+    fn visit_newtype_variant<T>(&mut self,
+                                name: &'static str,
+                                variant_index: usize,
+                                variant: &'static str,
+                                value: T) -> Result<(), Self::Error>
+        where T: Serialize,
+    {
+        self.visit_tuple_variant(
+            name,
+            variant_index,
+            variant,
+            Some(value))
+    }
+
+    /// Serializes a `None` value.
    fn visit_none(&mut self) -> Result<(), Self::Error>;

+    /// Serializes a `Some(...)` value.
    fn visit_some<V>(&mut self, value: V) -> Result<(), Self::Error>
        where V: Serialize;

+    /// Serializes a sequence.
+    ///
+    /// Callees of this method need to construct a `SeqVisitor`, which iterates through each item
+    /// in the sequence.
    fn visit_seq<V>(&mut self, visitor: V) -> Result<(), Self::Error>
        where V: SeqVisitor;

-    #[inline]
-    fn visit_named_seq<V>(&mut self,
-                          _name: &'static str,
-                          visitor: V) -> Result<(), Self::Error>
-        where V: SeqVisitor,
-    {
-        self.visit_seq(visitor)
-    }
-
-    #[inline]
-    fn visit_enum_seq<V>(&mut self,
-                         _name: &'static str,
-                         _variant: &'static str,
-                         visitor: V) -> Result<(), Self::Error>
-        where V: SeqVisitor,
-    {
-        self.visit_seq(visitor)
-    }
-
+    /// Serializes a sequence element.
    fn visit_seq_elt<T>(&mut self, value: T) -> Result<(), Self::Error>
        where T: Serialize;

+    /// Serializes a tuple.
+    ///
+    /// By default this serializes a tuple as a sequence.
+    #[inline]
+    fn visit_tuple<V>(&mut self, visitor: V) -> Result<(), Self::Error>
+        where V: SeqVisitor,
+    {
+        self.visit_seq(visitor)
+    }
+
+    /// Serializes a tuple element.
+    ///
+    /// By default, tuples are serialized as a sequence.
+    #[inline]
+    fn visit_tuple_elt<T>(&mut self, value: T) -> Result<(), Self::Error>
+        where T: Serialize
+    {
+        self.visit_seq_elt(value)
+    }
+
+    /// Serializes a tuple struct.
+    ///
+    /// By default, tuple structs are serialized as a tuple.
+    #[inline]
+    fn visit_tuple_struct<V>(&mut self,
+                             _name: &'static str,
+                             visitor: V) -> Result<(), Self::Error>
+        where V: SeqVisitor,
+    {
+        self.visit_tuple(visitor)
+    }
+
+    /// Serializes a tuple struct element.
+    ///
+    /// By default, tuple struct elements are serialized as a tuple element.
+    #[inline]
+    fn visit_tuple_struct_elt<T>(&mut self, value: T) -> Result<(), Self::Error>
+        where T: Serialize
+    {
+        self.visit_tuple_elt(value)
+    }
+
+    /// Serializes a tuple variant.
+    ///
+    /// By default, tuple variants are serialized as a tuple struct.
+    #[inline]
+    fn visit_tuple_variant<V>(&mut self,
+                              _name: &'static str,
+                              _variant_index: usize,
+                              variant: &'static str,
+                              visitor: V) -> Result<(), Self::Error>
+        where V: SeqVisitor,
+    {
+        self.visit_tuple_struct(variant, visitor)
+    }
+
+    /// Serializes a tuple element.
+    ///
+    /// By default, tuples are serialized as a sequence.
+    #[inline]
+    fn visit_tuple_variant_elt<T>(&mut self, value: T) -> Result<(), Self::Error>
+        where T: Serialize
+    {
+        self.visit_tuple_struct_elt(value)
+    }
+
+    /// Serializes a map.
+    ///
+    /// Callees of this method need to construct a `MapVisitor`, which iterates through each item
+    /// in the map.
    fn visit_map<V>(&mut self, visitor: V) -> Result<(), Self::Error>
        where V: MapVisitor;

-    #[inline]
-    fn visit_named_map<V>(&mut self,
-                          _name: &'static str,
-                          visitor: V) -> Result<(), Self::Error>
-        where V: MapVisitor,
-    {
-        self.visit_map(visitor)
-    }
-
-    #[inline]
-    fn visit_enum_map<V>(&mut self,
-                          _name: &'static str,
-                          _variant: &'static str,
-                          visitor: V) -> Result<(), Self::Error>
-        where V: MapVisitor,
-    {
-        self.visit_map(visitor)
-    }
-
+    /// Serializes a map element (key-value pair).
    fn visit_map_elt<K, V>(&mut self, key: K, value: V) -> Result<(), Self::Error>
        where K: Serialize,
              V: Serialize;

+    /// Serializes a struct.
+    ///
+    /// By default, structs are serialized as a map with the field name as the key.
+    #[inline]
+    fn visit_struct<V>(&mut self,
+                       _name: &'static str,
+                       visitor: V) -> Result<(), Self::Error>
+        where V: MapVisitor,
+    {
+        self.visit_map(visitor)
+    }
+
+    /// Serializes an element of a struct.
+    ///
+    /// By default, struct elements are serialized as a map element with the field name as the key.
+    #[inline]
+    fn visit_struct_elt<V>(&mut self,
+                           key: &'static str,
+                           value: V) -> Result<(), Self::Error>
+        where V: Serialize,
+    {
+        self.visit_map_elt(key, value)
+    }
+
+    /// Serializes a struct variant.
+    ///
+    /// By default, struct variants are serialized as a struct.
+    #[inline]
+    fn visit_struct_variant<V>(&mut self,
+                               _name: &'static str,
+                               _variant_index: usize,
+                               variant: &'static str,
+                               visitor: V) -> Result<(), Self::Error>
+        where V: MapVisitor,
+    {
+        self.visit_struct(variant, visitor)
+    }
+
+    /// Serializes an element of a struct variant.
+    ///
+    /// By default, struct variant elements are serialized as a struct element.
+    #[inline]
+    fn visit_struct_variant_elt<V>(&mut self,
+                                   key: &'static str,
+                                   value: V) -> Result<(), Self::Error>
+        where V: Serialize,
+    {
+        self.visit_struct_elt(key, value)
+    }
+
    /// Specify a format string for the serializer.
    ///
    /// The serializer format is used to determine which format
@@ -189,7 +321,12 @@ pub trait Serializer {
    }
 }

+/// A trait that is used by a `Serialize` to iterate through a sequence.
 pub trait SeqVisitor {
+    /// Serializes a sequence item in the serializer.
+    ///
+    /// This returns `Ok(Some(()))` when there are more items to serialize, or `Ok(None)` when
+    /// complete.
    fn visit<S>(&mut self, serializer: &mut S) -> Result<Option<()>, S::Error>
        where S: Serializer;

@@ -200,7 +337,12 @@ pub trait SeqVisitor {
    }
 }

+/// A trait that is used by a `Serializer` to iterate through a map.
 pub trait MapVisitor {
+    /// Serializes a map item in the serializer.
+    ///
+    /// This returns `Ok(Some(()))` when there are more items to serialize, or `Ok(None)` when
+    /// complete.
    fn visit<S>(&mut self, serializer: &mut S) -> Result<Option<()>, S::Error>
        where S: Serializer;

@@ -1,16 +1,18 @@
 [package]
 name = "serde_codegen"
-version = "0.4.1"
+version = "0.5.3"
 authors = ["Erick Tryzelaar <erick.tryzelaar@gmail.com>"]
 license = "MIT/Apache-2.0"
 description = "Macros to auto-generate implementations for the serde framework"
-repository = "https://github.com/erickt/rust-serde"
+repository = "https://github.com/serde-rs/serde"
+documentation = "https://serde-rs.github.io/serde/serde_codegen/serde_codegen/index.html"
 build = "build.rs"
+keywords = ["serde", "serialization"]

 [features]
 default = ["with-syntex"]
 nightly = ["quasi_macros"]
-with-syntex = ["quasi/with-syntex", "quasi_codegen/with-syntex", "syntex", "syntex_syntax"]
+with-syntex = ["quasi/with-syntex", "quasi_codegen", "quasi_codegen/with-syntex", "syntex", "syntex_syntax"]

 [build-dependencies]
 quasi_codegen = { verision = "*", optional = true }
@@ -16,15 +16,20 @@ pub enum FieldNames {

 /// Represents field attribute information
 pub struct FieldAttrs {
+    skip_serializing_field: bool,
    names: FieldNames,
    use_default: bool,
 }

 impl FieldAttrs {
-
    /// Create a FieldAttr with a single default field name
-    pub fn new(default_value: bool, name: P<ast::Expr>) -> FieldAttrs {
+    pub fn new(
+        skip_serializing_field: bool,
+        default_value: bool,
+        name: P<ast::Expr>,
+    ) -> FieldAttrs {
        FieldAttrs {
+            skip_serializing_field: skip_serializing_field,
            names: FieldNames::Global(name),
            use_default: default_value,
        }
@@ -32,12 +37,14 @@ impl FieldAttrs {

    /// Create a FieldAttr with format specific field names
    pub fn new_with_formats(
+        skip_serializing_field: bool,
        default_value: bool,
        default_name: P<ast::Expr>,
        formats: HashMap<P<ast::Expr>, P<ast::Expr>>,
-        ) -> FieldAttrs {
+    ) -> FieldAttrs {
        FieldAttrs {
-            names:  FieldNames::Format {
+            skip_serializing_field: skip_serializing_field,
+            names: FieldNames::Format {
                formats: formats,
                default: default_name,
            },
@@ -105,4 +112,9 @@ impl FieldAttrs {
    pub fn use_default(&self) -> bool {
        self.use_default
    }
+
+    /// Predicate for ignoring a field when serializing a value
+    pub fn skip_serializing_field(&self) -> bool {
+        self.skip_serializing_field
+    }
 }
@@ -129,15 +129,24 @@ fn deserialize_item_struct(
        }
    }

-    match (named_fields.is_empty(), unnamed_fields == 0) {
-        (true, true) => {
+    match (named_fields.is_empty(), unnamed_fields) {
+        (true, 0) => {
            deserialize_unit_struct(
                cx,
                &builder,
                item.ident,
            )
        }
-        (true, false) => {
+        (true, 1) => {
+            deserialize_newtype_struct(
+                cx,
+                &builder,
+                item.ident,
+                impl_generics,
+                ty,
+            )
+        }
+        (true, _) => {
            deserialize_tuple_struct(
                cx,
                &builder,
@@ -147,7 +156,7 @@ fn deserialize_item_struct(
                unnamed_fields,
            )
        }
-        (false, true) => {
+        (false, 0) => {
            deserialize_struct(
                cx,
                &builder,
@@ -157,7 +166,7 @@ fn deserialize_item_struct(
                struct_def,
            )
        }
-        (false, false) => {
+        (false, _) => {
            cx.bug("struct has named and unnamed fields")
        }
    }
@@ -190,11 +199,25 @@ fn deserialize_visitor(
        (
            builder.item().tuple_struct("__Visitor")
                .generics().with(trait_generics.clone()).build()
-                .with_tys(
-                    trait_generics.ty_params.iter().map(|ty_param| {
-                        builder.ty().phantom_data().id(ty_param.ident)
-                    })
-                )
+                .with_tys({
+                    let lifetimes = trait_generics.lifetimes.iter()
+                        .map(|lifetime_def| {
+                            builder.ty()
+                                .phantom_data()
+                                .ref_().lifetime(lifetime_def.lifetime.name)
+                                .ty()
+                                .unit()
+                        });
+
+                    let ty_params = trait_generics.ty_params.iter()
+                        .map(|ty_param| {
+                            builder.ty()
+                                .phantom_data()
+                                .id(ty_param.ident)
+                        });
+
+                    lifetimes.chain(ty_params)
+                })
                .build(),
            builder.ty().path()
                .segment("__Visitor").with_generics(trait_generics.clone()).build()
@@ -204,11 +227,11 @@ fn deserialize_visitor(
                .with_tys(forward_tys)
                .with_tys(placeholders)
                .build().build()
-                .with_args(
-                    trait_generics.ty_params.iter().map(|_| {
-                        builder.expr().phantom_data()
-                    })
-                )
+                .with_args({
+                    let len = trait_generics.lifetimes.len() + trait_generics.ty_params.len();
+
+                    (0 .. len).map(|_| builder.expr().phantom_data())
+                })
                .build(),
            trait_generics,
        )
@@ -260,7 +283,59 @@ fn deserialize_unit_struct(
            }
        }

-        deserializer.visit_named_unit($type_name, __Visitor)
+        deserializer.visit_unit_struct($type_name, __Visitor)
+    })
+}
+
+fn deserialize_newtype_struct(
+    cx: &ExtCtxt,
+    builder: &aster::AstBuilder,
+    type_ident: Ident,
+    impl_generics: &ast::Generics,
+    ty: P<ast::Ty>,
+) -> P<ast::Expr> {
+    let where_clause = &impl_generics.where_clause;
+
+    let (visitor_item, visitor_ty, visitor_expr, visitor_generics) =
+        deserialize_visitor(
+            builder,
+            impl_generics,
+            vec![deserializer_ty_param(builder)],
+            vec![deserializer_ty_arg(builder)],
+        );
+
+    let visit_seq_expr = deserialize_seq(
+        cx,
+        builder,
+        builder.path().id(type_ident).build(),
+        1,
+    );
+
+    let type_name = builder.expr().str(type_ident);
+
+    quote_expr!(cx, {
+        $visitor_item
+
+        impl $visitor_generics ::serde::de::Visitor for $visitor_ty $where_clause {
+            type Value = $ty;
+
+            #[inline]
+            fn visit_newtype_struct<D>(&mut self, deserializer: &mut D) -> ::std::result::Result<Self::Value, D::Error>
+                where D: ::serde::de::Deserializer,
+            {
+                let value = try!(::serde::de::Deserialize::deserialize(deserializer));
+                Ok($type_ident(value))
+            }
+
+            #[inline]
+            fn visit_seq<__V>(&mut self, mut visitor: __V) -> ::std::result::Result<$ty, __V::Error>
+                where __V: ::serde::de::SeqVisitor,
+            {
+                $visit_seq_expr
+            }
+        }
+
+        deserializer.visit_newtype_struct($type_name, $visitor_expr)
    })
 }

@@ -297,6 +372,7 @@ fn deserialize_tuple_struct(
        impl $visitor_generics ::serde::de::Visitor for $visitor_ty $where_clause {
            type Value = $ty;

+            #[inline]
            fn visit_seq<__V>(&mut self, mut visitor: __V) -> ::std::result::Result<$ty, __V::Error>
                where __V: ::serde::de::SeqVisitor,
            {
@@ -304,7 +380,7 @@ fn deserialize_tuple_struct(
            }
        }

-        deserializer.visit_named_seq($type_name, $visitor_expr)
+        deserializer.visit_tuple_struct($type_name, $fields, $visitor_expr)
    })
 }

@@ -321,7 +397,7 @@ fn deserialize_seq(
                let $name = match try!(visitor.visit()) {
                    Some(value) => { value },
                    None => {
-                        return Err(::serde::de::Error::end_of_stream_error());
+                        return Err(::serde::de::Error::end_of_stream());
                    }
                };
            ).unwrap()
@@ -342,6 +418,51 @@ fn deserialize_seq(
    })
 }

+fn deserialize_struct_as_seq(
+    cx: &ExtCtxt,
+    builder: &aster::AstBuilder,
+    struct_path: ast::Path,
+    struct_def: &StructDef,
+) -> P<ast::Expr> {
+    let let_values: Vec<P<ast::Stmt>> = (0 .. struct_def.fields.len())
+        .map(|i| {
+            let name = builder.id(format!("__field{}", i));
+            quote_stmt!(cx,
+                let $name = match try!(visitor.visit()) {
+                    Some(value) => { value },
+                    None => {
+                        return Err(::serde::de::Error::end_of_stream());
+                    }
+                };
+            ).unwrap()
+        })
+        .collect();
+
+    let result = builder.expr().struct_path(struct_path)
+        .with_id_exprs(
+            struct_def.fields.iter()
+                .enumerate()
+                .map(|(i, field)| {
+                    (
+                        match field.node.kind {
+                            ast::NamedField(name, _) => name.clone(),
+                            ast::UnnamedField(_) => panic!("struct contains unnamed fields"),
+                        },
+                        builder.expr().id(format!("__field{}", i)),
+                    )
+                })
+        )
+        .build();
+
+    quote_expr!(cx, {
+        $let_values
+
+        try!(visitor.end());
+
+        Ok($result)
+    })
+}
+
 fn deserialize_struct(
    cx: &ExtCtxt,
    builder: &aster::AstBuilder,
@@ -352,19 +473,27 @@ fn deserialize_struct(
 ) -> P<ast::Expr> {
    let where_clause = &impl_generics.where_clause;

-    let (visitor_item, visitor_ty, visitor_expr, visitor_generics) =
-        deserialize_visitor(
-            builder,
-            &impl_generics,
-            vec![deserializer_ty_param(builder)],
-            vec![deserializer_ty_arg(builder)],
-                );
+    let (visitor_item, visitor_ty, visitor_expr, visitor_generics) = deserialize_visitor(
+        builder,
+        &impl_generics,
+        vec![deserializer_ty_param(builder)],
+        vec![deserializer_ty_arg(builder)],
+    );

-    let (field_visitor, visit_map_expr) = deserialize_struct_visitor(
+    let type_path = builder.path().id(type_ident).build();
+
+    let visit_seq_expr = deserialize_struct_as_seq(
+        cx,
+        builder,
+        type_path.clone(),
+        struct_def
+    );
+
+    let (field_visitor, fields_stmt, visit_map_expr) = deserialize_struct_visitor(
        cx,
        builder,
        struct_def,
-        builder.path().id(type_ident).build(),
+        type_path.clone()
    );

    let type_name = builder.expr().str(type_ident);
@@ -377,6 +506,13 @@ fn deserialize_struct(
        impl $visitor_generics ::serde::de::Visitor for $visitor_ty $where_clause {
            type Value = $ty;

+            #[inline]
+            fn visit_seq<__V>(&mut self, mut visitor: __V) -> ::std::result::Result<$ty, __V::Error>
+                where __V: ::serde::de::SeqVisitor,
+            {
+                $visit_seq_expr
+            }
+
            #[inline]
            fn visit_map<__V>(&mut self, mut visitor: __V) -> ::std::result::Result<$ty, __V::Error>
                where __V: ::serde::de::MapVisitor,
@@ -385,7 +521,9 @@ fn deserialize_struct(
            }
        }

-        deserializer.visit_named_map($type_name, $visitor_expr)
+        $fields_stmt
+
+        deserializer.visit_struct($type_name, FIELDS, $visitor_expr)
    })
 }

@@ -407,11 +545,25 @@ fn deserialize_item_enum(
        enum_def.variants.iter()
            .map(|variant|
                 attr::FieldAttrs::new(
+                     false,
                     true,
                     builder.expr().str(variant.node.name)))
            .collect()
    );

+    let variants_expr = builder.expr().addr_of().slice()
+        .with_exprs(
+            enum_def.variants.iter()
+                .map(|variant| {
+                    builder.expr().str(variant.node.name)
+                })
+        )
+        .build();
+
+    let variants_stmt = quote_stmt!(cx,
+        const VARIANTS: &'static [&'static str] = $variants_expr;
+    ).unwrap();
+
    // Match arms to extract a variant from a string
    let variant_arms: Vec<_> = enum_def.variants.iter()
        .enumerate()
@@ -458,7 +610,9 @@ fn deserialize_item_enum(
            }
        }

-        deserializer.visit_enum($type_name, $visitor_expr)
+        $variants_stmt
+
+        deserializer.visit_enum($type_name, VARIANTS, $visitor_expr)
    })
 }

@@ -479,6 +633,12 @@ fn deserialize_variant(
                Ok($type_ident::$variant_ident)
            })
        }
+        ast::TupleVariantKind(ref args) if args.len() == 1 => {
+            quote_expr!(cx, {
+                let val = try!(visitor.visit_newtype());
+                Ok($type_ident::$variant_ident(val))
+            })
+        }
        ast::TupleVariantKind(ref args) => {
            deserialize_tuple_variant(
                cx,
@@ -543,7 +703,7 @@ fn deserialize_tuple_variant(
            }
        }

-        visitor.visit_seq($visitor_expr)
+        visitor.visit_tuple($fields, $visitor_expr)
    })
 }

@@ -558,11 +718,23 @@ fn deserialize_struct_variant(
 ) -> P<ast::Expr> {
    let where_clause = &generics.where_clause;

-    let (field_visitor, field_expr) = deserialize_struct_visitor(
+    let type_path = builder.path()
+        .id(type_ident)
+        .id(variant_ident)
+        .build();
+
+    let visit_seq_expr = deserialize_struct_as_seq(
+        cx,
+        builder,
+        type_path.clone(),
+        struct_def
+    );
+
+    let (field_visitor, fields_stmt, field_expr) = deserialize_struct_visitor(
        cx,
        builder,
        struct_def,
-        builder.path().id(type_ident).id(variant_ident).build(),
+        type_path
    );

    let (visitor_item, visitor_ty, visitor_expr, visitor_generics) =
@@ -581,6 +753,14 @@ fn deserialize_struct_variant(
        impl $visitor_generics ::serde::de::Visitor for $visitor_ty $where_clause {
            type Value = $ty;

+            #[inline]
+            fn visit_seq<__V>(&mut self, mut visitor: __V) -> ::std::result::Result<$ty, __V::Error>
+                where __V: ::serde::de::SeqVisitor,
+            {
+                $visit_seq_expr
+            }
+
+            #[inline]
            fn visit_map<__V>(&mut self, mut visitor: __V) -> ::std::result::Result<$ty, __V::Error>
                where __V: ::serde::de::MapVisitor,
            {
@@ -588,7 +768,9 @@ fn deserialize_struct_variant(
            }
        }

-        visitor.visit_map($visitor_expr)
+        $fields_stmt
+
+        visitor.visit_struct(FIELDS, $visitor_expr)
    })
 }

@@ -612,6 +794,20 @@ fn deserialize_field_visitor(
        )
        .build();

+    let index_field_arms: Vec<_> = field_idents.iter()
+        .enumerate()
+        .map(|(field_index, field_ident)| {
+            quote_arm!(cx, $field_index => { Ok(__Field::$field_ident) })
+        })
+        .collect();
+
+    let index_body = quote_expr!(cx,
+        match value {
+            $index_field_arms
+            _ => { Err(::serde::de::Error::syntax("expected a field")) }
+        }
+    );
+
    // A set of all the formats that have specialized field attributes
    let formats = field_attrs.iter()
        .fold(HashSet::new(), |mut set, field_expr| {
@@ -628,15 +824,15 @@ fn deserialize_field_visitor(
        })
        .collect();

-    let body = if formats.is_empty() {
+    let str_body = if formats.is_empty() {
        // No formats specific attributes, so no match on format required
        quote_expr!(cx,
-                    match value {
-                        $default_field_arms
-                        _ => { Err(::serde::de::Error::unknown_field_error(value)) }
-                    })
+            match value {
+                $default_field_arms
+                _ => { Err(::serde::de::Error::unknown_field(value)) }
+            })
    } else {
-        let field_arms : Vec<_> = formats.iter()
+        let field_arms: Vec<_> = formats.iter()
            .map(|fmt| {
                field_idents.iter()
                    .zip(field_attrs.iter())
@@ -648,27 +844,28 @@ fn deserialize_field_visitor(
            })
            .collect();

-        let fmt_matches : Vec<_> = formats.iter()
+        let fmt_matches: Vec<_> = formats.iter()
            .zip(field_arms.iter())
            .map(|(ref fmt, ref arms)| {
                quote_arm!(cx, $fmt => {
                    match value {
                        $arms
                        _ => {
-                            Err(::serde::de::Error::unknown_field_error(value))
+                            Err(::serde::de::Error::unknown_field(value))
                        }
                    }})
            })
            .collect();

        quote_expr!(cx,
-                    match __D::format() {
-                        $fmt_matches
-                        _ => match value {
-                            $default_field_arms
-                            _ => { Err(::serde::de::Error::unknown_field_error(value)) }
-                        }
-                    })
+            match __D::format() {
+                $fmt_matches
+                _ => match value {
+                    $default_field_arms
+                    _ => { Err(::serde::de::Error::unknown_field(value)) }
+                }
+            }
+        )
    };

    let impl_item = quote_item!(cx,
@@ -688,10 +885,16 @@ fn deserialize_field_visitor(
                {
                    type Value = __Field;

+                    fn visit_usize<E>(&mut self, value: usize) -> ::std::result::Result<__Field, E>
+                        where E: ::serde::de::Error,
+                    {
+                        $index_body
+                    }
+
                    fn visit_str<E>(&mut self, value: &str) -> ::std::result::Result<__Field, E>
                        where E: ::serde::de::Error,
                    {
-                        $body
+                        $str_body
                    }

                    fn visit_bytes<E>(&mut self, value: &[u8]) -> ::std::result::Result<__Field, E>
@@ -700,13 +903,18 @@ fn deserialize_field_visitor(
                        // TODO: would be better to generate a byte string literal match
                        match ::std::str::from_utf8(value) {
                            Ok(s) => self.visit_str(s),
-                            _ => Err(::serde::de::Error::syntax_error()),
+                            _ => {
+                                Err(
+                                    ::serde::de::Error::syntax(
+                                        "could not convert a byte string to a String"
+                                    )
+                                )
+                            }
                        }
                    }
                }

-                deserializer.visit(
-                    __FieldVisitor::<D>{ phantom: PhantomData })
+                deserializer.visit(__FieldVisitor::<D>{ phantom: PhantomData })
            }
        }
    ).unwrap();
@@ -719,7 +927,7 @@ fn deserialize_struct_visitor(
    builder: &aster::AstBuilder,
    struct_def: &ast::StructDef,
    struct_path: ast::Path,
-) -> (Vec<P<ast::Item>>, P<ast::Expr>) {
+) -> (Vec<P<ast::Item>>, P<ast::Stmt>, P<ast::Expr>) {
    let field_visitor = deserialize_field_visitor(
        cx,
        builder,
@@ -733,7 +941,23 @@ fn deserialize_struct_visitor(
        struct_def,
    );

-    (field_visitor, visit_map_expr)
+    let fields_expr = builder.expr().addr_of().slice()
+        .with_exprs(
+            struct_def.fields.iter()
+                .map(|field| {
+                    match field.node.kind {
+                        ast::NamedField(name, _) => builder.expr().str(name),
+                        ast::UnnamedField(_) => panic!("struct contains unnamed fields"),
+                    }
+                })
+        )
+        .build();
+
+    let fields_stmt = quote_stmt!(cx,
+        const FIELDS: &'static [&'static str] = $fields_expr;
+    ).unwrap();
+
+    (field_visitor, fields_stmt, visit_map_expr)
 }

 fn deserialize_map(
@@ -58,10 +58,18 @@ fn default_value(mi: &ast::MetaItem) -> bool {
    }
 }

+fn skip_serializing_field(mi: &ast::MetaItem) -> bool {
+    if let ast::MetaItem_::MetaWord(ref n) = mi.node {
+        n == &"skip_serializing"
+    } else {
+        false
+    }
+}
+
 fn field_attrs<'a>(
    builder: &aster::AstBuilder,
    field: &'a ast::StructField,
-) -> (Rename<'a>, bool) {
+) -> (Rename<'a>, bool, bool) {
    field.node.attrs.iter()
        .find(|sa| {
            if let ast::MetaList(ref n, _) = sa.node.value.node {
@@ -73,15 +81,18 @@ fn field_attrs<'a>(
        .and_then(|sa| {
            if let ast::MetaList(_, ref vals) = sa.node.value.node {
                attr::mark_used(&sa);
-                Some((vals.iter()
-                      .fold(None, |v, mi| v.or(rename(builder, mi)))
-                      .unwrap_or(Rename::None),
-                      vals.iter().any(|mi| default_value(mi))))
+                Some((
+                    vals.iter()
+                        .fold(None, |v, mi| v.or(rename(builder, mi)))
+                        .unwrap_or(Rename::None),
+                    vals.iter().any(|mi| default_value(mi)),
+                    vals.iter().any(|mi| skip_serializing_field(mi)),
+                ))
            } else {
-                Some((Rename::None, false))
+                Some((Rename::None, false, false))
            }
        })
-        .unwrap_or((Rename::None, false))
+        .unwrap_or((Rename::None, false, false))
 }

 pub fn struct_field_attrs(
@@ -92,23 +103,26 @@ pub fn struct_field_attrs(
    struct_def.fields.iter()
        .map(|field| {
            match field_attrs(builder, field) {
-                (Rename::Global(rename), default_value) =>
+                (Rename::Global(rename), default_value, skip_serializing_field) =>
                    FieldAttrs::new(
+                        skip_serializing_field,
                        default_value,
                        builder.expr().build_lit(P(rename.clone()))),
-                (Rename::Format(renames), default_value) => {
+                (Rename::Format(renames), default_value, skip_serializing_field) => {
                    let mut res = HashMap::new();
                    res.extend(
                        renames.into_iter()
                            .map(|(k,v)|
                                 (k, builder.expr().build_lit(P(v.clone())))));
                    FieldAttrs::new_with_formats(
+                        skip_serializing_field,
                        default_value,
                        default_field_name(cx, builder, field.node.kind),
                        res)
                },
-                (Rename::None, default_value) => {
+                (Rename::None, default_value, skip_serializing_field) => {
                    FieldAttrs::new(
+                        skip_serializing_field,
                        default_value,
                        default_field_name(cx, builder, field.node.kind))
                }
@@ -55,10 +55,7 @@ pub fn expand_derive_serialize(
        &builder,
        &item,
        &impl_generics,
-        builder.ty()
-            .ref_()
-            .lifetime("'__a")
-            .build_ty(ty.clone()),
+        ty.clone(),
    );

    let where_clause = &impl_generics.where_clause;
@@ -127,15 +124,22 @@ fn serialize_item_struct(
        }
    }

-    match (named_fields.is_empty(), unnamed_fields == 0) {
-        (true, true) => {
+    match (named_fields.is_empty(), unnamed_fields) {
+        (true, 0) => {
            serialize_unit_struct(
                cx,
                &builder,
                item.ident,
            )
        }
-        (true, false) => {
+        (true, 1) => {
+            serialize_newtype_struct(
+                cx,
+                &builder,
+                item.ident,
+            )
+        }
+        (true, _) => {
            serialize_tuple_struct(
                cx,
                &builder,
@@ -145,7 +149,7 @@ fn serialize_item_struct(
                unnamed_fields,
            )
        }
-        (false, true) => {
+        (false, 0) => {
            serialize_struct(
                cx,
                &builder,
@@ -156,7 +160,7 @@ fn serialize_item_struct(
                named_fields,
            )
        }
-        (false, false) => {
+        (false, _) => {
            cx.bug("struct has named and unnamed fields")
        }
    }
@@ -169,7 +173,17 @@ fn serialize_unit_struct(
 ) -> P<ast::Expr> {
    let type_name = builder.expr().str(type_ident);

-    quote_expr!(cx, serializer.visit_named_unit($type_name))
+    quote_expr!(cx, serializer.visit_unit_struct($type_name))
+}
+
+fn serialize_newtype_struct(
+    cx: &ExtCtxt,
+    builder: &aster::AstBuilder,
+    type_ident: Ident
+) -> P<ast::Expr> {
+    let type_name = builder.expr().str(type_ident);
+
+    quote_expr!(cx, serializer.visit_newtype_struct($type_name, &self.0))
 }

 fn serialize_tuple_struct(
@@ -184,7 +198,10 @@ fn serialize_tuple_struct(
        cx,
        builder,
        ty.clone(),
-        ty,
+        builder.ty()
+            .ref_()
+            .lifetime("'__a")
+            .build_ty(ty.clone()),
        fields,
        impl_generics,
    );
@@ -194,10 +211,10 @@ fn serialize_tuple_struct(
    quote_expr!(cx, {
        $visitor_struct
        $visitor_impl
-        serializer.visit_named_seq($type_name, Visitor {
+        serializer.visit_tuple_struct($type_name, Visitor {
            value: self,
            state: 0,
-            _structure_ty: ::std::marker::PhantomData,
+            _structure_ty: ::std::marker::PhantomData::<&$ty>,
        })
    })
 }
@@ -215,7 +232,10 @@ fn serialize_struct(
        cx,
        builder,
        ty.clone(),
-        ty,
+        builder.ty()
+            .ref_()
+            .lifetime("'__a")
+            .build_ty(ty.clone()),
        struct_def,
        impl_generics,
        fields.iter().map(|field| quote_expr!(cx, &self.value.$field)),
@@ -226,10 +246,10 @@ fn serialize_struct(
    quote_expr!(cx, {
        $visitor_struct
        $visitor_impl
-        serializer.visit_named_map($type_name, Visitor {
+        serializer.visit_struct($type_name, Visitor {
            value: self,
            state: 0,
-            _structure_ty: ::std::marker::PhantomData,
+            _structure_ty: ::std::marker::PhantomData::<&$ty>,
        })
    })
 }
@@ -243,7 +263,8 @@ fn serialize_item_enum(
    enum_def: &ast::EnumDef,
 ) -> P<ast::Expr> {
    let arms: Vec<ast::Arm> = enum_def.variants.iter()
-        .map(|variant| {
+        .enumerate()
+        .map(|(variant_index, variant)| {
            serialize_variant(
                cx,
                builder,
@@ -251,6 +272,7 @@ fn serialize_item_enum(
                impl_generics,
                ty.clone(),
                variant,
+                variant_index,
            )
        })
        .collect();
@@ -269,6 +291,7 @@ fn serialize_variant(
    generics: &ast::Generics,
    ty: P<ast::Ty>,
    variant: &ast::Variant,
+    variant_index: usize,
 ) -> ast::Arm {
    let type_name = builder.expr().str(type_ident);
    let variant_ident = variant.node.name;
@@ -282,14 +305,34 @@ fn serialize_variant(

            quote_arm!(cx,
                $pat => {
-                    ::serde::ser::Serializer::visit_enum_unit(
+                    ::serde::ser::Serializer::visit_unit_variant(
                        serializer,
                        $type_name,
+                        $variant_index,
                        $variant_name,
                    )
                }
            )
-        }
+        },
+        ast::TupleVariantKind(ref args) if args.len() == 1 => {
+            let field = builder.id("__simple_value");
+            let field = builder.pat().ref_id(field);
+            let pat = builder.pat().enum_()
+                .id(type_ident).id(variant_ident).build()
+                .with_pats(Some(field).into_iter())
+                .build();
+            quote_arm!(cx,
+                $pat => {
+                    ::serde::ser::Serializer::visit_newtype_variant(
+                        serializer,
+                        $type_name,
+                        $variant_index,
+                        $variant_name,
+                        __simple_value,
+                    )
+                }
+            )
+        },
        ast::TupleVariantKind(ref args) => {
            let fields: Vec<ast::Ident> = (0 .. args.len())
                .map(|i| builder.id(format!("__field{}", i)))
@@ -304,6 +347,7 @@ fn serialize_variant(
                cx,
                builder,
                type_name,
+                variant_index,
                variant_name,
                generics,
                ty,
@@ -340,6 +384,7 @@ fn serialize_variant(
                cx,
                builder,
                type_name,
+                variant_index,
                variant_name,
                generics,
                ty,
@@ -356,6 +401,7 @@ fn serialize_tuple_variant(
    cx: &ExtCtxt,
    builder: &aster::AstBuilder,
    type_name: P<ast::Expr>,
+    variant_index: usize,
    variant_name: P<ast::Expr>,
    generics: &ast::Generics,
    structure_ty: P<ast::Ty>,
@@ -376,7 +422,7 @@ fn serialize_tuple_variant(
    let (visitor_struct, visitor_impl) = serialize_tuple_struct_visitor(
        cx,
        builder,
-        structure_ty,
+        structure_ty.clone(),
        variant_ty,
        args.len(),
        generics,
@@ -385,9 +431,7 @@ fn serialize_tuple_variant(
    let value_expr = builder.expr().tuple()
        .with_exprs(
            fields.iter().map(|field| {
-                builder.expr()
-                    .addr_of()
-                    .id(field)
+                builder.expr().id(field)
            })
        )
        .build();
@@ -395,10 +439,10 @@ fn serialize_tuple_variant(
    quote_expr!(cx, {
        $visitor_struct
        $visitor_impl
-        serializer.visit_enum_seq($type_name, $variant_name, Visitor {
+        serializer.visit_tuple_variant($type_name, $variant_index, $variant_name, Visitor {
            value: $value_expr,
            state: 0,
-            _structure_ty: ::std::marker::PhantomData,
+            _structure_ty: ::std::marker::PhantomData::<&$structure_ty>,
        })
    })
 }
@@ -407,6 +451,7 @@ fn serialize_struct_variant(
    cx: &ExtCtxt,
    builder: &aster::AstBuilder,
    type_name: P<ast::Expr>,
+    variant_index: usize,
    variant_name: P<ast::Expr>,
    generics: &ast::Generics,
    structure_ty: P<ast::Ty>,
@@ -427,9 +472,7 @@ fn serialize_struct_variant(
    let value_expr = builder.expr().tuple()
        .with_exprs(
            fields.iter().map(|field| {
-                builder.expr()
-                    .addr_of()
-                    .id(field)
+                builder.expr().id(field)
            })
        )
        .build();
@@ -437,7 +480,7 @@ fn serialize_struct_variant(
    let (visitor_struct, visitor_impl) = serialize_struct_visitor(
        cx,
        builder,
-        structure_ty,
+        structure_ty.clone(),
        value_ty,
        struct_def,
        generics,
@@ -451,10 +494,10 @@ fn serialize_struct_variant(
    quote_expr!(cx, {
        $visitor_struct
        $visitor_impl
-        serializer.visit_enum_map($type_name, $variant_name, Visitor {
+        serializer.visit_struct_variant($type_name, $variant_index, $variant_name, Visitor {
            value: $value_expr,
            state: 0,
-            _structure_ty: ::std::marker::PhantomData,
+            _structure_ty: ::std::marker::PhantomData::<&$structure_ty>,
        })
    })
 }
@@ -476,7 +519,7 @@ fn serialize_tuple_struct_visitor(
            quote_arm!(cx,
                $i => {
                    self.state += 1;
-                    let v = try!(serializer.visit_seq_elt(&$expr));
+                    let v = try!(serializer.visit_tuple_struct_elt(&$expr));
                    Ok(Some(v))
                }
            )
@@ -494,19 +537,12 @@ fn serialize_tuple_struct_visitor(
        .strip_bounds()
        .build();

-    // Variants don't necessarily reference all generic lifetimes and type parameters,
-    // so to avoid a compilation failure, we'll just add a phantom type to capture these
-    // unused values.
-    let structure_ty = builder.ty()
-        .phantom_data()
-        .build(structure_ty);
-
    (
        quote_item!(cx,
            struct Visitor $visitor_impl_generics $where_clause {
                state: usize,
                value: $variant_ty,
-                _structure_ty: $structure_ty,
+                _structure_ty: ::std::marker::PhantomData<&'__a $structure_ty>,
            }
        ).unwrap(),

@@ -544,12 +580,16 @@ fn serialize_struct_visitor<I>(
 ) -> (P<ast::Item>, P<ast::Item>)
    where I: Iterator<Item=P<ast::Expr>>,
 {
-    let len = struct_def.fields.len();
-
    let field_attrs = struct_field_attrs(cx, builder, struct_def);

+    let len = struct_def.fields.len() - field_attrs.iter()
+        .fold(0, |sum, field| {
+            sum + if field.skip_serializing_field() { 1 } else { 0 }
+        });
+
    let arms: Vec<ast::Arm> = field_attrs.into_iter()
        .zip(value_exprs)
+        .filter(|&(ref field, _)| !field.skip_serializing_field())
        .enumerate()
        .map(|(i, (field, value_expr))| {
            let key_expr = field.serializer_key_expr(cx);
@@ -559,7 +599,7 @@ fn serialize_struct_visitor<I>(
                    Ok(
                        Some(
                            try!(
-                                serializer.visit_map_elt(
+                                serializer.visit_struct_elt(
                                    $key_expr,
                                    $value_expr,
                                )
@@ -582,19 +622,12 @@ fn serialize_struct_visitor<I>(
        .strip_bounds()
        .build();

-    // Variants don't necessarily reference all generic lifetimes and type parameters,
-    // so to avoid a compilation failure, we'll just add a phantom type to capture these
-    // unused values.
-    let structure_ty = builder.ty()
-        .phantom_data()
-        .build(structure_ty);
-
    (
        quote_item!(cx,
            struct Visitor $visitor_impl_generics $where_clause {
                state: usize,
                value: $variant_ty,
-                _structure_ty: $structure_ty,
+                _structure_ty: ::std::marker::PhantomData<&'__a $structure_ty>,
            }
        ).unwrap(),

@@ -1,10 +1,12 @@
 [package]
 name = "serde_macros"
-version = "0.4.1"
+version = "0.5.3"
 authors = ["Erick Tryzelaar <erick.tryzelaar@gmail.com>"]
 license = "MIT/Apache-2.0"
 description = "Macros to auto-generate implementations for the serde framework"
-repository = "https://github.com/erickt/rust-serde"
+repository = "https://github.com/serde-rs/serde"
+documentation = "https://github.com/serde-rs/serde"
+keywords = ["serde", "serialization"]

 [lib]
 name = "serde_macros"
@@ -16,4 +18,4 @@ serde_codegen = { version = "*", path = "../serde_codegen", default-features = f
 [dev-dependencies]
 num = "*"
 rustc-serialize = "*"
-serde = { version = "*", path = "../serde" }
+serde = { version = "*", path = "../serde", features = ["nightly"] }
@@ -1,64 +0,0 @@
-#![feature(custom_derive, plugin)]
-#![plugin(serde_macros)]
-
-extern crate serde;
-
-use std::collections::BTreeMap;
-use serde::json;
-
-// Creating serializable types with serde is quite simple with `serde_macros`. It implements a
-// syntax extension that automatically generates the necessary serde trait implementations.
-#[derive(Debug, Serialize, Deserialize)]
-struct Point {
-    x: i32,
-    y: i32,
-}
-
-fn main() {
-    let point = Point { x: 5, y: 6 };
-
-    // Serializing to JSON is pretty simple by using the `to_string` method:
-    let serialized_point = json::to_string(&point).unwrap();
-
-    println!("{}", serialized_point);
-    // prints:
-    //
-    // {"x":5,"y":6}
-
-    // There is also support for pretty printing using `to_string_pretty`:
-    let serialized_point = json::to_string_pretty(&point).unwrap();
-
-    println!("{}", serialized_point);
-    // prints:
-    //
-    // {
-    //   "x":5,
-    //   "y":6
-    // }
-
-    // Values can also be deserialized with the same style using `from_str`:
-    let deserialized_point: Point = json::from_str(&serialized_point).unwrap();
-
-    println!("{:?}", deserialized_point);
-    // prints:
-    //
-    // Point { x: 5, y: 6 }
-
-    // `Point`s aren't the only type that can be serialized to. Because `Point` members have the
-    // same type, they can be also serialized into a map. Also, 
-    let deserialized_map: BTreeMap<String, i64> = json::from_str(&serialized_point).unwrap();
-
-    println!("{:?}", deserialized_map);
-    // prints:
-    //
-    // {"x": 5, "y": 6}
-
-    // If you need to accept arbitrary data, you can also deserialize into `json::Value`, which
-    // can represent all JSON values.
-    let deserialized_value: json::Value = json::from_str(&serialized_point).unwrap();
-
-    println!("{:?}", deserialized_value);
-    // prints:
-    //
-    // {"x":5,"y":6}
-}
@@ -1,6 +1,6 @@
 [package]
 name = "serde_tests"
-version = "0.4.1"
+version = "0.5.0"
 authors = ["Erick Tryzelaar <erick.tryzelaar@gmail.com>"]
 license = "MIT/Apache-2.0"
 description = "A generic serialization/deserialization framework"
@@ -11,7 +11,7 @@ keywords = ["serialization"]
 build = "build.rs"

 [build-dependencies]
-syntex = { version = "*", optional = true }
+syntex = { version = "*" }
 syntex_syntax = { version = "*" }
 serde_codegen = { version = "*", path = "../serde_codegen", features = ["with-syntex"] }

@@ -1,5 +1,4 @@
 mod bench_enum;
-mod bench_log;
 mod bench_map;
 mod bench_struct;
 mod bench_vec;
@@ -20,13 +20,13 @@ pub enum Error {
 }

 impl serde::de::Error for Error {
-    fn syntax_error() -> Error { Error::SyntaxError }
+    fn syntax(_: &str) -> Error { Error::SyntaxError }

-    fn end_of_stream_error() -> Error { Error::EndOfStreamError }
+    fn end_of_stream() -> Error { Error::EndOfStreamError }

-    fn unknown_field_error(_: &str) -> Error { Error::SyntaxError }
+    fn unknown_field(_: &str) -> Error { Error::SyntaxError }

-    fn missing_field_error(_: &'static str) -> Error { Error::SyntaxError }
+    fn missing_field(_: &'static str) -> Error { Error::SyntaxError }
 }

 //////////////////////////////////////////////////////////////////////////////
@@ -288,7 +288,10 @@ mod deserializer {
        }

        #[inline]
-        fn visit_enum<V>(&mut self, _name: &str, mut visitor: V) -> Result<V::Value, Error>
+        fn visit_enum<V>(&mut self,
+                         _name: &str,
+                         _variants: &[&str],
+                         mut visitor: V) -> Result<V::Value, Error>
            where V: de::EnumVisitor,
        {
            match self.stack.pop() {
@@ -350,7 +353,9 @@ mod deserializer {
            de::Deserialize::deserialize(self.de)
        }

-        fn visit_seq<V>(&mut self, mut visitor: V) -> Result<V::Value, Error>
+        fn visit_tuple<V>(&mut self,
+                          _len: usize,
+                          mut visitor: V) -> Result<V::Value, Error>
            where V: de::Visitor,
        {
            visitor.visit_seq(self)
@@ -17,13 +17,13 @@ pub enum Error {
 }

 impl serde::de::Error for Error {
-    fn syntax_error() -> Error { Error::SyntaxError }
+    fn syntax(_: &str) -> Error { Error::SyntaxError }

-    fn end_of_stream_error() -> Error { Error::EndOfStream }
+    fn end_of_stream() -> Error { Error::EndOfStream }

-    fn unknown_field_error(_: &str) -> Error { Error::SyntaxError }
+    fn unknown_field(_: &str) -> Error { Error::SyntaxError }

-    fn missing_field_error(_: &'static str) -> Error {
+    fn missing_field(_: &'static str) -> Error {
        Error::MissingField
    }
 }
@@ -347,17 +347,17 @@ mod deserializer {

    impl de::Deserializer<Error> for IsizeDeserializer {
        #[inline]
-        fn end_of_stream_error(&mut self) -> Error {
+        fn end_of_stream(&mut self) -> Error {
            EndOfStream
        }

        #[inline]
-        fn syntax_error(&mut self, _token: de::Token, _expected: &[de::TokenKind]) -> Error {
+        fn syntax(&mut self, _token: de::Token, _expected: &[de::TokenKind]) -> Error {
            SyntaxError
        }

        #[inline]
-        fn unexpected_name_error(&mut self, _token: de::Token) -> Error {
+        fn unexpected_name(&mut self, _token: de::Token) -> Error {
            SyntaxError
        }

@@ -417,14 +417,14 @@ fn bench_decoder_100(b: &mut Bencher) {
    })
 }

-fn run_deserializer<
-    D: Deserializer<Error=E>,
-    E: Debug,
-    T: Clone + PartialEq + Debug + Deserialize
->(mut d: D, value: T) {
-    let v: T = Deserialize::deserialize(&mut d).unwrap();
+fn run_deserializer<D, T>(mut d: D, value: T)
+    where D: Deserializer,
+          D::Error: Debug + PartialEq,
+          T: Clone + PartialEq + Debug + Deserialize
+{
+    let v = T::deserialize(&mut d);

-    assert_eq!(value, v);
+    assert_eq!(Ok(value), v);
 }

 #[bench]
@@ -33,13 +33,13 @@ pub enum Error {
 }

 impl serde::de::Error for Error {
-    fn syntax_error() -> Error { Error::SyntaxError }
+    fn syntax(_: &str) -> Error { Error::SyntaxError }

-    fn end_of_stream_error() -> Error { Error::EndOfStream }
+    fn end_of_stream() -> Error { Error::EndOfStream }

-    fn unknown_field_error(_: &str) -> Error { Error::SyntaxError }
+    fn unknown_field(_: &str) -> Error { Error::SyntaxError }

-    fn missing_field_error(_: &'static str) -> Error {
+    fn missing_field(_: &'static str) -> Error {
        Error::MissingField
    }
 }
@@ -398,7 +398,10 @@ mod deserializer {
            }
        }

-        fn visit_named_map<V>(&mut self, name: &str, mut visitor: V) -> Result<V::Value, Error>
+        fn visit_struct<V>(&mut self,
+                           name: &str,
+                           _fields: &'static [&'static str],
+                           mut visitor: V) -> Result<V::Value, Error>
            where V: de::Visitor,
        {
            match self.stack.pop() {
@@ -15,13 +15,13 @@ pub enum Error {
 }

 impl serde::de::Error for Error {
-    fn syntax_error() -> Error { Error::SyntaxError }
+    fn syntax(_: &str) -> Error { Error::SyntaxError }

-    fn end_of_stream_error() -> Error { Error::EndOfStreamError }
+    fn end_of_stream() -> Error { Error::EndOfStreamError }

-    fn unknown_field_error(_: &str) -> Error { Error::SyntaxError }
+    fn unknown_field(_: &str) -> Error { Error::SyntaxError }

-    fn missing_field_error(_: &'static str) -> Error { Error::SyntaxError }
+    fn missing_field(_: &'static str) -> Error { Error::SyntaxError }
 }

 //////////////////////////////////////////////////////////////////////////////
@@ -504,14 +504,14 @@ fn run_decoder<
    assert_eq!(Ok(value), v);
 }

-fn run_deserializer<
-    D: Deserializer<Error=E>,
-    E: Debug,
-    T: Clone + PartialEq + Debug + Deserialize
->(mut d: D, value: T) {
-    let v: T = Deserialize::deserialize(&mut d).unwrap();
+fn run_deserializer<D, T>(mut d: D, value: T)
+    where D: Deserializer,
+          D::Error: Debug + PartialEq,
+          T: Clone + PartialEq + Debug + Deserialize
+{
+    let v = T::deserialize(&mut d);

-    assert_eq!(value, v);
+    assert_eq!(Ok(value), v);
 }

 #[bench]
@@ -0,0 +1,79 @@
+#[macro_export]
+macro_rules! declare_ser_tests {
+    ($($name:ident { $($value:expr => $tokens:expr,)+ })+) => {
+        $(
+            #[test]
+            fn $name() {
+                $(
+                    ::token::assert_ser_tokens(&$value, $tokens);
+                )+
+            }
+        )+
+    }
+}
+
+#[macro_export]
+macro_rules! btreemap {
+    () => {
+        BTreeMap::new()
+    };
+    ($($key:expr => $value:expr),+) => {
+        {
+            let mut map = BTreeMap::new();
+            $(map.insert($key, $value);)+
+            map
+        }
+    }
+}
+
+macro_rules! btreeset {
+    () => {
+        BTreeSet::new()
+    };
+    ($($value:expr),+) => {
+        {
+            let mut set = BTreeSet::new();
+            $(set.insert($value);)+
+            set
+        }
+    }
+}
+
+macro_rules! btreemap {
+    () => {
+        BTreeMap::new()
+    };
+    ($($key:expr => $value:expr),+) => {
+        {
+            let mut map = BTreeMap::new();
+            $(map.insert($key, $value);)+
+            map
+        }
+    }
+}
+
+macro_rules! hashset {
+    () => {
+        HashSet::new()
+    };
+    ($($value:expr),+) => {
+        {
+            let mut set = HashSet::new();
+            $(set.insert($value);)+
+            set
+        }
+    }
+}
+
+macro_rules! hashmap {
+    () => {
+        HashMap::new()
+    };
+    ($($key:expr => $value:expr),+) => {
+        {
+            let mut map = HashMap::new();
+            $(map.insert($key, $value);)+
+            map
+        }
+    }
+}
@@ -1,11 +1,10 @@
-/*
+#[macro_use]
+mod macros;
+
+mod token;
+
 mod test_annotations;
 mod test_bytes;
 mod test_de;
-mod test_json;
-mod test_json_builder;
-*/
 mod test_macros;
-/*
 mod test_ser;
-*/
@@ -1,4 +1,6 @@
-use serde::json;
+use std::default;
+
+use token::{Token, assert_tokens, assert_ser_tokens, assert_de_tokens};

 #[derive(Debug, PartialEq, Serialize, Deserialize)]
 struct Default {
@@ -17,7 +19,7 @@ struct Rename {
 #[derive(Debug, PartialEq, Serialize, Deserialize)]
 struct FormatRename {
    a1: i32,
-    #[serde(rename(xml= "a4", json="a5"))]
+    #[serde(rename(xml= "a4", token="a5"))]
    a2: i32,
 }

@@ -25,49 +27,145 @@ struct FormatRename {
 enum SerEnum<A> {
    Map {
        a: i8,
-        #[serde(rename(xml= "c", json="d"))]
+        #[serde(rename(xml= "c", token="d"))]
        b: A,
    },
 }

+#[derive(Debug, PartialEq, Deserialize, Serialize)]
+struct SkipSerializingFields<A: default::Default> {
+    a: i8,
+    #[serde(skip_serializing, default)]
+    b: A,
+}

 #[test]
 fn test_default() {
-    let deserialized_value: Default = json::from_str(&"{\"a1\":1,\"a2\":2}").unwrap();
-    assert_eq!(deserialized_value, Default { a1: 1, a2: 2 });
+    assert_de_tokens(
+        &Default { a1: 1, a2: 2 },
+        vec![
+            Token::StructStart("Default", Some(2)),

-    let deserialized_value: Default = json::from_str(&"{\"a1\":1}").unwrap();
-    assert_eq!(deserialized_value, Default { a1: 1, a2: 0 });
+            Token::MapSep,
+            Token::Str("a1"),
+            Token::I32(1),
+
+            Token::MapSep,
+            Token::Str("a2"),
+            Token::I32(2),
+
+            Token::MapEnd,
+        ]
+    );
+
+    assert_de_tokens(
+        &Default { a1: 1, a2: 0 },
+        vec![
+            Token::StructStart("Default", Some(1)),
+
+            Token::MapSep,
+            Token::Str("a1"),
+            Token::I32(1),
+
+            Token::MapEnd,
+        ]
+    );
 }

 #[test]
 fn test_rename() {
-    let value = Rename { a1: 1, a2: 2 };
-    let serialized_value = json::to_string(&value).unwrap();
-    assert_eq!(serialized_value, "{\"a1\":1,\"a3\":2}");
+    assert_tokens(
+        &Rename { a1: 1, a2: 2 },
+        vec![
+            Token::StructStart("Rename", Some(2)),

-    let deserialized_value: Rename = json::from_str(&serialized_value).unwrap();
-    assert_eq!(value, deserialized_value);
+            Token::MapSep,
+            Token::Str("a1"),
+            Token::I32(1),
+
+            Token::MapSep,
+            Token::Str("a3"),
+            Token::I32(2),
+
+            Token::MapEnd,
+        ]
+    );
 }

 #[test]
 fn test_format_rename() {
-    let value = FormatRename { a1: 1, a2: 2 };
-    let serialized_value = json::to_string(&value).unwrap();
-    assert_eq!(serialized_value, "{\"a1\":1,\"a5\":2}");
+    assert_tokens(
+        &FormatRename { a1: 1, a2: 2 },
+        vec![
+            Token::StructStart("FormatRename", Some(2)),

-    let deserialized_value = json::from_str("{\"a1\":1,\"a5\":2}").unwrap();
-    assert_eq!(value, deserialized_value);
+            Token::MapSep,
+            Token::Str("a1"),
+            Token::I32(1),
+
+            Token::MapSep,
+            Token::Str("a5"),
+            Token::I32(2),
+
+            Token::MapEnd,
+        ]
+    );
 }

 #[test]
 fn test_enum_format_rename() {
-    let s1 = String::new();
-    let value = SerEnum::Map { a: 0i8, b: s1 };
-    let serialized_value = json::to_string(&value).unwrap();
-    let ans = "{\"Map\":{\"a\":0,\"d\":\"\"}}";
-    assert_eq!(serialized_value, ans);
+    assert_tokens(
+        &SerEnum::Map {
+            a: 0,
+            b: String::new(),
+        },
+        vec![
+            Token::EnumMapStart("SerEnum", "Map", Some(2)),

-    let deserialized_value = json::from_str(ans).unwrap();
-    assert_eq!(value, deserialized_value);
+            Token::MapSep,
+            Token::Str("a"),
+            Token::I8(0),
+
+            Token::MapSep,
+            Token::Str("d"),
+            Token::Str(""),
+
+            Token::MapEnd,
+        ]
+    );
+}
+
+#[test]
+fn test_skip_serializing_fields() {
+    assert_ser_tokens(
+        &SkipSerializingFields {
+            a: 1,
+            b: 2,
+        },
+        &[
+            Token::StructStart("SkipSerializingFields", Some(1)),
+
+            Token::MapSep,
+            Token::Str("a"),
+            Token::I8(1),
+
+            Token::MapEnd,
+        ]
+    );
+
+    assert_de_tokens(
+        &SkipSerializingFields {
+            a: 1,
+            b: 0,
+        },
+        vec![
+            Token::StructStart("SkipSerializingFields", Some(1)),
+
+            Token::MapSep,
+            Token::Str("a"),
+            Token::I8(1),
+
+            Token::MapEnd,
+        ]
+    );
 }
@@ -1,7 +1,6 @@
 use serde;
 use serde::Serialize;
 use serde::bytes::{ByteBuf, Bytes};
-use serde::json;

 ///////////////////////////////////////////////////////////////////////////////

@@ -9,13 +8,13 @@ use serde::json;
 struct Error;

 impl serde::de::Error for Error {
-    fn syntax_error() -> Error { Error }
+    fn syntax(_: &str) -> Error { Error }

-    fn end_of_stream_error() -> Error { Error }
+    fn end_of_stream() -> Error { Error }

-    fn unknown_field_error(_field: &str) -> Error { Error }
+    fn unknown_field(_field: &str) -> Error { Error }

-    fn missing_field_error(_field: &'static str) -> Error { Error }
+    fn missing_field(_field: &'static str) -> Error { Error }
 }

 ///////////////////////////////////////////////////////////////////////////////
@@ -140,17 +139,6 @@ impl serde::Deserializer for BytesDeserializer {

 ///////////////////////////////////////////////////////////////////////////////

-#[test]
-fn test_bytes_ser_json() {
-    let buf = vec![];
-    let bytes = Bytes::from(&buf);
-    assert_eq!(json::to_string(&bytes).unwrap(), "[]".to_string());
-
-    let buf = vec![1, 2, 3];
-    let bytes = Bytes::from(&buf);
-    assert_eq!(json::to_string(&bytes).unwrap(), "[1,2,3]".to_string());
-}
-
 #[test]
 fn test_bytes_ser_bytes() {
    let buf = vec![];
@@ -164,39 +152,8 @@ fn test_bytes_ser_bytes() {
    bytes.serialize(&mut ser).unwrap();
 }

-#[test]
-fn test_byte_buf_ser_json() {
-    let bytes = ByteBuf::new();
-    assert_eq!(json::to_string(&bytes).unwrap(), "[]".to_string());
-
-    let bytes = ByteBuf::from(vec![1, 2, 3]);
-    assert_eq!(json::to_string(&bytes).unwrap(), "[1,2,3]".to_string());
-}
-
-#[test]
-fn test_byte_buf_ser_bytes() {
-    let bytes = ByteBuf::new();
-    let mut ser = BytesSerializer::new(vec![]);
-    bytes.serialize(&mut ser).unwrap();
-
-    let bytes = ByteBuf::from(vec![1, 2, 3]);
-    let mut ser = BytesSerializer::new(vec![1, 2, 3]);
-    bytes.serialize(&mut ser).unwrap();
-}
-
 ///////////////////////////////////////////////////////////////////////////////

-#[test]
-fn test_byte_buf_de_json() {
-    let bytes = ByteBuf::new();
-    let v: ByteBuf = json::from_str("[]").unwrap();
-    assert_eq!(v, bytes);
-
-    let bytes = ByteBuf::from(vec![1, 2, 3]);
-    let v: ByteBuf = json::from_str("[1, 2, 3]").unwrap();
-    assert_eq!(v, bytes);
-}
-
 #[test]
 fn test_byte_buf_de_bytes() {
    let mut de = BytesDeserializer::new(vec![]);
@@ -1,346 +1,19 @@
 use std::collections::{BTreeMap, BTreeSet, HashMap, HashSet};
-use std::iter;
-use std::vec;

-use serde::de::{self, Deserialize, Deserializer, Visitor};
+use serde::de::{Deserializer, Visitor};

-#[derive(Debug)]
-enum Token {
-    Bool(bool),
-    Isize(isize),
-    I8(i8),
-    I16(i16),
-    I32(i32),
-    I64(i64),
-    Usize(usize),
-    U8(u8),
-    U16(u16),
-    U32(u32),
-    U64(u64),
-    F32(f32),
-    F64(f64),
-    Char(char),
-    Str(&'static str),
-    String(String),
-
-    Option(bool),
-
-    Name(&'static str),
-
-    Unit,
-
-    SeqStart(usize),
-    SeqSep,
-    SeqEnd,
-
-    MapStart(usize),
-    MapSep,
-    MapEnd,
-
-    EnumStart(&'static str),
-    EnumEnd,
-}
-
-struct TokenDeserializer {
-    tokens: iter::Peekable<vec::IntoIter<Token>>,
-}
-
-impl<'a> TokenDeserializer {
-    fn new(tokens: Vec<Token>) -> TokenDeserializer {
-        TokenDeserializer {
-            tokens: tokens.into_iter().peekable(),
-        }
-    }
-}
-
-#[derive(Clone, PartialEq, Debug)]
-enum Error {
-    SyntaxError,
-    EndOfStreamError,
-    UnknownFieldError(String),
-    MissingFieldError(&'static str),
-    InvalidName(&'static str),
-}
-
-impl de::Error for Error {
-    fn syntax_error() -> Error { Error::SyntaxError }
-
-    fn end_of_stream_error() -> Error { Error::EndOfStreamError }
-
-    fn unknown_field_error(field: &str) -> Error {
-        Error::UnknownFieldError(field.to_string())
-    }
-
-    fn missing_field_error(field: &'static str) -> Error {
-        Error::MissingFieldError(field)
-    }
-}
-
-impl Deserializer for TokenDeserializer {
-    type Error = Error;
-
-    fn visit<V>(&mut self, mut visitor: V) -> Result<V::Value, Error>
-        where V: Visitor,
-    {
-        match self.tokens.next() {
-            Some(Token::Bool(v)) => visitor.visit_bool(v),
-            Some(Token::Isize(v)) => visitor.visit_isize(v),
-            Some(Token::I8(v)) => visitor.visit_i8(v),
-            Some(Token::I16(v)) => visitor.visit_i16(v),
-            Some(Token::I32(v)) => visitor.visit_i32(v),
-            Some(Token::I64(v)) => visitor.visit_i64(v),
-            Some(Token::Usize(v)) => visitor.visit_usize(v),
-            Some(Token::U8(v)) => visitor.visit_u8(v),
-            Some(Token::U16(v)) => visitor.visit_u16(v),
-            Some(Token::U32(v)) => visitor.visit_u32(v),
-            Some(Token::U64(v)) => visitor.visit_u64(v),
-            Some(Token::F32(v)) => visitor.visit_f32(v),
-            Some(Token::F64(v)) => visitor.visit_f64(v),
-            Some(Token::Char(v)) => visitor.visit_char(v),
-            Some(Token::Str(v)) => visitor.visit_str(v),
-            Some(Token::String(v)) => visitor.visit_string(v),
-            Some(Token::Option(false)) => visitor.visit_none(),
-            Some(Token::Option(true)) => visitor.visit_some(self),
-            Some(Token::Unit) => visitor.visit_unit(),
-            Some(Token::SeqStart(len)) => {
-                visitor.visit_seq(TokenDeserializerSeqVisitor {
-                    de: self,
-                    len: len,
-                })
-            }
-            Some(Token::MapStart(len)) => {
-                visitor.visit_map(TokenDeserializerMapVisitor {
-                    de: self,
-                    len: len,
-                })
-            }
-            Some(Token::Name(_)) => self.visit(visitor),
-            Some(_) => Err(Error::SyntaxError),
-            None => Err(Error::EndOfStreamError),
-        }
-    }
-
-    /// Hook into `Option` deserializing so we can treat `Unit` as a
-    /// `None`, or a regular value as `Some(value)`.
-    fn visit_option<V>(&mut self, mut visitor: V) -> Result<V::Value, Error>
-        where V: Visitor,
-    {
-        match self.tokens.peek() {
-            Some(&Token::Option(false)) => {
-                self.tokens.next();
-                visitor.visit_none()
-            }
-            Some(&Token::Option(true)) => {
-                self.tokens.next();
-                visitor.visit_some(self)
-            }
-            Some(&Token::Unit) => {
-                self.tokens.next();
-                visitor.visit_none()
-            }
-            Some(_) => visitor.visit_some(self),
-            None => Err(Error::EndOfStreamError),
-        }
-    }
-
-    fn visit_enum<V>(&mut self, name: &str, mut visitor: V) -> Result<V::Value, Error>
-        where V: de::EnumVisitor,
-    {
-        match self.tokens.next() {
-            Some(Token::EnumStart(n)) => {
-                if name == n {
-                    visitor.visit(TokenDeserializerVariantVisitor {
-                        de: self,
-                    })
-                } else {
-                    Err(Error::SyntaxError)
-                }
-            }
-            Some(_) => Err(Error::SyntaxError),
-            None => Err(Error::EndOfStreamError),
-        }
-    }
-
-    fn visit_named_unit<V>(&mut self, name: &str, visitor: V) -> Result<V::Value, Error>
-        where V: de::Visitor,
-    {
-        match self.tokens.peek() {
-            Some(&Token::Name(n)) => {
-                if name == n {
-                    self.tokens.next();
-                    self.visit_seq(visitor)
-                } else {
-                    Err(Error::InvalidName(n))
-                }
-            }
-            Some(_) => self.visit(visitor),
-            None => Err(Error::EndOfStreamError),
-        }
-    }
-
-    fn visit_named_seq<V>(&mut self, name: &str, visitor: V) -> Result<V::Value, Error>
-        where V: de::Visitor,
-    {
-        match self.tokens.peek() {
-            Some(&Token::Name(n)) => {
-                if name == n {
-                    self.tokens.next();
-                    self.visit_seq(visitor)
-                } else {
-                    Err(Error::InvalidName(n))
-                }
-            }
-            Some(_) => self.visit_seq(visitor),
-            None => Err(Error::EndOfStreamError),
-        }
-    }
-
-    fn visit_named_map<V>(&mut self, name: &str, visitor: V) -> Result<V::Value, Error>
-        where V: de::Visitor,
-    {
-        match self.tokens.peek() {
-            Some(&Token::Name(n)) => {
-                if name == n {
-                    self.tokens.next();
-                    self.visit_map(visitor)
-                } else {
-                    Err(Error::InvalidName(n))
-                }
-            }
-            Some(_) => self.visit_map(visitor),
-            None => Err(Error::EndOfStreamError),
-        }
-    }
-}
-
-//////////////////////////////////////////////////////////////////////////
-
-struct TokenDeserializerSeqVisitor<'a> {
-    de: &'a mut TokenDeserializer,
-    len: usize,
-}
-
-impl<'a> de::SeqVisitor for TokenDeserializerSeqVisitor<'a> {
-    type Error = Error;
-
-    fn visit<T>(&mut self) -> Result<Option<T>, Error>
-        where T: Deserialize,
-    {
-        match self.de.tokens.peek() {
-            Some(&Token::SeqSep) => {
-                self.len -= 1;
-                self.de.tokens.next();
-                Ok(Some(try!(Deserialize::deserialize(self.de))))
-            }
-            Some(&Token::SeqEnd) => Ok(None),
-            Some(_) => {
-                Err(Error::SyntaxError)
-            }
-            None => Err(Error::EndOfStreamError),
-        }
-    }
-
-    fn end(&mut self) -> Result<(), Error> {
-        assert_eq!(self.len, 0);
-        match self.de.tokens.next() {
-            Some(Token::SeqEnd) => Ok(()),
-            Some(_) => Err(Error::SyntaxError),
-            None => Err(Error::EndOfStreamError),
-        }
-    }
-
-    fn size_hint(&self) -> (usize, Option<usize>) {
-        (self.len, Some(self.len))
-    }
-}
-
-//////////////////////////////////////////////////////////////////////////
-
-struct TokenDeserializerMapVisitor<'a> {
-    de: &'a mut TokenDeserializer,
-    len: usize,
-}
-
-impl<'a> de::MapVisitor for TokenDeserializerMapVisitor<'a> {
-    type Error = Error;
-
-    fn visit_key<K>(&mut self) -> Result<Option<K>, Error>
-        where K: Deserialize,
-    {
-        match self.de.tokens.peek() {
-            Some(&Token::MapSep) => {
-                self.de.tokens.next();
-                self.len -= 1;
-                Ok(Some(try!(Deserialize::deserialize(self.de))))
-            }
-            Some(&Token::MapEnd) => Ok(None),
-            Some(_) => Err(Error::SyntaxError),
-            None => Err(Error::EndOfStreamError),
-        }
-    }
-
-    fn visit_value<V>(&mut self) -> Result<V, Error>
-        where V: Deserialize,
-    {
-        Ok(try!(Deserialize::deserialize(self.de)))
-    }
-
-    fn end(&mut self) -> Result<(), Error> {
-        assert_eq!(self.len, 0);
-        match self.de.tokens.next() {
-            Some(Token::MapEnd) => Ok(()),
-            Some(_) => Err(Error::SyntaxError),
-            None => Err(Error::EndOfStreamError),
-        }
-    }
-
-    fn size_hint(&self) -> (usize, Option<usize>) {
-        (self.len, Some(self.len))
-    }
-}
-
-//////////////////////////////////////////////////////////////////////////
-
-struct TokenDeserializerVariantVisitor<'a> {
-    de: &'a mut TokenDeserializer,
-}
-
-impl<'a> de::VariantVisitor for TokenDeserializerVariantVisitor<'a> {
-    type Error = Error;
-
-    fn visit_variant<V>(&mut self) -> Result<V, Error>
-        where V: de::Deserialize,
-    {
-        de::Deserialize::deserialize(self.de)
-    }
-
-    fn visit_unit(&mut self) -> Result<(), Error> {
-        de::Deserialize::deserialize(self.de)
-    }
-
-    fn visit_seq<V>(&mut self, visitor: V) -> Result<V::Value, Error>
-        where V: de::Visitor,
-    {
-        de::Deserializer::visit(self.de, visitor)
-    }
-
-    fn visit_map<V>(&mut self, visitor: V) -> Result<V::Value, Error>
-        where V: de::Visitor,
-    {
-        de::Deserializer::visit(self.de, visitor)
-    }
-}
+use token::{Token, assert_de_tokens};

 //////////////////////////////////////////////////////////////////////////

 #[derive(Copy, Clone, PartialEq, Debug, Deserialize)]
-struct NamedUnit;
+struct UnitStruct;

 #[derive(PartialEq, Debug, Deserialize)]
-struct NamedSeq(i32, i32, i32);
+struct TupleStruct(i32, i32, i32);

 #[derive(PartialEq, Debug, Deserialize)]
-struct NamedMap {
+struct Struct {
    a: i32,
    b: i32,
    c: i32,
@@ -349,72 +22,19 @@ struct NamedMap {
 #[derive(PartialEq, Debug, Deserialize)]
 enum Enum {
    Unit,
+    Simple(i32),
    Seq(i32, i32, i32),
    Map { a: i32, b: i32, c: i32 }
 }

 //////////////////////////////////////////////////////////////////////////

-macro_rules! btreeset {
-    () => {
-        BTreeSet::new()
-    };
-    ($($value:expr),+) => {
-        {
-            let mut set = BTreeSet::new();
-            $(set.insert($value);)+
-            set
-        }
-    }
-}
-
-macro_rules! btreemap {
-    () => {
-        BTreeMap::new()
-    };
-    ($($key:expr => $value:expr),+) => {
-        {
-            let mut map = BTreeMap::new();
-            $(map.insert($key, $value);)+
-            map
-        }
-    }
-}
-
-macro_rules! hashset {
-    () => {
-        HashSet::new()
-    };
-    ($($value:expr),+) => {
-        {
-            let mut set = HashSet::new();
-            $(set.insert($value);)+
-            set
-        }
-    }
-}
-
-macro_rules! hashmap {
-    () => {
-        HashMap::new()
-    };
-    ($($key:expr => $value:expr),+) => {
-        {
-            let mut map = HashMap::new();
-            $(map.insert($key, $value);)+
-            map
-        }
-    }
-}
-
 macro_rules! declare_test {
    ($name:ident { $($value:expr => $tokens:expr,)+ }) => {
        #[test]
        fn $name() {
            $(
-                let mut de = TokenDeserializer::new($tokens);
-                let value: Result<_, Error> = Deserialize::deserialize(&mut de);
-                assert_eq!(value, Ok($value));
+                assert_de_tokens(&$value, $tokens);
            )+
        }
    }
@@ -486,32 +106,50 @@ declare_tests! {
            Token::I32(1),
        ],
    }
+    test_result {
+        Ok::<i32, i32>(0) => vec![
+            Token::EnumStart("Result"),
+            Token::Str("Ok"),
+            Token::I32(0),
+        ],
+        Err::<i32, i32>(1) => vec![
+            Token::EnumStart("Result"),
+            Token::Str("Err"),
+            Token::I32(1),
+        ],
+    }
    test_unit {
        () => vec![Token::Unit],
        () => vec![
-            Token::SeqStart(0),
+            Token::SeqStart(Some(0)),
            Token::SeqEnd,
        ],
        () => vec![
-            Token::Name("Anything"),
-            Token::SeqStart(0),
+            Token::SeqStart(None),
+            Token::SeqEnd,
+        ],
+        () => vec![
+            Token::TupleStructStart("Anything", Some(0)),
            Token::SeqEnd,
        ],
    }
-    test_named_unit {
-        NamedUnit => vec![Token::Unit],
-        NamedUnit => vec![
-            Token::Name("NamedUnit"),
-            Token::Unit,
+    test_unit_struct {
+        UnitStruct => vec![Token::Unit],
+        UnitStruct => vec![
+            Token::UnitStruct("UnitStruct"),
        ],
-        NamedUnit => vec![
-            Token::SeqStart(0),
+        UnitStruct => vec![
+            Token::SeqStart(Some(0)),
+            Token::SeqEnd,
+        ],
+        UnitStruct => vec![
+            Token::SeqStart(None),
            Token::SeqEnd,
        ],
    }
-    test_named_seq {
-        NamedSeq(1, 2, 3) => vec![
-            Token::SeqStart(3),
+    test_tuple_struct {
+        TupleStruct(1, 2, 3) => vec![
+            Token::SeqStart(Some(3)),
                Token::SeqSep,
                Token::I32(1),

@@ -522,9 +160,32 @@ declare_tests! {
                Token::I32(3),
            Token::SeqEnd,
        ],
-        NamedSeq(1, 2, 3) => vec![
-            Token::Name("NamedSeq"),
-            Token::SeqStart(3),
+        TupleStruct(1, 2, 3) => vec![
+            Token::SeqStart(None),
+                Token::SeqSep,
+                Token::I32(1),
+
+                Token::SeqSep,
+                Token::I32(2),
+
+                Token::SeqSep,
+                Token::I32(3),
+            Token::SeqEnd,
+        ],
+        TupleStruct(1, 2, 3) => vec![
+            Token::TupleStructStart("TupleStruct", Some(3)),
+                Token::SeqSep,
+                Token::I32(1),
+
+                Token::SeqSep,
+                Token::I32(2),
+
+                Token::SeqSep,
+                Token::I32(3),
+            Token::SeqEnd,
+        ],
+        TupleStruct(1, 2, 3) => vec![
+            Token::TupleStructStart("TupleStruct", None),
                Token::SeqSep,
                Token::I32(1),

@@ -541,23 +202,23 @@ declare_tests! {
            Token::Unit,
        ],
        BTreeSet::<isize>::new() => vec![
-            Token::SeqStart(0),
+            Token::SeqStart(Some(0)),
            Token::SeqEnd,
        ],
        btreeset![btreeset![], btreeset![1], btreeset![2, 3]] => vec![
-            Token::SeqStart(3),
+            Token::SeqStart(Some(3)),
                Token::SeqSep,
-                Token::SeqStart(0),
+                Token::SeqStart(Some(0)),
                Token::SeqEnd,

                Token::SeqSep,
-                Token::SeqStart(1),
+                Token::SeqStart(Some(1)),
                    Token::SeqSep,
                    Token::I32(1),
                Token::SeqEnd,

                Token::SeqSep,
-                Token::SeqStart(2),
+                Token::SeqStart(Some(2)),
                    Token::SeqSep,
                    Token::I32(2),

@@ -567,12 +228,10 @@ declare_tests! {
            Token::SeqEnd,
        ],
        BTreeSet::<isize>::new() => vec![
-            Token::Name("Anything"),
-            Token::Unit,
+            Token::UnitStruct("Anything"),
        ],
        BTreeSet::<isize>::new() => vec![
-            Token::Name("Anything"),
-            Token::SeqStart(0),
+            Token::TupleStructStart("Anything", Some(0)),
            Token::SeqEnd,
        ],
    }
@@ -581,11 +240,11 @@ declare_tests! {
            Token::Unit,
        ],
        HashSet::<isize>::new() => vec![
-            Token::SeqStart(0),
+            Token::SeqStart(Some(0)),
            Token::SeqEnd,
        ],
        hashset![1, 2, 3] => vec![
-            Token::SeqStart(3),
+            Token::SeqStart(Some(3)),
                Token::SeqSep,
                Token::I32(1),

@@ -597,12 +256,10 @@ declare_tests! {
            Token::SeqEnd,
        ],
        HashSet::<isize>::new() => vec![
-            Token::Name("Anything"),
-            Token::Unit,
+            Token::UnitStruct("Anything"),
        ],
        HashSet::<isize>::new() => vec![
-            Token::Name("Anything"),
-            Token::SeqStart(0),
+            Token::TupleStructStart("Anything", Some(0)),
            Token::SeqEnd,
        ],
    }
@@ -611,23 +268,23 @@ declare_tests! {
            Token::Unit,
        ],
        Vec::<isize>::new() => vec![
-            Token::SeqStart(0),
+            Token::SeqStart(Some(0)),
            Token::SeqEnd,
        ],
        vec![vec![], vec![1], vec![2, 3]] => vec![
-            Token::SeqStart(3),
+            Token::SeqStart(Some(3)),
                Token::SeqSep,
-                Token::SeqStart(0),
+                Token::SeqStart(Some(0)),
                Token::SeqEnd,

                Token::SeqSep,
-                Token::SeqStart(1),
+                Token::SeqStart(Some(1)),
                    Token::SeqSep,
                    Token::I32(1),
                Token::SeqEnd,

                Token::SeqSep,
-                Token::SeqStart(2),
+                Token::SeqStart(Some(2)),
                    Token::SeqSep,
                    Token::I32(2),

@@ -637,12 +294,10 @@ declare_tests! {
            Token::SeqEnd,
        ],
        Vec::<isize>::new() => vec![
-            Token::Name("Anything"),
-            Token::Unit,
+            Token::UnitStruct("Anything"),
        ],
        Vec::<isize>::new() => vec![
-            Token::Name("Anything"),
-            Token::SeqStart(0),
+            Token::TupleStructStart("Anything", Some(0)),
            Token::SeqEnd,
        ],
    }
@@ -651,23 +306,23 @@ declare_tests! {
            Token::Unit,
        ],
        [0; 0] => vec![
-            Token::SeqStart(0),
+            Token::SeqStart(Some(0)),
            Token::SeqEnd,
        ],
        ([0; 0], [1], [2, 3]) => vec![
-            Token::SeqStart(3),
+            Token::SeqStart(Some(3)),
                Token::SeqSep,
-                Token::SeqStart(0),
+                Token::SeqStart(Some(0)),
                Token::SeqEnd,

                Token::SeqSep,
-                Token::SeqStart(1),
+                Token::SeqStart(Some(1)),
                    Token::SeqSep,
                    Token::I32(1),
                Token::SeqEnd,

                Token::SeqSep,
-                Token::SeqStart(2),
+                Token::SeqStart(Some(2)),
                    Token::SeqSep,
                    Token::I32(2),

@@ -677,24 +332,22 @@ declare_tests! {
            Token::SeqEnd,
        ],
        [0; 0] => vec![
-            Token::Name("Anything"),
-            Token::Unit,
+            Token::UnitStruct("Anything"),
        ],
        [0; 0] => vec![
-            Token::Name("Anything"),
-            Token::SeqStart(0),
+            Token::TupleStructStart("Anything", Some(0)),
            Token::SeqEnd,
        ],
    }
    test_tuple {
        (1,) => vec![
-            Token::SeqStart(1),
+            Token::SeqStart(Some(1)),
                Token::SeqSep,
                Token::I32(1),
            Token::SeqEnd,
        ],
        (1, 2, 3) => vec![
-            Token::SeqStart(3),
+            Token::SeqStart(Some(3)),
                Token::SeqSep,
                Token::I32(1),

@@ -711,18 +364,18 @@ declare_tests! {
            Token::Unit,
        ],
        BTreeMap::<isize, isize>::new() => vec![
-            Token::MapStart(0),
+            Token::MapStart(Some(0)),
            Token::MapEnd,
        ],
        btreemap![1 => 2] => vec![
-            Token::MapStart(1),
+            Token::MapStart(Some(1)),
                Token::MapSep,
                Token::I32(1),
                Token::I32(2),
            Token::MapEnd,
        ],
        btreemap![1 => 2, 3 => 4] => vec![
-            Token::MapStart(2),
+            Token::MapStart(Some(2)),
                Token::MapSep,
                Token::I32(1),
                Token::I32(2),
@@ -733,15 +386,15 @@ declare_tests! {
            Token::MapEnd,
        ],
        btreemap![1 => btreemap![], 2 => btreemap![3 => 4, 5 => 6]] => vec![
-            Token::MapStart(2),
+            Token::MapStart(Some(2)),
                Token::MapSep,
                Token::I32(1),
-                Token::MapStart(0),
+                Token::MapStart(Some(0)),
                Token::MapEnd,

                Token::MapSep,
                Token::I32(2),
-                Token::MapStart(2),
+                Token::MapStart(Some(2)),
                    Token::MapSep,
                    Token::I32(3),
                    Token::I32(4),
@@ -753,12 +406,10 @@ declare_tests! {
            Token::MapEnd,
        ],
        BTreeMap::<isize, isize>::new() => vec![
-            Token::Name("Anything"),
-            Token::Unit,
+            Token::UnitStruct("Anything"),
        ],
        BTreeMap::<isize, isize>::new() => vec![
-            Token::Name("Anything"),
-            Token::MapStart(0),
+            Token::StructStart("Anything", Some(0)),
            Token::MapEnd,
        ],
    }
@@ -767,18 +418,18 @@ declare_tests! {
            Token::Unit,
        ],
        HashMap::<isize, isize>::new() => vec![
-            Token::MapStart(0),
+            Token::MapStart(Some(0)),
            Token::MapEnd,
        ],
        hashmap![1 => 2] => vec![
-            Token::MapStart(1),
+            Token::MapStart(Some(1)),
                Token::MapSep,
                Token::I32(1),
                Token::I32(2),
            Token::MapEnd,
        ],
        hashmap![1 => 2, 3 => 4] => vec![
-            Token::MapStart(2),
+            Token::MapStart(Some(2)),
                Token::MapSep,
                Token::I32(1),
                Token::I32(2),
@@ -789,15 +440,15 @@ declare_tests! {
            Token::MapEnd,
        ],
        hashmap![1 => hashmap![], 2 => hashmap![3 => 4, 5 => 6]] => vec![
-            Token::MapStart(2),
+            Token::MapStart(Some(2)),
                Token::MapSep,
                Token::I32(1),
-                Token::MapStart(0),
+                Token::MapStart(Some(0)),
                Token::MapEnd,

                Token::MapSep,
                Token::I32(2),
-                Token::MapStart(2),
+                Token::MapStart(Some(2)),
                    Token::MapSep,
                    Token::I32(3),
                    Token::I32(4),
@@ -809,18 +460,16 @@ declare_tests! {
            Token::MapEnd,
        ],
        HashMap::<isize, isize>::new() => vec![
-            Token::Name("Anything"),
-            Token::Unit,
+            Token::UnitStruct("Anything"),
        ],
        HashMap::<isize, isize>::new() => vec![
-            Token::Name("Anything"),
-            Token::MapStart(0),
+            Token::StructStart("Anything", Some(0)),
            Token::MapEnd,
        ],
    }
-    test_named_map {
-        NamedMap { a: 1, b: 2, c: 3 } => vec![
-            Token::MapStart(3),
+    test_struct {
+        Struct { a: 1, b: 2, c: 3 } => vec![
+            Token::MapStart(Some(3)),
                Token::MapSep,
                Token::Str("a"),
                Token::I32(1),
@@ -834,9 +483,8 @@ declare_tests! {
                Token::I32(3),
            Token::MapEnd,
        ],
-        NamedMap { a: 1, b: 2, c: 3 } => vec![
-            Token::Name("NamedMap"),
-            Token::MapStart(3),
+        Struct { a: 1, b: 2, c: 3 } => vec![
+            Token::StructStart("Struct", Some(3)),
                Token::MapSep,
                Token::Str("a"),
                Token::I32(1),
@@ -853,47 +501,58 @@ declare_tests! {
    }
    test_enum_unit {
        Enum::Unit => vec![
-            Token::EnumStart("Enum"),
-                Token::Str("Unit"),
-                Token::Unit,
-            Token::EnumEnd,
+            Token::EnumUnit("Enum", "Unit"),
+        ],
+    }
+    test_enum_simple {
+        Enum::Simple(1) => vec![
+            Token::EnumNewtype("Enum", "Simple"),
+            Token::I32(1),
        ],
    }
    test_enum_seq {
        Enum::Seq(1, 2, 3) => vec![
-            Token::EnumStart("Enum"),
-                Token::Str("Seq"),
-                Token::SeqStart(3),
-                    Token::SeqSep,
-                    Token::I32(1),
+            Token::EnumSeqStart("Enum", "Seq", Some(3)),
+                Token::SeqSep,
+                Token::I32(1),

-                    Token::SeqSep,
-                    Token::I32(2),
+                Token::SeqSep,
+                Token::I32(2),

-                    Token::SeqSep,
-                    Token::I32(3),
-                Token::SeqEnd,
-            Token::EnumEnd,
+                Token::SeqSep,
+                Token::I32(3),
+            Token::SeqEnd,
        ],
    }
    test_enum_map {
        Enum::Map { a: 1, b: 2, c: 3 } => vec![
+            Token::EnumMapStart("Enum", "Map", Some(3)),
+                Token::MapSep,
+                Token::Str("a"),
+                Token::I32(1),
+
+                Token::MapSep,
+                Token::Str("b"),
+                Token::I32(2),
+
+                Token::MapSep,
+                Token::Str("c"),
+                Token::I32(3),
+            Token::MapEnd,
+        ],
+    }
+    test_enum_unit_usize {
+        Enum::Unit => vec![
            Token::EnumStart("Enum"),
-                Token::Str("Map"),
-                Token::MapStart(3),
-                    Token::MapSep,
-                    Token::Str("a"),
-                    Token::I32(1),
-
-                    Token::MapSep,
-                    Token::Str("b"),
-                    Token::I32(2),
-
-                    Token::MapSep,
-                    Token::Str("c"),
-                    Token::I32(3),
-                Token::MapEnd,
-            Token::EnumEnd,
+            Token::Usize(0),
+            Token::Unit,
+        ],
+    }
+    test_enum_unit_bytes {
+        Enum::Unit => vec![
+            Token::EnumStart("Enum"),
+            Token::Bytes(b"Unit"),
+            Token::Unit,
        ],
    }
 }
@@ -1,50 +0,0 @@
-use std::collections::BTreeMap;
-
-use serde::json::value::Value;
-use serde::json::builder::{ArrayBuilder, ObjectBuilder};
-
-#[test]
-fn test_array_builder() {
-    let value = ArrayBuilder::new().unwrap();
-    assert_eq!(value, Value::Array(Vec::new()));
-
-    let value = ArrayBuilder::new()
-        .push(1)
-        .push(2)
-        .push(3)
-        .unwrap();
-    assert_eq!(value, Value::Array(vec!(Value::U64(1), Value::U64(2), Value::U64(3))));
-
-    let value = ArrayBuilder::new()
-        .push_array(|bld| bld.push(1).push(2).push(3))
-        .unwrap();
-    assert_eq!(value, Value::Array(vec!(Value::Array(vec!(Value::U64(1), Value::U64(2), Value::U64(3))))));
-
-    let value = ArrayBuilder::new()
-        .push_object(|bld|
-            bld
-                .insert("a".to_string(), 1)
-                .insert("b".to_string(), 2))
-        .unwrap();
-
-    let mut map = BTreeMap::new();
-    map.insert("a".to_string(), Value::U64(1));
-    map.insert("b".to_string(), Value::U64(2));
-    assert_eq!(value, Value::Array(vec!(Value::Object(map))));
-}
-
-#[test]
-fn test_object_builder() {
-    let value = ObjectBuilder::new().unwrap();
-    assert_eq!(value, Value::Object(BTreeMap::new()));
-
-    let value = ObjectBuilder::new()
-        .insert("a".to_string(), 1)
-        .insert("b".to_string(), 2)
-        .unwrap();
-
-    let mut map = BTreeMap::new();
-    map.insert("a".to_string(), Value::U64(1));
-    map.insert("b".to_string(), Value::U64(2));
-    assert_eq!(value, Value::Object(map));
-}
@@ -1,18 +1,4 @@
-use std::collections::BTreeMap;
-use serde::json::{self, Value};
-
-macro_rules! btreemap {
-    () => {
-        BTreeMap::new()
-    };
-    ($($key:expr => $value:expr),+) => {
-        {
-            let mut map = BTreeMap::new();
-            $(map.insert($key, $value);)+
-            map
-        }
-    }
-}
+use token::{Token, assert_tokens, assert_ser_tokens, assert_de_tokens};

 /*
 trait Trait {
@@ -83,7 +69,7 @@ enum SerEnum<'a, B: 'a, C: /* Trait + */ 'a, D> where D: /* Trait + */ 'a {
    },
 }

-#[derive(Debug, PartialEq, Deserialize)]
+#[derive(Debug, PartialEq, Serialize, Deserialize)]
 enum DeEnum<B, C: /* Trait */, D> /* where D: Trait */ {
    Unit,
    Seq(
@@ -131,25 +117,31 @@ enum Lifetimes<'a> {
    NoLifetimeMap { a: i32 },
 }

+#[derive(Debug, PartialEq, Serialize, Deserialize)]
+pub struct GenericStruct<T> {
+    x: T,
+}
+
+#[derive(Debug, PartialEq, Serialize, Deserialize)]
+pub struct GenericNewtypeStruct<T>(T);
+
+#[derive(Debug, PartialEq, Serialize, Deserialize)]
+pub struct GenericTupleStruct<T, U>(T, U);
+
+#[derive(Debug, PartialEq, Serialize, Deserialize)]
+pub enum GenericEnum<T, U> {
+    Unit,
+    Newtype(T),
+    Seq(T, U),
+    Map { x: T, y: U },
+}
+
 #[test]
 fn test_named_unit() {
-    let named_unit = NamedUnit;
-
-    assert_eq!(
-        json::to_string(&named_unit).unwrap(),
-        "null".to_string()
+    assert_tokens(
+        &NamedUnit,
+        vec![Token::UnitStruct("NamedUnit")]
    );
-
-    assert_eq!(
-        json::to_value(&named_unit),
-        Value::Null
-    );
-
-    let v: NamedUnit = json::from_str("null").unwrap();
-    assert_eq!(v, named_unit);
-
-    let v: NamedUnit = json::from_value(Value::Null).unwrap();
-    assert_eq!(v, named_unit);
 }

 #[test]
@@ -157,35 +149,41 @@ fn test_ser_named_tuple() {
    let a = 5;
    let mut b = 6;
    let c = 7;
-    let named_tuple = SerNamedTuple(&a, &mut b, c);
+    assert_ser_tokens(
+        &SerNamedTuple(&a, &mut b, c),
+        &[
+            Token::TupleStructStart("SerNamedTuple", Some(3)),
+            Token::SeqSep,
+            Token::I32(5),

-    assert_eq!(
-        json::to_string(&named_tuple).unwrap(),
-        "[5,6,7]"
-    );
+            Token::SeqSep,
+            Token::I32(6),

-    assert_eq!(
-        json::to_value(&named_tuple),
-        Value::Array(vec![Value::U64(5), Value::U64(6), Value::U64(7)])
+            Token::SeqSep,
+            Token::I32(7),
+
+            Token::SeqEnd,
+        ],
    );
 }

 #[test]
 fn test_de_named_tuple() {
-    let v: DeNamedTuple<i32, i32, i32> = json::from_str("[1,2,3]").unwrap();
-    assert_eq!(
-        v,
-        DeNamedTuple(1, 2, 3)
-    );
+    assert_de_tokens(
+        &DeNamedTuple(5, 6, 7),
+        vec![
+            Token::TupleStructStart("DeNamedTuple", Some(3)),
+            Token::SeqSep,
+            Token::I32(5),

-    let v: Value = json::from_str("[1,2,3]").unwrap();
-    assert_eq!(
-        v,
-        Value::Array(vec![
-            Value::U64(1),
-            Value::U64(2),
-            Value::U64(3),
-        ])
+            Token::SeqSep,
+            Token::I32(6),
+
+            Token::SeqSep,
+            Token::I32(7),
+
+            Token::SeqEnd,
+        ]
    );
 }

@@ -194,60 +192,68 @@ fn test_ser_named_map() {
    let a = 5;
    let mut b = 6;
    let c = 7;
-    let named_map = SerNamedMap {
-        a: &a,
-        b: &mut b,
-        c: c,
-    };

-    assert_eq!(
-        json::to_string(&named_map).unwrap(),
-        "{\"a\":5,\"b\":6,\"c\":7}"
-    );
+    assert_ser_tokens(
+        &SerNamedMap {
+            a: &a,
+            b: &mut b,
+            c: c,
+        },
+        &[
+            Token::StructStart("SerNamedMap", Some(3)),

-    assert_eq!(
-        json::to_value(&named_map),
-        Value::Object(btreemap![
-            "a".to_string() => Value::U64(5),
-            "b".to_string() => Value::U64(6),
-            "c".to_string() => Value::U64(7)
-        ])
+            Token::MapSep,
+            Token::Str("a"),
+            Token::I32(5),
+
+            Token::MapSep,
+            Token::Str("b"),
+            Token::I32(6),
+
+            Token::MapSep,
+            Token::Str("c"),
+            Token::I32(7),
+
+            Token::MapEnd,
+        ]
    );
 }

 #[test]
 fn test_de_named_map() {
-    let v = DeNamedMap {
-        a: 5,
-        b: 6,
-        c: 7,
-    };
+    assert_de_tokens(
+        &DeNamedMap {
+            a: 5,
+            b: 6,
+            c: 7,
+        },
+        vec![
+            Token::StructStart("DeNamedMap", Some(3)),

-    let v2: DeNamedMap<i32, i32, i32> = json::from_str(
-        "{\"a\":5,\"b\":6,\"c\":7}"
-    ).unwrap();
-    assert_eq!(v, v2);
+            Token::MapSep,
+            Token::Str("a"),
+            Token::I32(5),

-    let v2 = json::from_value(Value::Object(btreemap![
-        "a".to_string() => Value::U64(5),
-        "b".to_string() => Value::U64(6),
-        "c".to_string() => Value::U64(7)
-    ])).unwrap();
-    assert_eq!(v, v2);
+            Token::MapSep,
+            Token::Str("b"),
+            Token::I32(6),
+
+            Token::MapSep,
+            Token::Str("c"),
+            Token::I32(7),
+
+            Token::MapEnd,
+        ]
+    );
 }

 #[test]
 fn test_ser_enum_unit() {
-    assert_eq!(
-        json::to_string(&SerEnum::Unit::<u32, u32, u32>).unwrap(),
-        "{\"Unit\":[]}"
-    );
-
-    assert_eq!(
-        json::to_value(&SerEnum::Unit::<u32, u32, u32>),
-        Value::Object(btreemap!(
-            "Unit".to_string() => Value::Array(vec![]))
-        )
+    assert_ser_tokens(
+        &SerEnum::Unit::<u32, u32, u32>,
+        &[
+            Token::EnumUnit("SerEnum", "Unit"),
+        ]
    );
 }

@@ -260,37 +266,32 @@ fn test_ser_enum_seq() {
    let mut e = 5;
    //let f = 6;

-    assert_eq!(
-        json::to_string(&SerEnum::Seq(
+    assert_ser_tokens(
+        &SerEnum::Seq(
            a,
            b,
            &c,
            //d,
            &mut e,
            //f,
-        )).unwrap(),
-        "{\"Seq\":[1,2,3,5]}".to_string()
-    );
+        ),
+        &[
+            Token::EnumSeqStart("SerEnum", "Seq", Some(4)),

-    assert_eq!(
-        json::to_value(&SerEnum::Seq(
-            a,
-            b,
-            &c,
-            //d,
-            &mut e,
-            //e,
-        )),
-        Value::Object(btreemap!(
-            "Seq".to_string() => Value::Array(vec![
-                Value::U64(1),
-                Value::U64(2),
-                Value::U64(3),
-                //Value::U64(4),
-                Value::U64(5),
-                //Value::U64(6),
-            ])
-        ))
+            Token::SeqSep,
+            Token::I8(1),
+
+            Token::SeqSep,
+            Token::I32(2),
+
+            Token::SeqSep,
+            Token::I32(3),
+
+            Token::SeqSep,
+            Token::I32(5),
+
+            Token::SeqEnd,
+        ],
    );
 }

@@ -303,54 +304,46 @@ fn test_ser_enum_map() {
    let mut e = 5;
    //let f = 6;

-    assert_eq!(
-        json::to_string(&SerEnum::Map {
+    assert_ser_tokens(
+        &SerEnum::Map {
            a: a,
            b: b,
            c: &c,
            //d: d,
            e: &mut e,
            //f: f,
-        }).unwrap(),
-        "{\"Map\":{\"a\":1,\"b\":2,\"c\":3,\"e\":5}}".to_string()
-    );
+        },
+        &[
+            Token::EnumMapStart("SerEnum", "Map", Some(4)),

-    assert_eq!(
-        json::to_value(&SerEnum::Map {
-            a: a,
-            b: b,
-            c: &c,
-            //d: d,
-            e: &mut e,
-            //f: f,
-        }),
-        Value::Object(btreemap!(
-            "Map".to_string() => Value::Object(btreemap![
-                "a".to_string() => Value::U64(1),
-                "b".to_string() => Value::U64(2),
-                "c".to_string() => Value::U64(3),
-                //"d".to_string() => Value::U64(4)
-                "e".to_string() => Value::U64(5)
-                //"f".to_string() => Value::U64(6)
-            ])
-        ))
+            Token::MapSep,
+            Token::Str("a"),
+            Token::I8(1),
+
+            Token::MapSep,
+            Token::Str("b"),
+            Token::I32(2),
+
+            Token::MapSep,
+            Token::Str("c"),
+            Token::I32(3),
+
+            Token::MapSep,
+            Token::Str("e"),
+            Token::I32(5),
+
+            Token::MapEnd,
+        ],
    );
 }

 #[test]
 fn test_de_enum_unit() {
-    let v: DeEnum<_, _, _> = json::from_str("{\"Unit\":[]}").unwrap();
-    assert_eq!(
-        v,
-        DeEnum::Unit::<u32, u32, u32>
-    );
-
-    let v: DeEnum<_, _, _> = json::from_value(Value::Object(btreemap!(
-        "Unit".to_string() => Value::Array(vec![]))
-    )).unwrap();
-    assert_eq!(
-        v,
-        DeEnum::Unit::<u32, u32, u32>
+    assert_tokens(
+        &DeEnum::Unit::<u32, u32, u32>,
+        vec![
+            Token::EnumUnit("DeEnum", "Unit"),
+        ],
    );
 }

@@ -363,39 +356,32 @@ fn test_de_enum_seq() {
    let e = 5;
    //let f = 6;

-    let v: DeEnum<_, _, _> = json::from_str("{\"Seq\":[1,2,3,5]}").unwrap();
-    assert_eq!(
-        v,
-        DeEnum::Seq(
+    assert_tokens(
+        &DeEnum::Seq(
            a,
            b,
            c,
            //d,
            e,
            //f,
-        )
-    );
+        ),
+        vec![
+            Token::EnumSeqStart("DeEnum", "Seq", Some(4)),

-    let v: DeEnum<_, _, _> = json::from_value(Value::Object(btreemap!(
-        "Seq".to_string() => Value::Array(vec![
-            Value::U64(1),
-            Value::U64(2),
-            Value::U64(3),
-            //Value::U64(4),
-            Value::U64(5),
-            //Value::U64(6),
-        ])
-    ))).unwrap();
-    assert_eq!(
-        v,
-        DeEnum::Seq(
-            a,
-            b,
-            c,
-            //d,
-            e,
-            //e,
-        )
+            Token::SeqSep,
+            Token::I8(1),
+
+            Token::SeqSep,
+            Token::I32(2),
+
+            Token::SeqSep,
+            Token::I32(3),
+
+            Token::SeqSep,
+            Token::I32(5),
+
+            Token::SeqEnd,
+        ],
    );
 }

@@ -408,70 +394,186 @@ fn test_de_enum_map() {
    let e = 5;
    //let f = 6;

-    let v: DeEnum<_, _, _> = json::from_str(
-        "{\"Map\":{\"a\":1,\"b\":2,\"c\":3,\"e\":5}}"
-    ).unwrap();
-    assert_eq!(
-        v,
-        DeEnum::Map {
+    assert_tokens(
+        &DeEnum::Map {
            a: a,
            b: b,
            c: c,
            //d: d,
            e: e,
            //f: f,
-        }
-    );
+        },
+        vec![
+            Token::EnumMapStart("DeEnum", "Map", Some(4)),

-    let v: DeEnum<_, _, _> = json::from_value(Value::Object(btreemap!(
-        "Map".to_string() => Value::Object(btreemap![
-            "a".to_string() => Value::U64(1),
-            "b".to_string() => Value::U64(2),
-            "c".to_string() => Value::U64(3),
-            //"d".to_string() => Value::U64(4)
-            "e".to_string() => Value::U64(5)
-            //"f".to_string() => Value::U64(6)
-        ])
-    ))).unwrap();
+            Token::MapSep,
+            Token::Str("a"),
+            Token::I8(1),

-    assert_eq!(
-        v,
-        DeEnum::Map {
-            a: a,
-            b: b,
-            c: c,
-            //d: d,
-            e: e,
-            //f: f,
-        }
+            Token::MapSep,
+            Token::Str("b"),
+            Token::I32(2),
+
+            Token::MapSep,
+            Token::Str("c"),
+            Token::I32(3),
+
+            Token::MapSep,
+            Token::Str("e"),
+            Token::I32(5),
+
+            Token::MapEnd,
+        ],
    );
 }

 #[test]
 fn test_lifetimes() {
    let value = 5;
-    let lifetime = Lifetimes::LifetimeSeq(&value);
-    assert_eq!(
-        json::to_string(&lifetime).unwrap(),
-        "{\"LifetimeSeq\":[5]}"
+
+    assert_ser_tokens(
+        &Lifetimes::LifetimeSeq(&value),
+        &[
+            Token::EnumNewtype("Lifetimes", "LifetimeSeq"),
+            Token::I32(5),
+        ]
    );

-    let lifetime = Lifetimes::NoLifetimeSeq(5);
-    assert_eq!(
-        json::to_string(&lifetime).unwrap(),
-        "{\"NoLifetimeSeq\":[5]}"
+    assert_ser_tokens(
+        &Lifetimes::NoLifetimeSeq(5),
+        &[
+            Token::EnumNewtype("Lifetimes", "NoLifetimeSeq"),
+            Token::I32(5),
+        ]
    );

-    let value = 5;
-    let lifetime = Lifetimes::LifetimeMap { a: &value };
-    assert_eq!(
-        json::to_string(&lifetime).unwrap(),
-        "{\"LifetimeMap\":{\"a\":5}}"
+    assert_ser_tokens(
+        &Lifetimes::LifetimeMap { a: &value },
+        &[
+            Token::EnumMapStart("Lifetimes", "LifetimeMap", Some(1)),
+
+            Token::MapSep,
+            Token::Str("a"),
+            Token::I32(5),
+
+            Token::MapEnd,
+        ]
    );

-    let lifetime = Lifetimes::NoLifetimeMap { a: 5 };
-    assert_eq!(
-        json::to_string(&lifetime).unwrap(),
-        "{\"NoLifetimeMap\":{\"a\":5}}"
+    assert_ser_tokens(
+        &Lifetimes::NoLifetimeMap { a: 5 },
+        &[
+            Token::EnumMapStart("Lifetimes", "NoLifetimeMap", Some(1)),
+
+            Token::MapSep,
+            Token::Str("a"),
+            Token::I32(5),
+
+            Token::MapEnd,
+        ]
+    );
+}
+
+#[test]
+fn test_generic_struct() {
+    assert_tokens(
+        &GenericStruct { x: 5u32 },
+        vec![
+            Token::StructStart("GenericStruct", Some(1)),
+
+            Token::MapSep,
+            Token::Str("x"),
+            Token::U32(5),
+
+            Token::MapEnd,
+        ]
+    );
+}
+
+#[test]
+fn test_generic_newtype_struct() {
+    assert_tokens(
+        &GenericNewtypeStruct(5u32),
+        vec![
+            Token::StructNewtype("GenericNewtypeStruct"),
+            Token::U32(5),
+        ]
+    );
+}
+
+#[test]
+fn test_generic_tuple_struct() {
+    assert_tokens(
+        &GenericTupleStruct(5u32, 6u32),
+        vec![
+            Token::TupleStructStart("GenericTupleStruct", Some(2)),
+
+            Token::SeqSep,
+            Token::U32(5),
+
+            Token::SeqSep,
+            Token::U32(6),
+
+            Token::SeqEnd,
+        ]
+    );
+}
+
+#[test]
+fn test_generic_enum_unit() {
+    assert_tokens(
+        &GenericEnum::Unit::<u32, u32>,
+        vec![
+            Token::EnumUnit("GenericEnum", "Unit"),
+        ]
+    );
+}
+
+#[test]
+fn test_generic_enum_newtype() {
+    assert_tokens(
+        &GenericEnum::Newtype::<u32, u32>(5),
+        vec![
+            Token::EnumNewtype("GenericEnum", "Newtype"),
+            Token::U32(5),
+        ]
+    );
+}
+
+#[test]
+fn test_generic_enum_seq() {
+    assert_tokens(
+        &GenericEnum::Seq::<u32, u32>(5, 6),
+        vec![
+            Token::EnumSeqStart("GenericEnum", "Seq", Some(2)),
+
+            Token::SeqSep,
+            Token::U32(5),
+
+            Token::SeqSep,
+            Token::U32(6),
+
+            Token::SeqEnd,
+        ]
+    );
+}
+
+#[test]
+fn test_generic_enum_map() {
+    assert_tokens(
+        &GenericEnum::Map::<u32, u32> { x: 5, y: 6 },
+        vec![
+            Token::EnumMapStart("GenericEnum", "Map", Some(2)),
+
+            Token::MapSep,
+            Token::Str("x"),
+            Token::U32(5),
+
+            Token::MapSep,
+            Token::Str("y"),
+            Token::U32(6),
+
+            Token::MapEnd,
+        ]
    );
 }
@@ -1,274 +1,17 @@
-use std::vec;
 use std::collections::BTreeMap;

-use serde::ser::{Serialize, Serializer, SeqVisitor, MapVisitor};
-
-#[derive(Clone, PartialEq, Debug)]
-pub enum Token<'a> {
-    Bool(bool),
-    Isize(isize),
-    I8(i8),
-    I16(i16),
-    I32(i32),
-    I64(i64),
-    Usize(usize),
-    U8(u8),
-    U16(u16),
-    U32(u32),
-    U64(u64),
-    F32(f32),
-    F64(f64),
-    Char(char),
-    Str(&'a str),
-
-    Option(bool),
-
-    Unit,
-    NamedUnit(&'a str),
-    EnumUnit(&'a str, &'a str),
-
-    SeqStart(Option<usize>),
-    NamedSeqStart(&'a str, Option<usize>),
-    EnumSeqStart(&'a str, &'a str, Option<usize>),
-    SeqSep,
-    SeqEnd,
-
-    MapStart(Option<usize>),
-    NamedMapStart(&'a str, Option<usize>),
-    EnumMapStart(&'a str, &'a str, Option<usize>),
-    MapSep,
-    MapEnd,
-}
-
-struct AssertSerializer<'a> {
-    iter: vec::IntoIter<Token<'a>>,
-}
-
-impl<'a> AssertSerializer<'a> {
-    fn new(values: Vec<Token<'a>>) -> AssertSerializer {
-        AssertSerializer {
-            iter: values.into_iter(),
-        }
-    }
-
-    fn visit_sequence<V>(&mut self, mut visitor: V) -> Result<(), ()>
-        where V: SeqVisitor
-    {
-        while let Some(()) = try!(visitor.visit(self)) { }
-
-        assert_eq!(self.iter.next(), Some(Token::SeqEnd));
-
-        Ok(())
-    }
-
-    fn visit_mapping<V>(&mut self, mut visitor: V) -> Result<(), ()>
-        where V: MapVisitor
-    {
-        while let Some(()) = try!(visitor.visit(self)) { }
-
-        assert_eq!(self.iter.next(), Some(Token::MapEnd));
-
-        Ok(())
-    }
-}
-
-impl<'a> Serializer for AssertSerializer<'a> {
-    type Error = ();
-
-    fn visit_unit(&mut self) -> Result<(), ()> {
-        assert_eq!(self.iter.next(), Some(Token::Unit));
-        Ok(())
-    }
-
-    fn visit_named_unit(&mut self, name: &str) -> Result<(), ()> {
-        assert_eq!(self.iter.next().unwrap(), Token::NamedUnit(name));
-        Ok(())
-    }
-
-    fn visit_enum_unit(&mut self, name: &str, variant: &str) -> Result<(), ()> {
-        assert_eq!(self.iter.next().unwrap(), Token::EnumUnit(name, variant));
-        Ok(())
-    }
-
-    fn visit_bool(&mut self, v: bool) -> Result<(), ()> {
-        assert_eq!(self.iter.next(), Some(Token::Bool(v)));
-        Ok(())
-    }
-
-    fn visit_isize(&mut self, v: isize) -> Result<(), ()> {
-        assert_eq!(self.iter.next(), Some(Token::Isize(v)));
-        Ok(())
-    }
-
-    fn visit_i8(&mut self, v: i8) -> Result<(), ()> {
-        assert_eq!(self.iter.next(), Some(Token::I8(v)));
-        Ok(())
-    }
-
-    fn visit_i16(&mut self, v: i16) -> Result<(), ()> {
-        assert_eq!(self.iter.next(), Some(Token::I16(v)));
-        Ok(())
-    }
-
-    fn visit_i32(&mut self, v: i32) -> Result<(), ()> {
-        assert_eq!(self.iter.next(), Some(Token::I32(v)));
-        Ok(())
-    }
-
-    fn visit_i64(&mut self, v: i64) -> Result<(), ()> {
-        assert_eq!(self.iter.next(), Some(Token::I64(v)));
-        Ok(())
-    }
-
-    fn visit_usize(&mut self, v: usize) -> Result<(), ()> {
-        assert_eq!(self.iter.next(), Some(Token::Usize(v)));
-        Ok(())
-    }
-
-    fn visit_u8(&mut self, v: u8) -> Result<(), ()> {
-        assert_eq!(self.iter.next(), Some(Token::U8(v)));
-        Ok(())
-    }
-
-    fn visit_u16(&mut self, v: u16) -> Result<(), ()> {
-        assert_eq!(self.iter.next(), Some(Token::U16(v)));
-        Ok(())
-    }
-
-    fn visit_u32(&mut self, v: u32) -> Result<(), ()> {
-        assert_eq!(self.iter.next(), Some(Token::U32(v)));
-        Ok(())
-    }
-
-    fn visit_u64(&mut self, v: u64) -> Result<(), ()> {
-        assert_eq!(self.iter.next(), Some(Token::U64(v)));
-        Ok(())
-    }
-
-    fn visit_f32(&mut self, v: f32) -> Result<(), ()> {
-        assert_eq!(self.iter.next(), Some(Token::F32(v)));
-        Ok(())
-    }
-
-    fn visit_f64(&mut self, v: f64) -> Result<(), ()> {
-        assert_eq!(self.iter.next(), Some(Token::F64(v)));
-        Ok(())
-    }
-
-    fn visit_char(&mut self, v: char) -> Result<(), ()> {
-        assert_eq!(self.iter.next(), Some(Token::Char(v)));
-        Ok(())
-    }
-
-    fn visit_str(&mut self, v: &str) -> Result<(), ()> {
-        assert_eq!(self.iter.next().unwrap(), Token::Str(v));
-        Ok(())
-    }
-
-    fn visit_none(&mut self) -> Result<(), ()> {
-        assert_eq!(self.iter.next(), Some(Token::Option(false)));
-        Ok(())
-    }
-
-    fn visit_some<V>(&mut self, value: V) -> Result<(), ()>
-        where V: Serialize,
-    {
-        assert_eq!(self.iter.next(), Some(Token::Option(true)));
-        value.serialize(self)
-    }
-
-
-    fn visit_seq<V>(&mut self, visitor: V) -> Result<(), ()>
-        where V: SeqVisitor
-    {
-        let len = visitor.len();
-
-        assert_eq!(self.iter.next(), Some(Token::SeqStart(len)));
-
-        self.visit_sequence(visitor)
-    }
-
-    fn visit_named_seq<V>(&mut self, name: &str, visitor: V) -> Result<(), ()>
-        where V: SeqVisitor
-    {
-        let len = visitor.len();
-
-        assert_eq!(self.iter.next().unwrap(), Token::NamedSeqStart(name, len));
-
-        self.visit_sequence(visitor)
-    }
-
-    fn visit_enum_seq<V>(&mut self,
-                         name: &str,
-                         variant: &str,
-                         visitor: V) -> Result<(), ()>
-        where V: SeqVisitor
-    {
-        let len = visitor.len();
-
-        assert_eq!(self.iter.next().unwrap(), Token::EnumSeqStart(name, variant, len));
-
-        self.visit_sequence(visitor)
-    }
-
-    fn visit_seq_elt<T>(&mut self, value: T) -> Result<(), ()>
-        where T: Serialize
-    {
-        assert_eq!(self.iter.next(), Some(Token::SeqSep));
-        value.serialize(self)
-    }
-
-    fn visit_map<V>(&mut self, visitor: V) -> Result<(), ()>
-        where V: MapVisitor
-    {
-        let len = visitor.len();
-
-        assert_eq!(self.iter.next(), Some(Token::MapStart(len)));
-
-        self.visit_mapping(visitor)
-    }
-
-    fn visit_named_map<V>(&mut self, name: &str, visitor: V) -> Result<(), ()>
-        where V: MapVisitor
-    {
-        let len = visitor.len();
-
-        assert_eq!(self.iter.next().unwrap(), Token::NamedMapStart(name, len));
-
-        self.visit_mapping(visitor)
-    }
-
-    fn visit_enum_map<V>(&mut self, name: &str, variant: &str, visitor: V) -> Result<(), ()>
-        where V: MapVisitor
-    {
-        let len = visitor.len();
-
-        assert_eq!(self.iter.next().unwrap(), Token::EnumMapStart(name, variant, len));
-
-        self.visit_mapping(visitor)
-    }
-
-    fn visit_map_elt<K, V>(&mut self, key: K, value: V) -> Result<(), ()>
-        where K: Serialize,
-              V: Serialize,
-    {
-        assert_eq!(self.iter.next(), Some(Token::MapSep));
-
-        try!(key.serialize(self));
-        value.serialize(self)
-    }
-}
+use token::Token;

 //////////////////////////////////////////////////////////////////////////

 #[derive(Serialize)]
-struct NamedUnit;
+struct UnitStruct;

 #[derive(Serialize)]
-struct NamedSeq(i32, i32, i32);
+struct TupleStruct(i32, i32, i32);

 #[derive(Serialize)]
-struct NamedMap {
+struct Struct {
    a: i32,
    b: i32,
    c: i32,
@@ -277,91 +20,69 @@ struct NamedMap {
 #[derive(Serialize)]
 enum Enum {
    Unit,
+    One(i32),
    Seq(i32, i32),
    Map { a: i32, b: i32 },
 }

 //////////////////////////////////////////////////////////////////////////

-macro_rules! btreemap {
-    () => {
-        BTreeMap::new()
-    };
-    ($($key:expr => $value:expr),+) => {
-        {
-            let mut map = BTreeMap::new();
-            $(map.insert($key, $value);)+
-            map
-        }
-    }
-}
-
-macro_rules! declare_test {
-    ($name:ident { $($value:expr => $tokens:expr,)+ }) => {
-        #[test]
-        fn $name() {
-            $(
-                let mut ser = AssertSerializer::new($tokens);
-                assert_eq!($value.serialize(&mut ser), Ok(()));
-            )+
-        }
-    }
-}
-
-macro_rules! declare_tests {
-    ($($name:ident { $($value:expr => $tokens:expr,)+ })+) => {
-        $(
-            declare_test!($name { $($value => $tokens,)+ });
-        )+
-    }
-}
-
-declare_tests! {
+declare_ser_tests! {
    test_unit {
-        () => vec![Token::Unit],
+        () => &[Token::Unit],
    }
    test_bool {
-        true => vec![Token::Bool(true)],
-        false => vec![Token::Bool(false)],
+        true => &[Token::Bool(true)],
+        false => &[Token::Bool(false)],
    }
    test_isizes {
-        0isize => vec![Token::Isize(0)],
-        0i8 => vec![Token::I8(0)],
-        0i16 => vec![Token::I16(0)],
-        0i32 => vec![Token::I32(0)],
-        0i64 => vec![Token::I64(0)],
+        0isize => &[Token::Isize(0)],
+        0i8 => &[Token::I8(0)],
+        0i16 => &[Token::I16(0)],
+        0i32 => &[Token::I32(0)],
+        0i64 => &[Token::I64(0)],
    }
    test_usizes {
-        0usize => vec![Token::Usize(0)],
-        0u8 => vec![Token::U8(0)],
-        0u16 => vec![Token::U16(0)],
-        0u32 => vec![Token::U32(0)],
-        0u64 => vec![Token::U64(0)],
+        0usize => &[Token::Usize(0)],
+        0u8 => &[Token::U8(0)],
+        0u16 => &[Token::U16(0)],
+        0u32 => &[Token::U32(0)],
+        0u64 => &[Token::U64(0)],
    }
    test_floats {
-        0f32 => vec![Token::F32(0.)],
-        0f64 => vec![Token::F64(0.)],
+        0f32 => &[Token::F32(0.)],
+        0f64 => &[Token::F64(0.)],
    }
    test_char {
-        'a' => vec![Token::Char('a')],
+        'a' => &[Token::Char('a')],
    }
    test_str {
-        "abc" => vec![Token::Str("abc")],
-        "abc".to_string() => vec![Token::Str("abc")],
+        "abc" => &[Token::Str("abc")],
+        "abc".to_string() => &[Token::Str("abc")],
    }
    test_option {
-        None::<i32> => vec![Token::Option(false)],
-        Some(1) => vec![
+        None::<i32> => &[Token::Option(false)],
+        Some(1) => &[
            Token::Option(true),
            Token::I32(1),
        ],
    }
+    test_result {
+        Ok::<i32, i32>(0) => &[
+            Token::EnumNewtype("Result", "Ok"),
+            Token::I32(0),
+        ],
+        Err::<i32, i32>(1) => &[
+            Token::EnumNewtype("Result", "Err"),
+            Token::I32(1),
+        ],
+    }
    test_slice {
-        &[0][..0] => vec![
+        &[0][..0] => &[
            Token::SeqStart(Some(0)),
            Token::SeqEnd,
        ],
-        &[1, 2, 3][..] => vec![
+        &[1, 2, 3][..] => &[
            Token::SeqStart(Some(3)),
                Token::SeqSep,
                Token::I32(1),
@@ -375,11 +96,11 @@ declare_tests! {
        ],
    }
    test_array {
-        [0; 0] => vec![
+        [0; 0] => &[
            Token::SeqStart(Some(0)),
            Token::SeqEnd,
        ],
-        [1, 2, 3] => vec![
+        [1, 2, 3] => &[
            Token::SeqStart(Some(3)),
                Token::SeqSep,
                Token::I32(1),
@@ -393,11 +114,11 @@ declare_tests! {
        ],
    }
    test_vec {
-        Vec::<isize>::new() => vec![
+        Vec::<isize>::new() => &[
            Token::SeqStart(Some(0)),
            Token::SeqEnd,
        ],
-        vec![vec![], vec![1], vec![2, 3]] => vec![
+        vec![vec![], vec![1], vec![2, 3]] => &[
            Token::SeqStart(Some(3)),
                Token::SeqSep,
                Token::SeqStart(Some(0)),
@@ -421,13 +142,13 @@ declare_tests! {
        ],
    }
    test_tuple {
-        (1,) => vec![
+        (1,) => &[
            Token::SeqStart(Some(1)),
                Token::SeqSep,
                Token::I32(1),
            Token::SeqEnd,
        ],
-        (1, 2, 3) => vec![
+        (1, 2, 3) => &[
            Token::SeqStart(Some(3)),
                Token::SeqSep,
                Token::I32(1),
@@ -441,14 +162,14 @@ declare_tests! {
        ],
    }
    test_btreemap {
-        btreemap![1 => 2] => vec![
+        btreemap![1 => 2] => &[
            Token::MapStart(Some(1)),
                Token::MapSep,
                Token::I32(1),
                Token::I32(2),
            Token::MapEnd,
        ],
-        btreemap![1 => 2, 3 => 4] => vec![
+        btreemap![1 => 2, 3 => 4] => &[
            Token::MapStart(Some(2)),
                Token::MapSep,
                Token::I32(1),
@@ -459,7 +180,7 @@ declare_tests! {
                Token::I32(4),
            Token::MapEnd,
        ],
-        btreemap![1 => btreemap![], 2 => btreemap![3 => 4, 5 => 6]] => vec![
+        btreemap![1 => btreemap![], 2 => btreemap![3 => 4, 5 => 6]] => &[
            Token::MapStart(Some(2)),
                Token::MapSep,
                Token::I32(1),
@@ -480,12 +201,12 @@ declare_tests! {
            Token::MapEnd,
        ],
    }
-    test_named_unit {
-        NamedUnit => vec![Token::NamedUnit("NamedUnit")],
+    test_unit_struct {
+        UnitStruct => &[Token::UnitStruct("UnitStruct")],
    }
-    test_named_seq {
-        NamedSeq(1, 2, 3) => vec![
-            Token::NamedSeqStart("NamedSeq", Some(3)),
+    test_tuple_struct {
+        TupleStruct(1, 2, 3) => &[
+            Token::TupleStructStart("TupleStruct", Some(3)),
                Token::SeqSep,
                Token::I32(1),

@@ -497,9 +218,9 @@ declare_tests! {
            Token::SeqEnd,
        ],
    }
-    test_named_map {
-        NamedMap { a: 1, b: 2, c: 3 } => vec![
-            Token::NamedMapStart("NamedMap", Some(3)),
+    test_struct {
+        Struct { a: 1, b: 2, c: 3 } => &[
+            Token::StructStart("Struct", Some(3)),
                Token::MapSep,
                Token::Str("a"),
                Token::I32(1),
@@ -515,8 +236,9 @@ declare_tests! {
        ],
    }
    test_enum {
-        Enum::Unit => vec![Token::EnumUnit("Enum", "Unit")],
-        Enum::Seq(1, 2) => vec![
+        Enum::Unit => &[Token::EnumUnit("Enum", "Unit")],
+        Enum::One(42) => &[Token::EnumNewtype("Enum", "One"), Token::I32(42)],
+        Enum::Seq(1, 2) => &[
            Token::EnumSeqStart("Enum", "Seq", Some(2)),
                Token::SeqSep,
                Token::I32(1),
@@ -525,7 +247,7 @@ declare_tests! {
                Token::I32(2),
            Token::SeqEnd,
        ],
-        Enum::Map { a: 1, b: 2 } => vec![
+        Enum::Map { a: 1, b: 2 } => &[
            Token::EnumMapStart("Enum", "Map", Some(2)),
                Token::MapSep,
                Token::Str("a"),
@@ -0,0 +1,789 @@
+use std::fmt;
+use std::iter;
+
+use serde::{ser, de};
+use serde::de::value::{self, ValueDeserializer};
+
+#[derive(Clone, PartialEq, Debug)]
+pub enum Token<'a> {
+    Bool(bool),
+    Isize(isize),
+    I8(i8),
+    I16(i16),
+    I32(i32),
+    I64(i64),
+    Usize(usize),
+    U8(u8),
+    U16(u16),
+    U32(u32),
+    U64(u64),
+    F32(f32),
+    F64(f64),
+    Char(char),
+    Str(&'a str),
+    String(String),
+    Bytes(&'a [u8]),
+
+    Option(bool),
+
+    Unit,
+    UnitStruct(&'a str),
+
+    StructNewtype(&'a str),
+
+    EnumStart(&'a str),
+    EnumUnit(&'a str, &'a str),
+    EnumNewtype(&'a str, &'a str),
+    EnumSeqStart(&'a str, &'a str, Option<usize>),
+    EnumMapStart(&'a str, &'a str, Option<usize>),
+
+    SeqStart(Option<usize>),
+    TupleStructStart(&'a str, Option<usize>),
+    SeqSep,
+    SeqEnd,
+
+    MapStart(Option<usize>),
+    StructStart(&'a str, Option<usize>),
+    MapSep,
+    MapEnd,
+}
+
+//////////////////////////////////////////////////////////////////////////////
+
+pub struct Serializer<I> {
+    tokens: I,
+}
+
+impl<'a, I> Serializer<I>
+    where I: Iterator<Item=&'a Token<'a>>
+{
+    pub fn new(tokens: I) -> Serializer<I> {
+        Serializer {
+            tokens: tokens,
+        }
+    }
+
+    fn visit_sequence<V>(&mut self, mut visitor: V) -> Result<(), ()>
+        where V: ser::SeqVisitor
+    {
+        while let Some(()) = try!(visitor.visit(self)) { }
+
+        assert_eq!(self.tokens.next(), Some(&Token::SeqEnd));
+
+        Ok(())
+    }
+
+    fn visit_mapping<V>(&mut self, mut visitor: V) -> Result<(), ()>
+        where V: ser::MapVisitor
+    {
+        while let Some(()) = try!(visitor.visit(self)) { }
+
+        assert_eq!(self.tokens.next(), Some(&Token::MapEnd));
+
+        Ok(())
+    }
+}
+
+impl<'a, I> ser::Serializer for Serializer<I>
+    where I: Iterator<Item=&'a Token<'a>>,
+{
+    type Error = ();
+
+    fn visit_unit(&mut self) -> Result<(), ()> {
+        assert_eq!(self.tokens.next(), Some(&Token::Unit));
+        Ok(())
+    }
+
+    fn visit_newtype_variant<T>(&mut self,
+                                name: &str,
+                                _variant_index: usize,
+                                variant: &str,
+                                value: T) -> Result<(), ()>
+        where T: ser::Serialize,
+    {
+        assert_eq!(self.tokens.next(), Some(&Token::EnumNewtype(name, variant)));
+        value.serialize(self)
+    }
+
+    fn visit_unit_struct(&mut self, name: &str) -> Result<(), ()> {
+        assert_eq!(self.tokens.next(), Some(&Token::UnitStruct(name)));
+        Ok(())
+    }
+
+    fn visit_unit_variant(&mut self,
+                          name: &str,
+                          _variant_index: usize,
+                          variant: &str) -> Result<(), ()> {
+        assert_eq!(self.tokens.next(), Some(&Token::EnumUnit(name, variant)));
+
+        Ok(())
+    }
+
+    fn visit_bool(&mut self, v: bool) -> Result<(), ()> {
+        assert_eq!(self.tokens.next(), Some(&Token::Bool(v)));
+        Ok(())
+    }
+
+    fn visit_isize(&mut self, v: isize) -> Result<(), ()> {
+        assert_eq!(self.tokens.next(), Some(&Token::Isize(v)));
+        Ok(())
+    }
+
+    fn visit_i8(&mut self, v: i8) -> Result<(), ()> {
+        assert_eq!(self.tokens.next(), Some(&Token::I8(v)));
+        Ok(())
+    }
+
+    fn visit_i16(&mut self, v: i16) -> Result<(), ()> {
+        assert_eq!(self.tokens.next(), Some(&Token::I16(v)));
+        Ok(())
+    }
+
+    fn visit_i32(&mut self, v: i32) -> Result<(), ()> {
+        assert_eq!(self.tokens.next(), Some(&Token::I32(v)));
+        Ok(())
+    }
+
+    fn visit_i64(&mut self, v: i64) -> Result<(), ()> {
+        assert_eq!(self.tokens.next(), Some(&Token::I64(v)));
+        Ok(())
+    }
+
+    fn visit_usize(&mut self, v: usize) -> Result<(), ()> {
+        assert_eq!(self.tokens.next(), Some(&Token::Usize(v)));
+        Ok(())
+    }
+
+    fn visit_u8(&mut self, v: u8) -> Result<(), ()> {
+        assert_eq!(self.tokens.next(), Some(&Token::U8(v)));
+        Ok(())
+    }
+
+    fn visit_u16(&mut self, v: u16) -> Result<(), ()> {
+        assert_eq!(self.tokens.next(), Some(&Token::U16(v)));
+        Ok(())
+    }
+
+    fn visit_u32(&mut self, v: u32) -> Result<(), ()> {
+        assert_eq!(self.tokens.next(), Some(&Token::U32(v)));
+        Ok(())
+    }
+
+    fn visit_u64(&mut self, v: u64) -> Result<(), ()> {
+        assert_eq!(self.tokens.next(), Some(&Token::U64(v)));
+        Ok(())
+    }
+
+    fn visit_f32(&mut self, v: f32) -> Result<(), ()> {
+        assert_eq!(self.tokens.next(), Some(&Token::F32(v)));
+        Ok(())
+    }
+
+    fn visit_f64(&mut self, v: f64) -> Result<(), ()> {
+        assert_eq!(self.tokens.next(), Some(&Token::F64(v)));
+        Ok(())
+    }
+
+    fn visit_char(&mut self, v: char) -> Result<(), ()> {
+        assert_eq!(self.tokens.next(), Some(&Token::Char(v)));
+        Ok(())
+    }
+
+    fn visit_str(&mut self, v: &str) -> Result<(), ()> {
+        assert_eq!(self.tokens.next(), Some(&Token::Str(v)));
+        Ok(())
+    }
+
+    fn visit_none(&mut self) -> Result<(), ()> {
+        assert_eq!(self.tokens.next(), Some(&Token::Option(false)));
+        Ok(())
+    }
+
+    fn visit_some<V>(&mut self, value: V) -> Result<(), ()>
+        where V: ser::Serialize,
+    {
+        assert_eq!(self.tokens.next(), Some(&Token::Option(true)));
+        value.serialize(self)
+    }
+
+
+    fn visit_seq<V>(&mut self, visitor: V) -> Result<(), ()>
+        where V: ser::SeqVisitor
+    {
+        let len = visitor.len();
+
+        assert_eq!(self.tokens.next(), Some(&Token::SeqStart(len)));
+
+        self.visit_sequence(visitor)
+    }
+
+    fn visit_newtype_struct<T>(&mut self,
+                               name: &'static str,
+                               value: T) -> Result<(), ()>
+        where T: ser::Serialize,
+    {
+        assert_eq!(self.tokens.next(), Some(&Token::StructNewtype(name)));
+        value.serialize(self)
+    }
+
+    fn visit_tuple_struct<V>(&mut self, name: &str, visitor: V) -> Result<(), ()>
+        where V: ser::SeqVisitor
+    {
+        let len = visitor.len();
+
+        assert_eq!(self.tokens.next(), Some(&Token::TupleStructStart(name, len)));
+
+        self.visit_sequence(visitor)
+    }
+
+    fn visit_tuple_variant<V>(&mut self,
+                              name: &str,
+                              _variant_index: usize,
+                              variant: &str,
+                              visitor: V) -> Result<(), ()>
+        where V: ser::SeqVisitor
+    {
+        let len = visitor.len();
+
+        assert_eq!(self.tokens.next(), Some(&Token::EnumSeqStart(name, variant, len)));
+
+        self.visit_sequence(visitor)
+    }
+
+    fn visit_seq_elt<T>(&mut self, value: T) -> Result<(), ()>
+        where T: ser::Serialize
+    {
+        assert_eq!(self.tokens.next(), Some(&Token::SeqSep));
+        value.serialize(self)
+    }
+
+    fn visit_map<V>(&mut self, visitor: V) -> Result<(), ()>
+        where V: ser::MapVisitor
+    {
+        let len = visitor.len();
+
+        assert_eq!(self.tokens.next(), Some(&Token::MapStart(len)));
+
+        self.visit_mapping(visitor)
+    }
+
+    fn visit_struct<V>(&mut self, name: &str, visitor: V) -> Result<(), ()>
+        where V: ser::MapVisitor
+    {
+        let len = visitor.len();
+
+        assert_eq!(self.tokens.next(), Some(&Token::StructStart(name, len)));
+
+        self.visit_mapping(visitor)
+    }
+
+    fn visit_struct_variant<V>(&mut self,
+                               name: &str,
+                               _variant_index: usize,
+                               variant: &str,
+                               visitor: V) -> Result<(), ()>
+        where V: ser::MapVisitor
+    {
+        let len = visitor.len();
+
+        assert_eq!(self.tokens.next(), Some(&Token::EnumMapStart(name, variant, len)));
+
+        self.visit_mapping(visitor)
+    }
+
+    fn visit_map_elt<K, V>(&mut self, key: K, value: V) -> Result<(), ()>
+        where K: ser::Serialize,
+              V: ser::Serialize,
+    {
+        assert_eq!(self.tokens.next(), Some(&Token::MapSep));
+
+        try!(key.serialize(self));
+        value.serialize(self)
+    }
+
+    fn format() -> &'static str {
+        "token"
+    }
+}
+
+//////////////////////////////////////////////////////////////////////////////
+
+#[derive(Clone, PartialEq, Debug)]
+enum Error {
+    SyntaxError,
+    EndOfStreamError,
+    UnknownFieldError(String),
+    MissingFieldError(&'static str),
+    InvalidName(&'static str),
+    UnexpectedToken(Token<'static>),
+    ValueError(value::Error),
+}
+
+impl de::Error for Error {
+    fn syntax(_: &str) -> Error { Error::SyntaxError }
+
+    fn end_of_stream() -> Error { Error::EndOfStreamError }
+
+    fn unknown_field(field: &str) -> Error {
+        Error::UnknownFieldError(field.to_string())
+    }
+
+    fn missing_field(field: &'static str) -> Error {
+        Error::MissingFieldError(field)
+    }
+}
+
+impl From<value::Error> for Error {
+    fn from(error: value::Error) -> Error {
+        Error::ValueError(error)
+    }
+}
+
+struct Deserializer<I> where I: Iterator<Item=Token<'static>> {
+    tokens: iter::Peekable<I>,
+}
+
+impl<I> Deserializer<I>
+    where I: Iterator<Item=Token<'static>>
+{
+    fn new(tokens: I) -> Deserializer<I> {
+        Deserializer {
+            tokens: tokens.peekable(),
+        }
+    }
+
+    fn visit_seq<V>(&mut self, len: Option<usize>, mut visitor: V) -> Result<V::Value, Error>
+        where V: de::Visitor,
+    {
+        visitor.visit_seq(DeserializerSeqVisitor {
+            de: self,
+            len: len,
+        })
+    }
+
+    fn visit_map<V>(&mut self, len: Option<usize>, mut visitor: V) -> Result<V::Value, Error>
+        where V: de::Visitor,
+    {
+        visitor.visit_map(DeserializerMapVisitor {
+            de: self,
+            len: len,
+        })
+    }
+}
+
+impl<I> de::Deserializer for Deserializer<I>
+    where I: Iterator<Item=Token<'static>>
+{
+    type Error = Error;
+
+    fn visit<V>(&mut self, mut visitor: V) -> Result<V::Value, Error>
+        where V: de::Visitor,
+    {
+        println!("visit {:?}", self.tokens.peek());
+        match self.tokens.next() {
+            Some(Token::Bool(v)) => visitor.visit_bool(v),
+            Some(Token::Isize(v)) => visitor.visit_isize(v),
+            Some(Token::I8(v)) => visitor.visit_i8(v),
+            Some(Token::I16(v)) => visitor.visit_i16(v),
+            Some(Token::I32(v)) => visitor.visit_i32(v),
+            Some(Token::I64(v)) => visitor.visit_i64(v),
+            Some(Token::Usize(v)) => visitor.visit_usize(v),
+            Some(Token::U8(v)) => visitor.visit_u8(v),
+            Some(Token::U16(v)) => visitor.visit_u16(v),
+            Some(Token::U32(v)) => visitor.visit_u32(v),
+            Some(Token::U64(v)) => visitor.visit_u64(v),
+            Some(Token::F32(v)) => visitor.visit_f32(v),
+            Some(Token::F64(v)) => visitor.visit_f64(v),
+            Some(Token::Char(v)) => visitor.visit_char(v),
+            Some(Token::Str(v)) => visitor.visit_str(v),
+            Some(Token::String(v)) => visitor.visit_string(v),
+            Some(Token::Bytes(v)) => visitor.visit_bytes(v),
+            Some(Token::Option(false)) => visitor.visit_none(),
+            Some(Token::Option(true)) => visitor.visit_some(self),
+            Some(Token::Unit) => visitor.visit_unit(),
+            Some(Token::UnitStruct(name)) => visitor.visit_unit_struct(name),
+            Some(Token::SeqStart(len)) | Some(Token::TupleStructStart(_, len)) => {
+                self.visit_seq(len, visitor)
+            }
+            Some(Token::MapStart(len)) | Some(Token::StructStart(_, len)) => {
+                self.visit_map(len, visitor)
+            }
+            //Some(Token::Name(_)) => self.visit(visitor),
+            Some(token) => Err(Error::UnexpectedToken(token)),
+            None => Err(Error::EndOfStreamError),
+        }
+    }
+
+    /// Hook into `Option` deserializing so we can treat `Unit` as a
+    /// `None`, or a regular value as `Some(value)`.
+    fn visit_option<V>(&mut self, mut visitor: V) -> Result<V::Value, Error>
+        where V: de::Visitor,
+    {
+        match self.tokens.peek() {
+            Some(&Token::Option(false)) => {
+                self.tokens.next();
+                visitor.visit_none()
+            }
+            Some(&Token::Option(true)) => {
+                self.tokens.next();
+                visitor.visit_some(self)
+            }
+            Some(&Token::Unit) => {
+                self.tokens.next();
+                visitor.visit_none()
+            }
+            Some(_) => visitor.visit_some(self),
+            None => Err(Error::EndOfStreamError),
+        }
+    }
+
+    fn visit_enum<V>(&mut self,
+                     name: &str,
+                     _variants: &'static [&'static str],
+                     mut visitor: V) -> Result<V::Value, Error>
+        where V: de::EnumVisitor,
+    {
+        match self.tokens.peek() {
+            Some(&Token::EnumStart(n)) if name == n => {
+                self.tokens.next();
+
+                visitor.visit(DeserializerVariantVisitor {
+                    de: self,
+                })
+            }
+            Some(&Token::EnumUnit(n, _))
+            | Some(&Token::EnumNewtype(n, _))
+            | Some(&Token::EnumSeqStart(n, _, _))
+            | Some(&Token::EnumMapStart(n, _, _)) if name == n => {
+                visitor.visit(DeserializerVariantVisitor {
+                    de: self,
+                })
+            }
+            Some(_) => {
+                let token = self.tokens.next().unwrap();
+                Err(Error::UnexpectedToken(token))
+            }
+            None => { return Err(Error::EndOfStreamError); }
+        }
+    }
+
+    fn visit_unit_struct<V>(&mut self, name: &str, mut visitor: V) -> Result<V::Value, Error>
+        where V: de::Visitor,
+    {
+        match self.tokens.peek() {
+            Some(&Token::UnitStruct(n)) => {
+                self.tokens.next();
+                if name == n {
+                    visitor.visit_unit()
+                } else {
+                    Err(Error::InvalidName(n))
+                }
+            }
+            Some(_) => self.visit(visitor),
+            None => Err(Error::EndOfStreamError),
+        }
+    }
+
+    fn visit_newtype_struct<V>(&mut self,
+                               name: &str,
+                               mut visitor: V) -> Result<V::Value, Error>
+        where V: de::Visitor,
+    {
+        match self.tokens.peek() {
+            Some(&Token::StructNewtype(n)) => {
+                self.tokens.next();
+                if name == n {
+                    visitor.visit_newtype_struct(self)
+                } else {
+                    Err(Error::InvalidName(n))
+                }
+            }
+            Some(_) => self.visit(visitor),
+            None => Err(Error::EndOfStreamError),
+        }
+    }
+
+    fn visit_tuple_struct<V>(&mut self,
+                             name: &str,
+                             len: usize,
+                             mut visitor: V) -> Result<V::Value, Error>
+        where V: de::Visitor,
+    {
+        match self.tokens.peek() {
+            Some(&Token::UnitStruct(n)) => {
+                self.tokens.next();
+                if name == n {
+                    visitor.visit_unit()
+                } else {
+                    Err(Error::InvalidName(n))
+                }
+            }
+            Some(&Token::TupleStructStart(n, _)) => {
+                self.tokens.next();
+                if name == n {
+                    self.visit_seq(Some(len), visitor)
+                } else {
+                    Err(Error::InvalidName(n))
+                }
+            }
+            Some(&Token::SeqStart(_)) => {
+                self.tokens.next();
+                self.visit_seq(Some(len), visitor)
+            }
+            Some(_) => self.visit(visitor),
+            None => Err(Error::EndOfStreamError),
+        }
+    }
+
+    fn visit_struct<V>(&mut self,
+                       name: &str,
+                       fields: &'static [&'static str],
+                       visitor: V) -> Result<V::Value, Error>
+        where V: de::Visitor,
+    {
+        match self.tokens.peek() {
+            Some(&Token::StructStart(n, _)) => {
+                self.tokens.next();
+                if name == n {
+                    self.visit_map(Some(fields.len()), visitor)
+                } else {
+                    Err(Error::InvalidName(n))
+                }
+            }
+            Some(&Token::MapStart(_)) => {
+                self.tokens.next();
+                self.visit_map(Some(fields.len()), visitor)
+            }
+            Some(_) => self.visit(visitor),
+            None => Err(Error::EndOfStreamError),
+        }
+    }
+
+    fn format() -> &'static str {
+        "token"
+    }
+}
+
+//////////////////////////////////////////////////////////////////////////
+
+struct DeserializerSeqVisitor<'a, I: 'a> where I: Iterator<Item=Token<'static>> {
+    de: &'a mut Deserializer<I>,
+    len: Option<usize>,
+}
+
+impl<'a, I> de::SeqVisitor for DeserializerSeqVisitor<'a, I>
+    where I: Iterator<Item=Token<'static>>,
+{
+    type Error = Error;
+
+    fn visit<T>(&mut self) -> Result<Option<T>, Error>
+        where T: de::Deserialize,
+    {
+        match self.de.tokens.peek() {
+            Some(&Token::SeqSep) => {
+                self.de.tokens.next();
+                self.len = self.len.map(|len| len - 1);
+                Ok(Some(try!(de::Deserialize::deserialize(self.de))))
+            }
+            Some(&Token::SeqEnd) => Ok(None),
+            Some(_) => {
+                let token = self.de.tokens.next().unwrap();
+                Err(Error::UnexpectedToken(token))
+            }
+            None => Err(Error::EndOfStreamError),
+        }
+    }
+
+    fn end(&mut self) -> Result<(), Error> {
+        //assert_eq!(self.len.unwrap_or(0), 0);
+        match self.de.tokens.next() {
+            Some(Token::SeqEnd) => Ok(()),
+            Some(token) => Err(Error::UnexpectedToken(token)),
+            None => Err(Error::EndOfStreamError),
+        }
+    }
+
+    fn size_hint(&self) -> (usize, Option<usize>) {
+        let len = self.len.unwrap_or(0);
+        (len, self.len)
+    }
+}
+
+//////////////////////////////////////////////////////////////////////////
+
+struct DeserializerMapVisitor<'a, I: 'a> where I: Iterator<Item=Token<'static>> {
+    de: &'a mut Deserializer<I>,
+    len: Option<usize>,
+}
+
+impl<'a, I> de::MapVisitor for DeserializerMapVisitor<'a, I>
+    where I: Iterator<Item=Token<'static>>,
+{
+    type Error = Error;
+
+    fn visit_key<K>(&mut self) -> Result<Option<K>, Error>
+        where K: de::Deserialize,
+    {
+        match self.de.tokens.peek() {
+            Some(&Token::MapSep) => {
+                self.de.tokens.next();
+                self.len = self.len.map(|len| len - 1);
+                Ok(Some(try!(de::Deserialize::deserialize(self.de))))
+            }
+            Some(&Token::MapEnd) => Ok(None),
+            Some(_) => {
+                let token = self.de.tokens.next().unwrap();
+                Err(Error::UnexpectedToken(token))
+            }
+            None => Err(Error::EndOfStreamError),
+        }
+    }
+
+    fn visit_value<V>(&mut self) -> Result<V, Error>
+        where V: de::Deserialize,
+    {
+        Ok(try!(de::Deserialize::deserialize(self.de)))
+    }
+
+    fn end(&mut self) -> Result<(), Error> {
+        //assert_eq!(self.len.unwrap_or(0), 0);
+        match self.de.tokens.next() {
+            Some(Token::MapEnd) => Ok(()),
+            Some(token) => Err(Error::UnexpectedToken(token)),
+            None => Err(Error::EndOfStreamError),
+        }
+    }
+
+    fn size_hint(&self) -> (usize, Option<usize>) {
+        let len = self.len.unwrap_or(0);
+        (len, self.len)
+    }
+}
+
+//////////////////////////////////////////////////////////////////////////
+
+struct DeserializerVariantVisitor<'a, I: 'a> where I: Iterator<Item=Token<'static>> {
+    de: &'a mut Deserializer<I>,
+}
+
+impl<'a, I> de::VariantVisitor for DeserializerVariantVisitor<'a, I>
+    where I: Iterator<Item=Token<'static>>,
+{
+    type Error = Error;
+
+    fn visit_variant<V>(&mut self) -> Result<V, Error>
+        where V: de::Deserialize,
+    {
+        match self.de.tokens.peek() {
+            Some(&Token::EnumUnit(_, v))
+            | Some(&Token::EnumNewtype(_, v))
+            | Some(&Token::EnumSeqStart(_, v, _))
+            | Some(&Token::EnumMapStart(_, v, _)) => {
+                let value = try!(de::Deserialize::deserialize(&mut v.into_deserializer()));
+                Ok(value)
+            }
+            Some(_) => {
+                de::Deserialize::deserialize(self.de)
+            }
+            None => Err(Error::EndOfStreamError),
+        }
+    }
+
+    fn visit_unit(&mut self) -> Result<(), Error> {
+        match self.de.tokens.peek() {
+            Some(&Token::EnumUnit(_, _)) => {
+                self.de.tokens.next();
+                Ok(())
+            }
+            Some(_) => {
+                de::Deserialize::deserialize(self.de)
+            }
+            None => Err(Error::EndOfStreamError),
+        }
+    }
+
+    fn visit_newtype<T>(&mut self) -> Result<T, Self::Error>
+        where T: de::Deserialize,
+    {
+        match self.de.tokens.peek() {
+            Some(&Token::EnumNewtype(_, _)) => {
+                self.de.tokens.next();
+                de::Deserialize::deserialize(self.de)
+            }
+            Some(_) => {
+                de::Deserialize::deserialize(self.de)
+            }
+            None => Err(Error::EndOfStreamError),
+        }
+    }
+
+    fn visit_tuple<V>(&mut self,
+                      len: usize,
+                      visitor: V) -> Result<V::Value, Error>
+        where V: de::Visitor,
+    {
+        match self.de.tokens.peek() {
+            Some(&Token::EnumSeqStart(_, _, Some(enum_len))) => {
+                let token = self.de.tokens.next().unwrap();
+
+                if len == enum_len {
+                    self.de.visit_seq(Some(len), visitor)
+                } else {
+                    Err(Error::UnexpectedToken(token))
+                }
+            }
+            Some(_) => {
+                de::Deserialize::deserialize(self.de)
+            }
+            None => Err(Error::EndOfStreamError),
+        }
+    }
+
+    fn visit_struct<V>(&mut self,
+                       fields: &'static [&'static str],
+                       visitor: V) -> Result<V::Value, Error>
+        where V: de::Visitor,
+    {
+        match self.de.tokens.peek() {
+            Some(&Token::EnumMapStart(_, _, Some(enum_len))) => {
+                let token = self.de.tokens.next().unwrap();
+
+                if fields.len() == enum_len {
+                    self.de.visit_map(Some(fields.len()), visitor)
+                } else {
+                    Err(Error::UnexpectedToken(token))
+                }
+            }
+            Some(_) => {
+                de::Deserialize::deserialize(self.de)
+            }
+            None => Err(Error::EndOfStreamError),
+        }
+    }
+}
+
+//////////////////////////////////////////////////////////////////////////////
+
+pub fn assert_ser_tokens<T>(value: &T, tokens: &[Token])
+    where T: ser::Serialize,
+{
+    let mut ser = Serializer::new(tokens.iter());
+    assert_eq!(ser::Serialize::serialize(value, &mut ser), Ok(()));
+    assert_eq!(ser.tokens.next(), None);
+}
+
+pub fn assert_de_tokens<T>(value: &T, tokens: Vec<Token<'static>>)
+    where T: de::Deserialize + PartialEq + fmt::Debug,
+{
+    let mut de = Deserializer::new(tokens.into_iter());
+    let v: Result<T, Error> = de::Deserialize::deserialize(&mut de);
+    assert_eq!(v.as_ref(), Ok(value));
+    assert_eq!(de.tokens.next(), None);
+}
+
+pub fn assert_tokens<T>(value: &T, tokens: Vec<Token<'static>>)
+    where T: ser::Serialize + de::Deserialize + PartialEq + fmt::Debug,
+{
+    assert_ser_tokens(value, &tokens[..]);
+    assert_de_tokens(value, tokens);
+}
Author	SHA1	Message	Date
Homu	a1bd0c1667	Auto merge of #153 - erickt:doc, r=erickt Start documenting everything	2015-09-03 00:54:55 +09:00
Erick Tryzelaar	48ea75fddc	Bump version This is because I removed some public, but unused things	2015-09-02 08:54:01 -07:00
Erick Tryzelaar	4b49f716b9	Document serde::de::impls.	2015-09-02 08:36:14 -07:00
Erick Tryzelaar	55f5f397d7	Document serde::de::value	2015-09-02 08:36:14 -07:00
Erick Tryzelaar	4be4f60f21	Document serde::de::mod.	2015-09-02 08:36:14 -07:00
Erick Tryzelaar	9a8037bbf2	Remove unused Enum{Seq,Map}Visitor	2015-09-02 08:36:14 -07:00
Erick Tryzelaar	c7f1af90b2	Document serde::iter	2015-09-02 08:36:14 -07:00
Erick Tryzelaar	902d3a0aa5	Document serde::bytes.	2015-09-02 08:36:14 -07:00
Erick Tryzelaar	c14eb28223	Remove unused buf module.	2015-09-02 08:36:14 -07:00
Erick Tryzelaar	2722a04e52	Document serde::ser::impls	2015-09-02 08:36:14 -07:00
Erick Tryzelaar	5dbcd7957a	Start documenting everything, starting with serde::ser.	2015-09-01 08:02:17 -07:00
Erick Tryzelaar	7511eeae7b	Version bump Closes #149	2015-08-31 10:04:34 -07:00
Erick Tryzelaar	5f4a7e54bc	Fix README deserialization-without-macros example Closes #150.	2015-08-31 09:23:33 -07:00
Erick Tryzelaar	b7e3058078	Add coverage badge	2015-08-29 21:09:20 -07:00
Erick Tryzelaar	f3358cc377	Merge pull request #144 from erickt/master Factor serde_json out into it's own module	2015-08-29 21:06:21 -07:00
Erick Tryzelaar	fa3460e0a7	Migrate serde_json into it's own repo New location is https://github.com/serde-rs/json.	2015-08-29 18:09:51 -07:00
Erick Tryzelaar	42069ca669	Refactor tests to not use serde_json	2015-08-29 17:29:42 -07:00
Homu	acc7141b64	Auto merge of #145 - erickt:travis, r=erickt Travis work	2015-08-30 08:31:25 +09:00
Erick Tryzelaar	3e1b950b14	Merge pull request #147 from jmesmon/fix-readme readme: fix example code so it builds	2015-08-28 08:31:17 -07:00
Cody P Schafer	b50b702d1c	readme: fix example code so it builds Might be worthwhile to look at trying to automate testing the code in the README (perhaps by generating the README from some special tests).	2015-08-28 11:27:03 -04:00
Erick Tryzelaar	caddd11c15	Travis work	2015-08-27 22:51:11 -07:00
Erick Tryzelaar	5711e3d860	Merge pull request #143 from 3Hren/master Add a Sized requirement to the Deserialize trait.	2015-08-24 21:41:58 -07:00
Evgeny Safronov	8b1058b8ec	Add a Sized requirement to the Deserialize trait.	2015-08-24 18:44:19 +03:00
Erick Tryzelaar	092ba6dae2	Merge pull request #139 from erickt/str-keys Reject serializing maps to JSON with non-string keys	2015-08-19 09:01:27 -07:00
Erick Tryzelaar	cab653e7c7	Version bump	2015-08-18 12:50:39 -07:00
Erick Tryzelaar	8d999a8edd	VecMap was removed from libcollections	2015-08-18 12:49:50 -07:00
Erick Tryzelaar	7b773ac088	Merge pull request #138 from erickt/master Expose serde_json::from_{iter,reader,slice}	2015-08-13 22:32:34 -07:00
Erick Tryzelaar	4f6b27eec1	Black box json benchmark numbers This prevents the optimizer from optimizing away the thing we're benchmarking.	2015-08-13 22:30:02 -07:00
Erick Tryzelaar	fe20852b2c	Reject serializing maps to JSON with non-string keys Closes #122. This is a breaking change since it modifies the return type of serde_json::to_vec{,pretty}, so it'll require a major version bump of serde_json.	2015-08-13 22:29:13 -07:00
Erick Tryzelaar	fc58ea7487	Expose serde_json::from_{iter,reader,slice}	2015-08-13 21:19:27 -07:00
Erick Tryzelaar	c61cea0eb1	Merge pull request #136 from erickt/visit Have deserializer numeric visits chain	2015-08-13 21:19:19 -07:00
Erick Tryzelaar	764b25bd07	Have Deserializer::visit_{usize,u8,...,isize,i8,...,f32} call visit_{u64,i64,f64} This cuts down the amount of overloading needed by a format like toml which wants to prevent casting a float to an integer and vice versa.	2015-08-13 08:40:19 -07:00
Erick Tryzelaar	a66cd25787	Merge pull request #135 from erickt/doc Add a table pointing to the serializers that support serde	2015-08-11 07:02:22 -07:00
Erick Tryzelaar	0e8d94750b	Add a table pointing to the serializers that support serde	2015-08-11 07:00:59 -07:00
Erick Tryzelaar	3c915189f4	version bump	2015-08-10 10:09:37 -07:00
Erick Tryzelaar	c5541cddeb	Merge pull request #134 from erickt/err Add Error::length_mismatch, Error::type_mismatch, and de::Type	2015-08-10 10:07:51 -07:00
Erick Tryzelaar	63561609a6	Add Error::length_mismatch, Error::type_mismatch, and de::Type This improves error handling to match the needs of msgpack	2015-08-09 21:42:42 -07:00
Erick Tryzelaar	5dc356ddb0	Merge pull request #133 from erickt/fixup Fix doc links, recover some json deserialization speed	2015-08-09 18:17:02 -07:00
Erick Tryzelaar	dc36fd38d6	Gain back 10MB/s on the json deserialization benchmark	2015-08-09 16:45:55 -07:00
Erick Tryzelaar	26873bf3d5	Don't use sudo in the travis	2015-08-09 16:40:35 -07:00
Erick Tryzelaar	ff53323790	Correct the documentation links in the crates	2015-08-09 16:38:10 -07:00
Erick Tryzelaar	fd3869d380	Update the README	2015-08-09 16:37:21 -07:00
Erick Tryzelaar	1d538bc59d	Merge pull request #132 from Byron/fix-codegen Use fully qualified `Result` type	2015-08-08 15:48:49 -07:00
Sebastian Thiel	784cfcd49e	Use fully qualified `Result` type If that is not the case, the generated code might attempt to use a custom `Result` type with incompatible type parameters.	2015-08-08 12:33:29 +02:00
Erick Tryzelaar	a142d319e7	Point the serde_json readme at the root readme	2015-08-07 12:05:01 -07:00
Erick Tryzelaar	da3bf3c20a	Merge pull request #130 from oli-obk/fix json deser from Value adjusted to be equal to deser from strings	2015-08-07 09:45:37 -07:00
Erick Tryzelaar	1672306fa1	Merge pull request #129 from erickt/remove-error Remove "_error" from de::Error methods, add string argument to Error::syntax()	2015-08-07 09:45:11 -07:00
Oliver Schneider	7fc780ba1b	json deser from Value adjusted to be equal to deser from strings	2015-08-07 18:31:42 +02:00
Erick Tryzelaar	7fb2bd50bf	Add a string argument to Error::syntax()	2015-08-07 08:08:56 -07:00
Erick Tryzelaar	2aeb51ad51	Remove "_error" from de::Error::*_error	2015-08-07 07:53:22 -07:00
Erick Tryzelaar	0482b756e8	Merge pull request #127 from erickt/json3 Rewrite json parser to not require consuming the full stream	2015-08-07 07:52:52 -07:00
Erick Tryzelaar	1d9c707a76	Rewrite json parser to not require consuming the full stream Closes #89	2015-08-06 11:12:37 -07:00
Erick Tryzelaar	199ed417bd	Merge pull request #126 from erickt/json-f64 Update json number parsing to switch to floats if the number gets too big	2015-08-06 10:08:31 -07:00
Erick Tryzelaar	199a02cb68	i64::wrapping_neg is not stable yet	2015-08-06 09:31:37 -07:00
Erick Tryzelaar	b6371f045f	Simplify parsing a number	2015-08-06 07:12:00 -07:00
Erick Tryzelaar	fd84aec485	Fix parsing min, max, and epsilon f64 values	2015-08-05 08:15:47 -07:00
Erick Tryzelaar	ed6777e59f	Fix json parsing i64::MIN, add tests for min and max i64 and u64 values	2015-08-03 09:09:44 -07:00
Erick Tryzelaar	22024a2b71	Simplify parsing floating point decimals and exponents	2015-08-01 14:26:53 -07:00
Erick Tryzelaar	8eff38b6f6	Eliminate some code duplication parsing an exponent as an integer	2015-08-01 13:50:42 -07:00
Erick Tryzelaar	fa562d449d	Minor optimization to not check if JSON number starts with '-' twice	2015-08-01 13:50:24 -07:00
Erick Tryzelaar	c9d55362d6	Add a serde_json::Result helper type	2015-08-01 13:49:57 -07:00
Erick Tryzelaar	23031d057f	Add test for parsing json "0" and "0.0"	2015-07-31 07:33:23 -07:00
Erick Tryzelaar	882d394352	Remove a debug comment	2015-07-31 07:28:07 -07:00
Erick Tryzelaar	fbdede68a4	Build the serde_json docs	2015-07-31 07:24:05 -07:00
Erick Tryzelaar	e88ef4715c	Explicitly make the visit_struct_{,variant}_elt key a `&'static str`	2015-07-31 07:22:14 -07:00
Erick Tryzelaar	94f3dd25d8	Allow VariantVisitor::visit_newtype to default to calling visit_tuple	2015-07-31 07:22:13 -07:00
Erick Tryzelaar	2c58a9c11d	Expose TupleVisitor*::new	2015-07-31 07:22:13 -07:00
Erick Tryzelaar	97528b59cf	Add support for serializing newtype structs This enables formats like JSON to serialize newtype wrapper structs without the normal object wrapper. Consider types like: ```rust struct Point { x: u32, y: u32, } stuct MyPoint(Point); ``` Before this patch, `MyPoint(1,2)` would get serialized as `[{"x":1,"y":2}]`, but now it gets serialized as `{"x":1,"y"2}`.	2015-07-31 07:22:13 -07:00
Erick Tryzelaar	6715fb6652	Rename visit_simple to visit_newtype	2015-07-31 07:22:13 -07:00
Erick Tryzelaar	fefc010deb	Rename visit_enum_simple to visit_newtype_variant	2015-07-31 07:22:13 -07:00
Erick Tryzelaar	6cbb72decf	Inlne the visit_seq method	2015-07-31 07:22:13 -07:00
Erick Tryzelaar	7e25ed863c	Merge pull request #120 from erickt/enum-fields Add enum fields and tuple length to deserialization visitor methods, renamed some more methods	2015-07-30 09:51:01 -07:00
Erick Tryzelaar	5a56394814	Add test to deserialize variants from usize and &[u8]	2015-07-30 08:06:04 -07:00
Erick Tryzelaar	de1059f648	Allow Result<T, E> to use usize variant names	2015-07-30 08:06:04 -07:00
Erick Tryzelaar	97f08086dd	Have visit_enum_simple default to calling visit_tuple_variant	2015-07-30 08:06:04 -07:00
Erick Tryzelaar	0348a3914d	Pass variant index to visit_enum_simple	2015-07-30 08:06:04 -07:00
Erick Tryzelaar	5dc245d2ce	Switch serializing Result to using simple enums	2015-07-30 08:06:04 -07:00
Erick Tryzelaar	71cc95248c	Allow Option<T> to be used directly as a ser::SeqVisitor	2015-07-30 08:06:04 -07:00
Erick Tryzelaar	2cb7d66767	Add test for deserializing a simple enum	2015-07-30 08:06:04 -07:00
Erick Tryzelaar	49fa208242	Minor cleanup	2015-07-30 08:06:04 -07:00
Erick Tryzelaar	d2fef27721	Rename ser::Serializer::visit_enum_{unit,seq,map} to visit_{unit,tuple,struct}_variant	2015-07-30 06:45:21 -07:00
Erick Tryzelaar	351b7039a8	Rename de::VariantVisitor::visit_{map,seq} to visit_{struct,tuple}	2015-07-30 06:45:21 -07:00
Erick Tryzelaar	7585ce9ed4	Re-indent	2015-07-30 06:45:21 -07:00
Erick Tryzelaar	578a0178b5	Make sure the visit_{enum,struct,tuple_struct} name is a `&'static str`	2015-07-30 06:45:21 -07:00
Erick Tryzelaar	6c9cebdcc3	Pass the variant fields and tuple lengths into visit_{enum,tuple,tuple_struct}	2015-07-30 06:45:21 -07:00
Erick Tryzelaar	35e2022e9a	Point at github.com/serde-rs/serde	2015-07-30 06:43:20 -07:00
Erick Tryzelaar	0058e3a8d4	Merge pull request #111 from oli-obk/master tuple enums with single element should not be a json-array	2015-07-29 13:35:43 -07:00
Erick Tryzelaar	abf28ee167	Merge pull request #118 from erickt/ignore-fields Add `#[serde(skip_serializing)] to skip serializing some fields	2015-07-29 10:08:19 -07:00
Oliver Schneider	5f1cb9b96c	rebased again	2015-07-24 09:31:35 +02:00
Oliver 'ker' Schneider	8f8fc6f3ff	nits and rebase fallout	2015-07-24 09:10:58 +02:00
Oliver Schneider	24787195a1	serialize tuple enums with single element directly as the value instead of a sequence	2015-07-24 09:10:58 +02:00
Oliver Schneider	5885111863	deserialize tuple enums with single element directly as the value instead of a sequence	2015-07-24 09:10:58 +02:00
Erick Tryzelaar	b1cb5379de	Add `#[serde(skip_serializing)] to skip serializing some fields Closes #99	2015-07-23 08:07:49 -07:00
Erick Tryzelaar	447d08bd91	Merge pull request #117 from erickt/fix-json Fix deriving traits for fully generic types.	2015-07-23 08:04:46 -07:00
Erick Tryzelaar	b0512a4479	Fix deriving traits for fully generic types. Closes #100	2015-07-23 07:25:27 -07:00
Erick Tryzelaar	8663435a05	Merge remote-tracking branch 'remotes/origin/master' into v5-5 # Conflicts: # serde_tests/tests/test_json.rs	2015-07-23 07:04:10 -07:00
Erick Tryzelaar	327990bc5f	Merge pull request #115 from erickt/fix-json Fix serializing maps/sequences with no size hint	2015-07-23 06:58:18 -07:00
Erick Tryzelaar	57753c9044	Fix references to serde::json	2015-07-22 10:44:43 -07:00
Erick Tryzelaar	e35603eb85	Fix serializing maps/sequences with no size hint Closes #101	2015-07-22 10:44:43 -07:00
Erick Tryzelaar	8fa40fe7e1	Move json into it's own crate Not everyone needs json, so no reason to force people to build it.	2015-07-22 10:44:43 -07:00
Erick Tryzelaar	d4c20829f6	Inline enum visit_map	2015-07-22 10:44:43 -07:00
Erick Tryzelaar	dbe2beacb0	Allow structs to be deserialized from sequences This relies on the sequence to have the same ordering as the struct field order.	2015-07-22 10:44:43 -07:00
Erick Tryzelaar	b9a938a01c	Some default de::Visitor::visit* should proxy to other methods	2015-07-22 10:44:43 -07:00
Erick Tryzelaar	4dd7345568	Simplify result serialization and deserialization	2015-07-22 10:44:43 -07:00
Erick Tryzelaar	b3cf9375d4	Add Tuple Deserializer Visitor constructor	2015-07-22 10:44:43 -07:00
Erick Tryzelaar	1751155a3a	Minor cleanup	2015-07-22 10:44:43 -07:00
Erick Tryzelaar	5dae700aec	Pass struct field names to deserializer	2015-07-22 10:44:42 -07:00
Erick Tryzelaar	affa9382be	Expose variant index to Serializer	2015-07-22 10:44:42 -07:00
Erick Tryzelaar	10f23dddfe	Rename named_* to use {enum,struct,unit}_* This better reflects how they're used.	2015-07-22 10:44:42 -07:00
Erick Tryzelaar	d30cf07254	Serializer::visit_enum_seq{,_elt} should call visit_named_seq{,_elt}	2015-07-22 10:44:42 -07:00
Erick Tryzelaar	31491b822f	Version bump	2015-07-22 10:44:42 -07:00
Erick Tryzelaar	4c19cfead5	Fix serializing maps/sequences with no size hint Closes #101	2015-07-22 10:41:51 -07:00
Erick Tryzelaar	b2754c2c3b	Merge pull request #116 from erickt/travis Use new travis containers	2015-07-22 10:41:38 -07:00
Erick Tryzelaar	f56976db1d	Fix running serde_tests with nightly cargo	2015-07-22 10:40:06 -07:00
Erick Tryzelaar	77b8a8baa0	Use new travis containers	2015-07-22 09:51:19 -07:00
Erick Tryzelaar	0b9190cce3	Merge pull request #108 from dswd/patch-1 Make the TupleVisitors public	2015-07-18 21:21:09 -04:00
dswd	2a40c5dd24	Make the TupleVisitors public This change is needed to use the TupleVisitor to implement a VariantVisitor	2015-07-17 09:58:55 +02:00
Erick Tryzelaar	60ab494226	Fix `cd serde_macros && cargo build`	2015-07-16 13:48:15 -04:00
Erick Tryzelaar	ac758ed3c8	Version bump	2015-07-16 11:28:18 -04:00
Erick Tryzelaar	236d40d73e	Add `Serializer` hooks for sequence elements	2015-07-16 10:51:01 -04:00
Erick Tryzelaar	92029a05c6	Add `Deserializer` type hints This allows file formats like bincode, which do not encode it's values with a type tag, to deserialize values.	2015-07-16 10:50:54 -04:00
Erick Tryzelaar	c7b9997dd1	Add all of the stdlib collection deserialization implementations	2015-07-16 10:42:34 -04:00
Erick Tryzelaar	48309bfdd0	Add all of the stdlib collection serialization implementations	2015-07-16 10:00:22 -04:00
Erick Tryzelaar	f76d1ab10d	Compile serde_macros tests with the nightly features	2015-07-16 10:00:22 -04:00
Erick Tryzelaar	45f552f006	Fix feature flag use for NonZero	2015-07-16 10:00:21 -04:00
Erick Tryzelaar	4d42cfea53	Fix warnings	2015-07-16 09:36:14 -04:00
Erick Tryzelaar	7109e2d379	Fix the tests	2015-07-16 09:35:09 -04:00
Erick Tryzelaar	ff214643ce	Merge remote-tracking branch 'remotes/origin/master' into nonzero # Conflicts: # serde/src/de/impls.rs	2015-07-16 09:34:45 -04:00
Erick Tryzelaar	04918a52eb	Merge pull request #105 from jnicholls/boolvisitor Make BoolVisitor public so it is documented as being in existence	2015-07-16 07:41:49 -04:00
Erick Tryzelaar	5dd71600f7	Merge pull request #102 from pcwalton/result Implement serialization for `Result`.	2015-07-16 07:29:28 -04:00
Patrick Walton	ea9ed22e3e	Implement serialization for `NonZero` values in nightly.	2015-07-14 12:00:46 -07:00
Jarred Nicholls	1611daf802	Make BoolVisitor public so it is documented as being in existence	2015-07-13 12:13:00 -04:00
Patrick Walton	e24f52d3ae	Implement serialization for `Result`. Servo wants this.	2015-07-10 15:08:59 -07:00
Erick Tryzelaar	bcc9e15b05	Merge pull request #94 from cmbrandenburg/master Fix spelling in README.md	2015-07-01 10:38:13 -07:00
Craig M. Brandenburg	af835a2699	Fix spelling in README.md	2015-06-29 07:18:48 -07:00
Erick Tryzelaar	5f2d306f9b	Merge pull request #92 from SkylerLipthay/cow-impls Add impls for Cow	2015-06-21 10:07:00 -07:00
Skyler Lipthay	36fb49b522	Add impls for Cow	2015-06-19 22:50:16 -07:00