thal 0.0.1

Reactive semantic runtime — molecules, reactions, and effect actors for building LLM-backed applications as dataflow programs.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130

use crate::value::PrimitiveType;

#[derive(Clone, Debug, Default)]
pub struct Program {
    pub types: Vec<TypeDecl>,
    pub mixins: Vec<MixinDecl>,
    pub molecules: Vec<MoleculeDecl>,
    pub reactions: Vec<ReactionDecl>,
}

#[derive(Clone, Debug)]
pub struct MixinDecl {
    pub name: String,
    pub fields: Vec<FieldDecl>,
    pub primary_key: Option<Vec<String>>,
    pub merge: Option<MergeFn>,
}

#[derive(Clone, Debug)]
pub struct TypeDecl {
    pub name: String,
    pub body: TypeDeclBody,
}

#[derive(Clone, Debug)]
pub enum TypeDeclBody {
    Enum(Vec<String>),
    // alias and refinement variants land in plan 05
}

#[derive(Clone, Debug)]
pub struct MoleculeDecl {
    pub name: String,
    pub mixins: Vec<String>,
    pub fields: Vec<FieldDecl>,
    pub primary_key: Option<Vec<String>>,
    pub merge: Option<MergeFn>,
}

#[derive(Clone, Debug)]
pub struct FieldDecl {
    pub name: String,
    pub ty: TypeExpr,
    pub default: Option<Expr>,
}

#[derive(Clone, Debug)]
pub enum TypeExpr {
    Primitive(PrimitiveType),
    Named(String),
    List(Box<TypeExpr>),
    Optional(Box<TypeExpr>),
}

#[derive(Clone, Debug)]
pub struct MergeFn {
    pub old_binding: String,
    pub new_binding: String,
    pub body: Expr,
}

#[derive(Clone, Debug)]
pub struct ReactionDecl {
    pub name: String,
    pub when: Vec<MoleculePattern>,
    pub rollup: Option<RollupClause>,
    pub where_clause: Option<Expr>,
    pub emit: Vec<EmitClause>,
}

#[derive(Clone, Debug)]
pub struct RollupClause {
    pub molecule_name: String,
    pub binding: String,
    pub predicate: Expr,
}

#[derive(Clone, Debug)]
pub struct MoleculePattern {
    pub molecule_name: String,
    pub binding: String,
}

#[derive(Clone, Debug)]
pub struct EmitClause {
    pub molecule_name: String,
    pub fields: Vec<FieldAssign>,
}

#[derive(Clone, Debug)]
pub struct FieldAssign {
    pub name: String,
    pub value: Expr,
}

#[derive(Clone, Debug)]
pub enum Expr {
    LitNull,
    LitBool(bool),
    LitInt(i64),
    LitFloat(f64),
    LitString(String),
    LitDuration(i64),
    Ident(String),
    FieldAccess(Box<Expr>, String),
    Call(String, Vec<Expr>),
    BinaryOp(BinaryOp, Box<Expr>, Box<Expr>),
    UnaryOp(UnaryOp, Box<Expr>),
    StructLit(String, Vec<FieldAssign>),
    ListLit(Vec<Expr>),
    ListComp {
        var: String,
        src: Box<Expr>,
        body: Box<Expr>,
        where_clause: Option<Box<Expr>>,
    },
}

#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub enum BinaryOp {
    Add, Sub, Mul, Div,
    Eq, Ne, Lt, Le, Gt, Ge,
    And, Or,
}

#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub enum UnaryOp {
    Not,
    Neg,
}