Run Makoto in the browser. Not yet.

1
2
3
4
5

use io

fn main() {
    io.println("hello from makoto")
}

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

//@ kind: run
// =============================================================================
// Makoto — Mix-match de memory-managers e transmissão de dados entre eles (§5)
// =============================================================================
// Objetivo (avaliação de DX): mostrar, num único programa executável, como o
// dado circula entre as estratégias de memória — gc (padrão), arena, none
// (manual) — e os verbos de fronteira: @promote, @transfer, @pin, @limit, free.
//
// Princípio-norte (§5): a estratégia é COLORLESS. O TIPO é `[*]int`/`Rec` em
// toda parte; o que muda é ONDE a memória vive, decidido por @mm no ESCOPO, não
// no tipo. Você "só paga pelo que invoca": sem anotação, é gc.
//
// Rode:  mk run docs/examples/mm_mixmatch.mko
// =============================================================================
use io
use mm

decl Rec { a: int; b: int }

// -----------------------------------------------------------------------------
// (1) gc — o PADRÃO. Nenhuma anotação: o coletor cuida do ciclo de vida.
//     Uma função gc pode simplesmente RETORNAR um valor gc; ele sobrevive à
//     função porque o coletor o mantém vivo enquanto houver referência.
// -----------------------------------------------------------------------------
fn make_gc() -> [*]Rec {
	var r: [*]Rec = mm.alloc(1)   // aloca no heap gc (padrão)
	r[0].a = 1
	r[0].b = 2
	return r                       // transmissão por RETURN: sai da fn, o gc o segura
}

// -----------------------------------------------------------------------------
// (2) none — manual. `@mm(none)` desliga o coletor NESTE escopo: você aloca e
//     LIBERA explicitamente (free / mm.release). Se a memória precisa SAIR do
//     escopo viva, você PROMOVE para o gc na fronteira (@promote(gc)) — a única
//     forma sound de um valor manual "escapar" para o mundo coletado.
// -----------------------------------------------------------------------------
@mm(none) fn make_escaping() -> [*]Rec {
	var tmp: [*]Rec = mm.alloc(1)      // memória manual, local a esta fn
	tmp[0].a = 10
	tmp[0].b = 20
	// @promote(gc): MOVE a alocação manual para o heap gc. `tmp` deixa de ser
	// sua responsabilidade (não precisa free) e o resultado sobrevive ao return.
	let escaped: [*]Rec = tmp @promote(gc)
	return escaped
}

// -----------------------------------------------------------------------------
// (3) Um worker que roda em OUTRO processo. Heaps são ISOLADOS entre processos
//     (§5/§8): o que cruza o `spawn` é COPIADO PROFUNDO por padrão, ou MOVIDO
//     com @transfer (evita a cópia e invalida a origem). Aqui recebe um Rec por
//     valor e devolve a soma por um canal.
// -----------------------------------------------------------------------------
fn sum_worker(out: Channel[<-int], p: Rec) {
	out <- p.a + p.b
}

@mm(none) fn main() {
	// ---- gc padrão: pega o valor retornado por uma fn gc ----
	let g: [*]Rec = make_gc()
	io.println("gc:      {{ g[0].a + g[0].b }}")        // 3

	// ---- none → gc via @promote na fronteira do return ----
	let promoted: [*]Rec = make_escaping()
	io.println("promote: {{ promoted[0].a + promoted[0].b }}")  // 30

	// ---- arena: alocação por bump, liberada em BLOCO no fim do escopo. ----
	// Ninguém libera célula por célula; o `}` do bloco recupera tudo de uma vez.
	@mm(arena) {
		let scratch: [*]int = mm.alloc(8)
		loop i in 0..8 { scratch[i] = i * 3 }
		var s := 0
		loop i in 0..8 { s = s + scratch[i] }
		io.println("arena:   {{ s }}")                  // 84  (0+3+..+21)
	}   // <- arena inteira recuperada aqui; nada de free manual

	// ---- none manual: aloca, usa, LIBERA você mesmo ----
	// (estamos numa fn @mm(none): mm.alloc aqui é memória manual)
	let buf: [*]int = mm.alloc(4)
	loop i in 0..4 { buf[i] = i + 100 }
	var bs := 0
	loop i in 0..4 { bs = bs + buf[i] }
	io.println("none:    {{ bs }}")                     // 406
	mm.release(buf)                                     // devolve a memória manual

	// ---- @pin: manter um objeto gc vivo através de uma tempestade de alocações ----
	let keep: [*]int = mm.alloc(2) @promote(gc)   // promovido pro gc p/ o coletor gerir
	keep[0] = 1000
	keep[1] = 337
	@pin keep                                     // o coletor não pode mover/recolher enquanto pinado
	loop k in 0..500 {
		let churn: [*]int = mm.alloc(4) @promote(gc)
		churn[0] = k                              // lixo: vira candidato à coleta
	}
	io.println("pin:     {{ keep[0] + keep[1] }}")      // 1337  (sobreviveu à churn)
	@unpin keep

	// ---- transmissão CRUZANDO um processo: deep-copy (padrão) vs @transfer ----
	let out: Channel[int] = Channel.new(1)
	let p := Rec{a: 40; b: 2}
	// @transfer: MOVE p para o processo filho (sem cópia profunda); p fica
	// inválido aqui depois — o dado viaja com sua memória para o outro heap.
	spawn sum_worker(out, p @transfer)
	let r := -> out catch |e| { return }
	io.println("spawn:   {{ r }}")                      // 42

	// ---- @limit: teto de alocação para um escopo/spawn (falha controlada se estourar) ----
	@limit(1mb)
	{
		let bounded: [*]int = mm.alloc(16)
		bounded[0] = 7
		io.println("limit:   {{ bounded[0] }}")         // 7
	}
}

1
2
3
4
5
6

fn parse_port(s: string) -> Result[u16, error{Empty, NotNumber, OutOfRange}] {
    if s == "" { return Err(error.Empty) }
    // ...
}

port := parse_port(input) catch |e| { return default_port() }

1
2
3
4
5

spawn worker(data) catch |e| {
    log("worker died: {{e}}")
}

reply := server <-> request timeout(5s)   // sync request-reply, deadline mandatory

1
2
3

decl Point    { x: int; y: int }      // fields     -> struct
decl Shape    { Circle(int); Square } // variants   -> enum
decl Drawable { fn draw() }           // signatures -> interface

1
2
3
4
5
6
7
8
9

decl Transaction @must_consume { conn: *Connection }

fn commit(t: Transaction @consume)   { … }
fn rollback(t: Transaction @consume) { … }

fn handle(t: Transaction) {
    if ok { commit(t) }
    // ERROR: on the else path, t is never consumed
}