Operadores

Operadores Aritméticos¶

Operadores de Comparación¶

Operadores Lógicos¶

Operadores de Asignación¶

Operador Pipe |>¶

El operador pipe pasa la expresión de la izquierda como el primer argumento a la función de la derecha. Esto crea un flujo de datos natural de arriba hacia abajo:

// Without pipe — hard to read (inside-out)
let result = collect(filter(map(list, |x| x * 2), |x| x > 5))

// With pipe — natural flow
let result = list
    |> map(|x| x * 2)
    |> filter(|x| x > 5)
    |> collect()

Cómo Funciona¶

a |> f(b, c) se transforma en f(a, b, c) — el lado izquierdo se convierte en el primer argumento.

"  Hello World  "
    |> string.trim()
    |> string.split(" ")
    |> Array.map(|s| string.to_upper(s))
    |> Array.join(", ")

Pipe con Marcador de Posición _¶

Cuando el valor pasado por el pipe no debe ser el primer argumento:

users
    |> sort(_, by: .name)
    |> group(_, key: |u| u.age)

Operador Tap &.¶

Ejecuta un efecto secundario sin interrumpir la cadena — el valor original pasa sin cambios. Perfecto para depuración y logging:

list
    |> sort()
    &. print()           // prints the sorted list, passes it along
    |> filter(|x| x > 0)
    &. |x| log(x)        // debug log
    |> collect()

Cómo Funciona¶

a &. f() llama a f(a) por su efecto secundario y luego devuelve a sin cambios.

Encadenamiento Opcional ?.¶

Accede de forma segura a campos en valores que podrían ser nil:

let city = user?.address?.city    // nil if any part is nil

Sin encadenamiento opcional, necesitarías verificaciones anidadas de nil:

// Equivalent without ?.
let city = if user != nil {
    if user.address != nil {
        user.address.city
    } else { nil }
} else { nil }

Coalescencia Nula ??¶

Proporciona un valor por defecto cuando el lado izquierdo es nil:

let name = user?.name ?? "Anonymous"
let port = config?.port ?? 8080

Combinando con Encadenamiento Opcional¶

let city = user?.address?.city ?? "unknown"

Propagación de Error ?¶

Propaga errores hacia arriba en la pila de llamadas, similar a Rust:

fn read_config(path: str) -> Result<Config, Error> {
    let text = fs.read(path)?        // returns early on error
    let config = json.parse(text)?
    Result.Ok(config)
}

Cuando ? se aplica a un Result.Err, la función retorna inmediatamente con ese error. Cuando se aplica a Result.Ok(value), desenvuelve a value.

Operadores de spread¶

Zolo usa dos grafías de forma intencional:

• ...valor expande un array dentro de un literal de array.
• ..valor copia campos dentro de un literal de struct nombrado.

let a = [1, 2, 3]
let b = [0, ...a, 4, 5]
print(b)

struct User {
    name: str,
    age: int,
}

let alice = User { name: "Alice", age: 30 }
let bob = User { name: "Bob", ..alice }
print("{bob.name} tiene {bob.age} años")

Salida:

[0, 1, 2, 3, 4, 5]
Bob tiene 30 años

Los campos nombrados tienen prioridad sobre los campos copiados, por lo que name: "Bob" reemplaza alice.name. Una copia pura es User { ..alice }. Los literales de mapa usan #{ clave: valor }; { ...map } no es sintaxis de spread de mapas.

Operadores de Rango¶

for i in 0..5 {     // 0, 1, 2, 3, 4
    print(i)
}

for i in 0..=5 {    // 0, 1, 2, 3, 4, 5
    print(i)
}

Precedencia de Operadores¶

De mayor a menor:

1. Unario: -x, !x
2. Exponenciación: **
3. Multiplicativo: *, /, %
4. Aditivo: +, -
5. Rango: .., ..=
6. Comparación: <, >, <=, >=
7. Igualdad: ==, !=
8. Y lógico: &&
9. O lógico: ||
10. Coalescencia nula: ??
11. Pipe: |>
12. Tap: &.
13. Asignación: =, +=, -=, *=, /=, %=