.github/workflows/ci.yaml

@@ -34,12 +34,31 @@ jobs:
         command: check
         args: --all --bins --examples
 
+    - name: check no-std
+      uses: actions-rs/cargo@v1
+      with:
+        command: check
+        args: --all --no-default-features
+
+    - name: check alloc
+      uses: actions-rs/cargo@v1
+      with:
+        command: check
+        args: --all --no-default-features --features alloc
+
     - name: tests
       uses: actions-rs/cargo@v1
       with:
         command: test
         args: --all
 
+  msrv:
+    runs-on: ubuntu-latest
+    steps:
+    - uses: actions/checkout@v4
+    - uses: taiki-e/install-action@cargo-hack
+    - run: cargo hack check --rust-version --workspace --all-targets --ignore-private
+
   miri:
     name: "Build and test (miri, nightly)"
     runs-on: ubuntu-latest
@@ -72,3 +91,11 @@ jobs:
 
     - name: Docs
       run: cargo doc
+
+  semver-checks:
+    runs-on: ubuntu-latest
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v3
+      - name: Check semver
+        uses: obi1kenobi/cargo-semver-checks-action@v2

Cargo.toml

@@ -1,17 +1,19 @@
 [package]
 name = "futures-concurrency"
-version = "7.2.1"
+version = "7.6.3"
 license = "MIT OR Apache-2.0"
 repository = "https://github.com/yoshuawuyts/futures-concurrency"
 documentation = "https://docs.rs/futures-concurrency"
 description = "Structured concurrency operations for async Rust"
 readme = "README.md"
-edition = "2018"
-keywords = []
-categories = []
-authors = [
-    "Yoshua Wuyts <yoshuawuyts@gmail.com>"
-]
+edition = "2021"
+keywords = ["async", "concurrency"]
+categories = ["asynchronous", "concurrency"]
+authors = ["Yoshua Wuyts <yoshuawuyts@gmail.com>"]
+rust-version = "1.75.0"
+
+[profile.bench]
+debug = true
 
 [lib]
 bench = false
@@ -24,15 +26,31 @@ harness = false
 name = "compare"
 harness = false
 
+[features]
+default = ["std"]
+std = ["alloc", "futures-lite/std"]
+alloc = ["dep:fixedbitset", "dep:slab", "dep:smallvec", "futures-lite/alloc"]
+
 [dependencies]
-bitvec = { version = "1.0.1", default-features = false, features = ["alloc"] }
-futures-core = "0.3"
-pin-project = "1.0.8"
+fixedbitset = { version = "0.5.7", default-features = false, optional = true }
+futures-core = { version = "0.3", default-features = false }
+futures-lite = { version = "2.5.0", default-features = false }
+pin-project = "1.1"
+slab = { version = "0.4.9", optional = true }
+smallvec = { version = "1.13", optional = true }
+futures-buffered = "0.2.9"
 
 [dev-dependencies]
-futures = "0.3.25"
-futures-lite = "1.12.0"
-criterion = { version = "0.3", features = ["async", "async_futures", "html_reports"] }
-async-std = { version = "1.12.0", features = ["attributes"] }
+async-io = "2.4"
+async-std = { version = "1.13.0", features = ["attributes"] }
+criterion = { version = "0.5", features = [
+    "async",
+    "async_futures",
+    "html_reports",
+] }
+futures = "0.3"
 futures-time = "3.0.0"
+itertools = "0.13"
+lending-stream = "1.0.1"
 rand = "0.8.5"
+tokio = { version = "1.41", features = ["macros", "time", "rt-multi-thread"] }

README.md

@@ -41,6 +41,68 @@
   </h3>
 </div>
 
+Performant, portable, structured concurrency operations for async Rust. It
+works with any runtime, does not erase lifetimes, always handles
+cancellation, and always returns output to the caller.
+
+`futures-concurrency` provides concurrency operations for both groups of futures
+and streams. Both for bounded and unbounded sets of futures and streams. In both
+cases performance should be on par with, if not exceed conventional executor
+implementations.
+
+## Examples
+
+**Await multiple futures of different types**
+```rust
+use futures_concurrency::prelude::*;
+use std::future;
+
+let a = future::ready(1u8);
+let b = future::ready("hello");
+let c = future::ready(3u16);
+assert_eq!((a, b, c).join().await, (1, "hello", 3));
+```
+
+**Concurrently process items in a stream**
+
+```rust
+use futures_concurrency::prelude::*;
+
+let v: Vec<_> = vec!["chashu", "nori"]
+    .into_co_stream()
+    .map(|msg| async move { format!("hello {msg}") })
+    .collect()
+    .await;
+
+assert_eq!(v, &["hello chashu", "hello nori"]);
+```
+
+**Access stack data outside the futures' scope**
+
+_Adapted from [`std::thread::scope`](https://doc.rust-lang.org/std/thread/fn.scope.html)._
+
+```rust
+use futures_concurrency::prelude::*;
+
+let mut container = vec![1, 2, 3];
+let mut num = 0;
+
+let a = async {
+    println!("hello from the first future");
+    dbg!(&container);
+};
+
+let b = async {
+    println!("hello from the second future");
+    num += container[0] + container[2];
+};
+
+println!("hello from the main future");
+let _ = (a, b).join().await;
+container.push(4);
+assert_eq!(num, container.len());
+```
+
 ## Installation
 ```sh
 $ cargo add futures-concurrency