Enum FlowStep 

pub enum FlowStep {
    Step(StepNode),
    If(ConditionalNode),
    ForIn(ForInStatement),
    Let(LetStatement),
    Return(ReturnStatement),
    Break(BreakStatement),
    Continue(ContinueStatement),
    LambdaDataApply(LambdaDataApplyNode),
    Probe(ProbeStep),
    Reason(ReasonStep),
    Validate(ValidateStep),
    Refine(RefineStep),
    Weave(WeaveStep),
    UseTool(UseToolStep),
    Remember(RememberStep),
    Recall(RecallStep),
    Par(ParBlock),
    Hibernate(HibernateStep),
    Deliberate(DeliberateBlock),
    Consensus(ConsensusBlock),
    Forge(ForgeBlock),
    Focus(FocusStep),
    Grad(GradStep),
    Associate(AssociateStep),
    Aggregate(AggregateStep),
    ExploreStep(ExploreStepNode),
    Ingest(IngestStep),
    ShieldApply(ShieldApplyStep),
    Declassify(DeclassifyStep),
    Stream(StreamBlock),
    Handle(HandleBlock),
    Perform(PerformStep),
    Resume(ResumeStep),
    Abort(AbortStep),
    Forward(ForwardStep),
    Navigate(NavigateStep),
    Drill(DrillStep),
    Trail(TrailStep),
    Corroborate(CorroborateStep),
    OtsApply(OtsApplyStep),
    MandateApply(MandateApplyStep),
    ComputeApply(ComputeApplyStep),
    AgentCall(AgentCallStep),
    Listen(ListenStep),
    DaemonStep(DaemonStepNode),
    Emit(EmitStatement),
    Mint(MintStep),
    Rotate(RotateStep),
    Publish(PublishStatement),
    Discover(DiscoverStatement),
    Persist(PersistStep),
    Retrieve(RetrieveStep),
    Mutate(MutateStep),
    Purge(PurgeStep),
    Transact(TransactBlock),
    Warden(WardenBlock),
    Quant(QuantBlock),
    Yield(YieldStatement),
    Run(RunStatement),
    GenericStep(GenericFlowStep),
}

Statements that can appear inside a flow body.

Variants

Step(StepNode)

If(ConditionalNode)

ForIn(ForInStatement)

Let(LetStatement)

Return(ReturnStatement)

Break(BreakStatement)

v1.14.0 — break keyword. Payload-free; carries only its source location for error reporting.

Continue(ContinueStatement)

v1.14.0 — continue keyword. Payload-free; same shape as Break.

LambdaDataApply(LambdaDataApplyNode)

Lambda Data application in a flow step.

Probe(ProbeStep)

Reason(ReasonStep)

Validate(ValidateStep)

Refine(RefineStep)

Weave(WeaveStep)

UseTool(UseToolStep)

Remember(RememberStep)

Recall(RecallStep)

Par(ParBlock)

Hibernate(HibernateStep)

Deliberate(DeliberateBlock)

Consensus(ConsensusBlock)

Forge(ForgeBlock)

Focus(FocusStep)

Grad(GradStep)

v2.65.0 — the proof-carrying derivative step.

Associate(AssociateStep)

Aggregate(AggregateStep)

ExploreStep(ExploreStepNode)

Ingest(IngestStep)

ShieldApply(ShieldApplyStep)

Declassify(DeclassifyStep)

Stream(StreamBlock)

Handle(HandleBlock)

v2.87.0 — handle E { … } in { … }, the delimited handler scope.

Perform(PerformStep)

v2.87.0 — perform Op(args). Legal at flow level and inside a step body (where it lands on StepNode::performs, NOT on pix_ops: a pix_op is an ELEVATION that runs BEFORE generation, and a perform whose argument is the step’s own output must run AFTER it).

Resume(ResumeStep)

v2.87.0 — resume(v). Clause bodies only.

Abort(AbortStep)

v2.87.0 — abort(v). Clause bodies only.

Forward(ForwardStep)

v2.87.0 — forward Op(args) (D12). Clause bodies only.

Navigate(NavigateStep)

Drill(DrillStep)

Trail(TrailStep)

Corroborate(CorroborateStep)

OtsApply(OtsApplyStep)

MandateApply(MandateApplyStep)

ComputeApply(ComputeApplyStep)

AgentCall(AgentCallStep)

v2.83.0 — <Agent>(arg, …), the step-body invocation of a declared agent. Dispatches v2.83.0’s bounded control loop.

Listen(ListenStep)

DaemonStep(DaemonStepNode)

Emit(EmitStatement)

v1.6.0 — π-calculus output prefix c⟨v⟩.P (Chan-Output / Chan-Mobility).

Mint(MintStep)

v2.46.0 — mint <Credential> as <binding>: ephemeral-credential minting (attenuated, TTL-bounded; authority_only_attenuates).

Rotate(RotateStep)

v2.48.0 — rotate <SecretsStore> [where "…"] with <Tool> as <binding>: mediated secret renewal (rotation_without_revelation).

Publish(PublishStatement)

v1.6.0 — capability extrusion (Publish-Ext, paper section 4.3).

Discover(DiscoverStatement)

v1.6.0 — dual of publish (dynamic typed handle import).

Persist(PersistStep)

Retrieve(RetrieveStep)

Mutate(MutateStep)

Purge(PurgeStep)

Transact(TransactBlock)

Warden(WardenBlock)

v2.43.0 — warden(<target>) within <Scope> { … } adversarial security-analysis block. A flow-body block (like quant): a target reference + a mandatory within <Scope> authorization clause + a nested body (find_exploits() → list[Vulnerability], fortify). NOT a top-level declaration.

Quant(QuantBlock)

v2.4.0 — quant { … } cognitive block (Hilbert-space projection). Carries an optional attribute header + a real nested body of flow steps (so v2.4.0’s Continuous Type Invariant can scan it). Lives inside a flow body like par; NOT a top-level declaration.

Yield(YieldStatement)

v2.4.0 — yield <expr> measurement point inside a quant block. Collapses the evolved amplitudes back to classical silicon; the effect operation whose resolution is a one-shot delimited continuation. Only well-formed inside a quant block (the checker rejects it elsewhere).

Run(RunStatement)

v2.4.0 — run <Flow>(args) as a flow-step: invoke a declared flow from inside a body (notably a daemon’s listen handler — the Q3 ask). Reuses the top-level RunStatement shape (flow name + args + optional persona/context/anchors). Distinct from Declaration::Run only by position (a step inside a body vs. a program-root run).

GenericStep(GenericFlowStep)

Flow-level statements we recognize but parse structurally.

Trait Implementations

impl Debug for FlowStep

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

Formats the value using the given formatter.