src/block.rs

         }
     }
 
+    /// Performs an internal iteration step. Returns `None` until there is a value for the iterator to
+    /// return. Returns `Some(None)` to end the iteration.
     #[inline]
+    #[allow(clippy::option_option)]
     fn step(&mut self) -> Option<Option<Element<'a>>> {
         match self.state {
             ElementsIterState::Group => {

src/lib.rs

 osmpbf = "0.1"
 ```
 
-and this to your crate root:
+and if you're using Rust 2015, add this line to the crate root:
 
 ```rust
 extern crate osmpbf;
 file:
 
 ```rust
-extern crate osmpbf;
-
-use osmpbf::*;
+use osmpbf::{ElementReader, Element};
 
-fn main() {
-    let reader = ElementReader::from_path("tests/test.osm.pbf").unwrap();
-    let mut ways = 0_u64;
+let reader = ElementReader::from_path("tests/test.osm.pbf").unwrap();
+let mut ways = 0_u64;
 
-    // Increment the counter by one for each way.
-    reader.for_each(|element| {
-        if let Element::Way(_) = element {
-            ways += 1;
-        }
-    }).unwrap();
+// Increment the counter by one for each way.
+reader.for_each(|element| {
+    if let Element::Way(_) = element {
+        ways += 1;
+    }
+}).unwrap();
 
-    println!("Number of ways: {}", ways);
-}
+println!("Number of ways: {}", ways);
 ```
 
 ## Example: Count ways in parallel
 decoding the file in parallel:
 
 ```rust
-use osmpbf::*;
-
-fn main() {
-    let reader = ElementReader::from_path("tests/test.osm.pbf").unwrap();
-
-    // Count the ways
-    let ways = reader.par_map_reduce(
-        |element| {
-            match element {
-                Element::Way(_) => 1,
-                _ => 0,
-            }
-        },
-        || 0_u64,      // Zero is the identity value for addition
-        |a, b| a + b   // Sum the partial results
-    ).unwrap();
-
-    println!("Number of ways: {}", ways);
-}
+use osmpbf::{ElementReader, Element};
+
+let reader = ElementReader::from_path("tests/test.osm.pbf").unwrap();
+
+// Count the ways
+let ways = reader.par_map_reduce(
+    |element| {
+        match element {
+            Element::Way(_) => 1,
+            _ => 0,
+        }
+    },
+    || 0_u64,      // Zero is the identity value for addition
+    |a, b| a + b   // Sum the partial results
+).unwrap();
+
+println!("Number of ways: {}", ways);
 ```
 */