diff --git a/src/data.rs b/src/data.rs
index 004a938..b6199a7 100644
--- a/src/data.rs
+++ b/src/data.rs
@@ -65,6 +65,48 @@
     }
 }
 
+/// The `Iterator` type returned by [`Fields::iter`].
+///
+/// [`Fields::iter`]: struct.Fields.html#method.iter
+///
+/// *This type is available if Syn is build with the `"derive"` or `"full"`
+/// feature.*
+pub struct FieldsIter<'a>(Option<punctuated::Iter<'a, Field, Token![,]>>);
+
+impl<'a> Iterator for FieldsIter<'a> {
+    type Item = &'a Field;
+    fn next(&mut self) -> Option<&'a Field> {
+        match self.0 {
+            Some(ref mut i) => i.next(),
+            None => None,
+        }
+    }
+}
+
+impl Fields {
+    /// Get an iterator over the [`Field`] items in this object. This iterator
+    /// can be used to iterate over a named or unnamed struct or variant's
+    /// fields uniformly.
+    ///
+    /// [`Field`]: struct.Field.html
+    pub fn iter(&self) -> FieldsIter {
+        match *self {
+            Fields::Unit => FieldsIter(None),
+            Fields::Named(ref f) => FieldsIter(Some(f.named.iter())),
+            Fields::Unnamed(ref f) => FieldsIter(Some(f.unnamed.iter())),
+        }
+    }
+}
+
+impl<'a> IntoIterator for &'a Fields {
+    type Item = &'a Field;
+    type IntoIter = FieldsIter<'a>;
+
+    fn into_iter(self) -> Self::IntoIter {
+        self.iter()
+    }
+}
+
 ast_struct! {
     /// A field of a struct or enum variant.
     ///
diff --git a/src/derive.rs b/src/derive.rs
index 1fb0e8f..3ad893d 100644
--- a/src/derive.rs
+++ b/src/derive.rs
@@ -7,7 +7,7 @@
 // except according to those terms.
 
 use super::*;
-use punctuated::{Iter, Punctuated};
+use punctuated::Punctuated;
 
 ast_struct! {
     /// Data structure sent to a `proc_macro_derive` macro.
@@ -75,26 +75,6 @@
     do_not_generate_to_tokens
 }
 
-impl Fields {
-    /// Returns an iterator over the fields
-    pub fn iter(&self) -> Iter<Field, Token![,]> {
-        match *self {
-            Fields::Unit => Iter::empty(),
-            Fields::Named(FieldsNamed { ref named, .. }) => named.iter(),
-            Fields::Unnamed(FieldsUnnamed { ref unnamed, .. }) => unnamed.iter(),
-        }
-    }
-}
-
-impl<'a> IntoIterator for &'a Fields {
-    type Item = &'a Field;
-    type IntoIter = Iter<'a, Field, Token![,]>;
-
-    fn into_iter(self) -> Self::IntoIter {
-        self.iter()
-    }
-}
-
 #[cfg(feature = "parsing")]
 pub mod parsing {
     use super::*;
diff --git a/src/lib.rs b/src/lib.rs
index 77b0d23..380552c 100644
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -287,8 +287,8 @@
 #[cfg(any(feature = "full", feature = "derive"))]
 mod data;
 #[cfg(any(feature = "full", feature = "derive"))]
-pub use data::{Field, Fields, FieldsNamed, FieldsUnnamed, Variant, VisCrate, VisPublic,
-               VisRestricted, Visibility};
+pub use data::{Field, Fields, FieldsNamed, FieldsUnnamed, FieldsIter, Variant,
+               VisCrate, VisPublic, VisRestricted, Visibility};
 
 #[cfg(any(feature = "full", feature = "derive"))]
 mod expr;
diff --git a/src/punctuated.rs b/src/punctuated.rs
index dd5af25..afc163c 100644
--- a/src/punctuated.rs
+++ b/src/punctuated.rs
@@ -398,14 +398,6 @@
     inner: slice::Iter<'a, (T, Option<P>)>,
 }
 
-impl<'a, T: 'a, P: 'a> Iter<'a, T, P> {
-    pub(crate) fn empty() -> Self {
-        Self {
-            inner: [].iter(),
-        }
-    }
-}
-
 impl<'a, T, P> Iterator for Iter<'a, T, P> {
     type Item = &'a T;