Struct Detached 

pub struct Detached<Input, Error, Context, NodeType = (), NodeOutput = (), NodeError = ()> { /* private fields */ }

Detached executes a node asynchronously and independently of the main flow.

The node is executed in a detached task using the SpawnAsync context trait and any result or error from the detached node is ignored.

This flow is useful for side-effect operations such as logging, analytics, or background triggers that should not block or influence the main execution path.

Type Parameters

• Input: The type of data accepted and produced by this flow.
• Error: The type of error emitted by this flow.
• Context: The type of context used during execution.

Examples

use node_flow::node::{Node, NodeOutput};
use node_flow::context::{SpawnAsync, Fork};
use node_flow::flows::Detached;
use std::future::Future;

#[derive(Clone)]
struct PrintNode;

struct ExampleCtx;
impl Fork for ExampleCtx // ...
impl SpawnAsync for ExampleCtx // ...

impl<Ctx: Send> Node<u8, NodeOutput<()>, (), Ctx> for PrintNode {
    async fn run(&mut self, input: u8, _: &mut Ctx) -> Result<NodeOutput<()>, ()> {
        println!("Running detached task with input: {input}");
        Ok(NodeOutput::Ok(()))
    }
}

async fn main() {
    let mut detached = Detached::<u8, (), _>::new(PrintNode);

    let mut ctx = ExampleCtx;
    let result = detached.run(7, &mut ctx).await;
    assert_eq!(result, Ok(NodeOutput::Ok(7)));
}

Implementations

impl<Input, Error, Context> Detached<Input, Error, Context>

pub fn new<NodeType, NodeOutput, NodeError>( node: NodeType, ) -> Detached<Input, Error, Context, NodeType, NodeOutput, NodeError>

where NodeType: Node<Input, NodeOutput, NodeError, Context> + Clone + Send, Input: Clone + Send,

Creates a new Detached flow by wrapping the given node.

See also Detached.

Examples

use node_flow::flows::Detached;
use node_flow::node::{Node, NodeOutput};

#[derive(Clone)]
struct BackgroundTask;
impl<Ctx: Send> Node<(), NodeOutput<()>, (), Ctx> for BackgroundTask // ...

let detached = Detached::<(), (), Ctx>::new(BackgroundTask);

Trait Implementations

impl<Input, Error, Context, NodeType, NodeOutput, NodeError> Clone for Detached<Input, Error, Context, NodeType, NodeOutput, NodeError>

fn clone(&self) -> Self

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<Input, Error, Context, NodeType, NodeOutput, NodeError> Debug for Detached<Input, Error, Context, NodeType, NodeOutput, NodeError>

where NodeType: Debug,

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

Formats the value using the given formatter.

impl<Input, Error, Context, NodeType, NodeOutput, NodeError> Node<Input, NodeOutput<Input>, Error, Context> for Detached<Input, Error, Context, NodeType, NodeOutput, NodeError>

where NodeType: Node<Input, NodeOutput, NodeError, Context> + Clone + Send + 'static, Context: SpawnAsync + Fork + Send + 'static, Input: Clone + Send + 'static,

fn run( &mut self, input: Input, context: &mut Context, ) -> impl Future<Output = Result<NodeOutput<Input>, Error>> + Send

Runs the node.

fn describe(&self) -> Description

Describes this node, its type signature and other specifics.