Decoradores

Los decoradores son anotaciones que modifican el comportamiento de funciones y structs. Usan la sintaxis @name colocada antes de una declaración.

@test¶

Marca una función como una prueba. Las funciones de prueba se recopilan y ejecutan con zolo test.

@test
fn test_addition() {
    assert_eq(2 + 2, 4, "basic math")
}

@test
fn test_string_concat() {
    let result = "hello" + " " + "world"
    assert_eq(result, "hello world", "string concat")
}

Ejecutando Pruebas¶

zolo test my_tests.zolo              # ejecutar todas las pruebas
zolo test my_tests.zolo --filter fib # solo pruebas que coincidan
zolo test my_tests.zolo --list       # listar nombres de pruebas

Aserciones de Prueba¶

assert_eq(actual, expected, "message")   // assert equality
assert_ne(actual, expected, "message")   // assert inequality

@memoize¶

Almacena en caché automáticamente los resultados de las funciones. Las llamadas repetidas con los mismos argumentos devuelven el valor en caché en lugar de recomputar.

@memoize
fn fibonacci(n: int) -> int {
    if n <= 1 { n } else { fibonacci(n - 1) + fibonacci(n - 2) }
}

// First call computes normally
print(fibonacci(40))  // fast! cached intermediate results

// Las llamadas siguientes con los mismos argumentos son instantáneas
print(fibonacci(40))  // returns from cache

Cómo Funciona¶

El compilador envuelve la función con una tabla de caché. Los argumentos se serializan como clave y el resultado se almacena. En llamadas repetidas con los mismos argumentos, el resultado en caché se devuelve inmediatamente.

Mejor Uso Para¶

• Funciones recursivas (como fibonacci, recorridos de árboles)
• Funciones puras con computación costosa
• Funciones llamadas repetidamente con los mismos argumentos

Limitaciones¶

• Solo funciona con argumentos serializables
• El caché crece sin límite (sin desalojo)
• No es adecuado para funciones con efectos secundarios

@deprecated¶

Marca una función como obsoleta. Cuando se llama, imprime una advertencia en stderr (una vez por función).

@deprecated("use new_calculate() instead")
fn old_calculate(x: int) -> int {
    x * 2
}

old_calculate(5)
// stderr: WARNING: 'old_calculate' is deprecated: use new_calculate() instead

Sin Mensaje¶

@deprecated
fn legacy_api() {
    // ...
}

legacy_api()
// stderr: WARNING: 'legacy_api' is deprecated

Comportamiento¶

• La advertencia se imprime solo una vez por función obsoleta (no en cada llamada)
• La función sigue ejecutándose normalmente después de la advertencia
• La salida va a stderr, no a stdout

@builder¶

Genera un patrón builder para structs. El builder permite construir structs campo a campo con encadenamiento de métodos.

@builder
struct Config {
    host: str,
    port: int,
    debug: bool,
}

let cfg = Config.builder()
    .host("localhost")
    .port(8080)
    .debug(true)
    .build()

print(cfg.host)   // "localhost"
print(cfg.port)   // 8080
print(cfg.debug)  // true

Métodos Generados¶

Para cada campo name: Type en el struct, @builder genera:

• StructName.builder() — crea una nueva instancia del builder
• .field_name(value) — establece el valor del campo, devuelve el builder
• .build() — crea la instancia final del struct

Ejemplo: Builder Complejo¶

@builder
struct Request {
    url: str,
    method: str,
    timeout: int,
    headers: {str: str},
}

let req = Request.builder()
    .url("https://api.example.com")
    .method("POST")
    .timeout(30)
    .build()

Decoradores Personalizados¶

Los decoradores siguen la sintaxis:

@name
@name(arg1, arg2)

El nombre y los argumentos del decorador se almacenan en el AST y se procesan durante la compilación. Actualmente, los decoradores integrados (@test, @memoize, @deprecated, @builder) son manejados por el compilador. El procesamiento de decoradores definidos por el usuario está planificado para una versión futura.

Combinando Decoradores¶

Se pueden aplicar múltiples decoradores a una sola declaración:

@test
@memoize
fn test_cached_fibonacci() {
    assert_eq(fibonacci(10), 55, "fib(10)")
}

Los decoradores se aplican de abajo hacia arriba (el más cercano a la función primero).