Recursão, laços e tabelas

Fibonacci comptime: fib(10) e fib(15) baked diretamente no binário.

// Feature: comptime recursion — a `@comptime fn` calling itself

// Syntax: same as above; recursion is fine, but you must terminate.

// When to use: classic precomputed sequences (Fibonacci, factorials,

// CRC tables) — the runtime sees only the final number.


@comptime
fn fib(n: int) -> int {
    if n <= 1 { return n }
    return fib(n - 1) + fib(n - 2)
}

let f10 = comptime fib(10)
print(f10)
// expected: 55


let f15 = comptime fib(15)
print(f15)
// expected: 610

Laço comptime: soma 1..=100 no compilador, o programa recebe o literal 5050.

// Feature: comptime loops — a `for` inside a comptime block

// Syntax: any control flow is fair game; the block runs in the

// compiler. The tail expression is the value baked in.

// When to use: precomputed sums, lookup tables, anything where the

// answer is known at build time and you want the binary to ship a

// literal instead of a loop.


// Gauss sum 1..=100, computed at build time.

let total = comptime {
    var s = 0
    for i in 1..=100 {
        s = s + i
    }
    s
}

print(total)
// expected: 5050

Array dos quadrados de 1 a 5 gerado em tempo de compilação.

// Feature: comptime arrays — emit a literal `[v1, v2, ...]`

// Syntax: build the array inside `comptime { ... }`, end with the

// array as the tail expression. The runtime sees a baked literal.

// When to use: lookup tables (squares, primes, lookup-by-index

// for hot paths), CRC tables, palette tables.


let squares = comptime {
    var out = []
    for n in 1..=5 {
        out = out.push(n * n)
    }
    out
}

print(squares[0])  // expected: 1

print(squares[1])  // expected: 4

print(squares[2])  // expected: 9

print(squares[3])  // expected: 16

print(squares[4])  // expected: 25