Implement entity's Iter in terms of std::iter::Enumerate.

Entity's `Iter` is essentially an `Enumerate`, so just use an
`Enumerate` under the covers. This makes the code simpler.

lib/entity/src/iter.rs

@@ -1,6 +1,7 @@
 //! A double-ended iterator over entity references and entities.
 
 use EntityRef;
+use std::iter::Enumerate;
 use std::marker::PhantomData;
 use std::slice;
 
@@ -9,9 +10,7 @@ pub struct Iter<'a, K: EntityRef, V>
 where
     V: 'a,
 {
-    pos: usize,
-    rev_pos: usize,
-    iter: slice::Iter<'a, V>,
+    enumerate: Enumerate<slice::Iter<'a, V>>,
     unused: PhantomData<K>,
 }
 
@@ -20,9 +19,7 @@ impl<'a, K: EntityRef, V> Iter<'a, K, V> {
     /// of `iter`.
     pub fn new(iter: slice::Iter<'a, V>) -> Self {
         Self {
-            pos: 0,
-            rev_pos: iter.len(),
-            iter,
+            enumerate: iter.enumerate(),
             unused: PhantomData,
         }
     }
@@ -32,29 +29,17 @@ impl<'a, K: EntityRef, V> Iterator for Iter<'a, K, V> {
     type Item = (K, &'a V);
 
     fn next(&mut self) -> Option<Self::Item> {
-        if let Some(next) = self.iter.next() {
-            let pos = self.pos;
-            self.pos += 1;
-            Some((K::new(pos), next))
-        } else {
-            None
-        }
+        self.enumerate.next().map(|(i, v)| (K::new(i), v))
     }
 
     fn size_hint(&self) -> (usize, Option<usize>) {
-        self.iter.size_hint()
+        self.enumerate.size_hint()
     }
 }
 
 impl<'a, K: EntityRef, V> DoubleEndedIterator for Iter<'a, K, V> {
     fn next_back(&mut self) -> Option<Self::Item> {
-        if let Some(next_back) = self.iter.next_back() {
-            let rev_pos = self.rev_pos - 1;
-            self.rev_pos -= 1;
-            Some((K::new(rev_pos), next_back))
-        } else {
-            None
-        }
+        self.enumerate.next_back().map(|(i, v)| (K::new(i), v))
     }
 }
 
@@ -65,9 +50,7 @@ pub struct IterMut<'a, K: EntityRef, V>
 where
     V: 'a,
 {
-    pos: usize,
-    rev_pos: usize,
-    iter: slice::IterMut<'a, V>,
+    enumerate: Enumerate<slice::IterMut<'a, V>>,
     unused: PhantomData<K>,
 }
 
@@ -76,9 +59,7 @@ impl<'a, K: EntityRef, V> IterMut<'a, K, V> {
     /// of `iter`.
     pub fn new(iter: slice::IterMut<'a, V>) -> Self {
         Self {
-            pos: 0,
-            rev_pos: iter.len(),
-            iter,
+            enumerate: iter.enumerate(),
             unused: PhantomData,
         }
     }
@@ -88,29 +69,17 @@ impl<'a, K: EntityRef, V> Iterator for IterMut<'a, K, V> {
     type Item = (K, &'a mut V);
 
     fn next(&mut self) -> Option<Self::Item> {
-        if let Some(next) = self.iter.next() {
-            let pos = self.pos;
-            self.pos += 1;
-            Some((K::new(pos), next))
-        } else {
-            None
-        }
+        self.enumerate.next().map(|(i, v)| (K::new(i), v))
     }
 
     fn size_hint(&self) -> (usize, Option<usize>) {
-        self.iter.size_hint()
+        self.enumerate.size_hint()
     }
 }
 
 impl<'a, K: EntityRef, V> DoubleEndedIterator for IterMut<'a, K, V> {
     fn next_back(&mut self) -> Option<Self::Item> {
-        if let Some(next_back) = self.iter.next_back() {
-            let rev_pos = self.rev_pos - 1;
-            self.rev_pos -= 1;
-            Some((K::new(rev_pos), next_back))
-        } else {
-            None
-        }
+        self.enumerate.next_back().map(|(i, v)| (K::new(i), v))
     }
 }