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

// Subsequent calls with same args are instant
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).