Improve error situation

7 files changed, 143 insertions, 131 deletions

diff --git a/src/binary/reader.rs b/src/binary/reader.rs
index eec7554..f983efe 100644
--- a/src/binary/reader.rs
+++ b/src/binary/reader.rs
@@ -4,20 +4,20 @@ use chrono::{TimeZone, UTC};
 use std::io::{Cursor, Read, Seek, SeekFrom};
 use std::string::FromUtf16Error;
 
-use {ReadError, ReadResult, PlistEvent};
+use {Error, Result, PlistEvent};
 
-impl From<ByteorderError> for ReadError {
-    fn from(err: ByteorderError) -> ReadError {
+impl From<ByteorderError> for Error {
+    fn from(err: ByteorderError) -> Error {
         match err {
-            ByteorderError::UnexpectedEOF => ReadError::UnexpectedEof,
-            ByteorderError::Io(err) => ReadError::Io(err),
+            ByteorderError::UnexpectedEOF => Error::UnexpectedEof,
+            ByteorderError::Io(err) => Error::Io(err),
         }
     }
 }
 
-impl From<FromUtf16Error> for ReadError {
-    fn from(_: FromUtf16Error) -> ReadError {
-        ReadError::InvalidData
+impl From<FromUtf16Error> for Error {
+    fn from(_: FromUtf16Error) -> Error {
+        Error::InvalidData
     }
 }
 
@@ -53,7 +53,7 @@ impl<R: Read + Seek> EventReader<R> {
         }
     }
 
-    fn read_trailer(&mut self) -> ReadResult<()> {
+    fn read_trailer(&mut self) -> Result<()> {
         try!(self.reader.seek(SeekFrom::Start(0)));
         let mut magic = [0; 8];
         try!(self.reader.read(&mut magic));
@@ -81,7 +81,7 @@ impl<R: Read + Seek> EventReader<R> {
         Ok(())
     }
 
-    fn read_ints(&mut self, len: u64, size: u8) -> ReadResult<Vec<u64>> {
+    fn read_ints(&mut self, len: u64, size: u8) -> Result<Vec<u64>> {
         let mut ints = Vec::with_capacity(len as usize);
         // TODO: Is the match hoisted out of the loop?
         for _ in 0..len {
@@ -90,18 +90,18 @@ impl<R: Read + Seek> EventReader<R> {
                 2 => ints.push(try!(self.reader.read_u16::<BigEndian>()) as u64),
                 4 => ints.push(try!(self.reader.read_u32::<BigEndian>()) as u64),
                 8 => ints.push(try!(self.reader.read_u64::<BigEndian>()) as u64),
-                _ => return Err(ReadError::InvalidData),
+                _ => return Err(Error::InvalidData),
             }
         }
         Ok(ints)
     }
 
-    fn read_refs(&mut self, len: u64) -> ReadResult<Vec<u64>> {
+    fn read_refs(&mut self, len: u64) -> Result<Vec<u64>> {
         let ref_size = self.ref_size;
         self.read_ints(len, ref_size)
     }
 
-    fn read_object_len(&mut self, len: u8) -> ReadResult<u64> {
+    fn read_object_len(&mut self, len: u8) -> Result<u64> {
         if (len & 0xf) == 0xf {
             let len_power_of_two = try!(self.reader.read_u8()) & 0x3;
             Ok(match len_power_of_two {
@@ -109,21 +109,21 @@ impl<R: Read + Seek> EventReader<R> {
                 1 => try!(self.reader.read_u16::<BigEndian>()) as u64,
                 2 => try!(self.reader.read_u32::<BigEndian>()) as u64,
                 3 => try!(self.reader.read_u64::<BigEndian>()),
-                _ => return Err(ReadError::InvalidData),
+                _ => return Err(Error::InvalidData),
             })
         } else {
             Ok(len as u64)
         }
     }
 
-    fn read_data(&mut self, len: u64) -> ReadResult<Vec<u8>> {
+    fn read_data(&mut self, len: u64) -> Result<Vec<u8>> {
         let mut data = vec![0; len as usize];
         let mut total_read = 0usize;
 
         while (total_read as u64) < len {
             let read = try!(self.reader.read(&mut data[total_read..]));
             if read == 0 {
-                return Err(ReadError::UnexpectedEof);
+                return Err(Error::UnexpectedEof);
             }
             total_read += read;
         }
@@ -131,13 +131,13 @@ impl<R: Read + Seek> EventReader<R> {
         Ok(data)
     }
 
-    fn seek_to_object(&mut self, object_ref: u64) -> ReadResult<u64> {
+    fn seek_to_object(&mut self, object_ref: u64) -> Result<u64> {
         let offset = *&self.object_offsets[object_ref as usize];
         let pos = try!(self.reader.seek(SeekFrom::Start(offset)));
         Ok(pos)
     }
 
-    fn read_next(&mut self) -> ReadResult<Option<PlistEvent>> {
+    fn read_next(&mut self) -> Result<Option<PlistEvent>> {
         if self.ref_size == 0 {
             // Initialise here rather than in new
             try!(self.read_trailer());
@@ -170,10 +170,10 @@ impl<R: Read + Seek> EventReader<R> {
         let size = token & 0x0f;
 
         let result = match (ty, size) {
-            (0x0, 0x00) => return Err(ReadError::UnsupportedType), // null
+            (0x0, 0x00) => return Err(Error::InvalidData), // null
             (0x0, 0x08) => Some(PlistEvent::BooleanValue(false)),
             (0x0, 0x09) => Some(PlistEvent::BooleanValue(true)),
-            (0x0, 0x0f) => return Err(ReadError::UnsupportedType), // fill
+            (0x0, 0x0f) => return Err(Error::InvalidData), // fill
             (0x1, 0) => Some(PlistEvent::IntegerValue(try!(self.reader.read_u8()) as i64)),
             (0x1, 1) => {
                 Some(PlistEvent::IntegerValue(try!(self.reader.read_u16::<BigEndian>()) as i64))
@@ -182,13 +182,13 @@ impl<R: Read + Seek> EventReader<R> {
                 Some(PlistEvent::IntegerValue(try!(self.reader.read_u32::<BigEndian>()) as i64))
             }
             (0x1, 3) => Some(PlistEvent::IntegerValue(try!(self.reader.read_i64::<BigEndian>()))),
-            (0x1, 4) => return Err(ReadError::UnsupportedType), // 128 bit int
-            (0x1, _) => return Err(ReadError::UnsupportedType), // variable length int
+            (0x1, 4) => return Err(Error::InvalidData), // 128 bit int
+            (0x1, _) => return Err(Error::InvalidData), // variable length int
             (0x2, 2) => {
                 Some(PlistEvent::RealValue(try!(self.reader.read_f32::<BigEndian>()) as f64))
             }
             (0x2, 3) => Some(PlistEvent::RealValue(try!(self.reader.read_f64::<BigEndian>()))),
-            (0x2, _) => return Err(ReadError::UnsupportedType), // odd length float
+            (0x2, _) => return Err(Error::InvalidData), // odd length float
             (0x3, 3) => {
                 // Date
                 // Seconds since 1/1/2001 00:00:00
@@ -265,7 +265,7 @@ impl<R: Read + Seek> EventReader<R> {
 
                 Some(PlistEvent::StartDictionary(Some(len as u64)))
             }
-            (_, _) => return Err(ReadError::InvalidData),
+            (_, _) => return Err(Error::InvalidData),
         };
 
         Ok(result)
@@ -273,9 +273,9 @@ impl<R: Read + Seek> EventReader<R> {
 }
 
 impl<R: Read + Seek> Iterator for EventReader<R> {
-    type Item = ReadResult<PlistEvent>;
+    type Item = Result<PlistEvent>;
 
-    fn next(&mut self) -> Option<ReadResult<PlistEvent>> {
+    fn next(&mut self) -> Option<Result<PlistEvent>> {
         if self.finished {
             None
         } else {
diff --git a/src/builder.rs b/src/builder.rs
index 15fc523..db56ee8 100644
--- a/src/builder.rs
+++ b/src/builder.rs
@@ -1,28 +1,13 @@
 use std::collections::BTreeMap;
 
-use {ReadError, ReadResult, Plist, PlistEvent};
-
-pub type BuildResult<T> = Result<T, BuildError>;
-
-#[derive(Debug)]
-pub enum BuildError {
-    InvalidEvent,
-    UnsupportedDictionaryKey,
-    ReadError(ReadError),
-}
-
-impl From<ReadError> for BuildError {
-    fn from(err: ReadError) -> BuildError {
-        BuildError::ReadError(err)
-    }
-}
+use {Error, Result, Plist, PlistEvent};
 
 pub struct Builder<T> {
     stream: T,
     token: Option<PlistEvent>,
 }
 
-impl<T: Iterator<Item = ReadResult<PlistEvent>>> Builder<T> {
+impl<T: Iterator<Item = Result<PlistEvent>>> Builder<T> {
     pub fn new(stream: T) -> Builder<T> {
         Builder {
             stream: stream,
@@ -30,7 +15,7 @@ impl<T: Iterator<Item = ReadResult<PlistEvent>>> Builder<T> {
         }
     }
 
-    pub fn build(mut self) -> BuildResult<Plist> {
+    pub fn build(mut self) -> Result<Plist> {
         try!(self.bump());
         if let Some(PlistEvent::StartPlist) = self.token {
             try!(self.bump());
@@ -42,24 +27,24 @@ impl<T: Iterator<Item = ReadResult<PlistEvent>>> Builder<T> {
             None => (),
             Some(PlistEvent::EndPlist) => try!(self.bump()),
             // The stream should have finished
-            _ => return Err(BuildError::InvalidEvent),
+            _ => return Err(Error::InvalidData),
         };
         Ok(plist)
     }
 
-    fn bump(&mut self) -> BuildResult<()> {
+    fn bump(&mut self) -> Result<()> {
         self.token = match self.stream.next() {
             Some(Ok(token)) => Some(token),
-            Some(Err(err)) => return Err(BuildError::ReadError(err)),
+            Some(Err(err)) => return Err(err),
             None => None,
         };
         Ok(())
     }
 
-    fn build_value(&mut self) -> BuildResult<Plist> {
+    fn build_value(&mut self) -> Result<Plist> {
         match self.token.take() {
-            Some(PlistEvent::StartPlist) => Err(BuildError::InvalidEvent),
-            Some(PlistEvent::EndPlist) => Err(BuildError::InvalidEvent),
+            Some(PlistEvent::StartPlist) => Err(Error::InvalidData),
+            Some(PlistEvent::EndPlist) => Err(Error::InvalidData),
 
             Some(PlistEvent::StartArray(len)) => Ok(Plist::Array(try!(self.build_array(len)))),
             Some(PlistEvent::StartDictionary(len)) => {
@@ -73,15 +58,15 @@ impl<T: Iterator<Item = ReadResult<PlistEvent>>> Builder<T> {
             Some(PlistEvent::RealValue(f)) => Ok(Plist::Real(f)),
             Some(PlistEvent::StringValue(s)) => Ok(Plist::String(s)),
 
-            Some(PlistEvent::EndArray) => Err(BuildError::InvalidEvent),
-            Some(PlistEvent::EndDictionary) => Err(BuildError::InvalidEvent),
+            Some(PlistEvent::EndArray) => Err(Error::InvalidData),
+            Some(PlistEvent::EndDictionary) => Err(Error::InvalidData),
 
             // The stream should not have ended here
-            None => Err(BuildError::InvalidEvent),
+            None => Err(Error::InvalidData),
         }
     }
 
-    fn build_array(&mut self, len: Option<u64>) -> Result<Vec<Plist>, BuildError> {
+    fn build_array(&mut self, len: Option<u64>) -> Result<Vec<Plist>> {
         let mut values = match len {
             Some(len) => Vec::with_capacity(len as usize),
             None => Vec::new(),
@@ -97,7 +82,7 @@ impl<T: Iterator<Item = ReadResult<PlistEvent>>> Builder<T> {
         }
     }
 
-    fn build_dict(&mut self, _len: Option<u64>) -> Result<BTreeMap<String, Plist>, BuildError> {
+    fn build_dict(&mut self, _len: Option<u64>) -> Result<BTreeMap<String, Plist>> {
         let mut values = BTreeMap::new();
 
         loop {
@@ -110,7 +95,7 @@ impl<T: Iterator<Item = ReadResult<PlistEvent>>> Builder<T> {
                 }
                 _ => {
                     // Only string keys are supported in plists
-                    return Err(BuildError::UnsupportedDictionaryKey);
+                    return Err(Error::InvalidData);
                 }
             }
         }
diff --git a/src/lib.rs b/src/lib.rs
index 7c699c7..5f3275f 100644
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -73,21 +73,17 @@ use rustc_serialize::base64::{STANDARD, ToBase64};
 use rustc_serialize::json::Json as RustcJson;
 
 impl Plist {
-    pub fn read<R: Read + Seek>(reader: R) -> Result<Plist, ()> {
+    pub fn read<R: Read + Seek>(reader: R) -> Result<Plist> {
         let reader = EventReader::new(reader);
         Plist::from_events(reader)
     }
 
-    pub fn from_events<T>(events: T) -> Result<Plist, ()>
-        where T: IntoIterator<Item = ReadResult<PlistEvent>>
+    pub fn from_events<T>(events: T) -> Result<Plist>
+        where T: IntoIterator<Item = Result<PlistEvent>>
     {
         let iter = events.into_iter();
         let builder = builder::Builder::new(iter);
-
-        match builder.build() {
-            Ok(plist) => Ok(plist),
-            Err(_) => Err(()),
-        }
+        builder.build()
     }
 
     pub fn into_events(self) -> Vec<PlistEvent> {
@@ -175,25 +171,63 @@ pub enum PlistEvent {
     StringValue(String),
 }
 
-pub type ReadResult<T> = Result<T, ReadError>;
+pub type Result<T> = ::std::result::Result<T, Error>;
 
 #[derive(Debug)]
-pub enum ReadError {
+pub enum Error {
     InvalidData,
     UnexpectedEof,
-    UnsupportedType,
     Io(IoError),
 }
 
-impl From<IoError> for ReadError {
-    fn from(io_error: IoError) -> ReadError {
-        ReadError::Io(io_error)
+impl ::std::error::Error for Error {
+    fn description(&self) -> &str {
+        match *self {
+            Error::InvalidData => "invalid data",
+            Error::UnexpectedEof => "unexpected eof",
+            Error::Io(ref err) => err.description(),
+        }
+    }
+
+    fn cause(&self) -> Option<&::std::error::Error> {
+        match *self {
+            Error::Io(ref err) => Some(err),
+            _ => None,
+        }
     }
 }
 
-impl From<ChronoParseError> for ReadError {
-    fn from(_: ChronoParseError) -> ReadError {
-        ReadError::InvalidData
+use std::fmt;
+
+impl fmt::Display for Error {
+    fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
+        match *self {
+            Error::Io(ref err) => err.fmt(fmt),
+            _ => <Self as ::std::error::Error>::description(self).fmt(fmt),
+        }
+    }
+}
+
+impl From<IoError> for Error {
+    fn from(err: IoError) -> Error {
+        Error::Io(err)
+    }
+}
+
+impl From<ChronoParseError> for Error {
+    fn from(_: ChronoParseError) -> Error {
+        Error::InvalidData
+    }
+}
+
+use xml_rs::writer::Error as XmlWriterError;
+
+impl From<XmlWriterError> for Error {
+    fn from(err: XmlWriterError) -> Error {
+        match err {
+            XmlWriterError::Io(err) => Error::Io(err),
+            _ => Error::InvalidData,
+        }
     }
 }
 
@@ -210,7 +244,7 @@ impl<R: Read + Seek> EventReader<R> {
         EventReader(EventReaderInner::Uninitialized(Some(reader)))
     }
 
-    fn is_binary(reader: &mut R) -> Result<bool, IoError> {
+    fn is_binary(reader: &mut R) -> Result<bool> {
         try!(reader.seek(SeekFrom::Start(0)));
         let mut magic = [0; 8];
         try!(reader.read(&mut magic));
@@ -225,9 +259,9 @@ impl<R: Read + Seek> EventReader<R> {
 }
 
 impl<R: Read + Seek> Iterator for EventReader<R> {
-    type Item = ReadResult<PlistEvent>;
+    type Item = Result<PlistEvent>;
 
-    fn next(&mut self) -> Option<ReadResult<PlistEvent>> {
+    fn next(&mut self) -> Option<Result<PlistEvent>> {
         let mut reader = match self.0 {
             EventReaderInner::Xml(ref mut parser) => return parser.next(),
             EventReaderInner::Binary(ref mut parser) => return parser.next(),
@@ -239,7 +273,7 @@ impl<R: Read + Seek> Iterator for EventReader<R> {
             Ok(false) => EventReaderInner::Xml(xml::EventReader::new(reader)),
             Err(err) => {
                 ::std::mem::replace(&mut self.0, EventReaderInner::Uninitialized(Some(reader)));
-                return Some(Err(ReadError::Io(err)));
+                return Some(Err(err));
             }
         };
 
@@ -250,5 +284,5 @@ impl<R: Read + Seek> Iterator for EventReader<R> {
 }
 
 pub trait EventWriter {
-    fn write(&mut self, event: &PlistEvent) -> Result<(), ()>;
+    fn write(&mut self, event: &PlistEvent) -> Result<()>;
 }
diff --git a/src/ser.rs b/src/ser.rs
index d0833bb..450aec7 100644
--- a/src/ser.rs
+++ b/src/ser.rs
@@ -3,7 +3,7 @@
 
 use serde::ser::{MapVisitor, Serialize, Serializer as SerdeSerializer, SeqVisitor};
 
-use {EventWriter, PlistEvent};
+use {Error, EventWriter, PlistEvent};
 
 pub struct Serializer<W: EventWriter> {
     writer: W,
@@ -15,7 +15,7 @@ impl<W: EventWriter> Serializer<W> {
     }
 
     #[inline]
-    fn emit(&mut self, event: PlistEvent) -> Result<(), ()> {
+    fn emit(&mut self, event: PlistEvent) -> Result<(), Error> {
         self.writer.write(&event)
     }
 
@@ -39,7 +39,7 @@ impl<W: EventWriter> Serializer<W> {
 }
 
 impl<W: EventWriter> SerdeSerializer for Serializer<W> {
-    type Error = ();
+    type Error = Error;
 
     fn visit_bool(&mut self, v: bool) -> Result<(), Self::Error> {
         self.emit(PlistEvent::BooleanValue(v))
diff --git a/src/xml/reader.rs b/src/xml/reader.rs
index 90422c2..e32dd4a 100644
--- a/src/xml/reader.rs
+++ b/src/xml/reader.rs
@@ -4,7 +4,7 @@ use std::io::Read;
 use std::str::FromStr;
 use xml_rs::reader::{EventReader as XmlEventReader, ParserConfig, XmlEvent};
 
-use super::super::{ReadError, ReadResult, PlistEvent};
+use {Error, Result, PlistEvent};
 
 pub struct EventReader<R: Read> {
     xml_reader: XmlEventReader<R>,
@@ -31,8 +31,8 @@ impl<R: Read> EventReader<R> {
         }
     }
 
-    fn read_content<F>(&mut self, f: F) -> ReadResult<PlistEvent>
-        where F: FnOnce(String) -> ReadResult<PlistEvent>
+    fn read_content<F>(&mut self, f: F) -> Result<PlistEvent>
+        where F: FnOnce(String) -> Result<PlistEvent>
     {
         match self.xml_reader.next() {
             Ok(XmlEvent::Characters(s)) => f(s),
@@ -40,11 +40,11 @@ impl<R: Read> EventReader<R> {
                 self.queued_event = Some(event);
                 f("".to_owned())
             }
-            _ => Err(ReadError::InvalidData),
+            _ => Err(Error::InvalidData),
         }
     }
 
-    fn next_event(&mut self) -> Result<XmlEvent, ()> {
+    fn next_event(&mut self) -> ::std::result::Result<XmlEvent, ()> {
         if let Some(event) = self.queued_event.take() {
             Ok(event)
         } else {
@@ -52,7 +52,7 @@ impl<R: Read> EventReader<R> {
         }
     }
 
-    fn read_next(&mut self) -> Option<ReadResult<PlistEvent>> {
+    fn read_next(&mut self) -> Option<Result<PlistEvent>> {
         loop {
             match self.next_event() {
                 Ok(XmlEvent::StartElement { name, .. }) => {
@@ -71,7 +71,7 @@ impl<R: Read> EventReader<R> {
                                 let s: String = s.replace(" ", "").replace("\t", "");
                                 match FromBase64::from_base64(&s[..]) {
                                     Ok(b) => Ok(PlistEvent::DataValue(b)),
-                                    Err(_) => Err(ReadError::InvalidData),
+                                    Err(_) => Err(Error::InvalidData),
                                 }
                             }))
                         }
@@ -85,7 +85,7 @@ impl<R: Read> EventReader<R> {
                             return Some(self.read_content(|s| {
                                 match FromStr::from_str(&s) {
                                     Ok(i) => Ok(PlistEvent::IntegerValue(i)),
-                                    Err(_) => Err(ReadError::InvalidData),
+                                    Err(_) => Err(Error::InvalidData),
                                 }
                             }))
                         }
@@ -93,22 +93,22 @@ impl<R: Read> EventReader<R> {
                             return Some(self.read_content(|s| {
                                 match FromStr::from_str(&s) {
                                     Ok(f) => Ok(PlistEvent::RealValue(f)),
-                                    Err(_) => Err(ReadError::InvalidData),
+                                    Err(_) => Err(Error::InvalidData),
                                 }
                             }))
                         }
                         "string" => {
                             return Some(self.read_content(|s| Ok(PlistEvent::StringValue(s))))
                         }
-                        _ => return Some(Err(ReadError::InvalidData)),
+                        _ => return Some(Err(Error::InvalidData)),
                     }
                 }
                 Ok(XmlEvent::EndElement { name, .. }) => {
                     // Check the corrent element is being closed
                     match self.element_stack.pop() {
                         Some(ref open_name) if &name.local_name == open_name => (),
-                        Some(ref _open_name) => return Some(Err(ReadError::InvalidData)),
-                        None => return Some(Err(ReadError::InvalidData)),
+                        Some(ref _open_name) => return Some(Err(Error::InvalidData)),
+                        None => return Some(Err(Error::InvalidData)),
                     }
 
                     match &name.local_name[..] {
@@ -121,10 +121,10 @@ impl<R: Read> EventReader<R> {
                 Ok(XmlEvent::EndDocument) => {
                     match self.element_stack.is_empty() {
                         true => return None,
-                        false => return Some(Err(ReadError::UnexpectedEof)),
+                        false => return Some(Err(Error::UnexpectedEof)),
                     }
                 }
-                Err(_) => return Some(Err(ReadError::InvalidData)),
+                Err(_) => return Some(Err(Error::InvalidData)),
                 _ => (),
             }
         }
@@ -132,9 +132,9 @@ impl<R: Read> EventReader<R> {
 }
 
 impl<R: Read> Iterator for EventReader<R> {
-    type Item = ReadResult<PlistEvent>;
+    type Item = Result<PlistEvent>;
 
-    fn next(&mut self) -> Option<ReadResult<PlistEvent>> {
+    fn next(&mut self) -> Option<Result<PlistEvent>> {
         if self.finished {
             None
         } else {
diff --git a/src/xml/writer.rs b/src/xml/writer.rs
index efca29e..633181b 100644
--- a/src/xml/writer.rs
+++ b/src/xml/writer.rs
@@ -7,7 +7,7 @@ use xml_rs::namespace::Namespace;
 use xml_rs::writer::{EventWriter as XmlEventWriter, EmitterConfig};
 use xml_rs::writer::events::XmlEvent as WriteXmlEvent;
 
-use PlistEvent;
+use {Error, EventWriter as EventWriterTrait, PlistEvent, Result};
 
 enum Element {
     Dictionary(DictionaryState),
@@ -48,46 +48,39 @@ impl<W: Write> EventWriter<W> {
         }
     }
 
-    fn write_element_and_value(&mut self, name: &str, value: &str) -> Result<(), ()> {
+    fn write_element_and_value(&mut self, name: &str, value: &str) -> Result<()> {
         try!(self.start_element(name));
         try!(self.write_value(value));
         try!(self.end_element(name));
         Ok(())
     }
 
-    fn start_element(&mut self, name: &str) -> Result<(), ()> {
-        let result = self.xml_writer.write(WriteXmlEvent::StartElement {
+    fn start_element(&mut self, name: &str) -> Result<()> {
+        try!(self.xml_writer.write(WriteXmlEvent::StartElement {
             name: Name::local(name),
             attributes: Cow::Borrowed(&[]),
             namespace: Cow::Borrowed(&self.empty_namespace),
-        });
-
-        match result {
-            Ok(()) => Ok(()),
-            Err(_) => Err(()),
-        }
+        }));
+        Ok(())
     }
 
-    fn end_element(&mut self, name: &str) -> Result<(), ()> {
-        let result = self.xml_writer
-                         .write(WriteXmlEvent::EndElement { name: Some(Name::local(name)) });
-
-        match result {
-            Ok(()) => Ok(()),
-            Err(_) => Err(()),
-        }
+    fn end_element(&mut self, name: &str) -> Result<()> {
+        try!(self.xml_writer.write(WriteXmlEvent::EndElement { name: Some(Name::local(name)) }));
+        Ok(())
     }
 
-    fn write_value(&mut self, value: &str) -> Result<(), ()> {
-        let result = self.xml_writer.write(WriteXmlEvent::Characters(value));
+    fn write_value(&mut self, value: &str) -> Result<()> {
+        try!(self.xml_writer.write(WriteXmlEvent::Characters(value)));
+        Ok(())
+    }
 
-        match result {
-            Ok(()) => Ok(()),
-            Err(_) => Err(()),
-        }
+    pub fn write(&mut self, event: &PlistEvent) -> Result<()> {
+        <Self as EventWriterTrait>::write(self, event)
     }
+}
 
-    pub fn write(&mut self, event: &PlistEvent) -> Result<(), ()> {
+impl<W: Write> EventWriterTrait for EventWriter<W> {
+    fn write(&mut self, event: &PlistEvent) -> Result<()> {
         match self.stack.pop() {
             Some(Element::Dictionary(DictionaryState::ExpectKey)) => {
                 match *event {
@@ -96,7 +89,7 @@ impl<W: Write> EventWriter<W> {
                         self.stack.push(Element::Dictionary(DictionaryState::ExpectValue));
                     }
                     PlistEvent::EndDictionary => try!(self.end_element("dict")),
-                    _ => return Err(()), // Invalid event
+                    _ => return Err(Error::InvalidData),
                 };
                 return Ok(());
             }
@@ -118,23 +111,23 @@ impl<W: Write> EventWriter<W> {
 
                         match result {
                             Ok(()) => (),
-                            Err(_) => return Err(()),
+                            Err(_) => return Err(Error::InvalidData),
                         }
 
                         self.stack.push(Element::Root);
                         return Ok(());
                     }
-                    _ => return Err(()), // Invalid event
+                    _ => return Err(Error::InvalidData),
                 }
             }
         }
 
         Ok(match *event {
-            PlistEvent::StartPlist => return Err(()), // Invalid event
+            PlistEvent::StartPlist => return Err(Error::InvalidData),
             PlistEvent::EndPlist => {
                 try!(self.end_element("plist"));
                 if let Some(Element::Root) = self.stack.pop() {} else {
-                    return Err(()); // Invalid event
+                    return Err(Error::InvalidData);
                 }
             }
 
@@ -145,7 +138,7 @@ impl<W: Write> EventWriter<W> {
             PlistEvent::EndArray => {
                 try!(self.end_element("array"));
                 if let Some(Element::Array) = self.stack.pop() {} else {
-                    return Err(()); // Invalid event
+                    return Err(Error::InvalidData);
                 }
             }
 
@@ -153,7 +146,7 @@ impl<W: Write> EventWriter<W> {
                 try!(self.start_element("dict"));
                 self.stack.push(Element::Dictionary(DictionaryState::ExpectKey));
             }
-            PlistEvent::EndDictionary => return Err(()), // Invalid event
+            PlistEvent::EndDictionary => return Err(Error::InvalidData),
 
             PlistEvent::BooleanValue(true) => {
                 try!(self.start_element("true"));
diff --git a/tests/serde_/mod.rs b/tests/serde_/mod.rs
index a2cbd41..184d4f0 100644
--- a/tests/serde_/mod.rs
+++ b/tests/serde_/mod.rs
@@ -1,4 +1,4 @@
-use plist::{Deserializer, EventWriter, PlistEvent, Serializer};
+use plist::{Deserializer, EventWriter, PlistEvent, Result as PlistResult, Serializer};
 use plist::PlistEvent::*;
 use serde::{Deserialize, Serialize};
 use std::fmt::Debug;
@@ -18,7 +18,7 @@ impl VecWriter {
 }
 
 impl EventWriter for VecWriter {
-    fn write(&mut self, event: &PlistEvent) -> Result<(), ()> {
+    fn write(&mut self, event: &PlistEvent) -> PlistResult<()> {
         self.events.push(event.clone());
         Ok(())
     }