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
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
<!--
```rs
let std = import("std");
let fmt = import("fmt");
let http = import("http");
let server = http::server();
server::route("/hello/:name", fn(params) = {
fn(request, response) = {
params::method |> match {
"GET" => fmt::format("Hello, {}!", params::name),
_ => "Method not allowed"
} |> response::send;
}
});
server::start(3003);
```
```rs
let std = import("std");
let fmt = import("fmt");
let http = import("http");
let server = http::server();
server::route("/hello/:name", fn({ params, query }) = {
let greeting = query::get("greeting")::unwrap_or("");
fn(request, response) = {
params::method |> match _ {
"GET" => {
let message = fmt::format("{} {}!", greeting, params::name);
message |> response::send;
},
_ => response::send("Method not allowed"),
}
}
});
server::start(3003);
```
#### Lemon IR
- lemon
```rs
fn compute(a: u32, b: u32): u32 = {
let mut sum = a + b;
if sum > 100 {
let diff = sum - 50;
return diff;
}
sum
}
fn main(): u32 = {
let x = 42;
let y = 58;
let result = compute(x, y);
result
}
```
- ir
```rs
fn compute r0: u32, r1: u32 -> u32
l0: add r0, r1 -> r2
l1: cmp_gt r2, 100 -> r3
jmp_if r3, l2, l3
l2: sub r2, 50 -> r4
free r2
ret r4
l3: ret r2
fn main -> u32
l0: own 42 -> r0
own 58 -> r1
call compute r0, r1 -> r2
free r0
free r1
ret r2
```
- optimizer steps
1. remove unused variables
```rs
fn compute r0: u32, r1: u32 -> u32
l0: add r0, r1 -> r2
l1: cmp_gt r2, 100 -> r3
jmp_if r3, l2, l3
l2: sub r2, 50 -> r4
ret r4
l3: ret r2
fn main -> u32
l0: own 42 -> r0
own 58 -> r1
call compute r0, r1 -> r2
free r0
free r1
ret r2
```
2. constant propagation
```rs
fn main -> u32
l0: add 42, 58 -> r0 # inline compute directly in main
l1: cmp_gt r0, 100 -> r1
jmp_if r1, l2, l3
l2: sub r0, 50 -> r2
ret r2
l3: ret r0
```
3. dead block elimination
```rs
fn main -> u32
l0: add 42, 58 -> r0 # constant propagation simplifies flow
l1: sub r0, 50 -> r1
ret r1
```
4. fn inlining
```rs
fn main -> u32
l0: add 42, 58 -> r0 # compute body is directly inlined
l1: sub r0, 50 -> r1
ret r1
```
5. constant folding
```rs
fn main -> u32
l0: own 50 -> r0 # compute constant values at compile time
ret r0
```
- compiler
1. llvm
2. wasm
3. lemon runtime (dev mode)
-->
#### Versioning strategy
- Start at **0.0.1** and increment the last number for each new feature (e.g., `0.0.2` for adding enums).
- Increase the middle number (e.g., `0.1.0`) after reaching a stable milestone with multiple improvements.
- When the language is stable and production-ready, move to **1.0.0**.
- Use Git tags like `v0.0.1`, `v0.1.0`, and maintain a changelog for tracking updates.
- No rush for version 1.0 – focus on steady growth and reliability.