Funciones en Zig: sintaxis, parámetros y retorno

Una función en Zig es un bloque de código con nombre, parámetros y tipo de retorno explícito. Hasta ahora hemos escrito casi todo dentro de main, pero para hacer software mantenible necesitamos modularidad.

Las funciones en Zig son el mecanismo principal para dividir problemas complejos en tareas pequeñas y reutilizables.

Aunque la sintaxis te resultará familiar si vienes de C, Go o Rust, Zig introduce una idea importante respecto a los parámetros: su valor no se puede reasignar dentro de la función.

Anatomía de una función

La declaración de una función en Zig sigue una estructura muy limpia. Leemos de izquierda a derecha: palabra clave, nombre, parámetros y tipo de retorno.

fn nombreFuncion(parametro1: Tipo, parametro2: Tipo) TipoRetorno {
    // Cuerpo de la función
    return valor;
}

Vamos a ver un ejemplo real de una función que suma dos enteros de 32 bits:

fn sumar(a: i32, b: i32) i32 {
    const resultado = a + b;
    return resultado;
}

Visibilidad con pub

Por defecto, una función no queda accesible para los módulos que importan el archivo donde se define. Para formar parte de la interfaz pública del módulo, debe declararse con pub.

Si queremos que una función sea accesible desde otros archivos (o que sea el punto de entrada como main), debemos usar la palabra clave pub.

// Solo visible en este archivo
fn funcionPrivada() void { ... }

// Visible desde cualquier archivo que importe este módulo
pub fn funcionPublica() void { ... }

Los parámetros son inmutables

Aquí es donde Zig se diferencia drásticamente de C o C++.

En C, cuando pasas un valor a una función, se crea una copia local. Tú puedes modificar esa copia dentro de la función sin afectar al exterior.

// C (Válido)
void contador(int x) {
    x = x + 1; // Modificamos la copia local de x
}

En Zig, esto está prohibido. Los parámetros de una función son considerados constantes (const).

// Zig (ERROR de compilación)
fn intentarModificar(x: i32) void {
    x = x + 1; // error: cannot assign to constant
}

¿Cómo lo solucionamos?

Si necesitas modificar un valor recibido para cálculos internos, simplemente crea una copia local mutable usando var:

fn calcular(entrada: i32) i32 {
    var copia_mutable = entrada;
    copia_mutable += 10;
    return copia_mutable;
}

Valores de retorno y descarte

Zig es muy estricto con los datos. Si una función devuelve un valor, estás obligado a usarlo.

fn obtenerNumero() i32 {
    return 5;
}

pub fn main() void {
    obtenerNumero(); // Error: value of type 'i32' ignored
}

Esto evita bugs donde llamamos a funciones que devuelven códigos de error o estados importantes y los ignoramos por despiste.

Si explícitamente quieres ignorar el resultado (porque solo te interesan los efectos secundarios de la función), debes asignarlo a la variable de descarte _:

pub fn main() void {
    _ = obtenerNumero(); // Correcto, "tiramos" el 5
}

Recursividad

Zig soporta recursividad (una función que se llama a sí misma), pero debemos usarla con cuidado. Cada llamada consume espacio en la pila y Zig 0.16 no protege el programa frente a un desbordamiento de pila.

fn factorial(n: u64) u64 {
    if (n == 0) return 1;
    return n * factorial(n - 1);
}

Paso por valor o por referencia

Una duda común es: ¿Zig pasa los datos por valor (copiando) o por referencia (puntero)?

La respuesta corta es: tú defines la semántica y el compilador decide la representación más eficiente.

Si quieres modificar el valor original, debes expresarlo mediante un puntero o un slice mutable. Veremos ambos casos en el capítulo de punteros y memoria.