Merge pull request #220 from matheus-consoli/empty-vec

handle empty collections

Author: yoshuawuyts

src/future/race/array.rs

@@ -70,6 +70,7 @@ where
     type Future = Race<Fut::IntoFuture, N>;
 
     fn race(self) -> Self::Future {
+        assert!(N > 0, "race requires at least one future");
         Race {
             futures: self.map(|fut| fut.into_future()),
             indexer: Indexer::new(N),
@@ -83,6 +84,13 @@ mod test {
     use super::*;
     use core::future;
 
+    #[test]
+    #[should_panic(expected = "race requires at least one future")]
+    fn empty_array() {
+        let futs: [future::Ready<()>; 0] = [];
+        let _ = futs.race();
+    }
+
     // NOTE: we should probably poll in random order.
     #[test]
     fn no_fairness() {

src/future/race/mod.rs

@@ -22,5 +22,10 @@ pub trait Race {
     /// other futures are cancelled.
     ///
     /// This function returns a new future which polls all futures concurrently.
+    ///
+    /// # Panics
+    ///
+    /// This method will panic if the collection is empty (for `Vec` and array
+    /// implementations) since there would be no future to race.
     fn race(self) -> Self::Future;
 }

src/future/race/vec.rs

@@ -73,6 +73,7 @@ where
     type Future = Race<Fut::IntoFuture>;
 
     fn race(self) -> Self::Future {
+        assert!(!self.is_empty(), "race requires at least one future");
         Race {
             indexer: Indexer::new(self.len()),
             futures: self.into_iter().map(|fut| fut.into_future()).collect(),
@@ -87,6 +88,15 @@ mod test {
     use alloc::vec;
     use core::future;
 
+    #[test]
+    #[should_panic(expected = "race requires at least one future")]
+    fn empty_vec() {
+        futures_lite::future::block_on(async {
+            let futs: Vec<future::Ready<()>> = vec![];
+            let _ = futs.race().await;
+        });
+    }
+
     // NOTE: we should probably poll in random order.
     #[test]
     fn no_fairness() {

src/stream/merge/array.rs

@@ -62,6 +62,11 @@ where
     fn poll_next(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Option<Self::Item>> {
         let mut this = self.project();
 
+        // return early if all streams are complete (handles empty array)
+        if *this.complete == N {
+            return Poll::Ready(None);
+        }
+
         let mut readiness = this.wakers.readiness();
         readiness.set_waker(cx.waker());
 
@@ -127,6 +132,16 @@ mod tests {
     use futures_lite::prelude::*;
     use futures_lite::stream;
 
+    #[test]
+    fn empty_array() {
+        block_on(async {
+            let streams: [stream::Once<i32>; 0] = [];
+            let mut s = streams.merge();
+            let result = s.next().await;
+            assert_eq!(result, None);
+        })
+    }
+
     #[test]
     fn merge_array_4() {
         block_on(async {

src/stream/merge/vec.rs

@@ -66,6 +66,11 @@ where
     fn poll_next(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Option<Self::Item>> {
         let mut this = self.project();
 
+        // return early if all streams are complete (handles empty vec)
+        if *this.complete == this.streams.len() {
+            return Poll::Ready(None);
+        }
+
         let mut readiness = this.wakers.readiness();
         readiness.set_waker(cx.waker());
 
@@ -140,6 +145,16 @@ mod tests {
 
     use crate::future::join::Join;
 
+    #[test]
+    fn empty_vec() {
+        block_on(async {
+            let streams: Vec<stream::Once<i32>> = vec![];
+            let mut s = streams.merge();
+            let result = s.next().await;
+            assert_eq!(result, None);
+        })
+    }
+
     #[test]
     fn merge_vec_4() {
         block_on(async {

src/utils/indexer.rs

@@ -17,7 +17,9 @@ impl Indexer {
     pub(crate) fn iter(&mut self) -> IndexIter {
         // Increment the starting point for next time.
         let offset = self.offset;
-        self.offset = (self.offset + 1).wrapping_rem(self.max);
+        if self.max > 0 {
+            self.offset = (self.offset + 1).wrapping_rem(self.max);
+        }
 
         IndexIter {
             iter: (0..self.max),