Visão geral da linguagem Zig

Zig 0.14 — linguagem de sistemas | nenhum fluxo de controle oculto | sem alocações ocultas | sem pré-processador | execução em tempo de compilação

Paradigma

Imperativo, processual, orientado a dados. Digitação estática com inferência, digitação estrutural (duck) via comptime. Compilação via LLVM + backend auto-hospedado. Sem sobrecarga de operador, sem exceções, sem RAII, sem macros.

Tipos

Declarações

Fluxo de controle

Alternar recursos

• Exaustividade verificada em tempo de compilação
• Vários itens por braço: 1, 2 => ...
• Armas de alcance: 0...10 => ...
• Capturar nomes de pinos: inline else => \|tag\| ...

Operadores

Comptime (Metaprogramação)

fn max(comptime T: type, a: T, b: T) T {
    return if (a > b) a else b;
}

comptime {
    // Runs at compile time
    @compileLog("building for", @tagName(builtin.cpu));
}

// Generics via comptime parameters
fn ArrayList(comptime T: type) type {
    return struct {
        items: []T,
        fn init(self: *Self) void { ... }
    };
}

Recursos do Comptime

• comptime blocos são executados durante a compilação
• comptime parâmetros de função são conhecidos em tempo de compilação
• inline for / inline while desenrola loops em tempo de compilação
• @Type(...) construir tipos em Comptime
• @fieldParentPtr pesquisa de campo reversa
• @hasDecl @hasField reflexão em tempo de compilação
• @typeInfo obtém informações de tipo como uma estrutura

Memória

Alocadores

std.heap.page_allocator std.heap.arena_allocator std.heap.FixedBufferAllocator std.heap.ArenaAllocator std.heap.StackFallbackAllocator std.heap.c_allocator

Filosofia do alocador de Zig

• Cada alocação recebe um parâmetro de alocador explícito
• Sem alocador global, sem alocações implícitas
• Alocadores compõem (piscina → arena → página)

Tratamento de erros

// Error union type: ReturnType!Error
fn div(a: i32, b: i32) !i32 {
    if (b == 0) return error.DivisionByZero;
    return a / b;
}

// Try operator: early return on error
const result = try div(10, 2);

// Catch: provide default
const val = div(10, 0) catch 0;

// Global error set vs specific
fn parse() ParseError!i32 { ... }

Adiar e Errdefer

{
    const buf = try allocator.alloc(u8, 100);
    defer allocator.free(buf);  // always runs at scope exit
    errdefer allocator.free(buf);  // runs only if error returned

    // ... use buf
}  // defer triggers here

Biblioteca Padrão (selecionada)

Teste

test "basic addition" {
    try std.testing.expectEqual(4, add(2, 2));
    try std.testing.expect(add(1, 1) == 2);
    try std.testing.expectError(error.DivisionByZero, div(1, 0));
}

zig test file.zig        # run tests
zig build test           # run all tests in project
zig test --name "filter" # filter test names

Compilação Cruzada

zig build-exe main.zig --target x86_64-windows  # cross-compile to Windows
zig build-exe main.zig --target aarch64-linux    # cross-compile to ARM64 Linux
zig build-exe main.zig --target riscv64-linux    # cross-compile to RISC-V

O Zig vem com cabeçalhos libc e conjuntos de ferramentas de compilação cruzada para todos os principais alvos — não é necessário um compilador cruzado separado.

Interoperabilidade C

// Import C header
const c = @cImport({
    @cInclude("stdio.h");
});

// Link C library
pub fn main() void {
    _ = c.printf("hello %d\n", 42);
}

// Direct use of C ABI
extern "c" fn strlen(s: [*:0]u8) usize;

// Zig is a better C:
// - @cImport for headers
// - export fn for C-ABI exports
// - [*:0]T for null-terminated strings
// - @ptrCast for pointer conversion
// - packed struct for ABI-compatible layouts

Diferenças notáveis ​​de C

• Sem pré-processador (use comptime)
• Nenhuma conversão implícita (explícita @intCast @floatCast)
• Nenhum UB por padrão (verificações de segurança na depuração, aceitação @setRuntimeSafety)
• defer substitui goto cleanup padrões
• anytype substitui void* + macro genéricos
• O tipo de matriz inclui comprimento ([N]T vs T[N])
• undefined em vez de não inicializado
• null de opcional ?*T, não ponteiro

Compilação

zig build-exe main.zig     # compile executable
zig build-lib lib.zig       # compile library
zig build-obj obj.zig       # compile object
zig run main.zig            # compile + run
zig test file.zig           # compile + run tests
zig fmt file.zig            # format code
zig build                   # build project (build.zig)
zig translate-c foo.h       # translate C header to Zig

Modos de construção