Operadores

Operadores Aritméticos¶

Operadores de Comparação¶

Operadores Lógicos¶

Operadores de Atribuição¶

Operador Pipe |>¶

O operador pipe passa a expressão à esquerda como o primeiro argumento para a função à direita. Isso cria um fluxo de dados natural de cima para baixo:

// 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()

Como Funciona¶

a |> f(b, c) transforma em f(a, b, c) — o lado esquerdo torna-se o primeiro argumento.

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

Pipe com Placeholder _¶

Quando o valor passado pelo pipe não deve ser o primeiro argumento:

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

Operador Tap &.¶

Executa um efeito colateral sem interromper a cadeia — o valor original passa inalterado. Perfeito para depuração e logging:

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

Como Funciona¶

a &. f() chama f(a) pelo efeito colateral e então retorna a inalterado.

Encadeamento Opcional ?.¶

Acessa campos com segurança em valores que podem ser nil:

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

Sem encadeamento opcional, você precisaria de verificações aninhadas de nil:

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

Coalescência Nula ??¶

Fornece um valor padrão quando o lado esquerdo é nil:

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

Combinando com Encadeamento Opcional¶

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

Propagação de Erro ?¶

Propaga erros para cima na pilha de chamadas, similar ao 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)
}

Quando ? é aplicado a um Result.Err, a função retorna imediatamente com esse erro. Quando aplicado a Result.Ok(value), desempacota para value.

Operadores de spread¶

Zolo usa duas grafias de propósito:

• ...valor expande um array dentro de um literal de array.
• ..valor copia campos dentro de um literal de struct nomeada.

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} tem {bob.age} anos")

Saída:

[0, 1, 2, 3, 4, 5]
Bob tem 30 anos

Campos nomeados têm precedência sobre os campos copiados, portanto name: "Bob" substitui alice.name. Uma cópia pura é User { ..alice }. Literais de mapa usam #{ chave: valor }; { ...map } não é sintaxe de spread de mapa.

Operadores de Intervalo¶

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)
}

Precedência de Operadores¶

Do maior para o menor:

1. Unário: -x, !x
2. Exponenciação: **
3. Multiplicativo: *, /, %
4. Aditivo: +, -
5. Intervalo: .., ..=
6. Comparação: <, >, <=, >=
7. Igualdade: ==, !=
8. E lógico: &&
9. OU lógico: ||
10. Coalescência nula: ??
11. Pipe: |>
12. Tap: &.
13. Atribuição: =, +=, -=, *=, /=, %=