Struct FnFlow 

pub struct FnFlow<Input, Output, Error, Context, InnerData = (), R = ()> { /* private fields */ }

FnFlow takes some async function and wraps around it to crate a node.

This flow allows for setting custom Description through the FnFlow::with_description function, since there is no other way to get it (like with Node::describe).

Type Parameters

• Input: The type of data accepted by this flow.
• Output: The type of data 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::flows::FnFlow;
use node_flow::node::{Node, NodeOutput};

#[derive(Clone)]
struct SomeExpensiveData(Vec<u32>);

async fn main() {
    let mut flow = FnFlow::<u32, u32, (), _>::new(
        SomeExpensiveData((0..1<<15).collect()),
        async |SomeExpensiveData(data), input, _: &mut _| {
            let res = data.iter().sum::<u32>() / data.len() as u32 + input;
            Ok(NodeOutput::Ok(res))
        },
    );

    let result = flow.run(1, &mut ()).await;
    assert_eq!(result, Ok(NodeOutput::Ok(1<<14)));
}

Implementations

impl<Input, Output, Error, Context> FnFlow<Input, Output, Error, Context>

where Input: Send, Context: Send,

pub fn new<InnerData, R>( inner_data: InnerData, runner: R, ) -> FnFlow<Input, Output, Error, Context, InnerData, R>

where InnerData: Clone + Send + Sync, for<'a> R: Runner<'a, Input, Output, Error, Context, InnerData>,

Creates a new FnFlow from a given runner.

The runner must satisfy:

• Self: Runner<'_, Input, Output, Error, _, InnerData>

When using closure as a runner it always needs:

• to be an async closure - because of lifetimes
• for context to:
  • have the type of a context specified when using context - because it cannot infer the type
    or
  • have the context specified as _: &mut _ when not using context - because it cannot satisfy that Runner is implemented
• to have the type of inner data specified when using inner data - because it cannot infer the type

Examples

struct SomeData(u16);

FnFlow::<u8, u16, (), Context>::new(
    SomeData(15),
    async |_, _, _: &mut _| {
        Ok(NodeOutput::Ok(30))
    },
);
FnFlow::<u8, u16, (), Context>::new(
    SomeData(15),
    async |data: SomeData, _, _: &mut _| {
        Ok(NodeOutput::Ok(data.0 + 30))
    },
);
FnFlow::<u8, u16, (), Context>::new(
    SomeData(15),
    async |_, _, ctx: &mut Context| {
        let _forked_ctx = ctx.fork();
        Ok(NodeOutput::Ok(30))
    },
);

impl<Input, Output, Error, Context, InnerData, R> FnFlow<Input, Output, Error, Context, InnerData, R>

pub fn with_description(self, description: Description) -> Self

Attaches a custom Description to this flow.

This is be useful when something complex happens in the flow.

Examples

use node_flow::flows::FnFlow;
use node_flow::describe::{Description, DescriptionBase};
use node_flow::node::NodeOutput;

let desc = Description::Node {
    base: DescriptionBase::from::<(), String, usize, u8, u32>()
}.with_description("I am lying about my types! But shh...");
let flow = FnFlow::<u8, u16, (), ()>::new((), async|_, x, _: &mut _| {
    Ok(NodeOutput::Ok(x as u16))
}).with_description(desc);

Trait Implementations

impl<Input, Output, Error, Context, InnerData, R> Clone for FnFlow<Input, Output, Error, Context, InnerData, R>

where R: Clone, InnerData: Clone,

fn clone(&self) -> Self

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<Input, Output, Error, Context, InnerData, R> Debug for FnFlow<Input, Output, Error, Context, InnerData, R>

where InnerData: Debug,

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

Formats the value using the given formatter.

impl<Input, Output, Error, Context, InnerData, R> Node<Input, NodeOutput<Output>, Error, Context> for FnFlow<Input, Output, Error, Context, InnerData, R>

where InnerData: Clone, for<'a> R: Runner<'a, Input, Output, Error, Context, InnerData>,

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

Runs the node.

fn describe(&self) -> Description

Describes this node, its type signature and other specifics.