Dino compiler: language, formatter, language server, docs, editor support

Compiler in Rust (lexer, parser, checker, C codegen), maps, chars,
dino fmt, dino lsp (diagnostics, formatting, outline, definition,
hover, completion, signature help), docs, examples, VS Code/Vim files.

Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>
This commit is contained in:
Your NameandClaude Sonnet 5.5 committed 2026-11-07 23:46:12 +01:00
1 parent 3e2779f447
commit eaf9567a36
117 files changed
+19970

No files matched your search

+139
View File
@@ -0,0 +1,139 @@
# 6. Structs and enums
## Structs
A struct groups related values. **Methods go inside the struct** and see the fields directly.
```dino
struct Player {
name: string
hp: int
x, y: float // names in a row share a type
func hurt(amount: int) { // changes hp, so Dino knows it modifies the player
hp -= amount
}
func alive(): bool {
return hp > 0
}
}
func main() {
var p = Player{name: "Ada", hp: 10} // fields left out start at zero
p.hurt(4)
print(p.hp, p.alive())
print(p)
}
```
```text
6 true
Player{name: Ada, hp: 6, x: 0.0, y: 0.0}
```
Ways to build one:
- Named: `Player{name: "Ada", hp: 10}`. Any field may be left out; it starts at `0`, `0.0`,
`false`, `""` or an empty list.
- Positional: `Vec2{1.0, 2.0}`. Every field must be given.
**You never write `mut`.** A method that assigns to a field is detected as changing the
struct, and the compiler stops you from calling it on a `const` or on a temporary.
Inside a method, a bare name means: a local or parameter first, then a field, then another
method of the same struct (`hurt(2)`), then a global function.
### Structs are values
```dino
struct Point { x, y: int }
func main() {
var a = Point{1, 2}
var b = a
b.x = 99
print(a, b)
}
```
```text
Point{x: 1, y: 2} Point{x: 99, y: 2}
```
`var b = a` is a real copy. If you want one value with several owners, see
[`shared`](08-memory.md).
### Methods that return values, and nested data
```dino
struct Vec2 {
x, y: float
func length_squared(): float {
return (x * x + y * y)
}
func plus(o: Vec2): Vec2 {
return Vec2{x + o.x, y + o.y}
}
}
struct Ship {
pos: Vec2
trail: []Vec2
}
func main() {
var s = Ship{pos: Vec2{1.0, 1.0}}
s.trail.push(s.pos)
s.pos = s.pos.plus(Vec2{2.0, 0.0})
print(s.pos, s.trail, s.pos.length_squared())
}
```
```text
Vec2{x: 3.0, y: 1.0} [Vec2{x: 1.0, y: 1.0}] 10.0
```
`==` on whole structs is not available yet; compare the fields.
## Enums
An enum is "one of these cases", and each case can carry data.
```dino
enum Event {
Quit
Key(code: int)
Click(x, y: int)
func describe(): string {
return match self {
Quit => "quit"
Key(c) => "key {c}"
Click(x, y) => "click at {x},{y}"
}
}
}
func main() {
var e = Event.Click(3, 4)
print(e.describe())
print(Event.Key(65), Event.Quit)
}
```
```text
click at 3,4
Event.Key(65) Event.Quit
```
- Build a value with the qualified name: `Event.Key(65)`, `Event.Quit`.
- Take it apart with [`match`](03-control-flow.md#match), which must cover every case.
- Inside an enum's methods, `self` is the whole value.
- The zero value of an enum is its first case.
- `==` works on enums whose cases carry no data.
## Privacy
Everything is private to its file unless you write `pub`. This matters once you split a
program into several files ([next chapters](10-modules-and-stdlib.md)). Inside one file you
never need `pub`.
Next: [Errors and nil](07-errors-and-nil.md)