¿Qué es un zig language feature list?

Zig es un lenguaje de programación moderno que combina la simplicidad de C con características avanzadas de gestión de memoria, tipado fuerte y compresión de código a través de su sistema de compilación.

¿Qué significa “feature list” en Zig?

En Zig, una feature list (lista de características) es un conjunto de opciones de compilación que pueden activarse o desactivarse para controlar el comportamiento del compilador y de los módulos estándar. Esta lista permite a los desarrolladores habilitar funcionalidades experimentales o de bajo nivel sin afectar al resto del código base.

Principales características de Zig

• Tipado estático y seguro: El compilador verifica tipos en tiempo de compilación, evitando conversiones implícitas peligrosas.
• Control total de la memoria: No hay recolector de basura; cada bloque de memoria debe ser liberado explícitamente.
• Compilación cruzada sencilla: Un único comando compila para cualquier arquitectura.
• Errores de compilación explícitos: Los mensajes son claros y orientados a la corrección.
• Inline assembly y llamadas FFI: Integración directa con C y código ensamblador.
• Macros y generics: Permiten la escritura de código reusable sin perder rendimiento.

Cómo consultar la lista de características

Para ver las opciones disponibles en tu versión de Zig, ejecuta:

zig build-exe --help

o, más específicamente, para ver las feature flags:

zig build-exe --feature-help

Estas opciones listan todas las banderas que se pueden pasar al compilador, por ejemplo, --feature=inline-asm para habilitar ensamblador en línea.

Ventajas de una lista de características

• Permite experimentar con funcionalidades sin romper la compatibilidad.
• Facilita la adopción gradual de mejoras en proyectos grandes.
• Reduce la necesidad de condicionales en tiempo de ejecución.

Ejemplo práctico: Utilizando características avanzadas

const std = @import("std");

// 1. Habilitamos una característica experimental de Zig
//    (suponiendo que esté disponible en la versión que usamos)
//    Esto se hace en la línea de comandos con: --feature=experimental-feature
//    Aquí lo anotamos para que el lector sepa que puede activar esta flag.

pub fn main() !void {
    // 2. Obtenemos el manejador de salida estándar
    const stdout = std.io.getStdOut().writer();

    // 3. Declaramos una variable con tipado explícito
    var value: i32 = 42; // 42 es un entero de 32 bits

    // 4. Usamos un bloque de código "deferred" para asegurar que se libere un recurso
    defer stdout.close() catch {}; // Cierra el writer cuando main termine

    // 5. Imprimimos el valor usando el formato de Zig
    //    std.fmt.print escribe directamente en stdout
    //    "{}" es el placeholder para el valor de la variable
    try std.fmt.print("El valor inicial es: {}\n", .{value});

    // 6. Modificamos la variable
    value += 58; // Ahora es 100

    // 7. Imprimimos de nuevo
    try std.fmt.print("El valor actualizado es: {}\n", .{value});

    // 8. Utilizamos una característica experimental: "try" con un tipo
    //    que devuelve un Result<T, E>.
    //    Aquí simulamos una función que puede fallar.
    const result = mightFail();

    // 9. Manejo de errores con "try" y "catch"
    //    Si result es Ok, continuamos; si es Err, lanzamos el error
    const data = try result; // Si resulta en error, se propaga el error de main

    // 10. Imprimimos los datos obtenidos
    try std.fmt.print("Datos obtenidos: {}\n", .{data});

    // 11. La función main termina sin errores; Zig se encargará de devolver 0
}

// 12. Función que simula un fallo aleatorio
fn mightFail() !u16 {
    // 13. Generamos un número aleatorio entre 0 y 1
    const rand = std.rand.DefaultPrng.init(1234);
    const n = rand.random().int(u8) % 2; // 0 o 1

    // 14. Si n es 0, devolvemos Ok con el valor 256
    //     Si n es 1, devolvemos un error personalizado
    if (n == 0) {
        return 256; // Ok
    } else {
        // 15. Definimos un error simple
        return error.FailedOperation;
    }
}

En el código anterior:

• Se muestra cómo usar el sistema de tipos de Zig, el manejo de errores con !T y try.
• Se ilustra el uso de defer para liberar recursos.
• Se hace referencia a una feature flag experimental que debe activarse con --feature=experimental-feature.
• Se demuestra la generación de un número aleatorio y el manejo condicional de errores.

Conclusión

La feature list de Zig es una herramienta poderosa que permite a los desarrolladores habilitar y probar nuevas funcionalidades de manera controlada. Comprender cómo funciona, qué opciones están disponibles y cómo se aplican en el código, abre la puerta a una programación más segura, eficiente y flexible con Zig.