fix: fix typos

.vscode/settings.json

@@ -0,0 +1,5 @@
+{
+    "rust-analyzer.linkedProjects": [
+        "./monoio/Cargo.toml"
+    ]
+}

examples/timer_select.rs

@@ -27,7 +27,7 @@ async fn main() {
         }
     }
 
-    // A very improtant thing is if you use select to do timeout io,
+    // A very important thing is if you use select to do timeout io,
     // you must cancel it manually.
     // In epoll, dropping a read future has no side effect since we
     // only wait for io ready, after waiting aborted, no syscall

monoio-compat/src/tcp_unsafe.rs

@@ -54,7 +54,7 @@ impl TcpStreamCompat {
     ///
     /// # Safety
     /// User must ensure that the data slice pointer and length is always
-    /// valid and the same among diffrent calls before Poll::Ready returns.
+    /// valid and the same among different calls before Poll::Ready returns.
     pub unsafe fn new(stream: TcpStream) -> Self {
         Self {
             stream,

monoio/Cargo.toml

@@ -71,7 +71,7 @@ debug = ["tracing"]
 legacy = ["mio"]
 # iouring support
 iouring = []
-# tokio-compatiable(only have effect when legacy is enabled and iouring is not)
+# tokio-compatible(only have effect when legacy is enabled and iouring is not)
 tokio-compat = ["tokio"]
 # signal enables setting ctrl_c handler
 signal = ["ctrlc", "sync"]

monoio/src/blocking.rs

@@ -25,7 +25,7 @@ pub enum JoinError {
 }
 
 /// BlockingTask is contrusted by monoio, ThreadPool impl
-/// will exeucte it with `.run()`.
+/// will execute it with `.run()`.
 pub struct BlockingTask {
     task: Option<crate::task::Task<NoopScheduler>>,
     blocking_vtable: &'static BlockingTaskVtable,
@@ -118,7 +118,7 @@ where
     join
 }
 
-/// DefaultThreadPool is a simple wrapped `threadpool::ThreadPool` that implememt
+/// DefaultThreadPool is a simple wrapped `threadpool::ThreadPool` that implement
 /// `monoio::blocking::ThreadPool`. You may use this implementation, or you can use your own thread
 /// pool implementation.
 #[derive(Clone)]

monoio/src/driver/op/accept.rs

@@ -81,7 +81,7 @@ impl OpAble for Accept {
         let fd = self.fd.as_raw_fd();
         let addr = self.addr.0.as_mut_ptr() as *mut _;
         let len = &mut self.addr.1;
-        // Here I use copied some code from mio because I don't want the convertion.
+        // Here I use copied some code from mio because I don't want the conversion.
 
         // On platforms that support it we can use `accept4(2)` to set `NONBLOCK`
         // and `CLOEXEC` in the call to accept the connection.

monoio/src/io/util/cancel.rs

@@ -10,13 +10,13 @@ pub struct CancelHandle {
 }
 
 /// Canceller is a user-hold struct to cancel io operations.
-/// A canceller can assocate with multiple io operations.
+/// A canceller can associate with multiple io operations.
 #[derive(Default)]
 pub struct Canceller {
     shared: Rc<RefCell<Shared>>,
 }
 
-pub(crate) struct AssocateGuard {
+pub(crate) struct AssociateGuard {
     op_canceller: OpCanceller,
     shared: Rc<RefCell<Shared>>,
 }
@@ -67,19 +67,19 @@ impl CancelHandle {
         self.shared.borrow().canceled
     }
 
-    pub(crate) fn assocate_op(self, op_canceller: OpCanceller) -> AssocateGuard {
+    pub(crate) fn associate_op(self, op_canceller: OpCanceller) -> AssociateGuard {
         {
             let mut shared = self.shared.borrow_mut();
             shared.slot_ref.insert(op_canceller.clone());
         }
-        AssocateGuard {
+        AssociateGuard {
             op_canceller,
             shared: self.shared,
         }
     }
 }
 
-impl Drop for AssocateGuard {
+impl Drop for AssociateGuard {
     fn drop(&mut self) {
         let mut shared = self.shared.borrow_mut();
         shared.slot_ref.remove(&self.op_canceller);

monoio/src/io/util/copy.rs

@@ -16,7 +16,7 @@ where
     W: AsyncWriteRent + ?Sized,
 {
     let mut buf: Vec<u8> = Vec::with_capacity(BUF_SIZE);
-    let mut transfered: u64 = 0;
+    let mut transferred: u64 = 0;
 
     'r: loop {
         let (read_res, mut buf_read) = reader.read(buf).await;
@@ -60,15 +60,15 @@ where
                 }
                 Ok(n) => {
                     // go read data
-                    transfered += n as u64;
+                    transferred += n as u64;
                     buf = buf_;
                     break;
                 }
             }
         }
     }
 
-    Ok(transfered)
+    Ok(transferred)
 }
 
 /// Copy with splice.
@@ -83,17 +83,17 @@ pub async fn zero_copy<SRC: crate::io::as_fd::AsReadFd, DST: crate::io::as_fd::A
     };
 
     let (mut pr, mut pw) = new_pipe()?;
-    let mut transfered: u64 = 0;
+    let mut transferred: u64 = 0;
     loop {
         let mut to_write = reader.splice_to_pipe(&mut pw, BUF_SIZE as u32).await?;
         if to_write == 0 {
             break;
         }
-        transfered += to_write as u64;
+        transferred += to_write as u64;
         while to_write > 0 {
             let written = writer.splice_from_pipe(&mut pr, to_write).await?;
             to_write -= written;
         }
     }
-    Ok(transfered)
+    Ok(transferred)
 }

monoio/src/net/mod.rs

@@ -43,7 +43,7 @@ pub(crate) fn new_socket(
     #[cfg(unix)]
     let socket = crate::syscall!(socket(domain, socket_type, 0));
 
-    // Mimick `libstd` and set `SO_NOSIGPIPE` on apple systems.
+    // Mimic `libstd` and set `SO_NOSIGPIPE` on apple systems.
     #[cfg(target_vendor = "apple")]
     let socket = socket.and_then(|socket| {
         crate::syscall!(setsockopt(

monoio/src/net/tcp/listener.rs

@@ -155,7 +155,7 @@ impl TcpListener {
             return Err(operation_canceled());
         }
         let op = Op::accept(&self.fd)?;
-        let _guard = c.assocate_op(op.op_canceller());
+        let _guard = c.associate_op(op.op_canceller());
 
         // Await the completion of the event
         let completion = op.await;

monoio/src/net/tcp/stream.rs

@@ -363,7 +363,7 @@ impl CancelableAsyncWriteRent for TcpStream {
             }
 
             let op = Op::send(fd, buf).unwrap();
-            let _guard = c.assocate_op(op.op_canceller());
+            let _guard = c.associate_op(op.op_canceller());
             op.write().await
         }
     }
@@ -381,7 +381,7 @@ impl CancelableAsyncWriteRent for TcpStream {
             }
 
             let op = Op::writev(&fd, buf_vec).unwrap();
-            let _guard = c.assocate_op(op.op_canceller());
+            let _guard = c.associate_op(op.op_canceller());
             op.write().await
         }
     }
@@ -450,7 +450,7 @@ impl CancelableAsyncReadRent for TcpStream {
             }
 
             let op = Op::recv(fd, buf).unwrap();
-            let _guard = c.assocate_op(op.op_canceller());
+            let _guard = c.associate_op(op.op_canceller());
             op.read().await
         }
     }
@@ -468,7 +468,7 @@ impl CancelableAsyncReadRent for TcpStream {
             }
 
             let op = Op::readv(fd, buf).unwrap();
-            let _guard = c.assocate_op(op.op_canceller());
+            let _guard = c.associate_op(op.op_canceller());
             op.read().await
         }
     }

monoio/src/net/udp.rs

@@ -210,7 +210,7 @@ impl UdpSocket {
         }
 
         let op = Op::recv_msg(self.fd.clone(), buf).unwrap();
-        let _guard = c.assocate_op(op.op_canceller());
+        let _guard = c.associate_op(op.op_canceller());
         op.wait().await
     }
 
@@ -227,7 +227,7 @@ impl UdpSocket {
         }
 
         let op = Op::send_msg(self.fd.clone(), buf, Some(socket_addr)).unwrap();
-        let _guard = c.assocate_op(op.op_canceller());
+        let _guard = c.associate_op(op.op_canceller());
         op.wait().await
     }
 
@@ -242,7 +242,7 @@ impl UdpSocket {
         }
 
         let op = Op::send_msg(self.fd.clone(), buf, None).unwrap();
-        let _guard = c.assocate_op(op.op_canceller());
+        let _guard = c.associate_op(op.op_canceller());
         op.wait().await
     }
 
@@ -258,7 +258,7 @@ impl UdpSocket {
         }
 
         let op = Op::recv(self.fd.clone(), buf).unwrap();
-        let _guard = c.assocate_op(op.op_canceller());
+        let _guard = c.associate_op(op.op_canceller());
         op.read().await
     }
 }

monoio/src/net/unix/listener.rs

@@ -96,7 +96,7 @@ impl UnixListener {
             return Err(operation_canceled());
         }
         let op = Op::accept(&self.fd)?;
-        let _guard = c.assocate_op(op.op_canceller());
+        let _guard = c.associate_op(op.op_canceller());
 
         // Await the completion of the event
         let completion = op.await;

monoio/src/net/unix/seq_packet/listener.rs

@@ -17,7 +17,7 @@ use crate::{
 
 const DEFAULT_BACKLOG: libc::c_int = 128;
 
-/// Listner for UnixSeqpacket
+/// Listener for UnixSeqpacket
 pub struct UnixSeqpacketListener {
     fd: SharedFd,
 }

monoio/src/net/unix/stream.rs

@@ -234,7 +234,7 @@ impl CancelableAsyncWriteRent for UnixStream {
             }
 
             let op = Op::send(fd, buf).unwrap();
-            let _guard = c.assocate_op(op.op_canceller());
+            let _guard = c.associate_op(op.op_canceller());
             op.write().await
         }
     }
@@ -252,7 +252,7 @@ impl CancelableAsyncWriteRent for UnixStream {
             }
 
             let op = Op::writev(&fd, buf_vec).unwrap();
-            let _guard = c.assocate_op(op.op_canceller());
+            let _guard = c.associate_op(op.op_canceller());
             op.write().await
         }
     }
@@ -316,7 +316,7 @@ impl CancelableAsyncReadRent for UnixStream {
             }
 
             let op = Op::recv(fd, buf).unwrap();
-            let _guard = c.assocate_op(op.op_canceller());
+            let _guard = c.associate_op(op.op_canceller());
             op.read().await
         }
     }
@@ -334,7 +334,7 @@ impl CancelableAsyncReadRent for UnixStream {
             }
 
             let op = Op::readv(fd, buf).unwrap();
-            let _guard = c.assocate_op(op.op_canceller());
+            let _guard = c.associate_op(op.op_canceller());
             op.read().await
         }
     }

monoio/src/utils/slab.rs

@@ -251,7 +251,7 @@ impl<T> Page<T> {
     }
 
     // alloc a slot
-    // Safety: after slot is allocated, the caller must guarante it will be
+    // Safety: after slot is allocated, the caller must guarantee it will be
     // initialized
     unsafe fn alloc(&mut self) -> Option<usize> {
         let next = self.next;