Enum StmtKind 

pub enum StmtKind {
    Expression(Expr),
    If {
        condition: Expr,
        body: Block,
        elsifs: Vec<(Expr, Block)>,
        else_block: Option<Block>,
    },
    Unless {
        condition: Expr,
        body: Block,
        else_block: Option<Block>,
    },
    While {
        condition: Expr,
        body: Block,
        label: Option<String>,
        continue_block: Option<Block>,
    },
    Until {
        condition: Expr,
        body: Block,
        label: Option<String>,
        continue_block: Option<Block>,
    },
    DoWhile {
        body: Block,
        condition: Expr,
    },
    For {
        init: Option<Box<Statement>>,
        condition: Option<Expr>,
        step: Option<Expr>,
        body: Block,
        label: Option<String>,
        continue_block: Option<Block>,
    },
    Foreach {
        var: String,
        list: Expr,
        body: Block,
        label: Option<String>,
        continue_block: Option<Block>,
    },
    SubDecl {
        name: String,
        params: Vec<SubSigParam>,
        body: Block,
        prototype: Option<String>,
    },
    Package {
        name: String,
    },
    Use {
        module: String,
        imports: Vec<Expr>,
    },
    UsePerlVersion {
        version: f64,
    },
    UseOverload {
        pairs: Vec<(String, String)>,
    },
    No {
        module: String,
        imports: Vec<Expr>,
    },
    Return(Option<Expr>),
    Last(Option<String>),
    Next(Option<String>),
    Redo(Option<String>),
    My(Vec<VarDecl>),
    Our(Vec<VarDecl>),
    Local(Vec<VarDecl>),
    State(Vec<VarDecl>),
    LocalExpr {
        target: Expr,
        initializer: Option<Expr>,
    },
    MySync(Vec<VarDecl>),
    OurSync(Vec<VarDecl>),
    Block(Block),
    StmtGroup(Block),
    Begin(Block),
    End(Block),
    UnitCheck(Block),
    Check(Block),
    Init(Block),
    Empty,
    Goto {
        target: Box<Expr>,
    },
    Continue(Block),
    StructDecl {
        def: StructDef,
    },
    EnumDecl {
        def: EnumDef,
    },
    ClassDecl {
        def: ClassDef,
    },
    TraitDecl {
        def: TraitDef,
    },
    EvalTimeout {
        timeout: Expr,
        body: Block,
    },
    TryCatch {
        try_block: Block,
        catch_var: String,
        catch_block: Block,
        finally_block: Option<Block>,
    },
    Given {
        topic: Expr,
        body: Block,
    },
    When {
        cond: Expr,
        body: Block,
    },
    DefaultCase {
        body: Block,
    },
    Tie {
        target: TieTarget,
        class: Expr,
        args: Vec<Expr>,
    },
    FormatDecl {
        name: String,
        lines: Vec<String>,
    },
    AdviceDecl {
        kind: AdviceKind,
        pattern: String,
        body: Block,
    },
}

Variants

Expression(Expr)

If

Fields

condition: Expr

body: Block

elsifs: Vec<(Expr, Block)>

else_block: Option<Block>

Unless

Fields

condition: Expr

body: Block

else_block: Option<Block>

While

Fields

condition: Expr

body: Block

label: Option<String>

continue_block: Option<Block>

while (...) { } continue { }

Until

Fields

condition: Expr

body: Block

label: Option<String>

continue_block: Option<Block>

DoWhile

Fields

body: Block

condition: Expr

For

Fields

init: Option<Box<Statement>>

condition: Option<Expr>

step: Option<Expr>

body: Block

label: Option<String>

continue_block: Option<Block>

Foreach

Fields

var: String

list: Expr

body: Block

label: Option<String>

continue_block: Option<Block>

SubDecl

Fields

name: String

params: Vec<SubSigParam>

body: Block

prototype: Option<String>

Subroutine prototype text from sub foo ($$) { } (excluding parens). None when using structured SubSigParam signatures instead.

Package

Fields

name: String

Use

Fields

module: String

imports: Vec<Expr>

UsePerlVersion

use 5.008; / use 5; — Perl version requirement (no-op at runtime in stryke).

Fields

version: f64

UseOverload

use overload '""' => 'as_string', '+' => 'add'; — operator maps (method names in current package).

Fields

pairs: Vec<(String, String)>

No

Fields

module: String

imports: Vec<Expr>

Return(Option<Expr>)

Last(Option<String>)

Next(Option<String>)

Redo(Option<String>)

My(Vec<VarDecl>)

Our(Vec<VarDecl>)

Local(Vec<VarDecl>)

State(Vec<VarDecl>)

state $x = 0 — persistent lexical variable (initialized once per sub)

LocalExpr

local $h{k} / local $SIG{__WARN__} — lvalues that are not plain my-style names.

Fields

target: Expr

initializer: Option<Expr>

MySync(Vec<VarDecl>)

mysync $x = 0 — thread-safe atomic variable for parallel blocks

OurSync(Vec<VarDecl>)

oursync $x = 0 — package-global thread-safe atomic variable. Same as mysync but the binding lives in the package stash (e.g. main::x) so it is visible across packages and parallel workers share one cell.

Block(Block)

Bare block (for scoping or do {})

StmtGroup(Block)

Statements run in order without an extra scope frame (parser desugar).

Begin(Block)

BEGIN { ... }

End(Block)

END { ... }

UnitCheck(Block)

UNITCHECK { ... } — end of compilation unit (reverse order before CHECK).

Check(Block)

CHECK { ... } — end of compile phase (reverse order).

Init(Block)

INIT { ... } — before runtime main (forward order).

Empty

Empty statement (bare semicolon)

Goto

goto EXPR — expression evaluates to a label name in the same block.

Fields

target: Box<Expr>

Continue(Block)

Standalone continue { BLOCK } (normally follows a loop; parsed for acceptance).

StructDecl

struct Name { field => Type, ... } — fixed-field records (Name->new, $x->field).

Fields

def: StructDef

EnumDecl

enum Name { Variant1 => Type, Variant2, ... } — algebraic data types.

Fields

def: EnumDef

ClassDecl

class Name extends Parent impl Trait { fields; methods } — full OOP.

Fields

def: ClassDef

TraitDecl

trait Name { fn required; fn with_default { } } — interface/mixin.

Fields

def: TraitDef

EvalTimeout

eval_timeout SECS { ... } — run block on a worker thread; main waits up to SECS (portable timeout).

Fields

timeout: Expr

body: Block

TryCatch

try { } catch ($err) { } [ finally { } ] — catch runtime/die errors (not last/next/return flow). finally runs after a successful try or after catch completes (including if catch rethrows).

Fields

try_block: Block

catch_var: String

catch_block: Block

finally_block: Option<Block>

Given

given (EXPR) { when ... default ... } — topic in $_, when matches with regex / eq / smartmatch.

Fields

topic: Expr

body: Block

When

when (COND) { } — only valid inside given (handled by given dispatcher).

Fields

cond: Expr

body: Block

DefaultCase

default { } — only valid inside given.

Fields

body: Block

Tie

tie %hash / tie @arr / tie $x — TIEHASH / TIEARRAY / TIESCALAR (FETCH/STORE).

Fields

target: TieTarget

class: Expr

args: Vec<Expr>

FormatDecl

format NAME = picture/value lines … . — report templates for write.

Fields

name: String

lines: Vec<String>

AdviceDecl

before|after|around "<glob>" { ... } — register AOP advice on user subs. Pattern is a glob (*, ?) matched against the called sub’s bare name.

Fields

kind: AdviceKind

pattern: String

body: Block

Trait Implementations

impl Clone for StmtKind

fn clone(&self) -> StmtKind

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for StmtKind

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for StmtKind

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Serialize for StmtKind

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

where __S: Serializer,

Serialize this value into the given Serde serializer.