Enum CompositionNode 

pub enum CompositionNode {
    Stage {
        id: StageId,
        config: Option<BTreeMap<String, Value>>,
    },
    RemoteStage {
        url: String,
        input: NType,
        output: NType,
    },
    Const {
        value: Value,
    },
    Sequential {
        stages: Vec<CompositionNode>,
    },
    Parallel {
        branches: BTreeMap<String, CompositionNode>,
    },
    Branch {
        predicate: Box<CompositionNode>,
        if_true: Box<CompositionNode>,
        if_false: Box<CompositionNode>,
    },
    Fanout {
        source: Box<CompositionNode>,
        targets: Vec<CompositionNode>,
    },
    Merge {
        sources: Vec<CompositionNode>,
        target: Box<CompositionNode>,
    },
    Retry {
        stage: Box<CompositionNode>,
        max_attempts: u32,
        delay_ms: Option<u64>,
    },
    Let {
        bindings: BTreeMap<String, CompositionNode>,
        body: Box<CompositionNode>,
    },
}

A composition graph node. The core AST for Noether’s composition language.

Variants

Stage

Leaf node: reference to a stage by its content hash.

The optional config provides static parameter values merged with the pipeline input before the stage executes. This separates data flow (from the pipeline) from configuration (from the graph).

Fields

id: StageId

config: Option<BTreeMap<String, Value>>

RemoteStage

Call a remote Noether API endpoint over HTTP.

The declared input and output types are verified by the type checker at build time — the remote server does not need to be running during noether build. In native builds, execution uses reqwest. In browser builds, the JS runtime makes a fetch() call.

Fields

url: String

URL of the remote Noether API (e.g. “http://localhost:8080”)

input: NType

Declared input type — what this node accepts from the pipeline

output: NType

Declared output type — what this node returns to the pipeline

Const

Emits a constant JSON value, ignoring its input entirely. Used to inject literal strings, numbers, or objects into a pipeline.

Fields

value: Value

Sequential

A >> B >> C: output of each stage feeds the next.

Fields

stages: Vec<CompositionNode>

Parallel

Execute branches concurrently, merge outputs into a Record keyed by branch name. Each branch receives input[branch_name] if the input is a Record containing that key; otherwise it receives the full input. Const branches ignore their input entirely — use them for literals.

Fields

branches: BTreeMap<String, CompositionNode>

Branch

Conditional routing based on a predicate stage.

Fields

predicate: Box<CompositionNode>

if_true: Box<CompositionNode>

if_false: Box<CompositionNode>

Fanout

Source output sent to all targets concurrently.

Fields

source: Box<CompositionNode>

targets: Vec<CompositionNode>

Merge

Multiple sources merge into a single target.

Fields

sources: Vec<CompositionNode>

target: Box<CompositionNode>

Retry

Retry a stage up to max_attempts times on failure.

Fields

stage: Box<CompositionNode>

max_attempts: u32

delay_ms: Option<u64>

Let

Bind named intermediate computations and reference them in body.

Each binding sub-node receives the outer Let input (the same value passed to the Let node). After all bindings have produced a value, the body runs against an augmented input record:

{ ...outer-input fields, <binding-name>: <binding-output>, ... }

Bindings with the same name as an outer-input field shadow it. This makes it possible to carry original-input fields into stages later in a Sequential pipeline — the canonical example is scan → hash → diff, where diff needs state_path from the original input but hash would otherwise erase it.

All bindings are scheduled concurrently — there are no inter-binding references. If you need a binding to depend on another, wrap it in a nested Sequential.

Fields

bindings: BTreeMap<String, CompositionNode>

body: Box<CompositionNode>

Trait Implementations

impl Clone for CompositionNode

fn clone(&self) -> CompositionNode

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for CompositionNode

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for CompositionNode

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl PartialEq for CompositionNode

fn eq(&self, other: &CompositionNode) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Serialize for CompositionNode

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

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl StructuralPartialEq for CompositionNode