Struct RunnableBranch 

pub struct RunnableBranch<I: Send + Sync + 'static, O: Send + Sync + 'static> { /* private fields */ }

A Runnable that routes input to different branches based on conditions.

Conditions are evaluated in order; the first matching branch wins. If no condition matches, the default branch is used.

The input type I must be Clone because the input may need to be evaluated against multiple conditions before a match is found.

Example

let branch = RunnableBranch::new(default_handler)
    .when_fn(|input: &String| input.len() > 100, long_handler)
    .when_fn(|input: &String| input.starts_with('?'), question_handler);

Implementations

impl<I: Clone + Send + Sync + 'static, O: Send + Sync + 'static> RunnableBranch<I, O>

pub fn new<R>(default: R) -> Self

where R: Runnable<I, O> + 'static, R::Error: Into<LcelError>,

Create a new branch with a default runnable.

pub fn when<R1, R2>(self, condition: R1, branch: R2) -> Self

where R1: Runnable<I, bool> + 'static, R1::Error: Into<LcelError>, R2: Runnable<I, O> + 'static, R2::Error: Into<LcelError>,

Add a branch with a condition runnable and a branch runnable.

The condition runnable takes I and returns bool. If the condition returns true, the branch runnable is executed.

pub fn when_fn<F, R2>(self, condition: F, branch: R2) -> Self

where F: Fn(&I) -> bool + Send + Sync + 'static, R2: Runnable<I, O> + 'static, R2::Error: Into<LcelError>,

Add a branch with a synchronous condition closure.

Convenience method that wraps the closure in a RunnableLambda.

pub fn len(&self) -> usize

Number of branches (excluding default).

pub fn is_empty(&self) -> bool

Whether there are no branches (only default).

Trait Implementations

impl<I: Send + Sync + 'static, O: Send + Sync + 'static> Debug for RunnableBranch<I, O>

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<I: Clone + Send + Sync + 'static, O: Send + Sync + 'static> Runnable<I, O> for RunnableBranch<I, O>

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

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

Evaluate conditions in order, execute the first matching branch. If no condition matches, execute the default.

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

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

Stream: invoke and return single-element stream.

type Error = LcelError

Error type.

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

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

Batch processing - transforms multiple inputs to outputs.

fn transform<'life0, 'async_trait>( &'life0 self, input: Pin<Box<dyn Stream<Item = Result<Input, Self::Error>> + Send>>, config: Option<RunnableConfig>, ) -> Pin<Box<dyn Future<Output = Result<Pin<Box<dyn Stream<Item = Result<Output, Self::Error>> + Send>>, Self::Error>> + Send + 'async_trait>>

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

Stream-to-stream transformation - the core of LCEL streaming.