Variáveis e Tipos

Declarações de Variáveis¶

Zolo tem três formas de declarar variáveis:

`let` — Vinculação Imutável¶

let x = 10
let name: str = "Zolo"

Uma vez atribuída, uma vinculação let não pode ser reatribuída:

let x = 10
x = 20  // Error: cannot reassign immutable variable

`let mut` — Vinculação Mutável¶

let mut counter = 0
counter = counter + 1  // OK
counter += 1           // OK — compound assignment

`const` — Constante¶

const PI: f64 = 3.14159
const MAX_SIZE: int = 1024

Constantes devem ter um valor no momento da declaração e não podem ser reatribuídas.

Anotações de Tipo¶

Anotações de tipo são opcionais — Zolo infere tipos quando possível:

let x = 42            // inferred: int
let y: f64 = 3.14     // explicit: f64
let name = "hello"    // inferred: str
let flag = true       // inferred: bool

Tipos Primitivos¶

Tipo	Descrição	Exemplos
`int`	Inteiro de 64 bits	`42`, `-7`, `0`
`f64`	Ponto flutuante de 64 bits	`3.14`, `-0.5`, `1.0`
`str`	Cadeia de caracteres	`"hello"`, `"world"`
`bool`	Booleano	`true`, `false`
`nil`	Nulo/ausência de valor	`nil`

Tipos Compostos¶

Arrays¶

let arr: [int] = [1, 2, 3]
let names: [str] = ["Alice", "Bob"]
let empty: [int] = []

Arrays são indexados a partir de 0:

let arr = [10, 20, 30]
print(arr[0])   // 10
print(arr[2])   // 30

Maps¶

let scores: {str: int} = { "Alice": 95, "Bob": 87 }
let config = { "host": "localhost", "port": 8080 }

Tuplas¶

let point: (int, int) = (10, 20)
let pair: (str, int) = ("age", 25)

Tipos Opcionais¶

O sufixo ? torna um tipo opcional (anulável):

let x: int? = 42       // has a value
let y: int? = nil       // no value

let name: str? = nil

Tipos de Função¶

let callback: fn(int) -> int = |x| x * 2
let predicate: fn(str) -> bool = |s| s.len() > 3

Tipos Genéricos¶

let map: Map<str, int> = Map.new()
let result: Result<int, str> = Result.Ok(42)

Atribuição Composta¶

Zolo suporta operadores de atribuição composta:

let mut x = 10
x += 5     // x = 15
x -= 3     // x = 12
x *= 2     // x = 24
x /= 4     // x = 6
x %= 5     // x = 1

Sombreamento¶

Você pode redeclarar uma variável com o mesmo nome:

let x = 10
let x = x * 2     // shadows the previous x
let x = "hello"   // can even change type

Notas sobre o Sistema de Tipos¶

Os tipos são verificados em tempo de compilação — sem custo em tempo de execução
O verificador de tipos é executado durante a compilação e relata erros com localizações no código-fonte
nil só é permitido para tipos opcionais (T?)
Zolo compila para Lua, portanto os tipos são apagados em tempo de execução