resonate-recursive-fan-out-pattern-rust

Resonate Recursive Fan-Out Pattern — Rust

SDK note. The Rust SDK is in active development (v0.6.0, on crates.io). This pattern uses ctx.run().spawn() and ctx.rpc().spawn() — both synchronous as of 0.5.0+. Verify against current SDK source before shipping.

Overview

Recursive fan-out spawns multiple child invocations in parallel, awaits them individually, and (optionally) recurses deeper. The Rust expression uses .spawn() on a Context execution builder to get a DurableFuture, collects those futures into a Vec, then awaits each in turn.

For the language-agnostic mental model, see resonate-recursive-fan-out-pattern-typescript.

When to use

• Batch processing where items are independent
• Web crawling / tree traversal with dynamic depth
• Map-reduce shaped workflows
• Any fan-out where each leaf is a discrete, retryable unit

Parallel fan-out in the same process

use resonate::prelude::*;

#[resonate::function]
async fn enrich_batch(ctx: &Context, order_ids: Vec<String>) -> Result<Vec<String>> {
    let mut futures = Vec::with_capacity(order_ids.len());

    // fire off N children in parallel
    for id in order_ids {
        let fut = ctx.run(enrich_one, id).spawn()?;
        futures.push(fut);
    }

    // await all; order preserved
    let mut results = Vec::with_capacity(futures.len());
    for f in futures {
        results.push(f.await?);
    }

    Ok(results)
}

#[resonate::function]
async fn enrich_one(order_id: String) -> Result<String> {
    Ok(format!("enriched-{}", order_id))
}

Each enrich_one is a durable promise. If the parent crashes mid-loop, the children are stored server-side; on parent replay, f.await? lookups hit the stored results.

Parallel fan-out across workers

#[resonate::function]
async fn parallel_enrich(ctx: &Context, ids: Vec<String>) -> Result<Vec<String>> {
    let mut futures = Vec::with_capacity(ids.len());
    for id in ids {
        let fut = ctx
            .rpc::<String>("enrich_one", id)
            .target("poll://any@enrichment-workers")
            .spawn()?;
        futures.push(fut);
    }
    let mut results = Vec::with_capacity(futures.len());
    for f in futures {
        results.push(f.await?);
    }
    Ok(results)
}