From 87afcbf67be49ef490409b645c3c493772945f25 Mon Sep 17 00:00:00 2001
From: IceSentry <c.giguere42@gmail.com>
Date: Sat, 7 May 2022 16:47:03 -0400
Subject: [PATCH 01/15] add any() check to event reader that consumes the
 iterator

---
 crates/bevy_ecs/src/event.rs | 35 +++++++++++++++++++++++++++++++++++
 1 file changed, 35 insertions(+)

diff --git a/crates/bevy_ecs/src/event.rs b/crates/bevy_ecs/src/event.rs
index 00e0c6b74607e..070dd9fe924b8 100644
--- a/crates/bevy_ecs/src/event.rs
+++ b/crates/bevy_ecs/src/event.rs
@@ -365,6 +365,41 @@ impl<I: Iterator> ExactSizeIterator for ExactSize<I> {
     }
 }
 
+impl<'w, 's, E: Event> EventReader<'w, 's, E> {
+    /// Iterates over the events this [`EventReader`] has not seen yet. This updates the
+    /// [`EventReader`]'s event counter, which means subsequent event reads will not include events
+    /// that happened before now.
+    pub fn iter(&mut self) -> impl DoubleEndedIterator<Item = &E> + ExactSizeIterator<Item = &E> {
+        self.iter_with_id().map(|(event, _id)| event)
+    }
+
+    /// Like [`iter`](Self::iter), except also returning the [`EventId`] of the events.
+    pub fn iter_with_id(
+        &mut self,
+    ) -> impl DoubleEndedIterator<Item = (&E, EventId<E>)> + ExactSizeIterator<Item = (&E, EventId<E>)>
+    {
+        internal_event_reader(&mut self.last_event_count.0, &self.events).map(|(event, id)| {
+            trace!("EventReader::iter() -> {}", id);
+            (event, id)
+        })
+    }
+
+    /// Determines the number of events available to be read from this [`EventReader`] without consuming any.
+    pub fn len(&self) -> usize {
+        internal_event_reader(&mut self.last_event_count.0.clone(), &self.events).len()
+    }
+
+    /// Determines if there are any events available to be read without consuming any.
+    pub fn is_empty(&self) -> bool {
+        self.len() == 0
+    }
+
+    /// Determines if there are any events available to be read and consumes all events.
+    pub fn any(&mut self) -> bool {
+        self.iter().last().is_some()
+    }
+}
+
 impl<E: Event> Events<E> {
     /// "Sends" an `event` by writing it to the current event buffer. [`EventReader`]s can then read
     /// the event.

From cbbdd2f8432027c6a79cc42674c417de0d838919 Mon Sep 17 00:00:00 2001
From: IceSentry <c.giguere42@gmail.com>
Date: Sat, 7 May 2022 17:06:42 -0400
Subject: [PATCH 02/15] update doc

---
 crates/bevy_ecs/src/event.rs | 3 +++
 1 file changed, 3 insertions(+)

diff --git a/crates/bevy_ecs/src/event.rs b/crates/bevy_ecs/src/event.rs
index 070dd9fe924b8..6f36a5751f696 100644
--- a/crates/bevy_ecs/src/event.rs
+++ b/crates/bevy_ecs/src/event.rs
@@ -390,11 +390,14 @@ impl<'w, 's, E: Event> EventReader<'w, 's, E> {
     }
 
     /// Determines if there are any events available to be read without consuming any.
+    /// If you need to consume the iterator you can use [`EventReader::any`]
     pub fn is_empty(&self) -> bool {
         self.len() == 0
     }
 
     /// Determines if there are any events available to be read and consumes all events.
+    /// If you don't need to consume the iterator you can use [`EventReader::is_empty`]
+    /// WARNING: `events.any()` is not the same as doing `!events.is_empty()`
     pub fn any(&mut self) -> bool {
         self.iter().last().is_some()
     }

From 4a69efd9b12d2aaec1e860a6f09199a9b225f65c Mon Sep 17 00:00:00 2001
From: IceSentry <c.giguere42@gmail.com>
Date: Sat, 7 May 2022 17:09:07 -0400
Subject: [PATCH 03/15] add warning to is_empty

---
 crates/bevy_ecs/src/event.rs | 1 +
 1 file changed, 1 insertion(+)

diff --git a/crates/bevy_ecs/src/event.rs b/crates/bevy_ecs/src/event.rs
index 6f36a5751f696..ad196babc464e 100644
--- a/crates/bevy_ecs/src/event.rs
+++ b/crates/bevy_ecs/src/event.rs
@@ -391,6 +391,7 @@ impl<'w, 's, E: Event> EventReader<'w, 's, E> {
 
     /// Determines if there are any events available to be read without consuming any.
     /// If you need to consume the iterator you can use [`EventReader::any`]
+    /// WARNING: `events.is_empty()` is not the same as doing `!events.any()`
     pub fn is_empty(&self) -> bool {
         self.len() == 0
     }

From 39fd84bba7fb24c91c2110fe668edb23c1eccf95 Mon Sep 17 00:00:00 2001
From: IceSentry <c.giguere42@gmail.com>
Date: Sat, 7 May 2022 17:32:37 -0400
Subject: [PATCH 04/15] rephrase is_empty docs

---
 crates/bevy_ecs/src/event.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/crates/bevy_ecs/src/event.rs b/crates/bevy_ecs/src/event.rs
index ad196babc464e..e3f1c7518133b 100644
--- a/crates/bevy_ecs/src/event.rs
+++ b/crates/bevy_ecs/src/event.rs
@@ -389,7 +389,7 @@ impl<'w, 's, E: Event> EventReader<'w, 's, E> {
         internal_event_reader(&mut self.last_event_count.0.clone(), &self.events).len()
     }
 
-    /// Determines if there are any events available to be read without consuming any.
+    /// Determines if no events are available to be read without consuming any.
     /// If you need to consume the iterator you can use [`EventReader::any`]
     /// WARNING: `events.is_empty()` is not the same as doing `!events.any()`
     pub fn is_empty(&self) -> bool {

From 228a4a8ba91496a1cb9c0424bc4d8e203e3cbdab Mon Sep 17 00:00:00 2001
From: IceSentry <c.giguere42@gmail.com>
Date: Mon, 9 May 2022 13:20:16 -0400
Subject: [PATCH 05/15] use clear instead of any

---
 crates/bevy_ecs/src/event.rs | 34 +++++++++++++++++++++++++++-------
 1 file changed, 27 insertions(+), 7 deletions(-)

diff --git a/crates/bevy_ecs/src/event.rs b/crates/bevy_ecs/src/event.rs
index e3f1c7518133b..15e05f25db171 100644
--- a/crates/bevy_ecs/src/event.rs
+++ b/crates/bevy_ecs/src/event.rs
@@ -390,17 +390,14 @@ impl<'w, 's, E: Event> EventReader<'w, 's, E> {
     }
 
     /// Determines if no events are available to be read without consuming any.
-    /// If you need to consume the iterator you can use [`EventReader::any`]
-    /// WARNING: `events.is_empty()` is not the same as doing `!events.any()`
+    /// If you need to consume the iterator you can use [`EventReader::clear`]
     pub fn is_empty(&self) -> bool {
         self.len() == 0
     }
 
-    /// Determines if there are any events available to be read and consumes all events.
-    /// If you don't need to consume the iterator you can use [`EventReader::is_empty`]
-    /// WARNING: `events.any()` is not the same as doing `!events.is_empty()`
-    pub fn any(&mut self) -> bool {
-        self.iter().last().is_some()
+    /// Consumes the iterator. This means all currently available events will be removed before the next frame.
+    pub fn clear(mut self) {
+        self.iter().last();
     }
 }
 
@@ -766,6 +763,29 @@ mod tests {
         assert!(reader.is_empty(&events));
     }
 
+    #[test]
+    fn test_event_reader_clear() {
+        use bevy_ecs::prelude::*;
+
+        let mut world = World::new();
+        let mut events = Events::<TestEvent>::default();
+        events.send(TestEvent { i: 0 });
+        world.insert_resource(events);
+
+        let mut reader = IntoSystem::into_system(|events: EventReader<TestEvent>| -> bool {
+            if !events.is_empty() {
+                events.clear();
+                return false;
+            } else {
+                return true;
+            }
+        });
+        reader.initialize(&mut world);
+
+        assert_eq!(reader.run((), &mut world), false);
+        assert_eq!(reader.run((), &mut world), true);
+    }
+
     #[derive(Clone, PartialEq, Debug, Default)]
     struct EmptyTestEvent;
 

From 87262e528d20a005a6f4d0eded2d03cddcd205ad Mon Sep 17 00:00:00 2001
From: IceSentry <c.giguere42@gmail.com>
Date: Mon, 9 May 2022 13:20:27 -0400
Subject: [PATCH 06/15] use clear in breakout example

---
 examples/games/breakout.rs | 9 +++++----
 1 file changed, 5 insertions(+), 4 deletions(-)

diff --git a/examples/games/breakout.rs b/examples/games/breakout.rs
index 06d091f76d93c..4c777fe325abd 100644
--- a/examples/games/breakout.rs
+++ b/examples/games/breakout.rs
@@ -411,13 +411,14 @@ fn check_for_collisions(
 }
 
 fn play_collision_sound(
-    mut collision_events: EventReader<CollisionEvent>,
+    collision_events: EventReader<CollisionEvent>,
     audio: Res<Audio>,
     sound: Res<CollisionSound>,
 ) {
-    // Play a sound once per frame if a collision occurred. `count` consumes the
-    // events, preventing them from triggering a sound on the next frame.
-    if collision_events.iter().count() > 0 {
+    // Play a sound once per frame if a collision occurred.
+    if !collision_events.is_empty() {
+        // This prevents events staying active on the next frame.
+        collision_events.clear();
         audio.play(sound.0.clone());
     }
 }

From de70598da9b6f4993309de5dbf97f466aa99e483 Mon Sep 17 00:00:00 2001
From: IceSentry <c.giguere42@gmail.com>
Date: Mon, 9 May 2022 13:28:07 -0400
Subject: [PATCH 07/15] fix clippy

---
 crates/bevy_ecs/src/event.rs | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/crates/bevy_ecs/src/event.rs b/crates/bevy_ecs/src/event.rs
index 15e05f25db171..f6a6967bd47c9 100644
--- a/crates/bevy_ecs/src/event.rs
+++ b/crates/bevy_ecs/src/event.rs
@@ -777,13 +777,13 @@ mod tests {
                 events.clear();
                 return false;
             } else {
-                return true;
+                true
             }
         });
         reader.initialize(&mut world);
 
-        assert_eq!(reader.run((), &mut world), false);
-        assert_eq!(reader.run((), &mut world), true);
+        assert!(!reader.run((), &mut world));
+        assert!(reader.run((), &mut world));
     }
 
     #[derive(Clone, PartialEq, Debug, Default)]

From eba3325d061934995562061fb67559b05b02ffd9 Mon Sep 17 00:00:00 2001
From: IceSentry <c.giguere42@gmail.com>
Date: Mon, 9 May 2022 13:52:35 -0400
Subject: [PATCH 08/15] actually fix clippy

---
 crates/bevy_ecs/src/event.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/crates/bevy_ecs/src/event.rs b/crates/bevy_ecs/src/event.rs
index f6a6967bd47c9..93cef3c1def34 100644
--- a/crates/bevy_ecs/src/event.rs
+++ b/crates/bevy_ecs/src/event.rs
@@ -775,7 +775,7 @@ mod tests {
         let mut reader = IntoSystem::into_system(|events: EventReader<TestEvent>| -> bool {
             if !events.is_empty() {
                 events.clear();
-                return false;
+                false
             } else {
                 true
             }

From f52c2477f0ef7678fb055d9b6f0487694f6b9267 Mon Sep 17 00:00:00 2001
From: IceSentry <c.giguere42@gmail.com>
Date: Mon, 9 May 2022 14:19:26 -0400
Subject: [PATCH 09/15] improve docs

---
 crates/bevy_ecs/src/event.rs | 36 ++++++++++++++++++++++++++++++++++--
 1 file changed, 34 insertions(+), 2 deletions(-)

diff --git a/crates/bevy_ecs/src/event.rs b/crates/bevy_ecs/src/event.rs
index 93cef3c1def34..bf1771783e33d 100644
--- a/crates/bevy_ecs/src/event.rs
+++ b/crates/bevy_ecs/src/event.rs
@@ -390,12 +390,44 @@ impl<'w, 's, E: Event> EventReader<'w, 's, E> {
     }
 
     /// Determines if no events are available to be read without consuming any.
-    /// If you need to consume the iterator you can use [`EventReader::clear`]
+    /// If you need to consume the iterator you can use [`EventReader::clear`].
+    ///
+    /// ```
+    /// use bevy_ecs::prelude::*;
+    ///
+    /// let mut world = World::new();
+    /// let mut events = Events::<TestEvent>::default();
+    /// events.send(TestEvent { i: 0 });
+    /// world.insert_resource(events);
+    ///
+    /// let mut reader = IntoSystem::into_system(|events: EventReader<TestEvent>| -> bool {
+    ///     if !events.is_empty() {
+    ///         events.clear();
+    ///         false
+    ///     } else {
+    ///         true
+    ///     }
+    /// });
+    /// reader.initialize(&mut world);
+    ///
+    /// let is_empty = reader.run((), &mut world);
+    /// assert!(!is_empty, "EventReader should not be empty");
+    ///
+    /// let is_empty = reader.run((), &mut world);
+    /// assert!(is_empty, "EventReader should be empty");
+    /// ```
     pub fn is_empty(&self) -> bool {
         self.len() == 0
     }
 
-    /// Consumes the iterator. This means all currently available events will be removed before the next frame.
+    /// Consumes the iterator.
+    ///
+    /// This means all currently available events will be removed before the next frame.
+    /// This is useful when multiple events are sent in a single frame and you want
+    /// to react to one or more events without needing to know how many were sent.
+    /// In those situations you generally want to consume those events to make sure they don't appear in the next frame.
+    ///
+    /// For more information see [`EventReader::is_empty()`].
     pub fn clear(mut self) {
         self.iter().last();
     }

From 84e1f64b5ec92ecb4b9b5c8ee56301dad1d5d1c4 Mon Sep 17 00:00:00 2001
From: IceSentry <c.giguere42@gmail.com>
Date: Mon, 9 May 2022 14:35:09 -0400
Subject: [PATCH 10/15] fix doc tests

---
 crates/bevy_ecs/src/event.rs | 9 ++++++---
 1 file changed, 6 insertions(+), 3 deletions(-)

diff --git a/crates/bevy_ecs/src/event.rs b/crates/bevy_ecs/src/event.rs
index bf1771783e33d..85e6160f024e8 100644
--- a/crates/bevy_ecs/src/event.rs
+++ b/crates/bevy_ecs/src/event.rs
@@ -394,13 +394,16 @@ impl<'w, 's, E: Event> EventReader<'w, 's, E> {
     ///
     /// ```
     /// use bevy_ecs::prelude::*;
+    /// use bevy_ecs::event::Events;
+    ///
+    /// struct MyEvent;
     ///
     /// let mut world = World::new();
-    /// let mut events = Events::<TestEvent>::default();
-    /// events.send(TestEvent { i: 0 });
+    /// let mut events = Events::<MyEvent>::default();
+    /// events.send(MyEvent);
     /// world.insert_resource(events);
     ///
-    /// let mut reader = IntoSystem::into_system(|events: EventReader<TestEvent>| -> bool {
+    /// let mut reader = IntoSystem::into_system(|events: EventReader<MyEvent>| -> bool {
     ///     if !events.is_empty() {
     ///         events.clear();
     ///         false

From 98c798685ed731899e919af97540ae0232535bb2 Mon Sep 17 00:00:00 2001
From: IceSentry <c.giguere42@gmail.com>
Date: Mon, 9 May 2022 14:54:07 -0400
Subject: [PATCH 11/15] clean up doc example

---
 crates/bevy_ecs/src/event.rs | 37 ++++++++++++------------------------
 1 file changed, 12 insertions(+), 25 deletions(-)

diff --git a/crates/bevy_ecs/src/event.rs b/crates/bevy_ecs/src/event.rs
index 85e6160f024e8..9a0674a8739f2 100644
--- a/crates/bevy_ecs/src/event.rs
+++ b/crates/bevy_ecs/src/event.rs
@@ -392,32 +392,17 @@ impl<'w, 's, E: Event> EventReader<'w, 's, E> {
     /// Determines if no events are available to be read without consuming any.
     /// If you need to consume the iterator you can use [`EventReader::clear`].
     ///
+    /// ## Example usage with .clear()
     /// ```
-    /// use bevy_ecs::prelude::*;
-    /// use bevy_ecs::event::Events;
-    ///
-    /// struct MyEvent;
-    ///
-    /// let mut world = World::new();
-    /// let mut events = Events::<MyEvent>::default();
-    /// events.send(MyEvent);
-    /// world.insert_resource(events);
-    ///
-    /// let mut reader = IntoSystem::into_system(|events: EventReader<MyEvent>| -> bool {
-    ///     if !events.is_empty() {
+    /// # use bevy_ecs::prelude::*;
+    /// #
+    /// # struct MyEvent;
+    /// fn event_reader(events: EventReader<MyEvent>) {
+    ///      if !events.is_empty() {
     ///         events.clear();
-    ///         false
-    ///     } else {
-    ///         true
     ///     }
-    /// });
-    /// reader.initialize(&mut world);
-    ///
-    /// let is_empty = reader.run((), &mut world);
-    /// assert!(!is_empty, "EventReader should not be empty");
-    ///
-    /// let is_empty = reader.run((), &mut world);
-    /// assert!(is_empty, "EventReader should be empty");
+    /// }
+    /// # bevy_ecs::system::assert_is_system(event_reader);
     /// ```
     pub fn is_empty(&self) -> bool {
         self.len() == 0
@@ -817,8 +802,10 @@ mod tests {
         });
         reader.initialize(&mut world);
 
-        assert!(!reader.run((), &mut world));
-        assert!(reader.run((), &mut world));
+        let is_empty = reader.run((), &mut world);
+        assert!(!is_empty, "EventReader should not be empty");
+        let is_empty = reader.run((), &mut world);
+        assert!(is_empty, "EventReader should be empty");
     }
 
     #[derive(Clone, PartialEq, Debug, Default)]

From 67ea749a0b663c8f8c5bbf6c956834d83807b542 Mon Sep 17 00:00:00 2001
From: IceSentry <c.giguere42@gmail.com>
Date: Mon, 9 May 2022 14:55:34 -0400
Subject: [PATCH 12/15] align code correctly

---
 crates/bevy_ecs/src/event.rs | 5 +++--
 1 file changed, 3 insertions(+), 2 deletions(-)

diff --git a/crates/bevy_ecs/src/event.rs b/crates/bevy_ecs/src/event.rs
index 9a0674a8739f2..e447187d0d5df 100644
--- a/crates/bevy_ecs/src/event.rs
+++ b/crates/bevy_ecs/src/event.rs
@@ -396,9 +396,10 @@ impl<'w, 's, E: Event> EventReader<'w, 's, E> {
     /// ```
     /// # use bevy_ecs::prelude::*;
     /// #
-    /// # struct MyEvent;
+    /// struct MyEvent;
+    ///
     /// fn event_reader(events: EventReader<MyEvent>) {
-    ///      if !events.is_empty() {
+    ///     if !events.is_empty() {
     ///         events.clear();
     ///     }
     /// }

From f3e095766897a6dcaeb4351245e8efe3d6faefce Mon Sep 17 00:00:00 2001
From: IceSentry <c.giguere42@gmail.com>
Date: Tue, 10 May 2022 10:53:03 -0400
Subject: [PATCH 13/15] make example a bit more concrete

---
 crates/bevy_ecs/src/event.rs | 7 ++++---
 1 file changed, 4 insertions(+), 3 deletions(-)

diff --git a/crates/bevy_ecs/src/event.rs b/crates/bevy_ecs/src/event.rs
index e447187d0d5df..a206cd863c06a 100644
--- a/crates/bevy_ecs/src/event.rs
+++ b/crates/bevy_ecs/src/event.rs
@@ -396,14 +396,15 @@ impl<'w, 's, E: Event> EventReader<'w, 's, E> {
     /// ```
     /// # use bevy_ecs::prelude::*;
     /// #
-    /// struct MyEvent;
+    /// struct CollisionEvent;
     ///
-    /// fn event_reader(events: EventReader<MyEvent>) {
+    /// fn play_collision_sound(events: EventReader<CollisionEvent>) {
     ///     if !events.is_empty() {
     ///         events.clear();
+    ///         // Play a sound
     ///     }
     /// }
-    /// # bevy_ecs::system::assert_is_system(event_reader);
+    /// # bevy_ecs::system::assert_is_system(play_collision_sound);
     /// ```
     pub fn is_empty(&self) -> bool {
         self.len() == 0

From 3df8d7051306c43bba30dfbc21ec4627453a1704 Mon Sep 17 00:00:00 2001
From: Charles <IceSentry@users.noreply.github.com>
Date: Thu, 12 May 2022 13:29:49 -0400
Subject: [PATCH 14/15] Update crates/bevy_ecs/src/event.rs

Co-authored-by: Federico Rinaldi <gisquerin@gmail.com>
---
 crates/bevy_ecs/src/event.rs | 6 +++++-
 1 file changed, 5 insertions(+), 1 deletion(-)

diff --git a/crates/bevy_ecs/src/event.rs b/crates/bevy_ecs/src/event.rs
index a206cd863c06a..1f11adec81d44 100644
--- a/crates/bevy_ecs/src/event.rs
+++ b/crates/bevy_ecs/src/event.rs
@@ -392,7 +392,11 @@ impl<'w, 's, E: Event> EventReader<'w, 's, E> {
     /// Determines if no events are available to be read without consuming any.
     /// If you need to consume the iterator you can use [`EventReader::clear`].
     ///
-    /// ## Example usage with .clear()
+    /// # Example
+    /// 
+    /// The following example shows a common pattern of this function in conjunction with `clear`
+    /// to avoid leaking events to the next schedule iteration while also checking if it was emitted.
+    /// 
     /// ```
     /// # use bevy_ecs::prelude::*;
     /// #

From f399c4aa1def55e72a13fb607dadb5afeb004cd5 Mon Sep 17 00:00:00 2001
From: IceSentry <c.giguere42@gmail.com>
Date: Thu, 12 May 2022 13:36:53 -0400
Subject: [PATCH 15/15] fix conflict

---
 crates/bevy_ecs/src/event.rs | 96 +++++++++++++-----------------------
 1 file changed, 33 insertions(+), 63 deletions(-)

diff --git a/crates/bevy_ecs/src/event.rs b/crates/bevy_ecs/src/event.rs
index 1f11adec81d44..22af1b3ed2dff 100644
--- a/crates/bevy_ecs/src/event.rs
+++ b/crates/bevy_ecs/src/event.rs
@@ -210,10 +210,42 @@ impl<'w, 's, E: Event> EventReader<'w, 's, E> {
         self.reader.len(&self.events)
     }
 
-    /// Determines if are any events available to be read without consuming any.
+    /// Determines if no events are available to be read without consuming any.
+    /// If you need to consume the iterator you can use [`EventReader::clear`].
+    ///
+    /// # Example
+    ///
+    /// The following example shows a common pattern of this function in conjunction with `clear`
+    /// to avoid leaking events to the next schedule iteration while also checking if it was emitted.
+    ///
+    /// ```
+    /// # use bevy_ecs::prelude::*;
+    /// #
+    /// struct CollisionEvent;
+    ///
+    /// fn play_collision_sound(events: EventReader<CollisionEvent>) {
+    ///     if !events.is_empty() {
+    ///         events.clear();
+    ///         // Play a sound
+    ///     }
+    /// }
+    /// # bevy_ecs::system::assert_is_system(play_collision_sound);
+    /// ```
     pub fn is_empty(&self) -> bool {
         self.len() == 0
     }
+
+    /// Consumes the iterator.
+    ///
+    /// This means all currently available events will be removed before the next frame.
+    /// This is useful when multiple events are sent in a single frame and you want
+    /// to react to one or more events without needing to know how many were sent.
+    /// In those situations you generally want to consume those events to make sure they don't appear in the next frame.
+    ///
+    /// For more information see [`EventReader::is_empty()`].
+    pub fn clear(mut self) {
+        self.iter().last();
+    }
 }
 
 /// Sends events of type `T`.
@@ -365,68 +397,6 @@ impl<I: Iterator> ExactSizeIterator for ExactSize<I> {
     }
 }
 
-impl<'w, 's, E: Event> EventReader<'w, 's, E> {
-    /// Iterates over the events this [`EventReader`] has not seen yet. This updates the
-    /// [`EventReader`]'s event counter, which means subsequent event reads will not include events
-    /// that happened before now.
-    pub fn iter(&mut self) -> impl DoubleEndedIterator<Item = &E> + ExactSizeIterator<Item = &E> {
-        self.iter_with_id().map(|(event, _id)| event)
-    }
-
-    /// Like [`iter`](Self::iter), except also returning the [`EventId`] of the events.
-    pub fn iter_with_id(
-        &mut self,
-    ) -> impl DoubleEndedIterator<Item = (&E, EventId<E>)> + ExactSizeIterator<Item = (&E, EventId<E>)>
-    {
-        internal_event_reader(&mut self.last_event_count.0, &self.events).map(|(event, id)| {
-            trace!("EventReader::iter() -> {}", id);
-            (event, id)
-        })
-    }
-
-    /// Determines the number of events available to be read from this [`EventReader`] without consuming any.
-    pub fn len(&self) -> usize {
-        internal_event_reader(&mut self.last_event_count.0.clone(), &self.events).len()
-    }
-
-    /// Determines if no events are available to be read without consuming any.
-    /// If you need to consume the iterator you can use [`EventReader::clear`].
-    ///
-    /// # Example
-    /// 
-    /// The following example shows a common pattern of this function in conjunction with `clear`
-    /// to avoid leaking events to the next schedule iteration while also checking if it was emitted.
-    /// 
-    /// ```
-    /// # use bevy_ecs::prelude::*;
-    /// #
-    /// struct CollisionEvent;
-    ///
-    /// fn play_collision_sound(events: EventReader<CollisionEvent>) {
-    ///     if !events.is_empty() {
-    ///         events.clear();
-    ///         // Play a sound
-    ///     }
-    /// }
-    /// # bevy_ecs::system::assert_is_system(play_collision_sound);
-    /// ```
-    pub fn is_empty(&self) -> bool {
-        self.len() == 0
-    }
-
-    /// Consumes the iterator.
-    ///
-    /// This means all currently available events will be removed before the next frame.
-    /// This is useful when multiple events are sent in a single frame and you want
-    /// to react to one or more events without needing to know how many were sent.
-    /// In those situations you generally want to consume those events to make sure they don't appear in the next frame.
-    ///
-    /// For more information see [`EventReader::is_empty()`].
-    pub fn clear(mut self) {
-        self.iter().last();
-    }
-}
-
 impl<E: Event> Events<E> {
     /// "Sends" an `event` by writing it to the current event buffer. [`EventReader`]s can then read
     /// the event.