Release: v1.0.0

Author: NfNitLoop

CHANGELOG.md

@@ -0,0 +1,24 @@
+Changelog
+=========
+
+v1.0.0 - November 18, 2018
+--------------------------
+
+ * Support for ordered mapping. Use `ordered_map()` if you need the order of
+   your outputs to match the order of their inputs. This adds a performance
+   penalty for the extra bookkeeping required. And you may see additional
+   performance loss due to head-of-line blocking, depending on your workload(s).
+ * Switched implementation to use crossbeam_channel, which greatly
+   [improves performance][1].
+ * Shrank the API. `map()` and `ordered_map()` return `impl Iterator`, so we
+   no longer leak the internal `PipelineIter` type(s).
+
+[1]: https://github.com/NfNitLoop/pipeliner/commit/c8b23a04242d6eac91df424022f62a3074c31eb0
+
+
+v0.1.1 - December 5, 2016
+-------------------------
+
+Initial release. 
+
+ * Used std::sync::mpsc

Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "pipeliner"
-version = "0.1.1"
+version = "1.0.0"
 authors = ["Cody Casterline <cody.casterline@gmail.com>"]
 license = "Apache-2.0"
 

README.md

@@ -1,8 +1,33 @@
 Pipeliner
 =========
 
-Pipeliner is a Rust library which aims to simplify doing multi-threaded work
-pipelines on iterators.
+Pipeliner is a Rust library to help you create multithreaded work pipelines. You
+can choose how many threads each step of the pipeline uses to tune performance
+for I/O- or CPU-bound workloads.
 
-Take a look at the code examples in the docs here:
-https://docs.rs/pipeliner/
+The [API docs] contain code examples.
+
+Links
+-----
+
+ * [API docs]
+ * [Changelog]
+ * [Pipeliner] crate on crates.io
+
+[API Docs]: https://docs.rs/pipeliner/
+[Changelog]: ./CHANGELOG.md
+[Pipeliner]: https://crates.io/crates/pipeliner
+
+Comparison with Rayon
+---------------------
+
+[Rayon] is another Rust library for parallel computation. If you're doing purely
+CPU-bound work, you may want to try that out to see if it offers better
+performance.
+
+Pipeliner, IMHO, offers a simpler interface. That simpler interface makes it
+easier to combine parts of a data pipeline that may be I/O-bound and CPU-bound.
+Usually in those cases, your bottleneck is I/O, not the speed of your parallel
+execution library, so having a nice API may be preferable.
+
+[Rayon]: https://crates.io/crates/rayon

src/lib.rs

@@ -9,11 +9,12 @@
 //!  * `panic`s in your worker threads are propagated out of the output
 //!     Iterator. (No silent loss of data.)
 //!  * No `unsafe` code.
-//!
-//! Since `IntoIterator`s implement [Pipeline], you can, for example:
 //! 
 //! ```
+//! // Import the Pipeline trait to give all Iterators and IntoIterators the 
+//! // .with_threads() method:
 //! use pipeliner::Pipeline;
+//!
 //! for result in (0..100).with_threads(10).map(|x| x + 1) {
 //!     println!("result: {}", result);
 //! }