Enum NodeKind 

#[non_exhaustive]
pub enum NodeKind {
    Filter {
        filter_name: String,
    },
    SubGraph {
        graph: Box<Graph>,
    },
    Loop {
        max_iterations: Option<usize>,
        until: LoopCondition,
    },
    Branch {
        arms: Vec<String>,
    },
    Step {
        step_name: String,
    },
}

What kind of computation a node represents.

Variants (Non-exhaustive)

Non-exhaustive enums could have additional variants added in future. Therefore, when matching against variants of non-exhaustive enums, an extra wildcard arm must be added to account for any future variants.

Filter

A single filter (the common case).

Fields

filter_name: String

Name the filter is registered under in the NodeCatalog.

SubGraph

A nested sub-graph (compiled recursively).

Fields

graph: Box<Graph>

The inner graph, boxed to keep NodeKind a fixed size.

Loop

A loop node. Its body is the sub-graph reached through its control edges; until names what decides to stop.

Fields

max_iterations: Option<usize>

Hard cap on iterations; None means the body runs until until signals stop.

until: LoopCondition

Defaults to LoopCondition::BodyTerminal, resolved by the compiler. Never inferred at runtime from execution order.

Branch

A branch/conditional node. Arms are the labelled control edges leaving it; arms optionally declares the complete set of labels the condition may produce, so the compiler can catch a mislabelled edge before the run rather than at the moment the branch is taken.

Fields

arms: Vec<String>

Declared labels. Empty means “infer from the edges” — the backwards-compatible default.

Step

An effectful node: calls models, tools, or other graphs, and decides what happens next. See crate::step::Step.

Fields

step_name: String

Name the step is registered under in the NodeCatalog.

Trait Implementations

impl Clone for NodeKind

fn clone(&self) -> NodeKind

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for NodeKind

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for NodeKind

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Serialize for NodeKind

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.