3 files changed, 54 insertions, 10 deletions
diff --git a/src/ser/key.rs b/src/ser/key.rs
index 6cbbff4..a84f311 100644
--- a/src/ser/key.rs
+++ b/src/ser/key.rs
@@ -1,4 +1,5 @@
-use ser::Error;
+use ser::{Error};
+use serde::ser::{SerializeStruct};
 use ser::part::Sink;
 use serde::Serialize;
 use std::borrow::Cow;
@@ -44,7 +45,6 @@ impl<End, Ok> KeySink<End>
 impl<End, Ok> Sink for KeySink<End>
     where End: for<'key> FnOnce(Key<'key>) -> Result<Ok, Error>
 {
-    type Ok = Ok;
 
     fn serialize_static_str(self,
                             value: &'static str)
@@ -74,3 +74,23 @@ impl<End, Ok> Sink for KeySink<End>
         Error::Custom("unsupported key".into())
     }
 }
+
+impl<End, Ok> SerializeStruct for KeySink<End>
+where End: for<'key> FnOnce(Key<'key>) -> Result<Ok, Error>
+{
+    type Ok = Ok;
+    type Error = Error;
+
+    fn serialize_field<T: ?Sized + Serialize>(&mut self,
+                                                   _key: &'static str,
+                                                   _value: &T)
+                                                   -> Result<(), Error> {
+        Err(Error::top_level())
+    }
+
+    fn end(self) -> Result<Self::Ok, Error> {
+        Err(self.unsupported())
+    }
+}
+
+
diff --git a/src/ser/part.rs b/src/ser/part.rs
index 42653c0..d2ade0a 100644
--- a/src/ser/part.rs
+++ b/src/ser/part.rs
@@ -14,8 +14,8 @@ impl<S: Sink> PartSerializer<S> {
     }
 }
 
-pub trait Sink: Sized {
-    type Ok;
+pub trait Sink: Sized + ser::SerializeStruct {
+    // type Ok;
 
     fn serialize_static_str(self,
                             value: &'static str)
@@ -33,7 +33,7 @@ pub trait Sink: Sized {
     fn unsupported(self) -> Error;
 }
 
-impl<S: Sink> ser::Serializer for PartSerializer<S> {
+impl<S: Sink<Error=Error>> ser::Serializer for PartSerializer<S> {
     type Ok = S::Ok;
     type Error = Error;
     type SerializeSeq = ser::Impossible<S::Ok, Error>;
@@ -41,7 +41,7 @@ impl<S: Sink> ser::Serializer for PartSerializer<S> {
     type SerializeTupleStruct = ser::Impossible<S::Ok, Error>;
     type SerializeTupleVariant = ser::Impossible<S::Ok, Error>;
     type SerializeMap = ser::Impossible<S::Ok, Error>;
-    type SerializeStruct = ser::Impossible<S::Ok, Error>;
+    type SerializeStruct = S;
     type SerializeStructVariant = ser::Impossible<S::Ok, Error>;
 
     fn serialize_bool(self, v: bool) -> Result<S::Ok, Error> {
@@ -193,7 +193,9 @@ impl<S: Sink> ser::Serializer for PartSerializer<S> {
                         _name: &'static str,
                         _len: usize)
                         -> Result<Self::SerializeStruct, Error> {
-        Err(self.sink.unsupported())
+        // Err(self.sink.unsupported())
+        Ok(self.sink)
+
     }
 
     fn serialize_struct_variant
@@ -207,7 +209,7 @@ impl<S: Sink> ser::Serializer for PartSerializer<S> {
     }
 }
 
-impl<S: Sink> PartSerializer<S> {
+impl<S: Sink<Error=Error>> PartSerializer<S> {
     fn serialize_integer<I>(self, value: I) -> Result<S::Ok, Error>
         where I: itoa::Integer,
     {
diff --git a/src/ser/value.rs b/src/ser/value.rs
index e4e1f2c..56b410e 100644
--- a/src/ser/value.rs
+++ b/src/ser/value.rs
@@ -1,6 +1,6 @@
 use ser::Error;
 use ser::part::{PartSerializer, Sink};
-use serde::ser::Serialize;
+use serde::ser::{Serialize, SerializeStruct};
 use std::str;
 use url::form_urlencoded::Serializer as UrlEncodedSerializer;
 use url::form_urlencoded::Target as UrlEncodedTarget;
@@ -28,7 +28,7 @@ impl<'key, 'target, Target> ValueSink<'key, 'target, Target>
 impl<'key, 'target, Target> Sink for ValueSink<'key, 'target, Target>
     where Target: 'target + UrlEncodedTarget,
 {
-    type Ok = ();
+    // type Ok = ();
 
     fn serialize_str(self, value: &str) -> Result<(), Error> {
         self.urlencoder.append_pair(self.key, value);
@@ -57,3 +57,25 @@ impl<'key, 'target, Target> Sink for ValueSink<'key, 'target, Target>
         Error::Custom("unsupported value".into())
     }
 }
+
+
+impl<'key, 'target, Target> SerializeStruct for ValueSink<'key, 'target, Target>
+    where Target: 'target + UrlEncodedTarget,
+{
+    type Ok = ();
+    type Error = Error;
+
+    fn serialize_field<T: ?Sized + Serialize>(&mut self,
+                                                   key: &'static str,
+                                                   value: &T)
+                                                   -> Result<(), Error> {
+        let newk = format!("{}[{}]", self.key, key);
+        let value_sink = ValueSink::new(self.urlencoder, &newk);
+        value.serialize(super::part::PartSerializer::new(value_sink))
+    }
+
+    fn end(self) -> Result<Self::Ok, Error> {
+        Ok(())
+    }
+}
+