Enum Instr 

pub enum Instr {
    Send {
        chan: Reg,
        val: Reg,
    },
    Receive {
        chan: Reg,
        dst: Reg,
    },
    Offer {
        chan: Reg,
        label: String,
    },
    Choose {
        chan: Reg,
        table: Vec<(String, PC)>,
    },
    Open {
        roles: Vec<String>,
        local_types: Vec<(String, LocalTypeR)>,
        handlers: Vec<((String, String), String)>,
        dsts: Vec<(String, Reg)>,
    },
    Close {
        session: Reg,
    },
    Invoke {
        action: InvokeAction,
        dst: Option<Reg>,
    },
    Acquire {
        layer: String,
        dst: Reg,
    },
    Release {
        layer: String,
        evidence: Reg,
    },
    Fork {
        ghost: Reg,
    },
    Join,
    Abort,
    Transfer {
        endpoint: Reg,
        target: Reg,
        bundle: Reg,
    },
    Tag {
        fact: Reg,
        dst: Reg,
    },
    Check {
        knowledge: Reg,
        target: Reg,
        dst: Reg,
    },
    Set {
        dst: Reg,
        val: ImmValue,
    },
    Move {
        dst: Reg,
        src: Reg,
    },
    Jump {
        target: PC,
    },
    Spawn {
        target: PC,
        args: Vec<Reg>,
    },
    Yield,
    Halt,
}

Bytecode instruction.

The initial instruction set covers communication, session lifecycle, effects, and control flow. Guard/speculation/ownership instructions are deferred.

Variants

Send

Send value in val register to channel in chan register.

Fields

chan: Reg

Channel register.

val: Reg

Value register to send.

Receive

Receive from channel in chan register, store in dst register.

Fields

chan: Reg

Channel register.

dst: Reg

Destination register for the received value.

Offer

Offer a label on channel.

Fields

chan: Reg

Channel register.

label: String

Label to select.

Choose

Choose from a branch table using a received label.

Fields

chan: Reg

Channel register.

table: Vec<(String, PC)>

Label-to-PC jump table.

Open

Open a new session with the given roles and endpoint destinations.

Fields

roles: Vec<String>

Role names for the session.

local_types: Vec<(String, LocalTypeR)>

Role-to-local-type mappings for session initialization.

handlers: Vec<((String, String), String)>

Edge-to-handler mappings as ((sender, receiver), handler_id).

dsts: Vec<(String, Reg)>

Role-to-register endpoint mappings.

Close

Close the session referenced by the register.

Fields

session: Reg

Register holding the session reference.

Invoke

Invoke an effect handler action.

Fields

action: InvokeAction

Action descriptor.

dst: Option<Reg>

Legacy compatibility field for register-result encoding.

Acquire

Acquire a guard layer and store evidence in a register.

Fields

layer: String

Guard layer identifier.

dst: Reg

Destination register for evidence.

Release

Release a guard layer using evidence from a register.

Fields

layer: String

Guard layer identifier.

evidence: Reg

Register holding evidence.

Fork

Enter speculation using a ghost session id.

Fields

ghost: Reg

Register holding the ghost session id.

Join

Join speculative execution.

Abort

Abort speculative execution.

Transfer

Transfer an endpoint to another coroutine.

Fields

endpoint: Reg

Register holding the endpoint.

target: Reg

Register holding the target coroutine id.

bundle: Reg

Register holding a bundle descriptor.

Tag

Tag a knowledge fact and return success.

Fields

fact: Reg

Register holding the fact.

dst: Reg

Destination register for the result.

Check

Check a knowledge fact against the flow policy.

Fields

knowledge: Reg

Register holding the knowledge fact.

target: Reg

Register holding the target role.

dst: Reg

Destination register for the result.

Set

Set a register to an immediate value.

Fields

dst: Reg

Destination register.

val: ImmValue

Immediate value to load.

Move

Copy register src to dst.

Fields

dst: Reg

Destination register.

src: Reg

Source register.

Jump

Unconditional jump.

Fields

target: PC

Target program counter.

Spawn

Spawn a new coroutine at target PC with argument registers.

Fields

target: PC

Target program counter for the spawned coroutine.

args: Vec<Reg>

Registers to copy into the spawned coroutine argument area.

Yield

Yield execution to the scheduler.

Halt

Halt this coroutine (normal termination).

Trait Implementations

impl Clone for Instr

fn clone(&self) -> Instr

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Instr

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for Instr

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Eq for Instr

impl PartialEq for Instr

fn eq(&self, other: &Instr) -> 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 Instr

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 Instr