std: Second pass stabilization for `comm`

This commit is a second pass stabilization for the `std::comm` module,
performing the following actions:

* The entire `std::comm` module was moved under `std::sync::mpsc`. This movement
  reflects that channels are just yet another synchronization primitive, and
  they don't necessarily deserve a special place outside of the other
  concurrency primitives that the standard library offers.
* The `send` and `recv` methods have all been removed.
* The `send_opt` and `recv_opt` methods have been renamed to `send` and `recv`.
  This means that all send/receive operations return a `Result` now indicating
  whether the operation was successful or not.
* The error type of `send` is now a `SendError` to implement a custom error
  message and allow for `unwrap()`. The error type contains an `into_inner`
  method to extract the value.
* The error type of `recv` is now `RecvError` for the same reasons as `send`.
* The `TryRecvError` and `TrySendError` types have had public reexports removed
  of their variants and the variant names have been tweaked with enum
  namespacing rules.
* The `Messages` iterator is renamed to `Iter`

This functionality is now all `#[stable]`:

* `Sender`
* `SyncSender`
* `Receiver`
* `std::sync::mpsc`
* `channel`
* `sync_channel`
* `Iter`
* `Sender::send`
* `Sender::clone`
* `SyncSender::send`
* `SyncSender::try_send`
* `SyncSender::clone`
* `Receiver::recv`
* `Receiver::try_recv`
* `Receiver::iter`
* `SendError`
* `RecvError`
* `TrySendError::{mod, Full, Disconnected}`
* `TryRecvError::{mod, Empty, Disconnected}`
* `SendError::into_inner`
* `TrySendError::into_inner`

This is a breaking change due to the modification of where this module is
located, as well as the changing of the semantics of `send` and `recv`. Most
programs just need to rename imports of `std::comm` to `std::sync::mpsc` and
add calls to `unwrap` after a send or a receive operation.

[breaking-change]

1 files changed, 43 insertions, 45 deletions

diff --git a/src/libstd/io/timer.rs b/src/libstd/io/timer.rs
index 2067a97fdac..e073f76af82 100644
--- a/src/libstd/io/timer.rs
+++ b/src/libstd/io/timer.rs
@@ -15,7 +15,7 @@
 
 // FIXME: These functions take Durations but only pass ms to the backend impls.
 
-use comm::{Receiver, Sender, channel};
+use sync::mpsc::{Receiver, Sender, channel};
 use time::Duration;
 use io::IoResult;
 use sys::timer::Callback;
@@ -40,11 +40,11 @@ use sys::timer::Timer as TimerImp;
 ///
 /// let timeout = timer.oneshot(Duration::milliseconds(10));
 /// // do some work
-/// timeout.recv(); // wait for the timeout to expire
+/// timeout.recv().unwrap(); // wait for the timeout to expire
 ///
 /// let periodic = timer.periodic(Duration::milliseconds(10));
 /// loop {
-///     periodic.recv();
+///     periodic.recv().unwrap();
 ///     // this loop is only executed once every 10ms
 /// }
 /// # }
@@ -126,7 +126,7 @@ impl Timer {
     /// for _ in range(0u, 100) { /* do work */ }
     ///
     /// // blocks until 10 ms after the `oneshot` call
-    /// ten_milliseconds.recv();
+    /// ten_milliseconds.recv().unwrap();
     /// ```
     ///
     /// ```rust
@@ -136,7 +136,7 @@ impl Timer {
     /// // Incorrect, method chaining-style:
     /// let mut five_ms = Timer::new().unwrap().oneshot(Duration::milliseconds(5));
     /// // The timer object was destroyed, so this will always fail:
-    /// // five_ms.recv()
+    /// // five_ms.recv().unwrap()
     /// ```
     ///
     /// When provided a zero or negative `duration`, the message will
@@ -147,7 +147,7 @@ impl Timer {
         if in_ms_u64(duration) != 0 {
             self.inner.oneshot(in_ms_u64(duration), box TimerCallback { tx: tx });
         } else {
-            tx.send(());
+            tx.send(()).unwrap();
         }
         return rx
     }
@@ -178,13 +178,13 @@ impl Timer {
     /// for _ in range(0u, 100) { /* do work */ }
     ///
     /// // blocks until 10 ms after the `periodic` call
-    /// ten_milliseconds.recv();
+    /// ten_milliseconds.recv().unwrap();
     ///
     /// for _ in range(0u, 100) { /* do work */ }
     ///
     /// // blocks until 20 ms after the `periodic` call (*not* 10ms after the
     /// // previous `recv`)
-    /// ten_milliseconds.recv();
+    /// ten_milliseconds.recv().unwrap();
     /// ```
     ///
     /// ```rust
@@ -194,7 +194,7 @@ impl Timer {
     /// // Incorrect, method chaining-style.
     /// let mut five_ms = Timer::new().unwrap().periodic(Duration::milliseconds(5));
     /// // The timer object was destroyed, so this will always fail:
-    /// // five_ms.recv()
+    /// // five_ms.recv().unwrap()
     /// ```
     ///
     /// When provided a zero or negative `duration`, the messages will
@@ -213,7 +213,7 @@ impl Timer {
 
 impl Callback for TimerCallback {
     fn call(&mut self) {
-        let _ = self.tx.send_opt(());
+        let _ = self.tx.send(());
     }
 }
 
@@ -225,8 +225,6 @@ fn in_ms_u64(d: Duration) -> u64 {
 
 #[cfg(test)]
 mod test {
-    use prelude::v1::*;
-
     use super::Timer;
     use thread::Thread;
     use time::Duration;
@@ -240,7 +238,7 @@ mod test {
     #[test]
     fn test_io_timer_sleep_oneshot() {
         let mut timer = Timer::new().unwrap();
-        timer.oneshot(Duration::milliseconds(1)).recv();
+        timer.oneshot(Duration::milliseconds(1)).recv().unwrap();
     }
 
     #[test]
@@ -254,8 +252,8 @@ mod test {
         let mut timer = Timer::new().unwrap();
         let rx1 = timer.oneshot(Duration::milliseconds(10000));
         let rx = timer.oneshot(Duration::milliseconds(1));
-        rx.recv();
-        assert_eq!(rx1.recv_opt(), Err(()));
+        rx.recv().unwrap();
+        assert!(rx1.recv().is_err());
     }
 
     #[test]
@@ -264,16 +262,16 @@ mod test {
         let rx = timer.oneshot(Duration::milliseconds(100000000));
         timer.sleep(Duration::milliseconds(1)); // this should invalidate rx
 
-        assert_eq!(rx.recv_opt(), Err(()));
+        assert!(rx.recv().is_err());
     }
 
     #[test]
     fn test_io_timer_sleep_periodic() {
         let mut timer = Timer::new().unwrap();
         let rx = timer.periodic(Duration::milliseconds(1));
-        rx.recv();
-        rx.recv();
-        rx.recv();
+        rx.recv().unwrap();
+        rx.recv().unwrap();
+        rx.recv().unwrap();
     }
 
     #[test]
@@ -292,12 +290,12 @@ mod test {
         let mut timer = Timer::new().unwrap();
 
         let rx = timer.oneshot(Duration::milliseconds(1));
-        rx.recv();
-        assert!(rx.recv_opt().is_err());
+        rx.recv().unwrap();
+        assert!(rx.recv().is_err());
 
         let rx = timer.oneshot(Duration::milliseconds(1));
-        rx.recv();
-        assert!(rx.recv_opt().is_err());
+        rx.recv().unwrap();
+        assert!(rx.recv().is_err());
     }
 
     #[test]
@@ -306,20 +304,20 @@ mod test {
         let orx = timer.oneshot(Duration::milliseconds(100));
         let prx = timer.periodic(Duration::milliseconds(100));
         timer.sleep(Duration::milliseconds(1));
-        assert_eq!(orx.recv_opt(), Err(()));
-        assert_eq!(prx.recv_opt(), Err(()));
-        timer.oneshot(Duration::milliseconds(1)).recv();
+        assert!(orx.recv().is_err());
+        assert!(prx.recv().is_err());
+        timer.oneshot(Duration::milliseconds(1)).recv().unwrap();
     }
 
     #[test]
     fn period() {
         let mut timer = Timer::new().unwrap();
         let rx = timer.periodic(Duration::milliseconds(1));
-        rx.recv();
-        rx.recv();
+        rx.recv().unwrap();
+        rx.recv().unwrap();
         let rx2 = timer.periodic(Duration::milliseconds(1));
-        rx2.recv();
-        rx2.recv();
+        rx2.recv().unwrap();
+        rx2.recv().unwrap();
     }
 
     #[test]
@@ -359,7 +357,7 @@ mod test {
         let timer_rx = timer.periodic(Duration::milliseconds(1000));
 
         Thread::spawn(move|| {
-            let _ = timer_rx.recv_opt();
+            let _ = timer_rx.recv();
         }).detach();
 
         // when we drop the TimerWatcher we're going to destroy the channel,
@@ -373,7 +371,7 @@ mod test {
         let timer_rx = timer.periodic(Duration::milliseconds(1000));
 
         Thread::spawn(move|| {
-            let _ = timer_rx.recv_opt();
+            let _ = timer_rx.recv();
         }).detach();
 
         timer.oneshot(Duration::milliseconds(1));
@@ -386,7 +384,7 @@ mod test {
         let timer_rx = timer.periodic(Duration::milliseconds(1000));
 
         Thread::spawn(move|| {
-            let _ = timer_rx.recv_opt();
+            let _ = timer_rx.recv();
         }).detach();
 
         timer.sleep(Duration::milliseconds(1));
@@ -398,7 +396,7 @@ mod test {
             let mut timer = Timer::new().unwrap();
             timer.oneshot(Duration::milliseconds(1000))
         };
-        assert_eq!(rx.recv_opt(), Err(()));
+        assert!(rx.recv().is_err());
     }
 
     #[test]
@@ -407,7 +405,7 @@ mod test {
             let mut timer = Timer::new().unwrap();
             timer.periodic(Duration::milliseconds(1000))
         };
-        assert_eq!(rx.recv_opt(), Err(()));
+        assert!(rx.recv().is_err());
     }
 
     #[test]
@@ -446,34 +444,34 @@ mod test {
     fn oneshot_zero() {
         let mut timer = Timer::new().unwrap();
         let rx = timer.oneshot(Duration::milliseconds(0));
-        rx.recv();
+        rx.recv().unwrap();
     }
 
     #[test]
     fn oneshot_negative() {
         let mut timer = Timer::new().unwrap();
         let rx = timer.oneshot(Duration::milliseconds(-1000000));
-        rx.recv();
+        rx.recv().unwrap();
     }
 
     #[test]
     fn periodic_zero() {
         let mut timer = Timer::new().unwrap();
         let rx = timer.periodic(Duration::milliseconds(0));
-        rx.recv();
-        rx.recv();
-        rx.recv();
-        rx.recv();
+        rx.recv().unwrap();
+        rx.recv().unwrap();
+        rx.recv().unwrap();
+        rx.recv().unwrap();
     }
 
     #[test]
     fn periodic_negative() {
         let mut timer = Timer::new().unwrap();
         let rx = timer.periodic(Duration::milliseconds(-1000000));
-        rx.recv();
-        rx.recv();
-        rx.recv();
-        rx.recv();
+        rx.recv().unwrap();
+        rx.recv().unwrap();
+        rx.recv().unwrap();
+        rx.recv().unwrap();
     }
 
 }