Enum Protocol 

pub enum Protocol {
    Begin {
        operation: String,
        args: Vec<String>,
        progress: Option<ProgressAttachment>,
        continuation: Box<Protocol>,
    },
    Await {
        operation: String,
        continuation: Box<Protocol>,
    },
    Resolve {
        operation: String,
        outcome: CommitmentOutcome,
        continuation: Box<Protocol>,
    },
    Invalidate {
        operation: String,
        continuation: Box<Protocol>,
    },
    Send {
        from: Role,
        to: Role,
        message: MessageType,
        continuation: Box<Protocol>,
        annotations: Annotations,
        from_annotations: Annotations,
        to_annotations: Annotations,
    },
    Broadcast {
        from: Role,
        to_all: NonEmptyVec<Role>,
        message: MessageType,
        continuation: Box<Protocol>,
        annotations: Annotations,
        from_annotations: Annotations,
    },
    Choice {
        role: Role,
        branches: NonEmptyVec<Branch>,
        annotations: Annotations,
    },
    Let {
        name: String,
        mode: AuthorityBindingMode,
        expr: AuthorityExpr,
        linear: bool,
        continuation: Box<Protocol>,
    },
    Case {
        expr: AuthorityExpr,
        branches: NonEmptyVec<CaseBranch>,
    },
    Timeout {
        role: Role,
        duration_ms: u64,
        body: Box<Protocol>,
        on_timeout: Box<Protocol>,
        on_cancel: Option<Box<Protocol>>,
    },
    Loop {
        condition: Option<Condition>,
        body: Box<Protocol>,
    },
    Parallel {
        protocols: NonEmptyVec<Protocol>,
    },
    Rec {
        label: Ident,
        body: Box<Protocol>,
    },
    Var(Ident),
    Publish {
        event: String,
        arg: Option<String>,
        continuation: Box<Protocol>,
    },
    PublishAuthority {
        witness: String,
        publication_name: String,
        continuation: Box<Protocol>,
    },
    Materialize {
        proof: String,
        publication: String,
        continuation: Box<Protocol>,
    },
    Handoff {
        operation: String,
        target: Role,
        receipt: String,
        continuation: Box<Protocol>,
    },
    DependentWork {
        name: String,
        arg: Option<String>,
        required_for: String,
        continuation: Box<Protocol>,
    },
    Extension {
        extension: Box<dyn ProtocolExtension>,
        continuation: Box<Protocol>,
        annotations: Annotations,
    },
    End,
}

Protocol specification using choreographic constructs

Variants

Begin

Begin one explicit semantic operation instance.

Fields

operation: String

args: Vec<String>

progress: Option<ProgressAttachment>

continuation: Box<Protocol>

Await

Await one previously begun semantic operation instance.

Fields

operation: String

continuation: Box<Protocol>

Resolve

Resolve one previously begun semantic operation instance.

Fields

operation: String

outcome: CommitmentOutcome

continuation: Box<Protocol>

Invalidate

Invalidate one previously begun semantic operation instance.

Fields

operation: String

continuation: Box<Protocol>

Send

Message send: A -> B: Message

Fields

from: Role

to: Role

message: MessageType

continuation: Box<Protocol>

annotations: Annotations

Statement-level annotations

from_annotations: Annotations

From role annotations

to_annotations: Annotations

To role annotations

Broadcast

Broadcast: A -> *: Message

Fields

from: Role

to_all: NonEmptyVec<Role>

message: MessageType

continuation: Box<Protocol>

annotations: Annotations

Statement-level annotations

from_annotations: Annotations

From role annotations

Choice

Choice made by a role

Fields

role: Role

branches: NonEmptyVec<Branch>

annotations: Annotations

Statement-level annotations

Let

Local authority/evidence binding.

Fields

name: String

Bound variable name.

mode: AuthorityBindingMode

Whether the binding is authoritative, observational, or plain.

expr: AuthorityExpr

Bound expression.

linear: bool

Whether the binding is linear/single-use.

continuation: Box<Protocol>

Continuation after the binding.

Case

Local authority/result match.

Fields

expr: AuthorityExpr

Scrutinee expression.

branches: NonEmptyVec<CaseBranch>

Match branches.

Timeout

Explicit timeout/cancel surface syntax prior to projection lowering.

Fields

role: Role

Role that owns the timeout decision.

duration_ms: u64

Timeout duration in milliseconds.

body: Box<Protocol>

Main body before timeout fires.

on_timeout: Box<Protocol>

Timeout branch.

on_cancel: Option<Box<Protocol>>

Optional explicit cancellation branch.

Loop

Loop construct

Fields

condition: Option<Condition>

body: Box<Protocol>

Parallel

Parallel composition

Fields

protocols: NonEmptyVec<Protocol>

Rec

Recursive protocol with label

Fields

label: Ident

body: Box<Protocol>

Var(Ident)

Reference to recursive label

Publish

Canonical semantic publication surface.

Fields

event: String

arg: Option<String>

continuation: Box<Protocol>

PublishAuthority

Canonical publication that lifts an authoritative witness into a named publication.

Fields

witness: String

publication_name: String

continuation: Box<Protocol>

Materialize

Canonical materialization from one named publication.

Fields

proof: String

publication: String

continuation: Box<Protocol>

Handoff

Explicit semantic owner handoff.

Fields

operation: String

target: Role

receipt: String

continuation: Box<Protocol>

DependentWork

Declared semantically required dependent work.

Fields

name: String

arg: Option<String>

required_for: String

continuation: Box<Protocol>

Extension

Protocol extension point for custom behaviors

Fields

extension: Box<dyn ProtocolExtension>

The extension implementation

continuation: Box<Protocol>

Continuation after this extension

annotations: Annotations

Statement-level annotations

End

Protocol termination

Implementations

impl Protocol

pub fn mentions_role(&self, role: &Role) -> bool

pub fn get_annotations(&self) -> &Annotations

Get statement-level annotations for this protocol node

pub fn get_from_annotations(&self) -> Option<&Annotations>

Get from-role annotations for Send/Broadcast statements

pub fn get_to_annotations(&self) -> Option<&Annotations>

Get to-role annotations for Send statements

pub fn get_annotations_mut(&mut self) -> Option<&mut Annotations>

Get mutable reference to annotations for modification

pub fn get_from_annotations_mut(&mut self) -> Option<&mut Annotations>

Get mutable reference to from-role annotations

pub fn get_to_annotations_mut(&mut self) -> Option<&mut Annotations>

Get mutable reference to to-role annotations

pub fn add_annotation(&mut self, annotation: ProtocolAnnotation) -> bool

Add a typed annotation

pub fn clear_annotations(&mut self)

Clear all annotations on this protocol node

pub fn has_any_annotations(&self) -> bool

Check if any annotations are present

pub fn annotation_count(&self) -> usize

Count total number of annotations (statement + role annotations)

pub fn merge_annotations_from(&mut self, other: &Protocol)

Merge annotations from another protocol node

pub fn validate_required_annotations( &self, required_keys: &[&str], ) -> Result<(), Vec<String>>

Validate that required annotations are present

pub fn collect_nodes_with_annotation<'a>( &'a self, key: &str, nodes: &mut Vec<&'a Protocol>, )

Collect all protocol nodes that have a specific annotation (recursive traversal)

pub fn collect_nodes_with_annotation_value<'a>( &'a self, key: &str, value: &str, nodes: &mut Vec<&'a Protocol>, )

Collect all protocol nodes that have a specific annotation with a specific value

pub fn deep_annotation_count(&self) -> usize

Count total annotations throughout the protocol tree (recursive)

pub fn visit_annotated_nodes<F>(&self, f: &mut F)

where F: FnMut(&Protocol),

Apply a function to all protocol nodes that have annotations (visitor pattern)

pub fn visit_annotated_nodes_mut<F>(&mut self, f: &mut F)

where F: FnMut(&mut Protocol),

Apply a mutable function to all protocol nodes that have annotations

Trait Implementations

impl Clone for Protocol

fn clone(&self) -> Protocol

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Protocol

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

Formats the value using the given formatter.