fix: change type alias restriction to satisfy latest nightly (#89)

Author: ihciah

deny.toml

@@ -1,23 +1,24 @@
 [licenses]
-unlicensed = "deny"
 allow = [
-    "MIT",
-    "Apache-2.0",
-    "Apache-2.0 WITH LLVM-exception",
-    "Zlib",
-    "BSD-3-Clause",
-    "Unlicense"
+  "MIT",
+  "Apache-2.0",
+  "Apache-2.0 WITH LLVM-exception",
+  "Zlib",
+  "BSD-3-Clause",
+  "Unlicense",
+  "Unicode-DFS-2016",
 ]
+confidence-threshold = 0.95
 copyleft = "deny"
 default = "deny"
-confidence-threshold = 0.95
-private = { ignore = true }
+private = {ignore = true}
+unlicensed = "deny"
 
 [advisories]
-vulnerability = "deny"
-unmaintained = "deny"
 notice = "deny"
+unmaintained = "deny"
 unsound = "deny"
+vulnerability = "deny"
 
 [bans]
-multiple-versions = "allow"
+multiple-versions = "allow"

monoio/src/io/async_read_rent.rs

@@ -10,12 +10,12 @@ pub trait AsyncReadRent {
     type ReadFuture<'a, T>: Future<Output = BufResult<usize, T>>
     where
         Self: 'a,
-        T: 'a;
+        T: IoBufMut + 'a;
     /// The future of readv Result<size, buffer>
     type ReadvFuture<'a, T>: Future<Output = BufResult<usize, T>>
     where
         Self: 'a,
-        T: 'a;
+        T: IoVecBufMut + 'a;
 
     /// Same as read(2)
     fn read<T: IoBufMut>(&mut self, buf: T) -> Self::ReadFuture<'_, T>;
@@ -39,12 +39,12 @@ impl<A: ?Sized + AsyncReadRent> AsyncReadRent for &mut A {
     type ReadFuture<'a, T> = A::ReadFuture<'a, T>
     where
         Self: 'a,
-        T: 'a;
+        T: IoBufMut + 'a;
 
     type ReadvFuture<'a, T> = A::ReadvFuture<'a, T>
     where
         Self: 'a,
-        T: 'a;
+        T: IoVecBufMut + 'a;
 
     fn read<T: IoBufMut>(&mut self, buf: T) -> Self::ReadFuture<'_, T> {
         (**self).read(buf)
@@ -57,9 +57,9 @@ impl<A: ?Sized + AsyncReadRent> AsyncReadRent for &mut A {
 
 impl AsyncReadRent for &[u8] {
     type ReadFuture<'a, B> = impl std::future::Future<Output = crate::BufResult<usize, B>> where
-        B: 'a, Self: 'a;
+        B: IoBufMut + 'a, Self: 'a;
     type ReadvFuture<'a, B> = impl std::future::Future<Output = crate::BufResult<usize, B>> where
-        B: 'a, Self: 'a;
+        B: IoVecBufMut + 'a, Self: 'a;
 
     fn read<T: IoBufMut>(&mut self, mut buf: T) -> Self::ReadFuture<'_, T> {
         let amt = std::cmp::min(self.len(), buf.bytes_total());

monoio/src/io/async_read_rent_ext.rs

@@ -51,7 +51,7 @@ pub trait AsyncReadRentExt {
     type ReadExactFuture<'a, T>: Future<Output = BufResult<usize, T>>
     where
         Self: 'a,
-        T: 'a;
+        T: IoBufMut + 'a;
 
     /// Read until buf capacity is fulfilled
     fn read_exact<T: 'static>(&mut self, buf: T) -> Self::ReadExactFuture<'_, T>
@@ -62,7 +62,7 @@ pub trait AsyncReadRentExt {
     type ReadVectoredExactFuture<'a, T>: Future<Output = BufResult<usize, T>>
     where
         Self: 'a,
-        T: 'a;
+        T: IoVecBufMut + 'a;
 
     /// Readv until buf capacity is fulfilled
     fn read_vectored_exact<T: 'static>(&mut self, buf: T) -> Self::ReadVectoredExactFuture<'_, T>
@@ -100,7 +100,7 @@ impl<A> AsyncReadRentExt for A
 where
     A: AsyncReadRent + ?Sized,
 {
-    type ReadExactFuture<'a, T> = impl Future<Output = BufResult<usize, T>> where A: 'a, T: 'a;
+    type ReadExactFuture<'a, T> = impl Future<Output = BufResult<usize, T>> where A: 'a, T: IoBufMut + 'a;
 
     fn read_exact<T>(&mut self, mut buf: T) -> Self::ReadExactFuture<'_, T>
     where
@@ -135,7 +135,7 @@ where
         }
     }
 
-    type ReadVectoredExactFuture<'a, T> = impl Future<Output = BufResult<usize, T>> where A: 'a, T: 'a;
+    type ReadVectoredExactFuture<'a, T> = impl Future<Output = BufResult<usize, T>> where A: 'a, T: IoVecBufMut + 'a;
 
     fn read_vectored_exact<T: 'static>(
         &mut self,

monoio/src/io/async_write_rent.rs

@@ -10,12 +10,12 @@ pub trait AsyncWriteRent {
     type WriteFuture<'a, T>: Future<Output = BufResult<usize, T>>
     where
         Self: 'a,
-        T: 'a;
+        T: IoBuf + 'a;
     /// The future of writev Result<size, buffer>
     type WritevFuture<'a, T>: Future<Output = BufResult<usize, T>>
     where
         Self: 'a,
-        T: 'a;
+        T: IoVecBuf + 'a;
 
     /// The future of flush
     type FlushFuture<'a>: Future<Output = std::io::Result<()>>
@@ -56,12 +56,12 @@ impl<A: ?Sized + AsyncWriteRent> AsyncWriteRent for &mut A {
     type WriteFuture<'a, T> = A::WriteFuture<'a, T>
     where
         Self: 'a,
-        T: 'a;
+        T: IoBuf + 'a;
 
     type WritevFuture<'a, T> = A::WritevFuture<'a, T>
     where
         Self: 'a,
-        T: 'a;
+        T: IoVecBuf + 'a;
 
     type FlushFuture<'a> = A::FlushFuture<'a>
     where

monoio/src/io/async_write_rent_ext.rs

@@ -11,7 +11,7 @@ pub trait AsyncWriteRentExt {
     type WriteExactFuture<'a, T>: Future<Output = BufResult<usize, T>>
     where
         Self: 'a,
-        T: 'a;
+        T: IoBuf + 'a;
 
     /// Write all
     fn write_all<T>(&mut self, buf: T) -> Self::WriteExactFuture<'_, T>
@@ -22,7 +22,7 @@ pub trait AsyncWriteRentExt {
     type WriteVectoredExactFuture<'a, T>: Future<Output = BufResult<usize, T>>
     where
         Self: 'a,
-        T: 'a;
+        T: IoVecBuf + 'a;
 
     /// Write all
     fn write_vectored_all<T>(&mut self, buf: T) -> Self::WriteVectoredExactFuture<'_, T>
@@ -34,7 +34,7 @@ impl<A> AsyncWriteRentExt for A
 where
     A: AsyncWriteRent + ?Sized,
 {
-    type WriteExactFuture<'a, T> = impl Future<Output = BufResult<usize, T>> where A: 'a, T: 'a;
+    type WriteExactFuture<'a, T> = impl Future<Output = BufResult<usize, T>> where A: 'a, T: IoBuf + 'a;
 
     fn write_all<T>(&mut self, mut buf: T) -> Self::WriteExactFuture<'_, T>
     where
@@ -66,7 +66,7 @@ where
         }
     }
 
-    type WriteVectoredExactFuture<'a, T> = impl Future<Output = BufResult<usize, T>> where A: 'a, T: 'a;
+    type WriteVectoredExactFuture<'a, T> = impl Future<Output = BufResult<usize, T>> where A: 'a, T: IoVecBuf + 'a;
 
     fn write_vectored_all<T>(&mut self, buf: T) -> Self::WriteVectoredExactFuture<'_, T>
     where

monoio/src/io/stream/stream_ext.rs

@@ -41,7 +41,8 @@ pub trait StreamExt: Stream {
 
 impl<T> StreamExt for T where T: Stream {}
 
-type ForEachFut<T: Stream, Fut, F> = impl Future<Output = ()>;
+type ForEachFut<T: Stream, Fut: Future<Output = ()>, F: FnMut(<T as Stream>::Item) -> Fut> =
+    impl Future<Output = ()>;
 
 #[must_use = "streams do nothing unless polled"]
 pub struct Map<St, F> {

monoio/src/io/util/buf_reader.rs

@@ -1,5 +1,5 @@
 use crate::{
-    buf::IoVecWrapperMut,
+    buf::{IoBuf, IoBufMut, IoVecBuf, IoVecBufMut, IoVecWrapperMut},
     io::{AsyncBufRead, AsyncReadRent, AsyncWriteRent},
 };
 use std::future::Future;
@@ -69,12 +69,12 @@ impl<R> BufReader<R> {
 
 impl<R: AsyncReadRent> AsyncReadRent for BufReader<R> {
     type ReadFuture<'a, T>  = impl Future<Output = crate::BufResult<usize, T>> where
-        T: 'a, R: 'a;
+        T: IoBufMut + 'a, R: 'a;
 
     type ReadvFuture<'a, T> = impl Future<Output = crate::BufResult<usize, T>> where
-        T: 'a, R: 'a;
+        T: IoVecBufMut + 'a, R: 'a;
 
-    fn read<T: crate::buf::IoBufMut>(&mut self, mut buf: T) -> Self::ReadFuture<'_, T> {
+    fn read<T: IoBufMut>(&mut self, mut buf: T) -> Self::ReadFuture<'_, T> {
         async move {
             // If we don't have any buffered data and we're doing a massive read
             // (larger than our internal buffer), bypass our internal buffer
@@ -101,7 +101,7 @@ impl<R: AsyncReadRent> AsyncReadRent for BufReader<R> {
         }
     }
 
-    fn readv<T: crate::buf::IoVecBufMut>(&mut self, mut buf: T) -> Self::ReadvFuture<'_, T> {
+    fn readv<T: IoVecBufMut>(&mut self, mut buf: T) -> Self::ReadvFuture<'_, T> {
         async move {
             let slice = match IoVecWrapperMut::new(buf) {
                 Ok(slice) => slice,
@@ -160,20 +160,20 @@ impl<R: AsyncReadRent> AsyncBufRead for BufReader<R> {
 
 impl<R: AsyncReadRent + AsyncWriteRent> AsyncWriteRent for BufReader<R> {
     type WriteFuture<'a, T> = R::WriteFuture<'a, T> where
-    T: 'a, R: 'a;
+    T: IoBuf + 'a, R: 'a;
 
     type WritevFuture<'a, T>= R::WritevFuture<'a, T> where
-    T: 'a, R: 'a;
+    T: IoVecBuf + 'a, R: 'a;
 
     type FlushFuture<'a> = R::FlushFuture<'a> where R: 'a;
 
     type ShutdownFuture<'a> = R::ShutdownFuture<'a> where R: 'a;
 
-    fn write<T: crate::buf::IoBuf>(&mut self, buf: T) -> Self::WriteFuture<'_, T> {
+    fn write<T: IoBuf>(&mut self, buf: T) -> Self::WriteFuture<'_, T> {
         self.inner.write(buf)
     }
 
-    fn writev<T: crate::buf::IoVecBuf>(&mut self, buf_vec: T) -> Self::WritevFuture<'_, T> {
+    fn writev<T: IoVecBuf>(&mut self, buf_vec: T) -> Self::WritevFuture<'_, T> {
         self.inner.writev(buf_vec)
     }
 

monoio/src/io/util/buf_writer.rs

@@ -1,7 +1,7 @@
 use std::{future::Future, io};
 
 use crate::{
-    buf::{IoVecWrapper, Slice},
+    buf::{IoBuf, IoBufMut, IoVecBuf, IoVecBufMut, IoVecWrapper, Slice},
     io::{AsyncBufRead, AsyncReadRent, AsyncWriteRent, AsyncWriteRentExt},
 };
 
@@ -85,18 +85,18 @@ impl<W: AsyncWriteRent> BufWriter<W> {
 
 impl<W: AsyncWriteRent> AsyncWriteRent for BufWriter<W> {
     type WriteFuture<'a, T> = impl Future<Output = crate::BufResult<usize, T>> where
-        T: 'a, W: 'a;
+        T: IoBuf + 'a, W: 'a;
 
     type WritevFuture<'a, T> = impl Future<Output = crate::BufResult<usize, T>> where
-        T: 'a, W: 'a;
+        T: IoVecBuf + 'a, W: 'a;
 
     type FlushFuture<'a> = impl Future<Output = io::Result<()>> where
         W: 'a;
 
     type ShutdownFuture<'a> = impl Future<Output = io::Result<()>> where
         W: 'a;
 
-    fn write<T: crate::buf::IoBuf>(&mut self, buf: T) -> Self::WriteFuture<'_, T> {
+    fn write<T: IoBuf>(&mut self, buf: T) -> Self::WriteFuture<'_, T> {
         async move {
             let owned_buf = self.buf.as_ref().unwrap();
             let owned_len = owned_buf.len();
@@ -136,7 +136,7 @@ impl<W: AsyncWriteRent> AsyncWriteRent for BufWriter<W> {
     }
 
     // TODO: implement it as real io_vec
-    fn writev<T: crate::buf::IoVecBuf>(&mut self, buf: T) -> Self::WritevFuture<'_, T> {
+    fn writev<T: IoVecBuf>(&mut self, buf: T) -> Self::WritevFuture<'_, T> {
         async move {
             let slice = match IoVecWrapper::new(buf) {
                 Ok(slice) => slice,
@@ -165,16 +165,16 @@ impl<W: AsyncWriteRent> AsyncWriteRent for BufWriter<W> {
 
 impl<W: AsyncWriteRent + AsyncReadRent> AsyncReadRent for BufWriter<W> {
     type ReadFuture<'a, T> = W::ReadFuture<'a, T> where
-        T: 'a, W: 'a;
+        T: IoBufMut + 'a, W: 'a;
 
     type ReadvFuture<'a, T> = W::ReadvFuture<'a, T> where
-        T: 'a, W: 'a;
+        T: IoVecBufMut + 'a, W: 'a;
 
-    fn read<T: crate::buf::IoBufMut>(&mut self, buf: T) -> Self::ReadFuture<'_, T> {
+    fn read<T: IoBufMut>(&mut self, buf: T) -> Self::ReadFuture<'_, T> {
         self.inner.read(buf)
     }
 
-    fn readv<T: crate::buf::IoVecBufMut>(&mut self, buf: T) -> Self::ReadvFuture<'_, T> {
+    fn readv<T: IoVecBufMut>(&mut self, buf: T) -> Self::ReadvFuture<'_, T> {
         self.inner.readv(buf)
     }
 }

monoio/src/io/util/prefixed_io.rs

@@ -1,5 +1,5 @@
 use crate::{
-    buf::IoVecWrapperMut,
+    buf::{IoBuf, IoBufMut, IoVecBuf, IoVecBufMut, IoVecWrapperMut},
     io::{AsyncReadRent, AsyncWriteRent},
 };
 
@@ -35,13 +35,13 @@ impl<I, P> PrefixedReadIo<I, P> {
 impl<I: AsyncReadRent, P: std::io::Read> AsyncReadRent for PrefixedReadIo<I, P> {
     type ReadFuture<'a, T> = impl std::future::Future<Output = crate::BufResult<usize, T>>
     where
-        T: 'a, Self: 'a;
+        T: IoBufMut + 'a, Self: 'a;
 
     type ReadvFuture<'a, T> = impl std::future::Future<Output = crate::BufResult<usize, T>>
     where
-        T: 'a, Self: 'a;
+        T: IoVecBufMut + 'a, Self: 'a;
 
-    fn read<T: crate::buf::IoBufMut>(&mut self, mut buf: T) -> Self::ReadFuture<'_, T> {
+    fn read<T: IoBufMut>(&mut self, mut buf: T) -> Self::ReadFuture<'_, T> {
         async move {
             if buf.bytes_total() == 0 {
                 return (Ok(0), buf);
@@ -69,7 +69,7 @@ impl<I: AsyncReadRent, P: std::io::Read> AsyncReadRent for PrefixedReadIo<I, P>
         }
     }
 
-    fn readv<T: crate::buf::IoVecBufMut>(&mut self, mut buf: T) -> Self::ReadvFuture<'_, T> {
+    fn readv<T: IoVecBufMut>(&mut self, mut buf: T) -> Self::ReadvFuture<'_, T> {
         async move {
             let slice = match IoVecWrapperMut::new(buf) {
                 Ok(slice) => slice,
@@ -88,20 +88,20 @@ impl<I: AsyncReadRent, P: std::io::Read> AsyncReadRent for PrefixedReadIo<I, P>
 
 impl<I: AsyncWriteRent, P> AsyncWriteRent for PrefixedReadIo<I, P> {
     type WriteFuture<'a, T> = I::WriteFuture<'a, T> where
-    T: 'a, Self: 'a;
+    T: IoBuf + 'a, Self: 'a;
 
     type WritevFuture<'a, T>= I::WritevFuture<'a, T> where
-    T: 'a, Self: 'a;
+    T: IoVecBuf + 'a, Self: 'a;
 
     type FlushFuture<'a> = I::FlushFuture<'a> where Self: 'a;
 
     type ShutdownFuture<'a> = I::ShutdownFuture<'a> where Self: 'a;
 
-    fn write<T: crate::buf::IoBuf>(&mut self, buf: T) -> Self::WriteFuture<'_, T> {
+    fn write<T: IoBuf>(&mut self, buf: T) -> Self::WriteFuture<'_, T> {
         self.io.write(buf)
     }
 
-    fn writev<T: crate::buf::IoVecBuf>(&mut self, buf_vec: T) -> Self::WritevFuture<'_, T> {
+    fn writev<T: IoVecBuf>(&mut self, buf_vec: T) -> Self::WritevFuture<'_, T> {
         self.io.writev(buf_vec)
     }
 

monoio/src/lib.rs

@@ -13,6 +13,7 @@
 #![feature(box_into_inner)]
 #![feature(new_uninit)]
 #![feature(io_error_more)]
+#![feature(unboxed_closures)]
 
 #[macro_use]
 pub mod macros;