Remove the Result<T, Error> type alias.

8 files changed, 46 insertions, 48 deletions

diff --git a/src/builder.rs b/src/builder.rs
index 8cd580e..d4d9364 100644
--- a/src/builder.rs
+++ b/src/builder.rs
@@ -1,14 +1,14 @@
 use std::collections::BTreeMap;
 
 use events::Event;
-use {u64_option_to_usize, Error, Result, Value};
+use {u64_option_to_usize, Error, Value};
 
 pub struct Builder<T> {
     stream: T,
     token: Option<Event>,
 }
 
-impl<T: Iterator<Item = Result<Event>>> Builder<T> {
+impl<T: Iterator<Item = Result<Event, Error>>> Builder<T> {
     pub fn new(stream: T) -> Builder<T> {
         Builder {
             stream: stream,
@@ -16,7 +16,7 @@ impl<T: Iterator<Item = Result<Event>>> Builder<T> {
         }
     }
 
-    pub fn build(mut self) -> Result<Value> {
+    pub fn build(mut self) -> Result<Value, Error> {
         self.bump()?;
 
         let plist = self.build_value()?;
@@ -29,7 +29,7 @@ impl<T: Iterator<Item = Result<Event>>> Builder<T> {
         Ok(plist)
     }
 
-    fn bump(&mut self) -> Result<()> {
+    fn bump(&mut self) -> Result<(), Error> {
         self.token = match self.stream.next() {
             Some(Ok(token)) => Some(token),
             Some(Err(err)) => return Err(err),
@@ -38,7 +38,7 @@ impl<T: Iterator<Item = Result<Event>>> Builder<T> {
         Ok(())
     }
 
-    fn build_value(&mut self) -> Result<Value> {
+    fn build_value(&mut self) -> Result<Value, Error> {
         match self.token.take() {
             Some(Event::StartArray(len)) => Ok(Value::Array(self.build_array(len)?)),
             Some(Event::StartDictionary(len)) => Ok(Value::Dictionary(self.build_dict(len)?)),
@@ -58,7 +58,7 @@ impl<T: Iterator<Item = Result<Event>>> Builder<T> {
         }
     }
 
-    fn build_array(&mut self, len: Option<u64>) -> Result<Vec<Value>> {
+    fn build_array(&mut self, len: Option<u64>) -> Result<Vec<Value>, Error> {
         let len = u64_option_to_usize(len)?;
         let mut values = match len {
             Some(len) => Vec::with_capacity(len),
@@ -75,7 +75,7 @@ impl<T: Iterator<Item = Result<Event>>> Builder<T> {
         }
     }
 
-    fn build_dict(&mut self, _len: Option<u64>) -> Result<BTreeMap<String, Value>> {
+    fn build_dict(&mut self, _len: Option<u64>) -> Result<BTreeMap<String, Value>, Error> {
         let mut values = BTreeMap::new();
 
         loop {
diff --git a/src/date.rs b/src/date.rs
index 3c83c9b..4ee1dae 100644
--- a/src/date.rs
+++ b/src/date.rs
@@ -3,7 +3,7 @@ use std::fmt;
 use std::result::Result as StdResult;
 use std::time::{Duration, SystemTime, UNIX_EPOCH};
 
-use {Error, Result};
+use Error;
 
 /// A UTC timestamp. Used for serialization to and from the plist date type.
 #[derive(Clone, PartialEq)]
@@ -12,7 +12,7 @@ pub struct Date {
 }
 
 impl Date {
-    pub(crate) fn from_rfc3339(date: &str) -> Result<Self> {
+    pub(crate) fn from_rfc3339(date: &str) -> Result<Self, Error> {
         Ok(Date {
             inner: humantime::parse_rfc3339(date).map_err(|_| Error::InvalidData)?,
         })
@@ -22,7 +22,7 @@ impl Date {
         format!("{}", humantime::format_rfc3339(self.inner))
     }
 
-    pub(crate) fn from_seconds_since_plist_epoch(timestamp: f64) -> Result<Date> {
+    pub(crate) fn from_seconds_since_plist_epoch(timestamp: f64) -> Result<Date, Error> {
         // `timestamp` is the number of seconds since the plist epoch of 1/1/2001 00:00:00.
         // `PLIST_EPOCH_UNIX_TIMESTAMP` is the unix timestamp of the plist epoch.
         const PLIST_EPOCH_UNIX_TIMESTAMP: u64 = 978307200;
diff --git a/src/events/binary_reader.rs b/src/events/binary_reader.rs
index e077904..553040d 100644
--- a/src/events/binary_reader.rs
+++ b/src/events/binary_reader.rs
@@ -4,7 +4,7 @@ use std::mem::size_of;
 use std::string::{FromUtf16Error, FromUtf8Error};
 
 use events::Event;
-use {u64_to_usize, Date, Error, Result};
+use {u64_to_usize, Date, Error};
 
 impl From<FromUtf8Error> for Error {
     fn from(_: FromUtf8Error) -> Error {
@@ -69,7 +69,7 @@ impl<R: Read + Seek> BinaryReader<R> {
         byte_len <= self.max_allocation_bytes as u64
     }
 
-    fn allocate_vec<T>(&self, len: u64, size: usize) -> Result<Vec<T>> {
+    fn allocate_vec<T>(&self, len: u64, size: usize) -> Result<Vec<T>, Error> {
         if self.can_allocate(len, size) {
             Ok(Vec::with_capacity(len as usize))
         } else {
@@ -77,7 +77,7 @@ impl<R: Read + Seek> BinaryReader<R> {
         }
     }
 
-    fn read_trailer(&mut self) -> Result<()> {
+    fn read_trailer(&mut self) -> Result<(), Error> {
         self.reader.seek(SeekFrom::Start(0))?;
         let mut magic = [0; 8];
         self.reader.read_exact(&mut magic)?;
@@ -123,7 +123,7 @@ impl<R: Read + Seek> BinaryReader<R> {
         Ok(())
     }
 
-    fn read_ints(&mut self, len: u64, size: u8) -> Result<Vec<u64>> {
+    fn read_ints(&mut self, len: u64, size: u8) -> Result<Vec<u64>, Error> {
         let mut ints = self.allocate_vec(len, size as usize)?;
         for _ in 0..len {
             match size {
@@ -137,12 +137,12 @@ impl<R: Read + Seek> BinaryReader<R> {
         Ok(ints)
     }
 
-    fn read_refs(&mut self, len: u64) -> Result<Vec<u64>> {
+    fn read_refs(&mut self, len: u64) -> Result<Vec<u64>, Error> {
         let ref_size = self.ref_size;
         self.read_ints(len, ref_size)
     }
 
-    fn read_object_len(&mut self, len: u8) -> Result<u64> {
+    fn read_object_len(&mut self, len: u8) -> Result<u64, Error> {
         if (len & 0x0f) == 0x0f {
             let len_power_of_two = self.reader.read_u8()? & 0x03;
             Ok(match len_power_of_two {
@@ -157,14 +157,14 @@ impl<R: Read + Seek> BinaryReader<R> {
         }
     }
 
-    fn read_data(&mut self, len: u64) -> Result<Vec<u8>> {
+    fn read_data(&mut self, len: u64) -> Result<Vec<u8>, Error> {
         let mut data = self.allocate_vec(len, size_of::<u8>())?;
         data.resize(len as usize, 0);
         self.reader.read_exact(&mut data)?;
         Ok(data)
     }
 
-    fn seek_to_object(&mut self, object_ref: u64) -> Result<u64> {
+    fn seek_to_object(&mut self, object_ref: u64) -> Result<u64, Error> {
         let object_ref = u64_to_usize(object_ref)?;
         let offset = *self
             .object_offsets
@@ -173,7 +173,7 @@ impl<R: Read + Seek> BinaryReader<R> {
         Ok(self.reader.seek(SeekFrom::Start(offset))?)
     }
 
-    fn read_next(&mut self) -> Result<Option<Event>> {
+    fn read_next(&mut self) -> Result<Option<Event>, Error> {
         if self.ref_size == 0 {
             // Initialise here rather than in new
             self.read_trailer()?;
@@ -306,9 +306,9 @@ impl<R: Read + Seek> BinaryReader<R> {
 }
 
 impl<R: Read + Seek> Iterator for BinaryReader<R> {
-    type Item = Result<Event>;
+    type Item = Result<Event, Error>;
 
-    fn next(&mut self) -> Option<Result<Event>> {
+    fn next(&mut self) -> Option<Result<Event, Error>> {
         if self.finished {
             None
         } else {
diff --git a/src/events/mod.rs b/src/events/mod.rs
index b933ceb..cf5aa67 100644
--- a/src/events/mod.rs
+++ b/src/events/mod.rs
@@ -8,7 +8,7 @@ mod xml_writer;
 pub use self::xml_writer::XmlWriter;
 
 use std::io::{Read, Seek, SeekFrom};
-use {Date, Result};
+use {Date, Error};
 
 /// An encoding of a plist as a flat structure.
 ///
@@ -55,7 +55,7 @@ impl<R: Read + Seek> Reader<R> {
         Reader(ReaderInner::Uninitialized(Some(reader)))
     }
 
-    fn is_binary(reader: &mut R) -> Result<bool> {
+    fn is_binary(reader: &mut R) -> Result<bool, Error> {
         reader.seek(SeekFrom::Start(0))?;
         let mut magic = [0; 8];
         reader.read_exact(&mut magic)?;
@@ -66,9 +66,9 @@ impl<R: Read + Seek> Reader<R> {
 }
 
 impl<R: Read + Seek> Iterator for Reader<R> {
-    type Item = Result<Event>;
+    type Item = Result<Event, Error>;
 
-    fn next(&mut self) -> Option<Result<Event>> {
+    fn next(&mut self) -> Option<Result<Event, Error>> {
         let mut reader = match self.0 {
             ReaderInner::Xml(ref mut parser) => return parser.next(),
             ReaderInner::Binary(ref mut parser) => return parser.next(),
@@ -91,5 +91,5 @@ impl<R: Read + Seek> Iterator for Reader<R> {
 }
 
 pub trait Writer {
-    fn write(&mut self, event: &Event) -> Result<()>;
+    fn write(&mut self, event: &Event) -> Result<(), Error>;
 }
diff --git a/src/events/xml_reader.rs b/src/events/xml_reader.rs
index 46e0062..6bb9936 100644
--- a/src/events/xml_reader.rs
+++ b/src/events/xml_reader.rs
@@ -4,7 +4,7 @@ use std::str::FromStr;
 use xml_rs::reader::{EventReader, ParserConfig, XmlEvent};
 
 use events::Event;
-use {Date, Error, Result};
+use {Date, Error};
 
 pub struct XmlReader<R: Read> {
     xml_reader: EventReader<R>,
@@ -30,9 +30,9 @@ impl<R: Read> XmlReader<R> {
         }
     }
 
-    fn read_content<F>(&mut self, f: F) -> Result<Event>
+    fn read_content<F>(&mut self, f: F) -> Result<Event, Error>
     where
-        F: FnOnce(String) -> Result<Event>,
+        F: FnOnce(String) -> Result<Event, Error>,
     {
         match self.xml_reader.next() {
             Ok(XmlEvent::Characters(s)) => f(s),
@@ -52,7 +52,7 @@ impl<R: Read> XmlReader<R> {
         }
     }
 
-    fn read_next(&mut self) -> Option<Result<Event>> {
+    fn read_next(&mut self) -> Option<Result<Event, Error>> {
         loop {
             match self.next_event() {
                 Ok(XmlEvent::StartElement { name, .. }) => {
@@ -126,9 +126,9 @@ impl<R: Read> XmlReader<R> {
 }
 
 impl<R: Read> Iterator for XmlReader<R> {
-    type Item = Result<Event>;
+    type Item = Result<Event, Error>;
 
-    fn next(&mut self) -> Option<Result<Event>> {
+    fn next(&mut self) -> Option<Result<Event, Error>> {
         if self.finished {
             None
         } else {
diff --git a/src/events/xml_writer.rs b/src/events/xml_writer.rs
index f89ea81..08f399f 100644
--- a/src/events/xml_writer.rs
+++ b/src/events/xml_writer.rs
@@ -6,7 +6,7 @@ use xml_rs::namespace::Namespace;
 use xml_rs::writer::{EmitterConfig, Error as XmlWriterError, EventWriter, XmlEvent};
 
 use events::{Event, Writer};
-use {Error, Result};
+use Error;
 
 impl From<XmlWriterError> for Error {
     fn from(err: XmlWriterError) -> Error {
@@ -54,14 +54,14 @@ impl<W: Write> XmlWriter<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<(), Error> {
         self.start_element(name)?;
         self.write_value(value)?;
         self.end_element(name)?;
         Ok(())
     }
 
-    fn start_element(&mut self, name: &str) -> Result<()> {
+    fn start_element(&mut self, name: &str) -> Result<(), Error> {
         self.xml_writer.write(XmlEvent::StartElement {
             name: Name::local(name),
             attributes: Cow::Borrowed(&[]),
@@ -70,19 +70,19 @@ impl<W: Write> XmlWriter<W> {
         Ok(())
     }
 
-    fn end_element(&mut self, name: &str) -> Result<()> {
+    fn end_element(&mut self, name: &str) -> Result<(), Error> {
         self.xml_writer.write(XmlEvent::EndElement {
             name: Some(Name::local(name)),
         })?;
         Ok(())
     }
 
-    fn write_value(&mut self, value: &str) -> Result<()> {
+    fn write_value(&mut self, value: &str) -> Result<(), Error> {
         self.xml_writer.write(XmlEvent::Characters(value))?;
         Ok(())
     }
 
-    fn maybe_end_plist(&mut self) -> Result<()> {
+    fn maybe_end_plist(&mut self) -> Result<(), Error> {
         // If there are no more open tags then write the </plist> element
         if self.stack.len() == 1 {
             // We didn't tell the xml_writer about the <plist> tag so we'll skip telling it
@@ -96,13 +96,13 @@ impl<W: Write> XmlWriter<W> {
         Ok(())
     }
 
-    pub fn write(&mut self, event: &Event) -> Result<()> {
+    pub fn write(&mut self, event: &Event) -> Result<(), Error> {
         <Self as Writer>::write(self, event)
     }
 }
 
 impl<W: Write> Writer for XmlWriter<W> {
-    fn write(&mut self, event: &Event) -> Result<()> {
+    fn write(&mut self, event: &Event) -> Result<(), Error> {
         match self.stack.pop() {
             Some(Element::Dictionary(DictionaryState::ExpectKey)) => {
                 match *event {
diff --git a/src/lib.rs b/src/lib.rs
index c129400..0415d7a 100644
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -88,8 +88,6 @@ pub use self::ser::{serialize_to_xml, Serializer};
 use std::fmt;
 use std::io;
 
-type Result<T> = ::std::result::Result<T, Error>;
-
 #[derive(Debug)]
 pub enum Error {
     InvalidData,
@@ -131,7 +129,7 @@ impl From<io::Error> for Error {
     }
 }
 
-fn u64_to_usize(len_u64: u64) -> Result<usize> {
+fn u64_to_usize(len_u64: u64) -> Result<usize, Error> {
     let len = len_u64 as usize;
     if len as u64 != len_u64 {
         return Err(Error::InvalidData); // Too long
@@ -139,7 +137,7 @@ fn u64_to_usize(len_u64: u64) -> Result<usize> {
     Ok(len)
 }
 
-fn u64_option_to_usize(len: Option<u64>) -> Result<Option<usize>> {
+fn u64_option_to_usize(len: Option<u64>) -> Result<Option<usize>, Error> {
     match len {
         Some(len) => Ok(Some(u64_to_usize(len)?)),
         None => Ok(None),
diff --git a/src/value.rs b/src/value.rs
index d04ad86..bb422e7 100644
--- a/src/value.rs
+++ b/src/value.rs
@@ -2,7 +2,7 @@ use std::collections::BTreeMap;
 use std::io::{Read, Seek};
 
 use events::{Event, Reader};
-use {builder, Date, Result};
+use {builder, Date, Error};
 
 #[derive(Clone, Debug, PartialEq)]
 pub enum Value {
@@ -17,14 +17,14 @@ pub enum Value {
 }
 
 impl Value {
-    pub fn read<R: Read + Seek>(reader: R) -> Result<Value> {
+    pub fn read<R: Read + Seek>(reader: R) -> Result<Value, Error> {
         let reader = Reader::new(reader);
         Value::from_events(reader)
     }
 
-    pub fn from_events<T>(events: T) -> Result<Value>
+    pub fn from_events<T>(events: T) -> Result<Value, Error>
     where
-        T: IntoIterator<Item = Result<Event>>,
+        T: IntoIterator<Item = Result<Event, Error>>,
     {
         let iter = events.into_iter();
         let builder = builder::Builder::new(iter);