Variables y Tipos

Declaraciones de Variables¶

Zolo tiene tres formas de declarar variables:

`let` — Vinculación Inmutable¶

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

Una vez asignada, una vinculación let no puede ser reasignada:

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

`let mut` — Vinculación Mutable¶

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

Las constantes deben tener un valor en el momento de la declaración y no pueden ser reasignadas.

Anotaciones de Tipo¶

Las anotaciones de tipo son opcionales — Zolo infiere tipos cuando es posible:

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	Descripción	Ejemplos
`int`	Entero de 64 bits	`42`, `-7`, `0`
`f64`	Punto flotante de 64 bits	`3.14`, `-0.5`, `1.0`
`str`	Cadena de caracteres	`"hello"`, `"world"`
`bool`	Booleano	`true`, `false`
`nil`	Nulo/ausencia de valor	`nil`

Tipos Compuestos¶

Arrays¶

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

Los arrays son indexados desde 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 Opcionales¶

El sufijo ? hace que un tipo sea opcional (anulable):

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

let name: str? = nil

Tipos de Función¶

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)

Asignación Compuesta¶

Zolo admite operadores de asignación compuesta:

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

Sombreado¶

Puedes redeclarar una variable con el mismo nombre:

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

Notas sobre el Sistema de Tipos¶

Los tipos se verifican en tiempo de compilación — sin costo en tiempo de ejecución
El verificador de tipos se ejecuta durante la compilación e informa errores con ubicaciones en el código fuente
nil solo está permitido para tipos opcionales (T?)
Zolo compila a Lua, por lo que los tipos se borran en tiempo de ejecución