Provide synchronous and asynchronous side by side

Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "loop"
-version = "0.3.2"
+version = "0.4.0"
 edition = "2021"
 license = "Apache-2.0/MIT"
 authors = ["Ivan Ukhov <ivan.ukhov@gmail.com>"]

README.md

@@ -7,17 +7,20 @@ The package allows for processing iterators in parallel.
 Synchronously:
 
 ```rust
+use r#loop::parallelize;
+
 let double = |value| 2 * value;
-let _ = r#loop::parallelize(0..10, double, None).collect::<Vec<_>>();
+let _ = parallelize(0..10, double, None).collect::<Vec<_>>();
 ```
 
 Asynchronously:
 
 ```rust
 use futures::stream::StreamExt;
+use r#loop::asynchronous::parallelize;
 
 let double = |value| async move { 2 * value };
-let _ = r#loop::parallelize(0..10, double).collect::<Vec<_>>().await;
+let _ = parallelize(0..10, double).collect::<Vec<_>>().await;
 ```
 
 ## Contribution

src/asynchronous.rs

@@ -1,8 +1,11 @@
+//! Asynchronous implementation.
+
 use std::sync::Arc;
 
 use tokio::sync::{mpsc, Mutex};
 use tokio_stream::wrappers::ReceiverStream;
 
+/// Process an iterator in parallel.
 pub fn parallelize<Items, Item, Map, Future, Output>(
     items: Items,
     mut map: Map,

src/lib.rs

@@ -5,13 +5,12 @@
 //! Synchronously:
 //!
 //! ```
-//! # #[cfg(not(feature = "asynchronous"))]
 //! fn main() {
+//!     use r#loop::parallelize;
+//!
 //!     let double = |value| 2 * value;
-//!     let _ = r#loop::parallelize(0..10, double).collect::<Vec<_>>();
+//!     let _ = parallelize(0..10, double).collect::<Vec<_>>();
 //! }
-//! # #[cfg(feature = "asynchronous")]
-//! # fn main() {}
 //!```
 //!
 //! Asynchronously:
@@ -21,23 +20,19 @@
 //! #[tokio::main]
 //! async fn main() {
 //!     use futures::stream::StreamExt;
+//!     use r#loop::asynchronous::parallelize;
 //!
 //!     let double = |value| async move { 2 * value };
-//!     let _ = r#loop::parallelize(0..10, double).collect::<Vec<_>>().await;
+//!     let _ = parallelize(0..10, double).collect::<Vec<_>>().await;
 //! }
 //! # #[cfg(not(feature = "asynchronous"))]
 //! # fn main() {}
 //! ```
 
 #[cfg(feature = "asynchronous")]
-#[path = "asynchronous.rs"]
-mod implementation;
-
-#[cfg(not(feature = "asynchronous"))]
-#[path = "synchronous.rs"]
-mod implementation;
+pub mod asynchronous;
+pub mod synchronous;
 
 mod support;
 
-/// Process an iterator in parallel.
-pub use implementation::parallelize;
+pub use synchronous::parallelize;

src/synchronous.rs

@@ -1,5 +1,8 @@
+//! Synchronous implementation.
+
 use std::sync::{mpsc, Arc, Mutex};
 
+/// Process an iterator in parallel.
 pub fn parallelize<Items, Item, Map, Output>(
     items: Items,
     mut map: Map,