Struct Parallel 

pub struct Parallel<I, O> { /* private fields */ }

Runs multiple runnables concurrently on a shared input and returns their outputs keyed by name.

Each branch must share the same input type I (cloned per branch) and the same output type O. For heterogeneous outputs, wrap each branch’s output in an enum or use serde_json::Value.

Implementations

impl<I, O> Parallel<I, O>

where I: Send + Sync + Clone + 'static, O: Send + 'static,

pub fn new() -> Self

Empty builder.

pub fn branch( self, name: impl Into<String>, runnable: Arc<dyn Runnable<I, O>>, ) -> Self

Add a named branch.

Panics if name is already registered. Two branches under the same key would race into the result map and the loser would be silently dropped — almost always a programming error, so we fail loudly at construction time rather than at run time.

Trait Implementations

impl<I, O> Default for Parallel<I, O>

where I: Send + Sync + Clone + 'static, O: Send + 'static,

fn default() -> Self

Returns the “default value” for a type.

impl<I, O> Runnable<I, HashMap<String, O>> for Parallel<I, O>

where I: Send + Sync + Clone + 'static, O: Send + 'static,

fn invoke<'life0, 'async_trait>( &'life0 self, input: I, config: RunnableConfig, ) -> Pin<Box<dyn Future<Output = Result<HashMap<String, O>>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

One-shot invocation. The hot path.

fn name(&self) -> &str

Friendly name for telemetry / introspection.

fn batch<'life0, 'async_trait>( &'life0 self, inputs: Vec<I>, config: RunnableConfig, ) -> Pin<Box<dyn Future<Output = Result<Vec<O>>> + Send + 'async_trait>>

where I: 'static, O: 'static, Self: Sized + Sync + 'async_trait, 'life0: 'async_trait,

Run multiple inputs in parallel. Defaults to buffer_unordered honouring config.max_concurrency.

fn stream<'life0, 'async_trait>( &'life0 self, input: I, config: RunnableConfig, ) -> Pin<Box<dyn Future<Output = Result<RunnableStream<O>>> + Send + 'async_trait>>

where Self: Sized + Sync + 'async_trait, 'life0: 'async_trait,

Stream the final output (chunks of O). Default emits one item via invoke — non-streaming runnables are correct without override.

fn stream_events<'life0, 'async_trait>( &'life0 self, input: I, config: RunnableConfig, ) -> Pin<Box<dyn Future<Output = Result<EventStream>> + Send + 'async_trait>>

where I: Serialize, O: Serialize, Self: Sized + Sync + 'async_trait, 'life0: 'async_trait,

Stream structured events. Default emits OnStart + OnEnd around an invoke call. Graph engines override to surface per-node events.

fn input_schema(&self) -> Option<Value>

JSON Schema for the input type, if known.

fn output_schema(&self) -> Option<Value>

JSON Schema for the output type, if known.