Files
rexlang/docs/06-structs-and-enums.md
Your NameandClaude Opus 5.5 7cf9727bcd Rename the language from Dino to Rex
Files use .rex, the command is rex, and the crate, runtime prefixes,
docs, editor files and examples all use the new name.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-11-08 13:51:23 +01:00

140 lines
3.0 KiB
Markdown

# 6. Structs and enums
## Structs
A struct groups related values. **Methods go inside the struct** and see the fields directly.
```rex
struct Player {
name: string
hp: int
x, y: float // names in a row share a type
func hurt(amount: int) { // changes hp, so Rex 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
```rex
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
```rex
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.
```rex
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)