feat: starting support of no-std

Cargo.toml

@@ -8,10 +8,15 @@ repository = "https://github.com/dariusc93/pollable-map"
 authors = ["Darius Clark"]
 exclude = [".gitignore"]
 
+[features]
+default = ["std", "alloc"]
+std = ["futures/std", "futures-timeout"]
+alloc = ["futures/alloc"]
+
 
 [dependencies]
-futures = { version = "0.3.31", default-features = false, features = ["std", "alloc", "async-await"] }
-futures-timeout = "0.1.3"
+futures = { version = "0.3.31", default-features = false, features = ["async-await"] }
+futures-timeout = { version = "0.1.3", optional = true }
 
 [dev-dependencies]
 futures = { version = "0.3.31", default-features = false, features = ["std", "alloc", "async-await", "thread-pool", "executor"] }

src/common.rs

@@ -1,10 +1,10 @@
-use futures::{FutureExt, Stream, StreamExt};
+use core::future::Future;
+use core::pin::Pin;
+use core::task::{Context, Poll};
+use futures::Stream;
+
+#[cfg(feature = "std")]
 use futures_timeout::{Timeout, TimeoutExt};
-use std::future::Future;
-use std::ops::{Deref, DerefMut};
-use std::pin::Pin;
-use std::task::{Context, Poll};
-use std::time::Duration;
 
 pub struct InnerMap<K, S> {
     key: K,
@@ -125,49 +125,56 @@ where
     }
 }
 
+#[cfg(feature = "std")]
 pub struct Timed<F>(Timeout<F>);
 
+#[cfg(feature = "std")]
 impl<F> Timed<F> {
     pub(crate) fn into_inner(self) -> F {
         self.0.into_inner()
     }
 }
 
-impl<F> Deref for Timed<F> {
+#[cfg(feature = "std")]
+impl<F> core::ops::Deref for Timed<F> {
     type Target = F;
     fn deref(&self) -> &Self::Target {
         self.0.deref()
     }
 }
 
-impl<F> DerefMut for Timed<F> {
+#[cfg(feature = "std")]
+impl<F> core::ops::DerefMut for Timed<F> {
     fn deref_mut(&mut self) -> &mut Self::Target {
         self.0.deref_mut()
     }
 }
 
+#[cfg(feature = "std")]
 impl<F> Timed<F> {
-    pub(crate) fn new(item: F, timeout: Duration) -> Self {
+    pub(crate) fn new(item: F, timeout: core::time::Duration) -> Self {
         Self(item.timeout(timeout))
     }
 }
 
+#[cfg(feature = "std")]
 impl<F> Future for Timed<F>
 where
     F: Future + Unpin,
 {
     type Output = std::io::Result<F::Output>;
     fn poll(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output> {
-        self.0.poll_unpin(cx)
+        Pin::new(&mut self.0).poll(cx)
     }
 }
 
+#[cfg(feature = "std")]
 impl<F> Stream for Timed<F>
 where
     F: Stream + Unpin,
 {
     type Item = std::io::Result<F::Item>;
     fn poll_next(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Option<Self::Item>> {
-        self.0.poll_next_unpin(cx)
+        Pin::new(&mut self.0).poll_next(cx)
     }
 }

src/futures.rs

@@ -1,15 +1,17 @@
 pub mod optional;
 pub mod ordered;
 pub mod set;
+#[cfg(feature = "std")]
 pub mod timeout_map;
+#[cfg(feature = "std")]
 pub mod timeout_set;
 
 use crate::common::InnerMap;
+use core::future::Future;
+use core::pin::Pin;
+use core::task::{Context, Poll, Waker};
 use futures::stream::{FusedStream, FuturesUnordered};
 use futures::{Stream, StreamExt};
-use std::future::Future;
-use std::pin::Pin;
-use std::task::{Context, Poll, Waker};
 
 pub struct FutureMap<K, S> {
     list: FuturesUnordered<InnerMap<K, S>>,
@@ -36,8 +38,8 @@ impl<K, T> FutureMap<K, T> {
 
 impl<K, T> FutureMap<K, T>
 where
-    K: Clone + PartialEq + Send + Unpin + 'static,
-    T: Future + Send + Unpin + 'static,
+    K: Clone + PartialEq + Unpin,
+    T: Future + Unpin,
 {
     /// Insert a future into the map with a unique key.
     /// The function will return true if the map does not have the key present,
@@ -162,8 +164,8 @@ where
 
 impl<K, T> FromIterator<(K, T)> for FutureMap<K, T>
 where
-    K: Clone + PartialEq + Send + Unpin + 'static,
-    T: Future + Send + Unpin + 'static,
+    K: Clone + PartialEq + Unpin,
+    T: Future + Unpin,
 {
     fn from_iter<I: IntoIterator<Item = (K, T)>>(iter: I) -> Self {
         let mut maps = Self::new();
@@ -176,8 +178,8 @@ where
 
 impl<K, T> Stream for FutureMap<K, T>
 where
-    K: Clone + PartialEq + Send + Unpin + 'static,
-    T: Future + Unpin + Send + 'static,
+    K: Clone + PartialEq + Unpin,
+    T: Future + Unpin,
 {
     type Item = (K, T::Output);
 
@@ -220,8 +222,8 @@ where
 
 impl<K, T> FusedStream for FutureMap<K, T>
 where
-    K: Clone + PartialEq + Send + Unpin + 'static,
-    T: Future + Unpin + Send + 'static,
+    K: Clone + PartialEq + Unpin,
+    T: Future + Unpin,
 {
     fn is_terminated(&self) -> bool {
         self.list.is_terminated()

src/futures/optional.rs

@@ -2,7 +2,7 @@ use crate::optional::Optional;
 
 /// A reusable future that is the equivalent to an `Option`.
 ///
-/// By default, this future will be empty, which would return  [`Poll::Pending`] when polled,
+/// By default, this future will be empty, which would return [`Poll::Pending`] when polled,
 /// but if a [`Future`] is supplied either upon construction via [`OptionalFuture::new`] or
 /// is set via [`OptionalFuture::replace`], the future would then be polled once [`OptionalFuture`]
 /// is polled. Once the future is polled to completion, the results will be returned, with

src/futures/ordered.rs

@@ -1,8 +1,8 @@
+use alloc::collections::VecDeque;
+use core::future::Future;
+use core::pin::Pin;
+use core::task::{Context, Poll, Waker};
 use futures::Stream;
-use std::collections::VecDeque;
-use std::future::Future;
-use std::pin::Pin;
-use std::task::{Context, Poll, Waker};
 
 /// An unbounded queue of futures imposed a FIFO order while polling one future at a time
 /// and returning the output to stream before popping the next future in queue to be polled.
@@ -57,7 +57,7 @@ impl<F> OrderedFutureSet<F> {
 
 impl<F> FromIterator<F> for OrderedFutureSet<F>
 where
-    F: Future + Send + Unpin + 'static,
+    F: Future + Unpin,
 {
     fn from_iter<T: IntoIterator<Item = F>>(iter: T) -> Self {
         let mut ordered = Self::new();
@@ -70,7 +70,7 @@ where
 
 impl<F> Stream for OrderedFutureSet<F>
 where
-    F: Future + Send + Unpin + 'static,
+    F: Future + Unpin,
 {
     type Item = F::Output;
     fn poll_next(mut self: Pin<&mut Self>, cx: &mut Context) -> Poll<Option<Self::Item>> {
@@ -109,6 +109,8 @@ where
 #[cfg(test)]
 mod tests {
     use crate::futures::ordered::OrderedFutureSet;
+    use alloc::vec;
+    use alloc::vec::Vec;
     use futures::StreamExt;
 
     #[test]

src/futures/set.rs

@@ -1,10 +1,10 @@
-use std::future::Future;
-use std::pin::Pin;
+use core::future::Future;
+use core::pin::Pin;
 
 use super::FutureMap;
+use core::task::{Context, Poll};
 use futures::stream::FusedStream;
 use futures::{Stream, StreamExt};
-use std::task::{Context, Poll};
 
 pub struct FutureSet<S> {
     id: i64,
@@ -13,7 +13,7 @@ pub struct FutureSet<S> {
 
 impl<S> Default for FutureSet<S>
 where
-    S: Future + Send + Unpin + 'static,
+    S: Future + Unpin,
 {
     fn default() -> Self {
         Self::new()
@@ -22,7 +22,7 @@ where
 
 impl<S> FutureSet<S>
 where
-    S: Future + Send + Unpin + 'static,
+    S: Future + Unpin,
 {
     /// Creates an empty ['FutureSet`]
     pub fn new() -> Self {
@@ -71,7 +71,7 @@ where
 
 impl<S> FromIterator<S> for FutureSet<S>
 where
-    S: Future + Send + Unpin + 'static,
+    S: Future + Unpin,
 {
     fn from_iter<I: IntoIterator<Item = S>>(iter: I) -> Self {
         let mut maps = Self::new();
@@ -84,7 +84,7 @@ where
 
 impl<S> Stream for FutureSet<S>
 where
-    S: Future + Send + Unpin + 'static,
+    S: Future + Unpin,
 {
     type Item = S::Output;
 
@@ -101,7 +101,7 @@ where
 
 impl<S> FusedStream for FutureSet<S>
 where
-    S: Future + Send + Unpin + 'static,
+    S: Future + Unpin,
 {
     fn is_terminated(&self) -> bool {
         self.map.is_terminated()

src/futures/timeout_map.rs

@@ -1,12 +1,12 @@
 use crate::common::Timed;
 use crate::futures::FutureMap;
+use core::future::Future;
+use core::ops::{Deref, DerefMut};
+use core::pin::Pin;
+use core::task::{Context, Poll};
+use core::time::Duration;
 use futures::stream::FusedStream;
 use futures::{Stream, StreamExt};
-use std::future::Future;
-use std::ops::{Deref, DerefMut};
-use std::pin::Pin;
-use std::task::{Context, Poll};
-use std::time::Duration;
 
 pub struct TimeoutFutureMap<K, F> {
     duration: Duration,
@@ -28,8 +28,8 @@ impl<K, F> DerefMut for TimeoutFutureMap<K, F> {
 
 impl<K, F> TimeoutFutureMap<K, F>
 where
-    K: Clone + PartialEq + Send + Unpin + 'static,
-    F: Future + Send + Unpin + 'static,
+    K: Clone + PartialEq + Unpin,
+    F: Future + Unpin,
 {
     /// Create an empty [`TimeoutFutureMap`]
     pub fn new(duration: Duration) -> Self {
@@ -49,8 +49,8 @@ where
 
 impl<K, F> Stream for TimeoutFutureMap<K, F>
 where
-    K: Clone + PartialEq + Send + Unpin + 'static,
-    F: Future + Send + Unpin + 'static,
+    K: Clone + PartialEq + Unpin,
+    F: Future + Unpin,
 {
     type Item = (K, std::io::Result<F::Output>);
     fn poll_next(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Option<Self::Item>> {
@@ -64,8 +64,8 @@ where
 
 impl<K, F> FusedStream for TimeoutFutureMap<K, F>
 where
-    K: Clone + PartialEq + Send + Unpin + 'static,
-    F: Future + Send + Unpin + 'static,
+    K: Clone + PartialEq + Unpin,
+    F: Future + Unpin,
 {
     fn is_terminated(&self) -> bool {
         self.map.is_terminated()

src/futures/timeout_set.rs

@@ -1,12 +1,12 @@
 use crate::common::Timed;
 use crate::futures::set::FutureSet;
+use core::future::Future;
+use core::ops::{Deref, DerefMut};
+use core::pin::Pin;
+use core::task::{Context, Poll};
+use core::time::Duration;
 use futures::stream::FusedStream;
 use futures::{Stream, StreamExt};
-use std::future::Future;
-use std::ops::{Deref, DerefMut};
-use std::pin::Pin;
-use std::task::{Context, Poll};
-use std::time::Duration;
 
 pub struct TimeoutFutureSet<S> {
     duration: Duration,
@@ -28,7 +28,7 @@ impl<S> DerefMut for TimeoutFutureSet<S> {
 
 impl<F> TimeoutFutureSet<F>
 where
-    F: Future + Send + Unpin + 'static,
+    F: Future + Unpin,
 {
     /// Create an empty [`TimeoutFutureSet`]
     pub fn new(duration: Duration) -> Self {
@@ -46,7 +46,7 @@ where
 
 impl<F> Stream for TimeoutFutureSet<F>
 where
-    F: Future + Send + Unpin + 'static,
+    F: Future + Unpin,
 {
     type Item = std::io::Result<F::Output>;
     fn poll_next(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Option<Self::Item>> {
@@ -60,7 +60,7 @@ where
 
 impl<F> FusedStream for TimeoutFutureSet<F>
 where
-    F: Future + Send + Unpin + 'static,
+    F: Future + Unpin,
 {
     fn is_terminated(&self) -> bool {
         self.set.is_terminated()

src/lib.rs

@@ -1,4 +1,14 @@
+#![no_std]
+
+#[cfg(feature = "alloc")]
+extern crate alloc;
+#[cfg(feature = "std")]
+extern crate std;
+
+#[cfg(feature = "alloc")]
 pub mod futures;
+
+#[cfg(feature = "alloc")]
 pub mod stream;
 
 pub(crate) mod common;

src/optional.rs

@@ -1,11 +1,12 @@
+#[cfg(feature = "std")]
 pub mod timeout;
 
+use core::future::Future;
+use core::pin::Pin;
+use core::task::{Context, Poll, Waker};
 use futures::future::FusedFuture;
 use futures::stream::FusedStream;
 use futures::Stream;
-use std::future::Future;
-use std::pin::Pin;
-use std::task::{Context, Poll, Waker};
 
 /// A reusable future or stream based on `Option`.
 ///