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:
1 parent
3e2779f447
commit
eaf9567a36
117 files changed
+19970
No files matched your search
@@ -0,0 +1,140 @@
|
||||
# 8. Memory: copies, sharing, and weak pointers
|
||||
|
||||
You never write `free`, `new` or `&`. Here is what the compiler does for you.
|
||||
|
||||
## One owner
|
||||
|
||||
Every value has exactly one owner: a variable, a field, a list slot. When the owner's block
|
||||
ends, the value is freed. That is true for strings, lists, maps, structs, enums and errors,
|
||||
and it also happens on an early `return`, `break`, `continue` or `?`.
|
||||
|
||||
Giving a value a new owner **copies** it:
|
||||
|
||||
```dino
|
||||
func main() {
|
||||
var a = [1, 2, 3]
|
||||
var b = a // b is a real copy
|
||||
b.push(4)
|
||||
print(a, b)
|
||||
}
|
||||
```
|
||||
```text
|
||||
[1, 2, 3] [1, 2, 3, 4]
|
||||
```
|
||||
|
||||
You don't pay for copies you don't need:
|
||||
|
||||
- If `a` is never used again, `var b = a` just *moves* the value, with no copying.
|
||||
- A function that only reads a parameter gets it without a copy.
|
||||
- Returning a local variable moves it out.
|
||||
- Strings are immutable and counted, so copying one only bumps a counter.
|
||||
|
||||
All tests of the compiler run under a memory checker, so leaks and double frees are caught.
|
||||
|
||||
## shared: one value, several owners
|
||||
|
||||
Sometimes you really do want several owners of **one** value (a texture used by many
|
||||
sprites, a window and its buttons). Write `shared`:
|
||||
|
||||
```dino
|
||||
struct Texture {
|
||||
name: string
|
||||
uses: int
|
||||
|
||||
func touch() { uses += 1 }
|
||||
}
|
||||
|
||||
struct Sprite {
|
||||
tex: shared Texture
|
||||
x: int
|
||||
}
|
||||
|
||||
func main() {
|
||||
var tex = shared Texture{"grass", 0}
|
||||
var a = Sprite{tex, 1}
|
||||
var b = Sprite{tex, 2}
|
||||
a.tex.touch()
|
||||
b.tex.touch()
|
||||
print(tex.uses, a.tex.uses)
|
||||
}
|
||||
```
|
||||
```text
|
||||
2 2
|
||||
```
|
||||
|
||||
- `shared Texture{...}` creates the shared value. The type is written `shared Texture`.
|
||||
- `var b = a`, passing it to a function, or putting it in a list or field gives another
|
||||
**owner** instead of copying the value.
|
||||
- A change through any owner is seen by all.
|
||||
- The value is freed when the **last** owner goes away.
|
||||
- Use it just like the value inside: `tex.name`, `tex.touch()`.
|
||||
- Only structs and enums can be shared for now.
|
||||
|
||||
## weak: pointing without owning
|
||||
|
||||
If a window owns its buttons and each button owns its window, neither would ever be freed.
|
||||
Make one side `weak`: it points at the value without keeping it alive.
|
||||
|
||||
```dino
|
||||
struct Window {
|
||||
title: string
|
||||
buttons: []shared Button
|
||||
|
||||
func add(b: shared Button) { buttons.push(b) }
|
||||
}
|
||||
|
||||
struct Button {
|
||||
label: string
|
||||
window: weak Window
|
||||
|
||||
func click() {
|
||||
if window != nil {
|
||||
print(label, "clicked in", window.title)
|
||||
} else {
|
||||
print(label, "clicked, window is gone")
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
func main() {
|
||||
var win = shared Window{"Main", []}
|
||||
var ok = shared Button{"OK", weak win}
|
||||
win.add(ok)
|
||||
ok.click()
|
||||
|
||||
win = shared Window{"Other", []} // the first window is freed
|
||||
ok.click()
|
||||
}
|
||||
```
|
||||
```text
|
||||
OK clicked in Main
|
||||
OK clicked, window is gone
|
||||
```
|
||||
|
||||
- `weak x` makes a weak pointer to the shared value `x`.
|
||||
- A weak pointer is **nilable**: `w == nil` tells you the value is gone. `weak T` and
|
||||
`weak T?` mean the same thing, and it starts as `nil`.
|
||||
- Using a gone weak pointer stops the program with a clear message.
|
||||
- To use the value as an owner, call `w.upgrade()`. It gives a `shared T?`: the value
|
||||
(now with one more owner, so it can't vanish while you hold it) or `nil`.
|
||||
|
||||
```dino
|
||||
struct Node { name: string }
|
||||
|
||||
func main() {
|
||||
var n = shared Node{"root"}
|
||||
var w = weak n
|
||||
var again = w.upgrade()
|
||||
if again != nil {
|
||||
print(again.name)
|
||||
}
|
||||
}
|
||||
```
|
||||
```text
|
||||
root
|
||||
```
|
||||
|
||||
**Rule of thumb:** the owner of something holds it `shared`; anything that merely points
|
||||
back at it (a child to its parent, a button to its window) holds it `weak`.
|
||||
|
||||
Next: [Generics and interfaces](09-generics-and-interfaces.md)
|
||||
Reference in new issue
Block a user