How does futures::future::join_all handle errors compared to try_join_all for futures returning Result types?
join_all waits for every future to complete and collects all results—including errors—into a Vec<Result<T, E>>, while try_join_all short-circuits on the first error and returns Result<Vec<T>, E>. This fundamental difference in error handling strategy determines which function to use: join_all when you need all results regardless of success or failure, and try_join_all when any failure should abort the entire operation.
Basic Behavior Comparison
use futures::future::{join_all, try_join_all};
async fn basic_comparison() {
// Three futures that return Result
let futures = vec![
async { Ok::<i32, &str>(1) },
async { Ok::<i32, &str>(2) },
async { Ok::<i32, &str>(3) },
];
// join_all: returns Vec<Result<i32, &str>>
let results: Vec<Result<i32, &str>> = join_all(futures).await;
// All three results collected: [Ok(1), Ok(2), Ok(3)]
let futures = vec![
async { Ok::<i32, &str>(1) },
async { Ok::<i32, &str>(2) },
async { Ok::<i32, &str>(3) },
];
// try_join_all: returns Result<Vec<i32>, &str>
let result: Result<Vec<i32>, &str> = try_join_all(futures).await;
// Single Ok containing all values: Ok(vec![1, 2, 3])
}Both functions handle success cases similarly, but their return types differ fundamentally.
Error Handling: join_all Collects All Results
use futures::future::join_all;
async fn join_all_with_errors() {
let futures = vec![
async { Ok::<i32, &str>(1) },
async { Err::<i32, &str>("error_2") },
async { Ok::<i32, &str>(3) },
async { Err::<i32, &str>("error_4") },
];
// join_all waits for ALL futures, including those that fail
let results: Vec<Result<i32, &str>> = join_all(futures).await;
// All results are collected:
// [Ok(1), Err("error_2"), Ok(3), Err("error_4")]
// You can process successes and failures separately:
let successes: Vec<i32> = results.iter()
.filter_map(|r| r.as_ref().ok())
.copied()
.collect();
assert_eq!(successes, vec![1, 3]);
let failures: Vec<&str> = results.iter()
.filter_map(|r| r.as_ref().err())
.copied()
.collect();
assert_eq!(failures, vec!["error_2", "error_4"]);
}join_all never fails—it always returns a Vec containing each future's result.
Error Handling: try_join_all Short-Circuits
use futures::future::try_join_all;
async fn try_join_all_with_errors() {
let futures = vec![
async { Ok::<i32, &str>(1) },
async { Err::<i32, &str>("failed") },
async { Ok::<i32, &str>(3) },
];
// try_join_all stops at the FIRST error
let result: Result<Vec<i32>, &str> = try_join_all(futures).await;
// Returns Err immediately when first error is encountered
assert_eq!(result, Err("failed"));
// The third future may not even complete!
// try_join_all cancels remaining futures on error
}
async fn try_join_all_success() {
let futures = vec![
async { Ok::<i32, &str>(1) },
async { Ok::<i32, &str>(2) },
async { Ok::<i32, &str>(3) },
];
let result: Result<Vec<i32>, &str> = try_join_all(futures).await;
// All successful: returns Ok with all values
assert_eq!(result, Ok(vec![1, 2, 3]));
}try_join_all returns early with an error, canceling remaining futures.
Execution Model Differences
use futures::future::{join_all, try_join_all};
use std::time::Duration;
use tokio::time::{sleep, Instant};
async fn execution_timing_join_all() {
let start = Instant::now();
let futures = vec![
async {
sleep(Duration::from_millis(100)).await;
Ok::<i32, &str>(1)
},
async {
sleep(Duration::from_millis(50)).await;
Err::<i32, &str>("quick error")
},
async {
sleep(Duration::from_millis(200)).await;
Ok::<i32, &str>(3)
},
];
// join_all waits for ALL to complete
let results = join_all(futures).await;
// Total time: ~200ms (longest future)
// All three futures ran to completion
// results: [Ok(1), Err("quick error"), Ok(3)]
}
async fn execution_timing_try_join_all() {
let start = Instant::now();
let futures = vec![
async {
sleep(Duration::from_millis(100)).await;
Ok::<i32, &str>(1)
},
async {
sleep(Duration::from_millis(50)).await;
Err::<i32, &str>("quick error")
},
async {
sleep(Duration::from_millis(200)).await;
Ok::<i32, &str>(3)
},
];
// try_join_all returns when first error is found
let result = try_join_all(futures).await;
// Total time: ~50ms (when error occurred)
// First and third futures are CANCELLED
// result: Err("quick error")
}try_join_all can be significantly faster when errors occur early.
Return Type Structure
use futures::future::{join_all, try_join_all};
async fn return_types() {
// ┌─────────────────────────────────────────────────────────────────────┐
// │ Function │ Input │ Output │
// ├─────────────────────────────────────────────────────────────────────┤
// │ join_all │ Vec<impl Future<Output=Result<T,E>>> │
// │ │ │ Vec<Result<T, E>> │
// │ │ Always succeeds │ Each result preserved │
// ├─────────────────────────────────────────────────────────────────────┤
// │ try_join_all │ Vec<impl TryFuture<Ok=T, Error=E>> │
// │ │ │ Result<Vec<T>, E> │
// │ │ Fails on first error │ Single Result for all │
// └─────────────────────────────────────────────────────────────────────┘
let futures = vec![
async { Ok::<i32, &str>(1) },
async { Ok::<i32, &str>(2) },
];
// join_all: Vec<Result<i32, &str>>
let results: Vec<Result<i32, &str>> = join_all(futures).await;
let futures = vec![
async { Ok::<i32, &str>(1) },
async { Ok::<i32, &str>(2) },
];
// try_join_all: Result<Vec<i32>, &str>
let result: Result<Vec<i32>, &str> = try_join_all(futures).await;
}The return type signature reveals the semantic difference: join_all wraps results, try_join_all wraps the entire operation.
When to Use join_all
use futures::future::join_all;
// Use case 1: Collecting partial results
async fn fetch_all_endpoints(urls: &[&str]) -> Vec<Result<String, reqwest::Error>> {
let futures: Vec<_> = urls.iter()
.map(|url| async move {
reqwest::get(*url).await?.text().await
})
.collect();
// We want results from all endpoints, even if some fail
// A failed endpoint shouldn't prevent us from getting others
join_all(futures).await
}
// Use case 2: Parallel validation with detailed error reporting
async fn validate_all_fields(fields: Vec<String>) -> Vec<Result<(), String>> {
let futures: Vec<_> = fields.into_iter()
.map(|field| async move {
// Each validation runs independently
validate_field(&field).await
})
.collect();
// Report ALL validation errors, not just the first
join_all(futures).await
}
async fn validate_field(field: &str) -> Result<(), String> {
if field.is_empty() {
Err(format!("Field '{}' cannot be empty", field))
} else {
Ok(())
}
}
// Use case 3: Fire-and-forget with result collection
async fn process_batch(items: Vec<i32>) -> Vec<Result<Processed, ProcessingError>> {
let futures: Vec<_> = items.into_iter()
.map(|item| async move { process_item(item).await })
.collect();
// Process all items, collect all outcomes
join_all(futures).await
}
struct Processed(i32);
enum ProcessingError { Failed(i32) }
async fn process_item(item: i32) -> Result<Processed, ProcessingError> {
if item < 0 {
Err(ProcessingError::Failed(item))
} else {
Ok(Processed(item * 2))
}
}Use join_all when you need all results or when failures are independent.
When to Use try_join_all
use futures::future::try_join_all;
// Use case 1: Transactional operations
async fn commit_transaction(operations: Vec<DbOperation>) -> Result<(), DbError> {
// All operations must succeed, or none should be considered successful
let futures: Vec<_> = operations.into_iter()
.map(|op| async move { execute_operation(op).await })
.collect();
// If any operation fails, the whole transaction is considered failed
try_join_all(futures).await?;
Ok(())
}
async fn execute_operation(op: DbOperation) -> Result<(), DbError> {
// Execute database operation
Ok(())
}
struct DbOperation;
struct DbError;
// Use case 2: Required dependencies
async fn load_all_required(resources: Vec<ResourceId>) -> Result<Vec<Resource>, LoadError> {
let futures: Vec<_> = resources.into_iter()
.map(|id| async move { load_resource(id).await })
.collect();
// All resources are required; fail fast if any is missing
try_join_all(futures).await
}
struct ResourceId(u32);
struct Resource;
struct LoadError;
async fn load_resource(id: ResourceId) -> Result<Resource, LoadError> {
Ok(Resource)
}
// Use case 3: Pipeline that requires all steps
async fn run_pipeline(stages: Vec<Stage>) -> Result<Vec<StageResult>, PipelineError> {
let futures: Vec<_> = stages.into_iter()
.map(|stage| async move { run_stage(stage).await })
.collect();
// All stages must complete; any failure aborts
try_join_all(futures).await
}
struct Stage;
struct StageResult;
struct PipelineError;
async fn run_stage(stage: Stage) -> Result<StageResult, PipelineError> {
Ok(StageResult)
}Use try_join_all when all operations must succeed for the overall result to be valid.
Combining Results After join_all
use futures::future::join_all;
async fn aggregate_results() -> Result<Vec<i32>, String> {
let futures = vec![
async { Ok::<i32, &str>(1) },
async { Err::<i32, &str>("failed") },
async { Ok::<i32, &str>(3) },
];
let results = join_all(futures).await;
// Option 1: Collect successes only
let successes: Vec<i32> = results.iter()
.filter_map(|r| r.as_ref().ok())
.copied()
.collect();
// Option 2: Fail if any failed
let all_results: Result<Vec<i32>, _> = results.into_iter().collect();
// This works because Result implements FromIterator
// It short-circuits on first Err after join_all completes
// Option 3: Partition successes and failures
let (successes, failures): (Vec<_>, Vec<_>) = results.into_iter()
.partition(Result::is_ok);
let successes: Vec<i32> = successes.into_iter()
.map(Result::unwrap)
.collect();
let failures: Vec<&str> = failures.into_iter()
.map(Result::unwrap_err)
.collect();
Ok(successes)
}You can post-process join_all results to implement various error-handling strategies.
Cancellation Behavior
use futures::future::{join_all, try_join_all};
use std::sync::atomic::{AtomicUsize, Ordering};
use std::sync::Arc;
use tokio::time::{sleep, Duration};
async fn cancellation_example() {
let counter = Arc::new(AtomicUsize::new(0));
// With join_all: all futures run to completion
{
let counter = counter.clone();
let futures = vec![
async { counter.fetch_add(1, Ordering::SeqCst); Ok::<i32, &str>(1) },
async { counter.fetch_add(1, Ordering::SeqCst); Err::<i32, &str>("fail") },
async { counter.fetch_add(1, Ordering::SeqCst); Ok::<i32, &str>(3) },
];
let _ = join_all(futures).await;
// Counter: 3 (all futures ran)
}
counter.store(0, Ordering::SeqCst);
// With try_join_all: remaining futures may be cancelled
{
let counter = counter.clone();
let futures = vec![
async {
sleep(Duration::from_millis(100)).await;
counter.fetch_add(1, Ordering::SeqCst);
Ok::<i32, &str>(1)
},
async {
counter.fetch_add(1, Ordering::SeqCst);
Err::<i32, &str>("fail")
},
async {
sleep(Duration::from_millis(100)).await;
counter.fetch_add(1, Ordering::SeqCst);
Ok::<i32, &str>(3)
},
];
let _ = try_join_all(futures).await;
// Counter: depends on execution order
// Futures 1 and 3 may be cancelled before completing
// If futures run concurrently, counter might be 1 or 2
}
}try_join_all cancels remaining futures when one fails; join_all lets all complete.
Practical Pattern: Best-Effort vs All-Required
use futures::future::{join_all, try_join_all};
// Pattern 1: Best-effort collection (join_all)
async fn fetch_user_data(user_ids: Vec<u32>) -> Vec<Result<User, FetchError>> {
let futures: Vec<_> = user_ids.into_iter()
.map(|id| async move { fetch_user(id).await })
.collect();
join_all(futures).await
}
// Usage: We can show which users loaded successfully
async fn handle_users_best_effort(ids: Vec<u32>) {
let results = fetch_user_data(ids).await;
for result in results {
match result {
Ok(user) => println!("Loaded: {:?}", user),
Err(e) => eprintln!("Failed: {}", e),
}
}
// Some users may have failed, but we handle each result individually
}
// Pattern 2: All-required collection (try_join_all)
async fn fetch_all_required_data(resources: Vec<String>) -> Result<Vec<Data>, FetchError> {
let futures: Vec<_> = resources.into_iter()
.map(|resource| async move { fetch_resource(&resource).await })
.collect();
try_join_all(futures).await
}
// Usage: We need all resources to proceed
async fn process_request(resources: Vec<String>) -> Result<ProcessedData, String> {
let all_data = fetch_all_required_data(resources)
.await
.map_err(|e| format!("Failed to load required resource: {}", e))?;
// All resources loaded successfully, proceed with processing
Ok(process_all(all_data))
}
struct User(u32);
struct Data;
struct ProcessedData;
struct FetchError;
async fn fetch_user(id: u32) -> Result<User, FetchError> {
Ok(User(id))
}
async fn fetch_resource(name: &str) -> Result<Data, FetchError> {
Ok(Data)
}
fn process_all(data: Vec<Data>) -> ProcessedData {
ProcessedData
}Choose based on whether partial success is meaningful for your use case.
Error Type Requirements
use futures::future::{join_all, try_join_all};
async fn type_requirements() {
// join_all: No trait requirements on error type
// Just needs futures that produce some output
let futures = vec![
async { 1_i32 },
async { 2_i32 },
async { 3_i32 },
];
let results: Vec<i32> = join_all(futures).await;
// Works even with non-Result outputs
// try_join_all: Requires futures implementing Try trait
// Must produce Result, Option, or similar
let futures = vec![
async { Ok::<i32, &str>(1) },
async { Ok::<i32, &str>(2) },
];
let result: Result<Vec<i32>, &str> = try_join_all(futures).await;
// Works because Result<T, E> implements Try
// Also works with Option
let futures = vec![
async { Some(1) },
async { Some(2) },
async { Some(3) },
];
let result: Option<Vec<i32>> = futures::future::try_join_all(futures).await;
// Returns Some(vec![1, 2, 3]) if all are Some
// Returns None if any is None
}try_join_all works with any Try type; join_all works with any Future.
Synthesis
use futures::future::{join_all, try_join_all};
async fn complete_guide_summary() {
// ┌─────────────────────────────────────────────────────────────────────────┐
// │ Aspect │ join_all │ try_join_all │
// ├─────────────────────────────────────────────────────────────────────────┤
// │ Return type │ Vec<Result<T, E>> │ Result<Vec<T>, E> │
// │ Error handling │ Collects all results │ Short-circuits on Err │
// │ Execution │ All futures complete │ Cancel remaining on Err│
// │ When all succeed │ Vec<Ok<T>> │ Ok(Vec<T>) │
// │ When some fail │ Mixed Ok/Err │ Err(first error) │
// │ Use case │ Partial success OK │ All-or-nothing │
// │ Performance on Err │ Waits for all │ Returns immediately │
// └─────────────────────────────────────────────────────────────────────────┘
// Summary recommendations:
// Use join_all when:
// - You want to collect results from all futures
// - Failures are independent (one failure doesn't affect others)
// - You need detailed error information for each operation
// - Partial success is meaningful (e.g., fetching optional data)
// Use try_join_all when:
// - All operations must succeed for the result to be useful
// - You want to fail fast on the first error
// - The error type is sufficient (don't need per-operation details)
// - Resources should be saved when errors occur (cancellation)
}
// Key insight:
// join_all and try_join_all have the same signature for input (Vec<Future>)
// but fundamentally different semantics for output:
// - join_all: "Run all, collect all results"
// - try_join_all: "Run all until first error, then abort"
//
// The choice depends on your error handling strategy:
// - Can you proceed with partial results? Use join_all
// - Must all succeed? Use try_join_all
//
// Consider the cancellation semantics:
// - try_join_all cancels remaining futures on error
// - join_all lets all futures complete
// This matters for side effects and resource cleanup.Key insight: The difference between join_all and try_join_all reflects two fundamentally different error-handling philosophies. join_all embodies "collect everything"—every future runs to completion, every result is preserved. This is ideal for operations where each result is independently useful and you want full visibility into successes and failures. try_join_all embodies "all or nothing"—the first failure aborts the entire operation, canceling remaining futures. This is ideal for transactional operations where all results are needed or none are meaningful. The return types encode this difference: join_all returns Vec<Result<T, E>> (each result preserved), while try_join_all returns Result<Vec<T>, E> (the collection is the atomic unit of success or failure).