Use crossbeam_channel instead of std::sync::mpsc.

I really didn't expect this to be a bottleneck. The input itreator
is a shared Arc<Mutex<Iterator>>, and I expected fighting over the lock
for that was the bottleneck. Boy was I wrong!

With mpsc:
test sending_and_receiving ... bench: 122,697,790 ns/iter (+/- 22,716,060)

With crossbeam_channel:
test sending_and_receiving ... bench:  21,863,243 ns/iter (+/- 1,364,702)

A big thanks to the crossbeam_channel author(s) for bringing back the
ability to know when all senders/receivers have been closed. That was
previously a blocker for me using crossbeam_channel v0.2.

Author: NfNitLoop

Cargo.toml

@@ -10,4 +10,5 @@ repository = "https://github.com/NfNitLoop/pipeliner"
 documentation = "https://docs.rs/pipeliner/"
 
 [dependencies]
-# None! :)
+# 0.3 reintroduces the ability to know when all receivers are closed:
+crossbeam-channel = "0.3"

src/lib.rs

@@ -39,11 +39,12 @@
 //!
 //! [Pipeline]: trait.Pipeline.html
 
+extern crate crossbeam_channel;
+
 mod tests;
 mod panic_guard;
 
 use std::sync::{Arc, Mutex};
-use std::sync::mpsc::{sync_channel};
 use std::thread::spawn;
 
 use panic_guard::*;
@@ -114,7 +115,7 @@ where It: Iterator<Item=In> + Send + 'static, In: Send + 'static
 
         let input = SharedIterator::wrap(input);
 
-        let (output_tx, output_rx) = sync_channel(out_buffer);
+        let (output_tx, output_rx) = crossbeam_channel::bounded(out_buffer);
         let callable = Arc::new(callable);
 
         let mut iter = PipelineIter {

src/panic_guard.rs

@@ -47,6 +47,14 @@ impl<T> Sender for mpsc::SyncSender<T> {
     }
 }
 
+impl <T> Sender for ::crossbeam_channel::Sender<T> {
+    type Item = T;
+    type Error = ::crossbeam_channel::SendError<Self::Item>;
+    fn send(&self, t: Self::Item) -> Result<(), Self::Error> {
+        ::crossbeam_channel::Sender::send(&self, t)
+    }
+}
+
 impl<T, S: Sender<Item=Result<T,()>>> Drop for PanicGuard<T,S>
 {
     fn drop(&mut self) {