bumpup version

.github/workflows/ci.yml

@@ -126,7 +126,8 @@ jobs:
           command: tarpaulin
           args: --all-features --run-types tests --workspace --out xml
       - name: Upload to codecov.io
-        uses: codecov/codecov-action@v3.1.1
+        uses: codecov/codecov-action@v4
         with:
           token: ${{ secrets.CODECOV_TOKEN }}
           fail_ci_if_error: true
+          slug: ${{ github.repository }}

agnostic/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "agnostic"
-version = "0.3.6"
+version = "0.3.7"
 edition.workspace = true
 license.workspace = true
 rust-version.workspace = true
@@ -98,7 +98,7 @@ io = ["futures-util/io"]
 # by enable this feature, TcpStream will implement
 # both futures::AsyncRead/AsyncWrite and tokio::io::AsyncRead/AsyncWrite.
 # But if you are using tokio, this feature can be ignored.
-tokio-compat = ["tokio-util/compat", "dep:tokio"]
+tokio-compat = ["tokio-util/compat", "dep:tokio", "net"]
 
 tokio = [
   "dep:tokio",

agnostic/src/async_std/net.rs

@@ -7,8 +7,6 @@ use std::{
 
 use ::async_std::net::{TcpListener, TcpStream, UdpSocket};
 use futures_util::FutureExt;
-#[cfg(feature = "compat")]
-use tokio_util::compat::FuturesAsyncWriteCompatExt;
 
 use crate::net::{Net, TcpStreamOwnedReadHalf, TcpStreamOwnedWriteHalf, ToSocketAddrs};
 

agnostic/src/lib.rs

@@ -5,8 +5,8 @@
 #![allow(clippy::needless_return)]
 #![allow(unreachable_code)]
 
-#[cfg(all(feature = "compat", not(feature = "net")))]
-compile_error!("`compat` feature is enabled, but `net` feature is disabled, `compact` feature must only be enabled with `net` feature");
+#[cfg(all(feature = "tokio-compat", not(feature = "net")))]
+compile_error!("`tokio-compat` feature is enabled, but `net` feature is disabled, `tokio-compact` feature must only be enabled with `net` feature");
 
 #[macro_use]
 mod macros;

agnostic/src/smol/net.rs

@@ -7,8 +7,6 @@ use std::{
 
 use futures_util::FutureExt;
 use smol::net::{TcpListener, TcpStream, UdpSocket};
-#[cfg(feature = "compat")]
-use tokio_util::compat::FuturesAsyncWriteCompatExt;
 
 use crate::net::{Net, TcpStreamOwnedReadHalf, TcpStreamOwnedWriteHalf, ToSocketAddrs};
 

lite/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "agnostic-lite"
-version = "0.3.15"
+version = "0.3.16"
 edition.workspace = true
 license.workspace = true
 rust-version.workspace = true

lite/src/async_std.rs

@@ -30,7 +30,10 @@ impl Yielder for AsyncStdSpawner {
 }
 
 impl AsyncSpawner for AsyncStdSpawner {
-  type JoinHandle<F> = ::async_std::task::JoinHandle<F> where F: Send + 'static;
+  type JoinHandle<F>
+    = ::async_std::task::JoinHandle<F>
+  where
+    F: Send + 'static;
 
   fn spawn<F>(future: F) -> Self::JoinHandle<F::Output>
   where
@@ -42,7 +45,10 @@ impl AsyncSpawner for AsyncStdSpawner {
 }
 
 impl AsyncLocalSpawner for AsyncStdSpawner {
-  type JoinHandle<F> = ::async_std::task::JoinHandle<F> where F: 'static;
+  type JoinHandle<F>
+    = ::async_std::task::JoinHandle<F>
+  where
+    F: 'static;
 
   fn spawn_local<F>(future: F) -> Self::JoinHandle<F::Output>
   where
@@ -54,7 +60,8 @@ impl AsyncLocalSpawner for AsyncStdSpawner {
 }
 
 impl AsyncBlockingSpawner for AsyncStdSpawner {
-  type JoinHandle<R> = ::async_std::task::JoinHandle<R>
+  type JoinHandle<R>
+    = ::async_std::task::JoinHandle<R>
   where
     R: Send + 'static;
 
@@ -96,13 +103,25 @@ impl super::RuntimeLite for AsyncStdRuntime {
   #[cfg(feature = "time")]
   type LocalSleep = AsyncIoSleep;
   #[cfg(feature = "time")]
-  type Delay<F> = AsyncIoDelay<F> where F: Future + Send;
+  type Delay<F>
+    = AsyncIoDelay<F>
+  where
+    F: Future + Send;
   #[cfg(feature = "time")]
-  type LocalDelay<F> = AsyncIoDelay<F> where F: Future;
+  type LocalDelay<F>
+    = AsyncIoDelay<F>
+  where
+    F: Future;
   #[cfg(feature = "time")]
-  type Timeout<F> = AsyncIoTimeout<F> where F: Future + Send;
+  type Timeout<F>
+    = AsyncIoTimeout<F>
+  where
+    F: Future + Send;
   #[cfg(feature = "time")]
-  type LocalTimeout<F> = AsyncIoTimeout<F> where F: Future;
+  type LocalTimeout<F>
+    = AsyncIoTimeout<F>
+  where
+    F: Future;
 
   fn new() -> Self {
     Self

lite/src/async_std/after.rs

@@ -283,9 +283,10 @@ where
 impl AsyncAfterSpawner for AsyncStdSpawner {
   type JoinError = Infallible;
 
-  type JoinHandle<F> = AsyncStdAfterHandle<F>
-    where
-      F: Send + 'static;
+  type JoinHandle<F>
+    = AsyncStdAfterHandle<F>
+  where
+    F: Send + 'static;
 
   fn spawn_after<F>(duration: core::time::Duration, future: F) -> Self::JoinHandle<F::Output>
   where
@@ -306,9 +307,10 @@ impl AsyncAfterSpawner for AsyncStdSpawner {
 
 impl AsyncLocalAfterSpawner for AsyncStdSpawner {
   type JoinError = Infallible;
-  type JoinHandle<F> = AsyncStdAfterHandle<F>
-    where
-      F: 'static;
+  type JoinHandle<F>
+    = AsyncStdAfterHandle<F>
+  where
+    F: 'static;
 
   fn spawn_local_after<F>(duration: core::time::Duration, future: F) -> Self::JoinHandle<F::Output>
   where

lite/src/smol.rs

@@ -32,7 +32,10 @@ impl Yielder for SmolSpawner {
 }
 
 impl AsyncSpawner for SmolSpawner {
-  type JoinHandle<F> = ::smol::Task<F> where F: Send + 'static;
+  type JoinHandle<F>
+    = ::smol::Task<F>
+  where
+    F: Send + 'static;
 
   fn spawn<F>(future: F) -> Self::JoinHandle<F::Output>
   where
@@ -52,7 +55,10 @@ impl AsyncSpawner for SmolSpawner {
 }
 
 impl AsyncLocalSpawner for SmolSpawner {
-  type JoinHandle<F> = ::smol::Task<F> where F: 'static;
+  type JoinHandle<F>
+    = ::smol::Task<F>
+  where
+    F: 'static;
 
   fn spawn_local<F>(future: F) -> Self::JoinHandle<F::Output>
   where
@@ -72,7 +78,8 @@ impl AsyncLocalSpawner for SmolSpawner {
 }
 
 impl AsyncBlockingSpawner for SmolSpawner {
-  type JoinHandle<R> = ::smol::Task<R>
+  type JoinHandle<R>
+    = ::smol::Task<R>
   where
     R: Send + 'static;
 
@@ -122,13 +129,25 @@ impl super::RuntimeLite for SmolRuntime {
   #[cfg(feature = "time")]
   type LocalSleep = AsyncIoSleep;
   #[cfg(feature = "time")]
-  type Delay<F> = AsyncIoDelay<F> where F: Future + Send;
+  type Delay<F>
+    = AsyncIoDelay<F>
+  where
+    F: Future + Send;
   #[cfg(feature = "time")]
-  type LocalDelay<F> = AsyncIoDelay<F> where F: Future;
+  type LocalDelay<F>
+    = AsyncIoDelay<F>
+  where
+    F: Future;
   #[cfg(feature = "time")]
-  type Timeout<F> = AsyncIoTimeout<F> where F: Future + Send;
+  type Timeout<F>
+    = AsyncIoTimeout<F>
+  where
+    F: Future + Send;
   #[cfg(feature = "time")]
-  type LocalTimeout<F> = AsyncIoTimeout<F> where F: Future;
+  type LocalTimeout<F>
+    = AsyncIoTimeout<F>
+  where
+    F: Future;
 
   fn new() -> Self {
     Self

lite/src/smol/after.rs

@@ -312,9 +312,10 @@ where
 impl AsyncAfterSpawner for SmolSpawner {
   type JoinError = JoinError;
 
-  type JoinHandle<F> = SmolAfterHandle<F>
-    where
-      F: Send + 'static;
+  type JoinHandle<F>
+    = SmolAfterHandle<F>
+  where
+    F: Send + 'static;
 
   fn spawn_after<F>(duration: core::time::Duration, future: F) -> Self::JoinHandle<F::Output>
   where
@@ -335,9 +336,10 @@ impl AsyncAfterSpawner for SmolSpawner {
 
 impl AsyncLocalAfterSpawner for SmolSpawner {
   type JoinError = JoinError;
-  type JoinHandle<F> = SmolAfterHandle<F>
-    where
-      F: 'static;
+  type JoinHandle<F>
+    = SmolAfterHandle<F>
+  where
+    F: 'static;
 
   fn spawn_local_after<F>(duration: core::time::Duration, future: F) -> Self::JoinHandle<F::Output>
   where

lite/src/time/delay.rs

@@ -24,6 +24,7 @@ fn _assert1(_: Box<dyn AsyncLocalDelay<impl Future>>) {}
 fn _assert2(_: Box<dyn AsyncDelay<impl Future>>) {}
 
 /// Simlilar to Go's `time.AfterFunc`, but does not spawn a new thread.
+///
 /// If you want the future to run in its own thread, you should use
 /// [`RuntimeLite::spawn_after`](crate::RuntimeLite::spawn_after) instead.
 pub trait AsyncDelay<F>: Future<Output = Result<F::Output, Aborted>> + Send

lite/src/tokio.rs

@@ -45,8 +45,10 @@ impl Yielder for TokioSpawner {
 }
 
 impl AsyncSpawner for TokioSpawner {
-  type JoinHandle<F> = tokio::task::JoinHandle<F> where
-  F: Send + 'static;
+  type JoinHandle<F>
+    = tokio::task::JoinHandle<F>
+  where
+    F: Send + 'static;
 
   fn spawn<F>(future: F) -> Self::JoinHandle<F::Output>
   where
@@ -58,8 +60,10 @@ impl AsyncSpawner for TokioSpawner {
 }
 
 impl AsyncLocalSpawner for TokioSpawner {
-  type JoinHandle<F> = ::tokio::task::JoinHandle<F> where
-  F: 'static;
+  type JoinHandle<F>
+    = ::tokio::task::JoinHandle<F>
+  where
+    F: 'static;
 
   fn spawn_local<F>(future: F) -> Self::JoinHandle<F::Output>
   where
@@ -73,7 +77,8 @@ impl AsyncLocalSpawner for TokioSpawner {
 impl<T> super::Detach for ::tokio::task::JoinHandle<T> {}
 
 impl AsyncBlockingSpawner for TokioSpawner {
-  type JoinHandle<R> = ::tokio::task::JoinHandle<R>
+  type JoinHandle<R>
+    = ::tokio::task::JoinHandle<R>
   where
     R: Send + 'static;
 
@@ -123,13 +128,25 @@ impl super::RuntimeLite for TokioRuntime {
   #[cfg(feature = "time")]
   type LocalSleep = TokioSleep;
   #[cfg(feature = "time")]
-  type Delay<F> = TokioDelay<F> where F: Future + Send;
+  type Delay<F>
+    = TokioDelay<F>
+  where
+    F: Future + Send;
   #[cfg(feature = "time")]
-  type LocalDelay<F> = TokioDelay<F> where F: Future;
+  type LocalDelay<F>
+    = TokioDelay<F>
+  where
+    F: Future;
   #[cfg(feature = "time")]
-  type Timeout<F> = TokioTimeout<F> where F: Future + Send;
+  type Timeout<F>
+    = TokioTimeout<F>
+  where
+    F: Future + Send;
   #[cfg(feature = "time")]
-  type LocalTimeout<F> = TokioTimeout<F> where F: Future;
+  type LocalTimeout<F>
+    = TokioTimeout<F>
+  where
+    F: Future;
 
   fn new() -> Self {
     Self

lite/src/tokio/after.rs

@@ -275,9 +275,10 @@ where
 impl AsyncAfterSpawner for TokioSpawner {
   type JoinError = JoinError;
 
-  type JoinHandle<F> = TokioAfterHandle<F>
-    where
-      F: Send + 'static;
+  type JoinHandle<F>
+    = TokioAfterHandle<F>
+  where
+    F: Send + 'static;
 
   fn spawn_after<F>(duration: core::time::Duration, future: F) -> Self::JoinHandle<F::Output>
   where
@@ -299,9 +300,10 @@ impl AsyncAfterSpawner for TokioSpawner {
 impl AsyncLocalAfterSpawner for TokioSpawner {
   type JoinError = JoinError;
 
-  type JoinHandle<F> = TokioAfterHandle<F>
-    where
-      F: 'static;
+  type JoinHandle<F>
+    = TokioAfterHandle<F>
+  where
+    F: 'static;
 
   fn spawn_local_after<F>(duration: core::time::Duration, future: F) -> Self::JoinHandle<F::Output>
   where