---
title: "anytype em Zig — O que é e Como Usar"
url: "https://ziglang.com.br/glossario/anytype-em-zig-o-que-%C3%A9-e-como-usar/"
markdown_url: "https://ziglang.com.br/glossario/anytype-em-zig-o-que-%C3%A9-e-como-usar.MD"
description: "Entenda anytype em Zig: parâmetro de tipo inferido pelo compilador para funções genéricas. Como Zig implementa genéricos sem sintaxe especial. Guia pt-BR."
date: "2026-02-21"
author: "Zig Brasil"
---

# anytype em Zig — O que é e Como Usar

Entenda anytype em Zig: parâmetro de tipo inferido pelo compilador para funções genéricas. Como Zig implementa genéricos sem sintaxe especial. Guia pt-BR.


# anytype em Zig — O que é e Como Usar

## Definição

**anytype** é uma anotação de tipo especial em Zig que permite que o compilador **infira o tipo** de um parâmetro a partir do argumento passado na chamada da função. É o mecanismo principal para criar funções genéricas em Zig, substituindo a necessidade de sintaxes como `<T>` de outras linguagens.

Quando uma função aceita `anytype`, o compilador gera uma versão especializada para cada combinação de tipos usada. Isso é semelhante a templates em C++, mas com uma sintaxe mais simples e mensagens de erro mais claras.

## Por que anytype Importa

1. **Genéricos simples**: Cria funções que aceitam qualquer tipo sem boilerplate.
2. **Duck typing em comptime**: O compilador verifica se o tipo suporta as operações usadas na função.
3. **Zero overhead**: Cada especialização é compilada individualmente, sem indireção.
4. **Composição**: Combina com `@TypeOf` e `@typeInfo` para introspecção poderosa.

## Exemplo Prático

### Função Genérica com anytype

```zig
const std = @import("std");

fn dobrar(valor: anytype) @TypeOf(valor) {
    return valor * 2;
}

pub fn main() void {
    const a: u32 = dobrar(@as(u32, 21));
    const b: f64 = dobrar(@as(f64, 1.5));
    const c: i8 = dobrar(@as(i8, -10));

    std.debug.print("u32: {}\n", .{a});   // 42
    std.debug.print("f64: {d}\n", .{b});   // 3.0
    std.debug.print("i8: {}\n", .{c});     // -20
}
```

### anytype com Introspecção de Tipo

```zig
const std = @import("std");

fn imprimir(valor: anytype) void {
    const T = @TypeOf(valor);
    const info = @typeInfo(T);

    switch (info) {
        .int => std.debug.print("Inteiro: {}\n", .{valor}),
        .float => std.debug.print("Float: {d}\n", .{valor}),
        .pointer => |ptr_info| {
            if (ptr_info.size == .Slice and ptr_info.child == u8) {
                std.debug.print("String: {s}\n", .{valor});
            } else {
                std.debug.print("Ponteiro: {*}\n", .{valor});
            }
        },
        .bool => std.debug.print("Bool: {}\n", .{valor}),
        else => std.debug.print("Tipo: {s}\n", .{@typeName(T)}),
    }
}

pub fn main() void {
    imprimir(@as(u32, 42));
    imprimir(@as(f64, 3.14));
    imprimir(true);
}
```

### Writer Genérico com anytype

```zig
const std = @import("std");

fn escreverSaudacao(writer: anytype, nome: []const u8) !void {
    try writer.print("Olá, {s}! Bem-vindo ao Zig.\n", .{nome});
}

pub fn main() !void {
    const stdout = std.io.getStdOut().writer();
    try escreverSaudacao(stdout, "Brasil");

    // Funciona com qualquer writer — arquivo, buffer, etc.
    var buffer: [256]u8 = undefined;
    var stream = std.io.fixedBufferStream(&buffer);
    try escreverSaudacao(stream.writer(), "Mundo");
}
```

## anytype vs comptime T: type

| Aspecto | `anytype` | `comptime T: type` |
|---------|----------|-------------------|
| Sintaxe | Implícita | Explícita |
| Acesso ao tipo | Via `@TypeOf(param)` | Diretamente via `T` |
| Múltiplos parâmetros do mesmo tipo | Cada um pode ser diferente | Força o mesmo tipo `T` |
| Uso típico | Funções simples, writers | Contêineres, funções com tipo explícito |

## Validando Tipos com @compileError

Quando `anytype` recebe um tipo inadequado, o erro padrão do compilador pode ser difícil de interpretar. A solução é adicionar validações explícitas no início da função:

```zig
const std = @import("std");

fn somar(a: anytype, b: anytype) @TypeOf(a) {
    const T = @TypeOf(a);
    const info = @typeInfo(T);

    // Rejeita tipos não-numéricos com mensagem clara
    if (info != .int and info != .float) {
        @compileError("somar() requer tipo numérico, recebeu: " ++ @typeName(T));
    }

    return a + b;
}

pub fn main() void {
    std.debug.print("{}\n", .{somar(@as(u32, 10), @as(u32, 20))});
    // somar("texto", "outro"); // erro claro: "somar() requer tipo numérico..."
}
```

Esse padrão é amplamente usado na biblioteca padrão do Zig para produzir mensagens de erro acionáveis.

## Casos de Uso Típicos

- **Funções matemáticas**: `fn abs(x: anytype) @TypeOf(x)` funciona para qualquer tipo numérico.
- **Writers genéricos**: A interface `std.io.Writer` usa `anytype` para aceitar qualquer writer (arquivo, buffer, socket).
- **Logging e formatação**: `std.debug.print` aceita `anytype` para formatar valores arbitrários.
- **Wrappers e decorators**: Funções que envolvem outras sem conhecer o tipo específico.

## Armadilhas Comuns

- **Mensagens de erro**: Quando `anytype` recebe um tipo que não suporta as operações da função, o erro pode ser confuso. Adicione `@compileError` para mensagens claras.
- **Múltiplos anytype**: Dois parâmetros `anytype` podem receber tipos diferentes. Se precisar forçar o mesmo tipo, use `comptime T: type`.
- **Não é tipagem dinâmica**: `anytype` é resolvido em comptime. Não existe dispatch dinâmico — cada uso gera código especializado.
- **Tipo de retorno**: Use `@TypeOf(param)` no tipo de retorno para que ele corresponda ao tipo do argumento.

## Termos Relacionados

- [Comptime](/glossario/comptime/) — Execução em tempo de compilação
- [comptime_int](/glossario/comptime-int/) — Tipo inteiro em comptime
- [Type Coercion](/glossario/type-coercion/) — Conversão implícita de tipos
- [Writer Interface](/glossario/writer-interface/) — Padrão de interface genérica com anytype

## Tutoriais Relacionados

- [Comptime em Zig — Guia Completo](/tutoriais/comptime-em-zig/)
- [Zig Comptime e Reflection](/tutoriais/zig-comptime-reflection/)
- [Zig Design Patterns](/tutoriais/zig-design-patterns/)