Struct RunnableLambda 

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

A Runnable that wraps a closure.

Created via RunnableLambda::new_sync or RunnableLambda::new_async.

Example

let doubler = RunnableLambda::new_sync(|x: i32| x * 2);
let result = doubler.invoke(5, None).await?; // 10

Implementations

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

pub fn new_sync<F>(func: F) -> Self

where F: Fn(I) -> O + Send + Sync + 'static,

Create from a synchronous (blocking) closure.

The closure’s output is automatically wrapped in Ok(...).

Example

let upper = RunnableLambda::new_sync(|s: String| s.to_uppercase());

pub fn new_sync_fallible<F>(func: F) -> Self

where F: Fn(I) -> Result<O, LcelError> + Send + Sync + 'static,

Create from a synchronous closure that can fail.

The closure returns Result<O, LcelError>.

pub fn new_async<F, Fut>(func: F) -> Self

where F: Fn(I) -> Fut + Send + Sync + 'static, Fut: Future<Output = Result<O, LcelError>> + Send + 'static,

Create from an async closure.

Example

let fetch = RunnableLambda::new_async(|url: String| async move {
    reqwest::get(&url).await?.text().await.map_err(|e| LcelError::Other(e.to_string()))
});

Trait Implementations

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

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

Formats the value using the given formatter.

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

type Error = LcelError

Error type.

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,

Transforms single input to output.

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 batch_as_completed<'life0, 'async_trait>( &'life0 self, inputs: Vec<Input>, config: Option<RunnableConfig>, ) -> Pin<Box<dyn Future<Output = Result<Vec<(usize, Output)>, Self::Error>> + Send + 'async_trait>>

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

Batch processing that returns results in completion order.

fn stream<'life0, 'async_trait>( &'life0 self, input: Input, 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,

Streaming output - for real-time responses (LLM, etc).

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.