Struct SendEdge 

pub struct SendEdge<S>
where
    S: Clone + Send + Sync + 'static,
{
    pub selector: Arc<dyn Fn(&S) -> Vec<(String, S)> + Send + Sync>,
    pub merger: Arc<dyn Fn(S, S) -> S + Send + Sync>,
    pub join: String,
    /* private fields */
}

Parallel fan-out edge.

After the source node completes, the runtime evaluates selector to obtain branches, runs each target node in parallel, folds the post-branch states via the state’s StateMerge::merge impl, then jumps to join.

The target list is stored as both an ordered Vec (preserving the declaration order the operator passed to crate::StateGraph::add_send_edges) and a HashSet for O(1) membership checks at dispatch time. The split lets compile- error messages and Debug output reflect the operator’s source order — flaky test output and grep-unfriendly logs would otherwise leak into every dashboard.

Fields

selector: Arc<dyn Fn(&S) -> Vec<(String, S)> + Send + Sync>

Branch-set producer. Must return (target, branch_state) pairs whose target is a member of targets.

merger: Arc<dyn Fn(S, S) -> S + Send + Sync>

Per-branch merger applied during the post-fan-out fold — see SendMerger.

join: String

Node that receives the merged state, or crate::END for terminal fan-outs that complete after the merge.

Implementations

impl<S> SendEdge<S>

where S: Clone + Send + Sync + 'static,

pub fn new( targets: impl IntoIterator<Item = String>, selector: Arc<dyn Fn(&S) -> Vec<(String, S)> + Send + Sync>, merger: Arc<dyn Fn(S, S) -> S + Send + Sync>, join: String, ) -> SendEdge<S>

Construct a SendEdge from its parts. The target list is deduplicated while preserving first-occurrence order — a repeated declaration is a no-op (the deduped name still dispatches once).

pub fn targets(&self) -> &[String]

Borrow the declaration-ordered target list. Order matches the names the operator passed to crate::StateGraph::add_send_edges.

pub fn has_target(&self, name: &str) -> bool

True when name is a declared dispatch target. O(1) via the internal HashSet.