Common error types

Author: DanglingPointer

src/lib.rs

@@ -10,6 +10,7 @@ pub mod prelude {
     pub use crate::stopwatch::Stopwatch;
     pub use crate::sync::bounded as local_bounded;
     pub use crate::sync::condvar as local_condvar;
+    pub use crate::sync::error as local_sync_error;
     pub use crate::sync::oneshot as local_oneshot;
     pub use crate::sync::semaphore as local_semaphore;
     pub use crate::sync::unbounded as local_unbounded;

src/sync/bounded.rs

@@ -1,10 +1,10 @@
 use crate::shared::UnsafeShared;
+use crate::sync::error::{SendError, TrySendError};
 use futures::Stream;
 use std::cell::UnsafeCell;
 use std::collections::VecDeque;
 use std::rc::Rc;
 use std::task::{Context, Poll, Waker};
-use std::{fmt, io};
 use std::{future::poll_fn, pin::Pin};
 
 struct State<T> {
@@ -25,17 +25,6 @@ fn take_and_wake(waker: &mut Option<Waker>) {
     waker.take().inspect(Waker::wake_by_ref);
 }
 
-#[derive(PartialEq, Eq)]
-pub enum TrySendError<T> {
-    Full(T),
-    Closed(T),
-}
-
-#[derive(PartialEq, Eq)]
-pub enum SendError<T> {
-    Closed(T),
-}
-
 /// Bounded SPSC channel
 pub fn channel<T>(limit: usize) -> (Sender<T>, Receiver<T>) {
     let shared = Rc::new(UnsafeCell::new(State {
@@ -170,63 +159,6 @@ impl<T> Drop for Receiver<T> {
     }
 }
 
-impl<T> fmt::Debug for TrySendError<T> {
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        match self {
-            TrySendError::Full(_) => f.write_str("TrySendError::Full(..)"),
-            TrySendError::Closed(_) => f.write_str("TrySendError::Closed(..)"),
-        }
-    }
-}
-
-impl<T> fmt::Display for TrySendError<T> {
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        match self {
-            TrySendError::Full(_) => f.write_str("channel is full"),
-            TrySendError::Closed(_) => f.write_str("channel is closed"),
-        }
-    }
-}
-
-impl<T> std::error::Error for TrySendError<T> {}
-
-impl<T> From<TrySendError<T>> for io::Error {
-    fn from(err: TrySendError<T>) -> Self {
-        let source = format!("{err}");
-        match err {
-            TrySendError::Full(_) => io::Error::new(io::ErrorKind::StorageFull, source),
-            TrySendError::Closed(_) => io::Error::new(io::ErrorKind::BrokenPipe, source),
-        }
-    }
-}
-
-impl<T> fmt::Debug for SendError<T> {
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        match self {
-            SendError::Closed(_) => f.write_str("SendError::Closed(..)"),
-        }
-    }
-}
-
-impl<T> fmt::Display for SendError<T> {
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        match self {
-            SendError::Closed(_) => f.write_str("channel is closed"),
-        }
-    }
-}
-
-impl<T> std::error::Error for SendError<T> {}
-
-impl<T> From<SendError<T>> for io::Error {
-    fn from(err: SendError<T>) -> Self {
-        let source = format!("{err}");
-        match err {
-            SendError::Closed(_) => io::Error::new(io::ErrorKind::BrokenPipe, source),
-        }
-    }
-}
-
 #[cfg(test)]
 mod tests {
     use super::*;

src/sync/error.rs

@@ -0,0 +1,69 @@
+use std::{fmt, io};
+
+#[derive(PartialEq, Eq)]
+pub enum TrySendError<T> {
+    Full(T),
+    Closed(T),
+}
+
+#[derive(PartialEq, Eq)]
+pub enum SendError<T> {
+    Closed(T),
+}
+
+impl<T> fmt::Debug for TrySendError<T> {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        match self {
+            TrySendError::Full(_) => f.write_str("TrySendError::Full(..)"),
+            TrySendError::Closed(_) => f.write_str("TrySendError::Closed(..)"),
+        }
+    }
+}
+
+impl<T> fmt::Display for TrySendError<T> {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        match self {
+            TrySendError::Full(_) => f.write_str("channel is full"),
+            TrySendError::Closed(_) => f.write_str("channel is closed"),
+        }
+    }
+}
+
+impl<T> std::error::Error for TrySendError<T> {}
+
+impl<T> From<TrySendError<T>> for io::Error {
+    fn from(err: TrySendError<T>) -> Self {
+        let source = format!("{err}");
+        match err {
+            TrySendError::Full(_) => io::Error::new(io::ErrorKind::StorageFull, source),
+            TrySendError::Closed(_) => io::Error::new(io::ErrorKind::BrokenPipe, source),
+        }
+    }
+}
+
+impl<T> fmt::Debug for SendError<T> {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        match self {
+            SendError::Closed(_) => f.write_str("SendError::Closed(..)"),
+        }
+    }
+}
+
+impl<T> fmt::Display for SendError<T> {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        match self {
+            SendError::Closed(_) => f.write_str("channel is closed"),
+        }
+    }
+}
+
+impl<T> std::error::Error for SendError<T> {}
+
+impl<T> From<SendError<T>> for io::Error {
+    fn from(err: SendError<T>) -> Self {
+        let source = format!("{err}");
+        match err {
+            SendError::Closed(_) => io::Error::new(io::ErrorKind::BrokenPipe, source),
+        }
+    }
+}

src/sync/mod.rs

@@ -1,5 +1,6 @@
 pub mod bounded;
 pub mod condvar;
+pub mod error;
 pub mod oneshot;
 pub mod semaphore;
 mod shared_state;

src/sync/oneshot.rs

@@ -1,4 +1,5 @@
 use super::shared_state::{SharedState, Source};
+use crate::sync::error::SendError;
 use std::cell::Cell;
 use std::future::Future;
 use std::ops::ControlFlow;
@@ -40,13 +41,13 @@ pub fn channel<T>() -> (Sender<T>, Receiver<T>) {
 }
 
 impl<T> Sender<T> {
-    pub fn send(self, value: T) -> Result<(), T> {
+    pub fn send(self, value: T) -> Result<(), SendError<T>> {
         if self.0.has_receiver.get() {
             self.0.value.set(Some(value));
             self.0.notify();
             Ok(())
         } else {
-            Err(value)
+            Err(SendError::Closed(value))
         }
     }
 }

src/sync/unbounded.rs

@@ -1,5 +1,6 @@
 use super::shared_state::{SharedState, Source};
 use crate::sealed;
+use crate::sync::error::SendError;
 use std::cell::Cell;
 use std::ops::ControlFlow;
 use std::pin::Pin;
@@ -47,9 +48,9 @@ impl<T> Sender<T> {
         !self.0.has_receiver.get()
     }
 
-    pub fn send(&self, item: T) -> Result<(), T> {
+    pub fn send(&self, item: T) -> Result<(), SendError<T>> {
         if self.is_closed() {
-            Err(item)
+            Err(SendError::Closed(item))
         } else {
             self.0.queue.push(item);
             self.0.notify();