Rename with_retrying to retry_on_intr.

This makes it more explicit what it's doing.

Author: sunfishcode

src/imp/libc/io/errno.rs

@@ -271,9 +271,9 @@ impl Errno {
     /// `EINTR`
     ///
     /// For a convenient way to retry system calls that exit with `INTR`, use
-    /// [`with_retrying`].
+    /// [`retry_on_intr`].
     ///
-    /// [`with_retrying`]: crate::io::with_retrying
+    /// [`retry_on_intr`]: crate::io::retry_on_intr
     pub const INTR: Self = Self(c::EINTR);
     /// `EINVAL`
     pub const INVAL: Self = Self(c::EINVAL);

src/imp/linux_raw/io/errno.rs

@@ -311,9 +311,9 @@ impl Errno {
     /// `EINTR`.
     ///
     /// For a convenient way to retry system calls that exit with `INTR`, use
-    /// [`with_retrying`].
+    /// [`retry_on_intr`].
     ///
-    /// [`with_retrying`]: io::with_retrying
+    /// [`retry_on_intr`]: io::retry_on_intr
     pub const INTR: Self = Self::from_errno(errno::EINTR);
     /// `EINVAL`
     pub const INVAL: Self = Self::from_errno(errno::EINVAL);

src/io/errno.rs

@@ -75,7 +75,7 @@ impl From<Errno> for std::io::Error {
 
 /// Call `f` until it either succeeds or fails other than [`Errno::INTR`].
 #[inline]
-pub fn with_retrying<T, F: FnMut() -> Result<T>>(mut f: F) -> Result<T> {
+pub fn retry_on_intr<T, F: FnMut() -> Result<T>>(mut f: F) -> Result<T> {
     loop {
         match f() {
             Err(Errno::INTR) => (),

src/io/mod.rs

@@ -30,7 +30,7 @@ pub use crate::imp::io::epoll;
 pub use close::close;
 #[cfg(not(any(windows, target_os = "wasi")))]
 pub use dup::{dup, dup2, dup3, DupFlags};
-pub use errno::{with_retrying, Errno, Result};
+pub use errno::{retry_on_intr, Errno, Result};
 #[cfg(any(target_os = "android", target_os = "linux"))]
 pub use eventfd::{eventfd, EventfdFlags};
 #[cfg(any(target_os = "ios", target_os = "macos"))]

tests/io/poll.rs

@@ -1,6 +1,6 @@
 use rustix::fd::{AsFd, AsRawFd, FromRawFd, IntoRawFd, OwnedFd};
 #[cfg(not(windows))]
-use rustix::io::{poll, with_retrying};
+use rustix::io::{poll, retry_on_intr};
 use rustix::io::{PollFd, PollFlags};
 
 #[cfg(not(windows))]
@@ -14,16 +14,16 @@ fn test_poll() {
     assert_eq!(poll_fds[0].as_fd().as_raw_fd(), reader.as_fd().as_raw_fd());
 
     // `poll` should say there's nothing ready to be read from the pipe.
-    let num = with_retrying(|| poll(&mut poll_fds, 0)).unwrap();
+    let num = retry_on_intr(|| poll(&mut poll_fds, 0)).unwrap();
     assert_eq!(num, 0);
     assert!(poll_fds[0].revents().is_empty());
     assert_eq!(poll_fds[0].as_fd().as_raw_fd(), reader.as_fd().as_raw_fd());
 
     // Write a byte to the pipe.
-    assert_eq!(with_retrying(|| write(&writer, b"a")).unwrap(), 1);
+    assert_eq!(retry_on_intr(|| write(&writer, b"a")).unwrap(), 1);
 
     // `poll` should now say there's data to be read.
-    let num = with_retrying(|| poll(&mut poll_fds, -1)).unwrap();
+    let num = retry_on_intr(|| poll(&mut poll_fds, -1)).unwrap();
     assert_eq!(num, 1);
     assert_eq!(poll_fds[0].revents(), PollFlags::IN);
     assert_eq!(poll_fds[0].as_fd().as_raw_fd(), reader.as_fd().as_raw_fd());
@@ -35,12 +35,12 @@ fn test_poll() {
 
     // Read the byte from the pipe.
     let mut buf = [b'\0'];
-    assert_eq!(with_retrying(|| read(&reader, &mut buf)).unwrap(), 1);
+    assert_eq!(retry_on_intr(|| read(&reader, &mut buf)).unwrap(), 1);
     assert_eq!(buf[0], b'a');
     assert_eq!(poll_fds[0].as_fd().as_raw_fd(), reader.as_fd().as_raw_fd());
 
     // Poll should now say there's no more data to be read.
-    let num = with_retrying(|| poll(&mut poll_fds, 0)).unwrap();
+    let num = retry_on_intr(|| poll(&mut poll_fds, 0)).unwrap();
     assert_eq!(num, 0);
     assert!(poll_fds[0].revents().is_empty());
     assert_eq!(poll_fds[0].as_fd().as_raw_fd(), reader.as_fd().as_raw_fd());