New design for EventIterator

Cargo.toml

@@ -20,6 +20,9 @@ categories = ["asynchronous", "no-std", "rust-patterns"]
 readme = "README.md"
 rust-version = "1.70"
 
+[dependencies.pin-project-lite]
+version = "0.2"
+
 [dev-dependencies.async_main]
 version = "0.4"
 features = ["pasts"]

examples/empty.rs

@@ -2,8 +2,8 @@ use event_iterator::{Empty, EventIterator};
 
 #[async_main::async_main]
 async fn main(_spawner: async_main::LocalSpawner) {
-    let ei: Empty<u32> = event_iterator::empty();
+    let mut ei: Empty<u32> = event_iterator::empty();
 
-    assert!(ei.next_unpinned().await.is_none());
-    assert!(ei.next_unpinned().await.is_none());
+    assert!(ei.next().await.is_none());
+    assert!(ei.next().await.is_none());
 }

examples/enumerate.rs

@@ -2,11 +2,10 @@ use event_iterator::EventIterator;
 
 #[async_main::async_main]
 async fn main(_spawner: async_main::LocalSpawner) {
-    let ei = event_iterator::from_iter(['a', 'b', 'c']);
-    let ei = ei.enumerate();
+    let mut ei = event_iterator::from_iter_ref(['a', 'b', 'c']).enumerate();
 
-    assert_eq!(ei.next_unpinned().await, Some((0, 'a')));
-    assert_eq!(ei.next_unpinned().await, Some((1, 'b')));
-    assert_eq!(ei.next_unpinned().await, Some((2, 'c')));
-    assert_eq!(ei.next_unpinned().await, None);
+    assert_eq!(ei.next().await, Some((0, &'a')));
+    assert_eq!(ei.next().await, Some((1, &'b')));
+    assert_eq!(ei.next().await, Some((2, &'c')));
+    assert_eq!(ei.next().await, None);
 }

examples/filter.rs

@@ -2,11 +2,12 @@ use event_iterator::EventIterator;
 
 #[async_main::async_main]
 async fn main(_spawner: async_main::LocalSpawner) {
-    let ei = event_iterator::from_iter([1, 2, 3, 4, 5]).filter(|&x| x > 1);
+    let mut ei =
+        event_iterator::from_iter_ref([1, 2, 3, 4, 5]).filter(|&x| x > 1);
     let mut events = Vec::new();
 
-    while let Some(event) = ei.next_unpinned().await {
-        events.push(event);
+    while let Some(event) = ei.next().await {
+        events.push(event.clone());
     }
 
     println!("{events:?}");

examples/filter_map_ref.rs

@@ -0,0 +1,24 @@
+use event_iterator::EventIterator;
+
+#[async_main::async_main]
+async fn main(_spawner: async_main::LocalSpawner) {
+    let mut ei =
+        event_iterator::from_iter_ref(["1", "two", "NaN", "four", "5"])
+            .filter_map_ref(|&s| s.parse().ok());
+
+    assert_eq!(ei.next().await, Some(&1));
+    assert_eq!(ei.next().await, Some(&5));
+    assert_eq!(ei.next().await, None);
+
+    // Here’s the same example, but with `filter()` and `map_ref()`:
+
+    let mut ei =
+        event_iterator::from_iter_ref(["1", "two", "NaN", "four", "5"])
+            .map_ref(|&s| s.parse())
+            .filter(|s| s.is_ok())
+            .map_ref(|s| s.clone().unwrap());
+
+    assert_eq!(ei.next().await, Some(&1));
+    assert_eq!(ei.next().await, Some(&5));
+    assert_eq!(ei.next().await, None);
+}

examples/from_fn.rs

@@ -16,11 +16,11 @@ async fn main(_spawner: async_main::LocalSpawner) {
         })
     });
 
-    assert_eq!(ei.next_unpinned().await, Some(1));
-    assert_eq!(ei.next_unpinned().await, Some(2));
-    assert_eq!(ei.next_unpinned().await, Some(3));
-    assert_eq!(ei.next_unpinned().await, Some(4));
-    assert_eq!(ei.next_unpinned().await, Some(5));
-    assert_eq!(ei.next_unpinned().await, None);
-    assert_eq!(ei.next_unpinned().await, None);
+    assert_eq!(ei.next().await, Some(1));
+    assert_eq!(ei.next().await, Some(2));
+    assert_eq!(ei.next().await, Some(3));
+    assert_eq!(ei.next().await, Some(4));
+    assert_eq!(ei.next().await, Some(5));
+    assert_eq!(ei.next().await, None);
+    assert_eq!(ei.next().await, None);
 }

examples/from_iter.rs → examples/from_iter_ref.rs

@@ -2,9 +2,9 @@ use event_iterator::EventIterator;
 
 #[async_main::async_main]
 async fn main(_spawner: async_main::LocalSpawner) {
-    let ei = event_iterator::from_iter([1, 2, 3, 4, 5]);
+    let mut ei = event_iterator::from_iter_ref([1, 2, 3, 4, 5]);
 
-    while let Some(i) = ei.next_unpinned().await {
+    while let Some(&i) = ei.next().await {
         println!("{i}");
     }
 }

examples/fuse.rs

@@ -4,11 +4,11 @@ use event_iterator::EventIterator;
 
 #[async_main::async_main]
 async fn main(_spawner: async_main::LocalSpawner) {
-    let ei = event_iterator::from_iter([1, 2, 3]).fuse();
+    let mut ei = event_iterator::from_iter_ref([1, 2, 3]).fuse();
 
-    assert_eq!(futures::poll!(ei.next_unpinned()), Poll::Ready(Some(1)));
-    assert_eq!(futures::poll!(ei.next_unpinned()), Poll::Ready(Some(2)));
-    assert_eq!(futures::poll!(ei.next_unpinned()), Poll::Ready(Some(3)));
-    assert_eq!(futures::poll!(ei.next_unpinned()), Poll::Ready(None));
-    assert_eq!(futures::poll!(ei.next_unpinned()), Poll::Ready(None));
+    assert_eq!(futures::poll!(ei.next()), Poll::Ready(Some(&1)));
+    assert_eq!(futures::poll!(ei.next()), Poll::Ready(Some(&2)));
+    assert_eq!(futures::poll!(ei.next()), Poll::Ready(Some(&3)));
+    assert_eq!(futures::poll!(ei.next()), Poll::Ready(None));
+    assert_eq!(futures::poll!(ei.next()), Poll::Ready(None));
 }

examples/inspect.rs

@@ -2,11 +2,11 @@ use event_iterator::EventIterator;
 
 #[async_main::async_main]
 async fn main(_spawner: async_main::LocalSpawner) {
-    let ei = event_iterator::from_iter([1, 2, 3, 4, 5]).inspect(|&x| {
+    let mut ei = event_iterator::from_iter_ref([1, 2, 3, 4, 5]).inspect(|&x| {
         let uwu = "uwu".repeat(x);
 
         println!("{uwu}");
     });
 
-    while ei.next_unpinned().await.is_some() {}
+    while ei.next().await.is_some() {}
 }

examples/map.rs

@@ -1,11 +1,25 @@
-use event_iterator::EventIterator;
+use event_iterator::{EventIterator, LendAs};
+
+#[derive(Copy, Clone)]
+struct Uwu<'a>(&'a i32);
+
+#[derive(Copy, Clone)]
+struct LendAsUwu;
+
+impl LendAs for LendAsUwu {
+    type From<'a> = &'a i32;
+    type Into<'a> = Uwu<'a>;
+
+    fn lend_as<'a>(self, from: Self::From<'a>) -> Self::Into<'a> {
+        Uwu(from)
+    }
+}
 
 #[async_main::async_main]
 async fn main(_spawner: async_main::LocalSpawner) {
-    let ei =
-        event_iterator::from_iter([1, 2, 3, 4, 5]).map(|x| "uwu".repeat(x));
+    let mut ei = event_iterator::from_iter_ref([1, 2, 3, 4, 5]).map(LendAsUwu);
 
-    while let Some(i) = ei.next_unpinned().await {
+    while let Some(Uwu(i)) = ei.next().await {
         println!("{i}");
     }
 }

examples/map_ref.rs

@@ -0,0 +1,13 @@
+use event_iterator::EventIterator;
+
+#[async_main::async_main]
+async fn main(_spawner: async_main::LocalSpawner) {
+    let mut ei = event_iterator::from_iter_ref([1, 2, 3, 4, 5])
+        .map_ref(|&x| "uwu".repeat(x));
+
+    while let Some(i) = ei.next().await {
+        let i: &String = i;
+
+        println!("{i}");
+    }
+}

examples/next.rs

@@ -1,13 +1,11 @@
-use std::pin::pin;
-
 use event_iterator::EventIterator;
 
 #[async_main::async_main]
 async fn main(_spawner: async_main::LocalSpawner) {
-    let ei = pin!(event_iterator::from_iter([3, 1, 2]));
+    let mut ei = event_iterator::from_iter_ref([3, 1, 2]);
 
-    assert_eq!(Some(3), ei.as_ref().next().await);
-    assert_eq!(Some(1), ei.as_ref().next().await);
-    assert_eq!(Some(2), ei.as_ref().next().await);
-    assert_eq!(None, ei.as_ref().next().await);
+    assert_eq!(Some(&3), ei.next().await);
+    assert_eq!(Some(&1), ei.next().await);
+    assert_eq!(Some(&2), ei.next().await);
+    assert_eq!(None, ei.next().await);
 }