ternlang_core/
ast.rs

1#[derive(Debug, Clone, PartialEq)]
2pub enum Expr {
3    TritLiteral(i8),
4    IntLiteral(i64),
5    FloatLiteral(f64),
6    StringLiteral(String),
7    Ident(String),
8    BinaryOp {
9        op: BinOp,
10        lhs: Box<Expr>,
11        rhs: Box<Expr>,
12    },
13    UnaryOp {
14        op: UnOp,
15        expr: Box<Expr>,
16    },
17    Call {
18        callee: String,
19        args: Vec<Expr>,
20    },
21    /// field access: `object.field`
22    FieldAccess {
23        object: Box<Expr>,
24        field: String,
25    },
26    /// cast(expr) — type coercion built-in
27    Cast {
28        expr: Box<Expr>,
29        ty: Type,
30    },
31    /// spawn AgentName — creates a local agent instance, evaluates to AgentRef
32    /// spawn remote "addr" AgentName — creates a remote agent instance (Phase 5.1)
33    Spawn {
34        agent_name: String,
35        /// None = local, Some("host:port") = remote node
36        node_addr: Option<String>,
37    },
38    /// await <agentref_expr> — receive result from agent mailbox
39    Await {
40        target: Box<Expr>,
41    },
42    /// tensor[row, col] indexing (Phase 4.1)
43    Index {
44        object: Box<Expr>,
45        row: Box<Expr>,
46        col: Box<Expr>,
47    },
48    /// nodeid — returns the current node's address (Phase 5.1)
49    NodeId,
50    /// expr? — ternary error propagation.
51    /// If the inner expression evaluates to -1 (conflict), the current function
52    /// returns -1 immediately.  Otherwise execution continues with the value.
53    Propagate {
54        expr: Box<Expr>,
55    },
56    /// [1, 0, -1]
57    TritTensorLiteral(Vec<i8>),
58    /// Struct initialization: `Name { field: value, ... }`
59    StructLiteral {
60        name: String,
61        fields: Vec<(String, Expr)>,
62    },
63}
64
65#[derive(Debug, Clone, Copy, PartialEq)]
66pub enum BinOp {
67    Add,
68    Sub,
69    Mul,
70    Div,
71    Mod,
72    Equal,
73    NotEqual,
74    Less,
75    Greater,
76    LessEqual,
77    GreaterEqual,
78    And,
79    Or,
80}
81
82#[derive(Debug, Clone, Copy, PartialEq)]
83pub enum UnOp {
84    Neg,
85}
86
87#[derive(Debug, Clone, PartialEq)]
88pub enum Stmt {
89    Let {
90        name: String,
91        ty: Type,
92        value: Expr,
93    },
94    IfTernary {
95        condition: Expr,
96        on_pos: Box<Stmt>,   // branch when +1
97        on_zero: Box<Stmt>,  // branch when  0
98        on_neg: Box<Stmt>,   // branch when -1
99    },
100    Match {
101        condition: Expr,
102        arms: Vec<(Pattern, Stmt)>,
103    },
104    /// for <var> in <iter_expr> { body }
105    ForIn {
106        var: String,
107        iter: Expr,
108        body: Box<Stmt>,
109    },
110    /// while <condition> ? { on_pos } else { on_zero } else { on_neg }
111    WhileTernary {
112        condition: Expr,
113        on_pos: Box<Stmt>,
114        on_zero: Box<Stmt>,
115        on_neg: Box<Stmt>,
116    },
117    /// loop { body } — infinite loop, exited via break
118    Loop {
119        body: Box<Stmt>,
120    },
121    Break,
122    Continue,
123    Block(Vec<Stmt>),
124    Return(Expr),
125    Expr(Expr),
126    Decorated {
127        directive: String,
128        stmt: Box<Stmt>,
129    },
130    /// use path::to::module;
131    Use {
132        path: Vec<String>,
133    },
134    /// from <source> import <names>;
135    FromImport {
136        spec: ImportSpec,
137    },
138    /// send <agentref_expr> <message_expr>;
139    Send {
140        target: Expr,
141        message: Expr,
142    },
143    /// instance.field = value;
144    FieldSet {
145        object: String,
146        field: String,
147        value: Expr,
148    },
149    /// tensor[row, col] = value;
150    IndexSet {
151        object: String,
152        row: Expr,
153        col: Expr,
154        value: Expr,
155    },
156    /// ident = value;
157    Set {
158        name: String,
159        value: Expr,
160    },
161}
162
163#[derive(Debug, Clone, PartialEq)]
164pub enum Pattern {
165    Int(i64),
166    Trit(i8),
167    Float(f64),
168}
169
170#[derive(Debug, Clone, PartialEq)]
171pub enum Type {
172    Trit,
173    TritTensor { dims: Vec<usize> },
174    Int,
175    IntTensor { dims: Vec<usize> },
176    Bool,
177    Float,
178    FloatTensor { dims: Vec<usize> },
179    String,
180    /// User-defined struct type
181    Named(String),
182    /// Handle to a running agent instance
183    AgentRef,
184}
185
186#[derive(Debug, Clone, PartialEq)]
187pub struct Function {
188    pub name: String,
189    pub params: Vec<(String, Type)>,
190    pub return_type: Type,
191    pub body: Vec<Stmt>,
192    pub directive: Option<String>,
193}
194
195/// Top-level struct definition: `struct Name { field: type, ... }`
196#[derive(Debug, Clone, PartialEq)]
197pub struct StructDef {
198    pub name: String,
199    pub fields: Vec<(String, Type)>,
200}
201
202/// Top-level agent definition: `agent Name { fn handle(msg: trit) -> trit { ... } }`
203/// v0.1: agents have a single `handle` method that processes each incoming message.
204#[derive(Debug, Clone, PartialEq)]
205pub struct AgentDef {
206    pub name: String,
207    pub methods: Vec<Function>,
208}
209
210/// Source of a `from ... import` statement.
211#[derive(Debug, Clone, PartialEq)]
212pub enum ImportSource {
213    /// `from stdlib::net` — double-colon module path (stdlib or relative .tern)
214    Module(Vec<String>),
215    /// `from "path/to/file.tern"` — explicit file path (string literal)
216    File(String),
217}
218
219/// What to pull out of the import source.
220#[derive(Debug, Clone, PartialEq)]
221pub enum ImportNames {
222    /// `import *` — everything (same as legacy `use`)
223    Wildcard,
224    /// `import foo, bar` — only these named symbols
225    Named(Vec<String>),
226}
227
228/// A `from <source> import <names>` statement.
229#[derive(Debug, Clone, PartialEq)]
230pub struct ImportSpec {
231    pub source: ImportSource,
232    pub names: ImportNames,
233}
234
235#[derive(Debug, Clone, PartialEq)]
236pub struct Program {
237    /// Legacy `use std::trit;` paths (kept for backward compat)
238    pub imports: Vec<Vec<String>>,
239    /// New `from ... import ...` statements
240    pub import_specs: Vec<ImportSpec>,
241    pub structs: Vec<StructDef>,
242    pub agents: Vec<AgentDef>,
243    pub functions: Vec<Function>,
244}
ternlang_core/ast.rs

ternlang_core/
ast.rs
