feat: Move EventListener back onto the heap

Minimal amount of changes to make EventListener a heap-allocated type
again. The existence of the EventListener implies that it is already
listening; accordingly the new() and listen() methods on EventListener
have been removed.

cc #104

Signed-off-by: John Nunley <dev@notgull.net>

benches/bench.rs

@@ -1,31 +1,22 @@
 use std::iter;
-use std::pin::Pin;
 
 use criterion::{criterion_group, criterion_main, Criterion};
-use event_listener::{Event, EventListener};
+use event_listener::Event;
 
 const COUNT: usize = 8000;
 
 fn bench_events(c: &mut Criterion) {
     c.bench_function("notify_and_wait", |b| {
         let ev = Event::new();
-        let mut handles = iter::repeat_with(EventListener::new)
-            .take(COUNT)
-            .collect::<Vec<_>>();
+        let mut handles = Vec::with_capacity(COUNT);
 
         b.iter(|| {
-            for handle in &mut handles {
-                // SAFETY: The handle is not moved out.
-                let listener = unsafe { Pin::new_unchecked(handle) };
-                listener.listen(&ev);
-            }
+            handles.extend(iter::repeat_with(|| ev.listen()).take(COUNT));
 
             ev.notify(COUNT);
 
-            for handle in &mut handles {
-                // SAFETY: The handle is not moved out.
-                let listener = unsafe { Pin::new_unchecked(handle) };
-                listener.wait();
+            for handle in handles.drain(..) {
+                handle.wait();
             }
         });
     });

examples/mutex.rs

@@ -65,9 +65,9 @@ mod example {
                         // Start listening and then try locking again.
                         listener = Some(self.lock_ops.listen());
                     }
-                    Some(mut l) => {
+                    Some(l) => {
                         // Wait until a notification is received.
-                        l.as_mut().wait();
+                        l.wait();
                     }
                 }
             }
@@ -90,9 +90,9 @@ mod example {
                         // Start listening and then try locking again.
                         listener = Some(self.lock_ops.listen());
                     }
-                    Some(mut l) => {
+                    Some(l) => {
                         // Wait until a notification is received.
-                        l.as_mut().wait_deadline(deadline)?;
+                        l.wait_deadline(deadline)?;
                     }
                 }
             }