const_assert

Falhe a build se um invariante em tempo de compilação não for satisfeito — zero custo em produção.

const_assert <expr> avalia uma expressão booleana no compilador. Se o resultado for false, a compilação falha com E_AssertFailed e a mensagem opcional que você forneceu — antes de qualquer binário ser gerado. Se for true, não produz nenhum código: custo zero em tempo de execução.

Use const_assert para proteger invariantes sobre constantes, tamanhos de buffer, versões de protocolo e qualquer outra propriedade que você possa verificar em tempo de compilação. Ele complementa o assert() de tempo de execução: enquanto assert() verifica condições que dependem de entrada em tempo de execução, const_assert verifica propriedades que nunca deveriam mudar entre compilações.

Invariantes sobre literais, bindings const e uso dentro de funções; diagnósticos comentados no final.

08-const-assert.zolo

Playground

// Feature: `const_assert` — compile-time assertions
// Syntax: `const_assert <expr> [, "message"]`
// When to use: validate compile-time invariants over `const`s and other
// comptime-constant expressions. If the expression evaluates to `false`,
// the build fails with `E_AssertFailed`. Successful asserts produce no
// runtime code — zero cost.
//
// See `specs/const-assert.md` for the full specification.

// Simple assertion over a literal.
const_assert 1 + 1 == 2
const_assert true

// Assertion with an optional human-readable message.
const_assert 10 > 5, "ten must be greater than five"

// Assertions can reference `const` bindings — the comptime engine
// looks them up automatically.
const MAX_BUFFER = 4096
const MIN_BUFFER = 64

const_assert MAX_BUFFER > MIN_BUFFER
const_assert MAX_BUFFER >= 256, "buffer too small for protocol header"
const_assert MAX_BUFFER % 2 == 0, "buffer size must be even"

// `const_assert` is valid inside functions too. Useful when generic
// or template-like code needs to enforce an invariant per call site.
fn validate() {
  const_assert MAX_BUFFER < 1000000
  print("validate ran (asserts already passed at compile time)")
}

validate()
print("PORT validated: max_buffer={MAX_BUFFER}, min={MIN_BUFFER}")
// expected:
// validate ran (asserts already passed at compile time)
// PORT validated: max_buffer=4096, min=64

// Diagnostics (uncomment to see):
//
// 1. `E_AssertFailed` — the expression evaluated to `false`.
//
//    const_assert false, "this must fail"
//    // error[E_AssertFailed]: static assertion failed: this must fail
//
// 2. `E_AssertNotBool` — the expression is not a bool.
//
//    const_assert 42
//    // error[E_AssertNotBool]: `const_assert` expects `bool`, got `Int`
//
// 3. `E_AssertNotConst` — the expression depends on runtime state.
//
//    let runtime_val = some_fn()
//    const_assert runtime_val == 3
//    // error[E_AssertNotConst]: expression in `const_assert` is not
//    //                          comptime-constant

// Difference vs. `assert()` (runtime):
//   const_assert  — evaluated at BUILD time, blocks compilation if false.
//   assert(cond)  — evaluated at RUN time, raises a panic if false.
//
// Use `const_assert` for invariants over `const`s, types, and buffer
// sizes. Use `assert()` for runtime preconditions that depend on input.

Três erros de compilação possíveis resumem as regras:

E_AssertFailed — a expressão avaliou como false.
E_AssertNotBool — a expressão não é booleana (ex.: const_assert 42).
E_AssertNotConst — a expressão depende de estado de tempo de execução.

Desafio

Adicione const MIN_BUFFER = 4096 e um const_assert MIN_BUFFER < MAX_BUFFER que falhe. Observe a mensagem de erro do compilador e corrija o valor.

Encontre seu caminho pela Zolo

Comece por aqui