Enum StmtKind 

pub enum StmtKind {
    Let {
        name: String,
        mutable: bool,
        type_ann: Option<TypeExpr>,
        value: Expr,
        is_public: bool,
    },
    FnDecl {
        name: String,
        type_params: Vec<String>,
        params: Vec<Param>,
        return_type: Option<TypeExpr>,
        bounds: Vec<TraitBound>,
        body: Vec<Stmt>,
        is_generator: bool,
        is_public: bool,
        is_async: bool,
    },
    Expr(Expr),
    Return(Option<Expr>),
    If {
        condition: Expr,
        then_body: Vec<Stmt>,
        else_ifs: Vec<(Expr, Vec<Stmt>)>,
        else_body: Option<Vec<Stmt>>,
    },
    While {
        condition: Expr,
        body: Vec<Stmt>,
    },
    For {
        name: String,
        iter: Expr,
        body: Vec<Stmt>,
    },
    ParallelFor {
        name: String,
        iter: Expr,
        body: Vec<Stmt>,
    },
    Schema {
        name: String,
        fields: Vec<SchemaField>,
        is_public: bool,
        version: Option<i64>,
        parent_version: Option<i64>,
    },
    Migrate {
        schema_name: String,
        from_version: i64,
        to_version: i64,
        operations: Vec<MigrateOp>,
    },
    Train {
        name: String,
        algorithm: String,
        config: Vec<(String, Expr)>,
    },
    Pipeline {
        name: String,
        extract: Vec<Stmt>,
        transform: Vec<Stmt>,
        load: Vec<Stmt>,
        schedule: Option<String>,
        timeout: Option<String>,
        retries: Option<i64>,
        on_failure: Option<Vec<Stmt>>,
        on_success: Option<Vec<Stmt>>,
    },
    StreamDecl {
        name: String,
        source: Expr,
        transform: Vec<Stmt>,
        sink: Option<Expr>,
        window: Option<WindowSpec>,
        watermark: Option<String>,
    },
    SourceDecl {
        name: String,
        connector_type: String,
        config: Vec<(String, Expr)>,
    },
    SinkDecl {
        name: String,
        connector_type: String,
        config: Vec<(String, Expr)>,
    },
    StructDecl {
        name: String,
        type_params: Vec<String>,
        fields: Vec<SchemaField>,
        is_public: bool,
    },
    EnumDecl {
        name: String,
        type_params: Vec<String>,
        variants: Vec<EnumVariant>,
        is_public: bool,
    },
    ImplBlock {
        type_name: String,
        type_params: Vec<String>,
        methods: Vec<Stmt>,
    },
    TryCatch {
        try_body: Vec<Stmt>,
        catch_var: String,
        catch_body: Vec<Stmt>,
        finally_body: Option<Vec<Stmt>>,
    },
    Throw(Expr),
    Import {
        path: String,
        alias: Option<String>,
    },
    Test {
        name: String,
        body: Vec<Stmt>,
    },
    Use {
        item: UseItem,
        is_public: bool,
    },
    ModDecl {
        name: String,
        is_public: bool,
    },
    TraitDef {
        name: String,
        type_params: Vec<String>,
        methods: Vec<TraitMethod>,
        is_public: bool,
    },
    TraitImpl {
        trait_name: String,
        type_name: String,
        type_params: Vec<String>,
        methods: Vec<Stmt>,
    },
    LetDestructure {
        pattern: Pattern,
        mutable: bool,
        value: Expr,
        is_public: bool,
    },
    TypeAlias {
        name: String,
        type_params: Vec<String>,
        value: TypeExpr,
        is_public: bool,
    },
    Agent {
        name: String,
        model: String,
        system_prompt: Option<String>,
        tools: Vec<(String, Expr)>,
        max_turns: Option<i64>,
        temperature: Option<f64>,
        max_tokens: Option<i64>,
        base_url: Option<String>,
        api_key: Option<String>,
        output_format: Option<String>,
        on_tool_call: Option<Vec<Stmt>>,
        on_complete: Option<Vec<Stmt>>,
    },
    Break,
    Continue,
}

Statement variants

Variants

Let

let x = expr or let mut x: type = expr

Fields

name: String

mutable: bool

type_ann: Option<TypeExpr>

value: Expr

is_public: bool

FnDecl

fn name<T, U>(params) -> return_type where T: Bound { body }

Fields

name: String

type_params: Vec<String>

params: Vec<Param>

return_type: Option<TypeExpr>

bounds: Vec<TraitBound>

body: Vec<Stmt>

is_generator: bool

is_public: bool

is_async: bool

Expr(Expr)

Expression statement (e.g., a function call on its own line)

Return(Option<Expr>)

return expr

If

if cond { body } else if cond { body } else { body }

Fields

condition: Expr

then_body: Vec<Stmt>

else_ifs: Vec<(Expr, Vec<Stmt>)>

else_body: Option<Vec<Stmt>>

While

while cond { body }

Fields

condition: Expr

body: Vec<Stmt>

For

for name in iter { body }

Fields

name: String

iter: Expr

body: Vec<Stmt>

ParallelFor

parallel for name in iter { body }

Fields

name: String

iter: Expr

body: Vec<Stmt>

Schema

schema Name { field: type, ... }

Fields

name: String

fields: Vec<SchemaField>

is_public: bool

version: Option<i64>

Schema version from @version N doc comment annotation

parent_version: Option<i64>

Parent version this schema evolves from

Migrate

migrate SchemaName from V1 to V2 { add_column(...), ... }

Fields

schema_name: String

from_version: i64

to_version: i64

operations: Vec<MigrateOp>

Train

model name = train algorithm { key: value, ... }

Fields

name: String

algorithm: String

config: Vec<(String, Expr)>

Pipeline

pipeline name { extract { ... } transform { ... } load { ... } }

Fields

name: String

extract: Vec<Stmt>

transform: Vec<Stmt>

load: Vec<Stmt>

schedule: Option<String>

timeout: Option<String>

retries: Option<i64>

on_failure: Option<Vec<Stmt>>

on_success: Option<Vec<Stmt>>

StreamDecl

stream name { source: expr, window: spec, transform: { ... }, sink: expr }

Fields

name: String

source: Expr

transform: Vec<Stmt>

sink: Option<Expr>

window: Option<WindowSpec>

watermark: Option<String>

SourceDecl

source name = connector TYPE { key: value, ... }

Fields

name: String

connector_type: String

config: Vec<(String, Expr)>

SinkDecl

sink name = connector TYPE { key: value, ... }

Fields

name: String

connector_type: String

config: Vec<(String, Expr)>

StructDecl

struct Name<T, U> { field: type, ... }

Fields

name: String

type_params: Vec<String>

fields: Vec<SchemaField>

is_public: bool

EnumDecl

enum Name<T, E> { Variant, Variant(types), ... }

Fields

name: String

type_params: Vec<String>

variants: Vec<EnumVariant>

is_public: bool

ImplBlock

impl<T> Type { fn methods... }

Fields

type_name: String

type_params: Vec<String>

methods: Vec<Stmt>

TryCatch

try { ... } catch e { ... } finally { ... }

Fields

try_body: Vec<Stmt>

catch_var: String

catch_body: Vec<Stmt>

finally_body: Option<Vec<Stmt>>

Throw(Expr)

throw expr

Import

import "path.tl" or import "path.tl" as name

Fields

path: String

alias: Option<String>

Test

test "name" { ... }

Fields

name: String

body: Vec<Stmt>

Use

use data.transforms.clean_users etc.

Fields

item: UseItem

is_public: bool

ModDecl

mod transforms or pub mod transforms

Fields

name: String

is_public: bool

TraitDef

trait Display<T> { fn show(self) -> string }

Fields

name: String

type_params: Vec<String>

methods: Vec<TraitMethod>

is_public: bool

TraitImpl

impl Display for Point { fn show(self) -> string { ... } }

Fields

trait_name: String

type_name: String

type_params: Vec<String>

methods: Vec<Stmt>

LetDestructure

let { x, y } = expr or let [a, b] = expr

Fields

pattern: Pattern

mutable: bool

value: Expr

is_public: bool

TypeAlias

type Mapper = fn(int64) -> int64

Fields

name: String

type_params: Vec<String>

value: TypeExpr

is_public: bool

Agent

agent name { model: "...", system: "...", tools { ... }, max_turns: N, on_tool_call { ... }, on_complete { ... } }

Fields

name: String

model: String

system_prompt: Option<String>

tools: Vec<(String, Expr)>

max_turns: Option<i64>

temperature: Option<f64>

max_tokens: Option<i64>

base_url: Option<String>

api_key: Option<String>

output_format: Option<String>

on_tool_call: Option<Vec<Stmt>>

on_complete: Option<Vec<Stmt>>

Break

break

Continue

continue

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.