Enum Node 

pub enum Node {
    Pipeline {
        name: String,
        params: Vec<String>,
        body: Vec<SNode>,
        extends: Option<String>,
        is_pub: bool,
    },
    LetBinding {
        pattern: BindingPattern,
        type_ann: Option<TypeExpr>,
        value: Box<SNode>,
    },
    VarBinding {
        pattern: BindingPattern,
        type_ann: Option<TypeExpr>,
        value: Box<SNode>,
    },
    OverrideDecl {
        name: String,
        params: Vec<String>,
        body: Vec<SNode>,
    },
    ImportDecl {
        path: String,
    },
    SelectiveImport {
        names: Vec<String>,
        path: String,
    },
    EnumDecl {
        name: String,
        type_params: Vec<TypeParam>,
        variants: Vec<EnumVariant>,
        is_pub: bool,
    },
    StructDecl {
        name: String,
        type_params: Vec<TypeParam>,
        fields: Vec<StructField>,
        is_pub: bool,
    },
    InterfaceDecl {
        name: String,
        type_params: Vec<TypeParam>,
        associated_types: Vec<(String, Option<TypeExpr>)>,
        methods: Vec<InterfaceMethod>,
    },
    ImplBlock {
        type_name: String,
        methods: Vec<SNode>,
    },
    IfElse {
        condition: Box<SNode>,
        then_body: Vec<SNode>,
        else_body: Option<Vec<SNode>>,
    },
    ForIn {
        pattern: BindingPattern,
        iterable: Box<SNode>,
        body: Vec<SNode>,
    },
    MatchExpr {
        value: Box<SNode>,
        arms: Vec<MatchArm>,
    },
    WhileLoop {
        condition: Box<SNode>,
        body: Vec<SNode>,
    },
    Retry {
        count: Box<SNode>,
        body: Vec<SNode>,
    },
    ReturnStmt {
        value: Option<Box<SNode>>,
    },
    TryCatch {
        body: Vec<SNode>,
        error_var: Option<String>,
        error_type: Option<TypeExpr>,
        catch_body: Vec<SNode>,
        finally_body: Option<Vec<SNode>>,
    },
    TryExpr {
        body: Vec<SNode>,
    },
    FnDecl {
        name: String,
        type_params: Vec<TypeParam>,
        params: Vec<TypedParam>,
        return_type: Option<TypeExpr>,
        where_clauses: Vec<WhereClause>,
        body: Vec<SNode>,
        is_pub: bool,
    },
    ToolDecl {
        name: String,
        description: Option<String>,
        params: Vec<TypedParam>,
        return_type: Option<TypeExpr>,
        body: Vec<SNode>,
        is_pub: bool,
    },
    TypeDecl {
        name: String,
        type_params: Vec<TypeParam>,
        type_expr: TypeExpr,
    },
    SpawnExpr {
        body: Vec<SNode>,
    },
    DurationLiteral(u64),
    RangeExpr {
        start: Box<SNode>,
        end: Box<SNode>,
        inclusive: bool,
    },
    GuardStmt {
        condition: Box<SNode>,
        else_body: Vec<SNode>,
    },
    RequireStmt {
        condition: Box<SNode>,
        message: Option<Box<SNode>>,
    },
    DeferStmt {
        body: Vec<SNode>,
    },
    DeadlineBlock {
        duration: Box<SNode>,
        body: Vec<SNode>,
    },
    YieldExpr {
        value: Option<Box<SNode>>,
    },
    MutexBlock {
        body: Vec<SNode>,
    },
    BreakStmt,
    ContinueStmt,
    Parallel {
        mode: ParallelMode,
        expr: Box<SNode>,
        variable: Option<String>,
        body: Vec<SNode>,
        options: Vec<(String, SNode)>,
    },
    SelectExpr {
        cases: Vec<SelectCase>,
        timeout: Option<(Box<SNode>, Vec<SNode>)>,
        default_body: Option<Vec<SNode>>,
    },
    FunctionCall {
        name: String,
        args: Vec<SNode>,
    },
    MethodCall {
        object: Box<SNode>,
        method: String,
        args: Vec<SNode>,
    },
    OptionalMethodCall {
        object: Box<SNode>,
        method: String,
        args: Vec<SNode>,
    },
    PropertyAccess {
        object: Box<SNode>,
        property: String,
    },
    OptionalPropertyAccess {
        object: Box<SNode>,
        property: String,
    },
    SubscriptAccess {
        object: Box<SNode>,
        index: Box<SNode>,
    },
    SliceAccess {
        object: Box<SNode>,
        start: Option<Box<SNode>>,
        end: Option<Box<SNode>>,
    },
    BinaryOp {
        op: String,
        left: Box<SNode>,
        right: Box<SNode>,
    },
    UnaryOp {
        op: String,
        operand: Box<SNode>,
    },
    Ternary {
        condition: Box<SNode>,
        true_expr: Box<SNode>,
        false_expr: Box<SNode>,
    },
    Assignment {
        target: Box<SNode>,
        value: Box<SNode>,
        op: Option<String>,
    },
    ThrowStmt {
        value: Box<SNode>,
    },
    EnumConstruct {
        enum_name: String,
        variant: String,
        args: Vec<SNode>,
    },
    StructConstruct {
        struct_name: String,
        fields: Vec<DictEntry>,
    },
    InterpolatedString(Vec<StringSegment>),
    StringLiteral(String),
    RawStringLiteral(String),
    IntLiteral(i64),
    FloatLiteral(f64),
    BoolLiteral(bool),
    NilLiteral,
    Identifier(String),
    ListLiteral(Vec<SNode>),
    DictLiteral(Vec<DictEntry>),
    Spread(Box<SNode>),
    TryOperator {
        operand: Box<SNode>,
    },
    TryStar {
        operand: Box<SNode>,
    },
    Block(Vec<SNode>),
    Closure {
        params: Vec<TypedParam>,
        body: Vec<SNode>,
        fn_syntax: bool,
    },
}

AST nodes for the Harn language.

Variants

Pipeline

Fields

name: String

params: Vec<String>

body: Vec<SNode>

extends: Option<String>

is_pub: bool

LetBinding

Fields

pattern: BindingPattern

type_ann: Option<TypeExpr>

value: Box<SNode>

VarBinding

Fields

pattern: BindingPattern

type_ann: Option<TypeExpr>

value: Box<SNode>

OverrideDecl

Fields

name: String

params: Vec<String>

body: Vec<SNode>

ImportDecl

Fields

path: String

SelectiveImport

Selective import: import { foo, bar } from “module”

Fields

names: Vec<String>

path: String

EnumDecl

Fields

name: String

type_params: Vec<TypeParam>

variants: Vec<EnumVariant>

is_pub: bool

StructDecl

Fields

name: String

type_params: Vec<TypeParam>

fields: Vec<StructField>

is_pub: bool

InterfaceDecl

Fields

name: String

type_params: Vec<TypeParam>

associated_types: Vec<(String, Option<TypeExpr>)>

methods: Vec<InterfaceMethod>

ImplBlock

Impl block: impl TypeName { fn method(self, …) { … } … }

Fields

type_name: String

methods: Vec<SNode>

IfElse

Fields

condition: Box<SNode>

then_body: Vec<SNode>

else_body: Option<Vec<SNode>>

ForIn

Fields

pattern: BindingPattern

iterable: Box<SNode>

body: Vec<SNode>

MatchExpr

Fields

value: Box<SNode>

arms: Vec<MatchArm>

WhileLoop

Fields

condition: Box<SNode>

body: Vec<SNode>

Retry

Fields

count: Box<SNode>

body: Vec<SNode>

ReturnStmt

Fields

value: Option<Box<SNode>>

TryCatch

Fields

body: Vec<SNode>

error_var: Option<String>

error_type: Option<TypeExpr>

catch_body: Vec<SNode>

finally_body: Option<Vec<SNode>>

TryExpr

Try expression: try { body } — returns Result.Ok(value) or Result.Err(error).

Fields

body: Vec<SNode>

FnDecl

Fields

name: String

type_params: Vec<TypeParam>

params: Vec<TypedParam>

return_type: Option<TypeExpr>

where_clauses: Vec<WhereClause>

body: Vec<SNode>

is_pub: bool

ToolDecl

Fields

name: String

description: Option<String>

params: Vec<TypedParam>

return_type: Option<TypeExpr>

body: Vec<SNode>

is_pub: bool

TypeDecl

Fields

name: String

type_params: Vec<TypeParam>

type_expr: TypeExpr

SpawnExpr

Fields

body: Vec<SNode>

DurationLiteral(u64)

Duration literal: 500ms, 5s, 30m, 2h, 1d, 1w

RangeExpr

Range expression: start to end (inclusive) or start to end exclusive (half-open)

Fields

start: Box<SNode>

end: Box<SNode>

inclusive: bool

GuardStmt

Guard clause: guard condition else { body }

Fields

condition: Box<SNode>

else_body: Vec<SNode>

RequireStmt

Fields

condition: Box<SNode>

message: Option<Box<SNode>>

DeferStmt

Defer statement: defer { body } — runs body at scope exit.

Fields

body: Vec<SNode>

DeadlineBlock

Deadline block: deadline DURATION { body }

Fields

duration: Box<SNode>

body: Vec<SNode>

YieldExpr

Yield expression: yields control to host, optionally with a value.

Fields

value: Option<Box<SNode>>

MutexBlock

Mutex block: mutual exclusion for concurrent access.

Fields

body: Vec<SNode>

BreakStmt

Break out of a loop.

ContinueStmt

Continue to next loop iteration.

Parallel

Fields

mode: ParallelMode

expr: Box<SNode>

For Count mode: the count expression. For Each/Settle: the list expression.

variable: Option<String>

body: Vec<SNode>

options: Vec<(String, SNode)>

Optional trailing with { max_concurrent: N, ... } option block. A vec (rather than a dict) preserves source order for error reporting and keeps parsing cheap. Only max_concurrent is currently honored; unknown keys are rejected by the parser.

SelectExpr

Fields

cases: Vec<SelectCase>

timeout: Option<(Box<SNode>, Vec<SNode>)>

default_body: Option<Vec<SNode>>

FunctionCall

Fields

name: String

args: Vec<SNode>

MethodCall

Fields

object: Box<SNode>

method: String

args: Vec<SNode>

OptionalMethodCall

Optional method call: obj?.method(args) — returns nil if obj is nil.

Fields

object: Box<SNode>

method: String

args: Vec<SNode>

PropertyAccess

Fields

object: Box<SNode>

property: String

OptionalPropertyAccess

Optional chaining: obj?.property — returns nil if obj is nil.

Fields

object: Box<SNode>

property: String

SubscriptAccess

Fields

object: Box<SNode>

index: Box<SNode>

SliceAccess

Fields

object: Box<SNode>

start: Option<Box<SNode>>

end: Option<Box<SNode>>

BinaryOp

Fields

op: String

left: Box<SNode>

right: Box<SNode>

UnaryOp

Fields

op: String

operand: Box<SNode>

Ternary

Fields

condition: Box<SNode>

true_expr: Box<SNode>

false_expr: Box<SNode>

Assignment

Fields

target: Box<SNode>

value: Box<SNode>

op: Option<String>

None = plain =, Some(“+”) = +=, etc.

ThrowStmt

Fields

value: Box<SNode>

EnumConstruct

Enum variant construction: EnumName.Variant(args)

Fields

enum_name: String

variant: String

args: Vec<SNode>

StructConstruct

Struct construction: StructName { field: value, … }

Fields

struct_name: String

fields: Vec<DictEntry>

InterpolatedString(Vec<StringSegment>)

StringLiteral(String)

RawStringLiteral(String)

Raw string literal r"..." — no escape processing.

IntLiteral(i64)

FloatLiteral(f64)

BoolLiteral(bool)

NilLiteral

Identifier(String)

ListLiteral(Vec<SNode>)

DictLiteral(Vec<DictEntry>)

Spread(Box<SNode>)

Spread expression ...expr inside list/dict literals.

TryOperator

Try operator: expr? — unwraps Result.Ok or propagates Result.Err.

Fields

operand: Box<SNode>

TryStar

Try-star operator: try* EXPR — evaluates EXPR; on throw, runs pending finally blocks up to the enclosing catch and rethrows the original value. On success, evaluates to EXPR’s value. Lowered per spec/HARN_SPEC.md as: { let _r = try { EXPR } guard is_ok(_r) else { throw unwrap_err(_r) } unwrap(_r) }

Fields

operand: Box<SNode>

Block(Vec<SNode>)

Closure

Fields

params: Vec<TypedParam>

body: Vec<SNode>

fn_syntax: bool

When true, this closure was written as fn(params) { body }. The formatter preserves this distinction.

Trait Implementations

impl Clone for Node

fn clone(&self) -> Node

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Node

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

Formats the value using the given formatter.

impl PartialEq for Node

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