Index: serde-ini/Cargo.toml
===================================================================
--- serde-ini.orig/Cargo.toml
+++ serde-ini/Cargo.toml
@@ -20,13 +20,9 @@ readme = "README.md"
 keywords = ["ini", "cfg", "serde"]
 license = "MIT"
 repository = "https://github.com/arcnmx/serde-ini"
-[dependencies.result]
-version = "^1.0.0"
 
 [dependencies.serde]
 version = "^1.0.0"
 
-[dependencies.void]
-version = "^1.0.2"
 [dev-dependencies.serde_derive]
 version = "^1.0.0"
Index: serde-ini/src/lib.rs
===================================================================
--- serde-ini.orig/src/lib.rs
+++ serde-ini/src/lib.rs
@@ -3,8 +3,6 @@
 
 //! Windows INI format serialization for serde
 
-extern crate result;
-extern crate void;
 #[macro_use]
 extern crate serde;
 
Index: serde-ini/src/parse.rs
===================================================================
--- serde-ini.orig/src/parse.rs
+++ serde-ini/src/parse.rs
@@ -1,6 +1,4 @@
-use std::{io, fmt, error, str};
-use result::prelude::*;
-use void::Void;
+use std::{io, fmt, error, str, convert::Infallible};
 
 #[derive(Clone, Eq, PartialEq, Ord, PartialOrd, Debug)]
 pub enum Item {
@@ -106,11 +104,7 @@ impl<R: io::Read> Parser<io::Lines<io::B
 }
 
 impl<T> Parser<T> {
-    fn parse_next<E, S: AsRef<str>>(line: Option<S>) -> Result<Option<Item>, Error<E>> {
-        let line = match line {
-            Some(line) => line,
-            None => return Ok(None),
-        };
+    fn parse_next<E, S: AsRef<str>>(line: S) -> Result<Item, Error<E>> {
         let line = line.as_ref();
 
         if line.starts_with('[') {
@@ -119,27 +113,27 @@ impl<T> Parser<T> {
                 if line.contains(']') {
                     Err(Error::Syntax(SyntaxError::SectionName))
                 } else {
-                    Ok(Some(Item::Section {
+                    Ok(Item::Section {
                         name: line.into(),
-                    }))
+                    })
                 }
             } else {
                 Err(Error::Syntax(SyntaxError::SectionNotClosed))
             }
         } else if line.starts_with(';') || line.starts_with('#') {
-            Ok(Some(Item::Comment {
+            Ok(Item::Comment {
                 text: line.into(),
-            }))
+            })
         } else {
             let mut line = line.splitn(2, '=');
             if let Some(key) = line.next() {
                 if let Some(value) = line.next() {
-                    Ok(Some(Item::Value {
+                    Ok(Item::Value {
                         key: key.trim().into(),
                         value: value.trim().into(),
-                    }))
+                    })
                 } else if key.is_empty() {
-                    Ok(Some(Item::Empty))
+                    Ok(Item::Empty)
                 } else {
                     Err(Error::Syntax(SyntaxError::MissingEquals))
                 }
@@ -154,14 +148,15 @@ impl<E, S: AsRef<str>, T: Iterator<Item=
     type Item = Result<Item, Error<E>>;
 
     fn next(&mut self) -> Option<Self::Item> {
-        self.input.next_invert().map_err(Error::Inner).and_then(|l| Self::parse_next(l)).invert()
+        self.input.next()
+            .map(|v| v.map_err(Error::Inner).and_then(Self::parse_next))
     }
 }
 
 pub struct OkIter<I>(pub I);
 
 impl<T, I: Iterator<Item=T>> Iterator for OkIter<I> {
-    type Item = Result<T, Void>;
+    type Item = Result<T, Infallible>;
 
     fn next(&mut self) -> Option<Self::Item> {
         (self.0).next().map(Ok)
