Biblioteca Estándar

Zolo incluye una biblioteca estándar completa construida sobre el runtime de Lua. Todas las funciones están disponibles automáticamente sin importaciones.

Funciones de Cadena¶

Todas las funciones de cadena están en el espacio de nombres string:

Función	Descripción	Ejemplo
`string.trim(s)`	Eliminar espacios en blanco al inicio/final	`string.trim(" hi ")` → `"hi"`
`string.trim_start(s)`	Eliminar espacios en blanco al inicio	`string.trim_start(" hi")` → `"hi"`
`string.trim_end(s)`	Eliminar espacios en blanco al final	`string.trim_end("hi ")` → `"hi"`
`string.starts_with(s, prefix)`	Verificar si comienza con prefijo	`string.starts_with("hello", "he")` → `true`
`string.ends_with(s, suffix)`	Verificar si termina con sufijo	`string.ends_with("hello", "lo")` → `true`
`string.contains(s, substr)`	Verificar si contiene subcadena	`string.contains("hello", "ell")` → `true`
`string.split(s, sep)`	Dividir en array	`string.split("a,b,c", ",")` → `["a","b","c"]`
`string.replace(s, old, new)`	Reemplazar ocurrencias	`string.replace("aa", "a", "b")` → `"bb"`
`string.chars(s)`	Dividir en caracteres	`string.chars("hi")` → `["h","i"]`
`string.pad_start(s, len, fill)`	Rellenar al inicio	`string.pad_start("42", 5, "0")` → `"00042"`
`string.pad_end(s, len, fill)`	Rellenar al final	`string.pad_end("hi", 5, ".")` → `"hi..."`
`string.is_empty(s)`	Verificar si está vacía	`string.is_empty("")` → `true`

Funciones de Array¶

Todas las funciones de array están en el espacio de nombres Array:

Creación y Operaciones Básicas¶

Función	Descripción
`Array.new(...)`	Crear array desde argumentos
`Array.len(arr)`	Obtener longitud del array
`Array.push(arr, val)`	Añadir elemento al final
`Array.pop(arr)`	Eliminar y devolver el último elemento
`Array.shift(arr)`	Eliminar y devolver el primer elemento
`Array.unshift(arr, val)`	Añadir elemento al inicio
`Array.slice(arr, from, to)`	Extraer sub-array
`Array.concat(a, b)`	Concatenar dos arrays
`Array.reverse(arr)`	Invertir array
`Array.sort(arr, cmp?)`	Ordenar array (comparador opcional)
`Array.flat(arr)`	Aplanar arrays anidados
`Array.join(arr, sep)`	Unir elementos en cadena

Operaciones Funcionales¶

Función	Descripción	Ejemplo
`Array.map(arr, fn)`	Transformar cada elemento	`Array.map([1,2,3], \|x\| x * 2)` → `[2,4,6]`
`Array.filter(arr, fn)`	Mantener elementos coincidentes	`Array.filter([1,2,3,4], \|x\| x > 2)` → `[3,4]`
`Array.reduce(arr, fn, init)`	Reducir a un único valor	`Array.reduce([1,2,3], \|a,b\| a + b, 0)` → `6`
`Array.each(arr, fn)`	Ejecutar para cada elemento	`Array.each(items, \|x\| print(x))`
`Array.find(arr, fn)`	Encontrar el primero coincidente	`Array.find([1,2,3], \|x\| x > 1)` → `2`
`Array.find_index(arr, fn)`	Encontrar índice del primero coincidente	`Array.find_index([1,2,3], \|x\| x > 1)` → `1`
`Array.contains(arr, val)`	Verificar si el elemento existe	`Array.contains([1,2,3], 2)` → `true`
`Array.any(arr, fn)`	Verificar si alguno coincide	`Array.any([1,2,3], \|x\| x > 2)` → `true`
`Array.all(arr, fn)`	Verificar si todos coinciden	`Array.all([1,2,3], \|x\| x > 0)` → `true`
`Array.zip(a, b)`	Emparejar elementos de dos arrays	`Array.zip([1,2], ["a","b"])` → `[(1,"a"),(2,"b")]`
`Array.enumerate(arr)`	Añadir índices	`Array.enumerate(["a","b"])` → `[(0,"a"),(1,"b")]`

Usando con Pipe¶

let result = [1, 2, 3, 4, 5]
    |> Array.map(|x| x * x)
    |> Array.filter(|x| x > 5)
    |> Array.reduce(|a, b| a + b, 0)
// result = 9 + 16 + 25 = 50

Funciones de Map¶

Todas las funciones de map están en el espacio de nombres Map:

Función	Descripción
`Map.new()`	Crear map vacío
`Map.from(tbl)`	Crear desde tabla
`Map.set(m, key, val)`	Establecer par clave-valor
`Map.get(m, key)`	Obtener valor por clave
`Map.has(m, key)`	Verificar si la clave existe
`Map.remove(m, key)`	Eliminar par clave-valor
`Map.keys(m)`	Obtener todas las claves como array
`Map.values(m)`	Obtener todos los valores como array
`Map.entries(m)`	Obtener todos los pares clave-valor
`Map.len(m)`	Obtener número de entradas
`Map.each(m, fn)`	Iterar sobre entradas
`Map.clear(m)`	Eliminar todas las entradas

Ejemplo¶

let scores = Map.new()
Map.set(scores, "Alice", 95)
Map.set(scores, "Bob", 87)

print(Map.get(scores, "Alice"))  // 95
print(Map.has(scores, "Carol"))  // false

Map.each(scores, |key, val| {
    print("{key}: {val}")
})

Funciones de Set¶

Todas las funciones de set están en el espacio de nombres Set:

Función	Descripción
`Set.new()`	Crear set vacío
`Set.from(arr)`	Crear desde array
`Set.add(s, val)`	Añadir elemento
`Set.has(s, val)`	Verificar membresía
`Set.remove(s, val)`	Eliminar elemento
`Set.len(s)`	Obtener tamaño
`Set.to_array(s)`	Convertir a array
`Set.union(a, b)`	Unión de dos sets
`Set.intersect(a, b)`	Intersección de dos sets
`Set.difference(a, b)`	Elementos en a pero no en b
`Set.each(s, fn)`	Iterar sobre elementos

Ejemplo¶

let fruits = Set.from(["apple", "banana", "cherry"])
Set.add(fruits, "date")
print(Set.has(fruits, "apple"))   // true
print(Set.len(fruits))            // 4

let tropical = Set.from(["banana", "mango", "papaya"])
let common = Set.intersect(fruits, tropical)  // {"banana"}

Funciones de Option¶

El tipo Option representa un valor que puede o no existir:

Función	Descripción
`Option.Some(val)`	Crear Some con un valor
`Option.None()`	Crear None (sin valor)
`Option.is_some(opt)`	Verificar si tiene un valor
`Option.is_none(opt)`	Verificar si está vacío
`Option.unwrap(opt)`	Extraer valor (error si None)
`Option.unwrap_or(opt, default)`	Extraer valor o usar por defecto
`Option.map(opt, fn)`	Transformar el valor si está presente
`Option.and_then(opt, fn)`	Flat map (encadenar opcionales)
`Option.or_else(opt, fn)`	Proporcionar alternativa si None
`Option.from(val)`	Crear desde valor (nil → None)

Ejemplo¶

let maybe = Option.Some(42)
let nothing = Option.None()

print(Option.is_some(maybe))         // true
print(Option.unwrap_or(nothing, 0))  // 0

let doubled = Option.map(maybe, |x| x * 2)
print(Option.unwrap(doubled))        // 84

Funciones de Result¶

El tipo Result representa éxito o fracaso:

Función	Descripción
`Result.Ok(val)`	Crear éxito
`Result.Err(err)`	Crear error
`Result.is_ok(r)`	Verificar si es éxito
`Result.is_err(r)`	Verificar si es error
`Result.unwrap(r)`	Extraer valor (error si Err)
`Result.unwrap_or(r, default)`	Extraer valor o usar por defecto
`Result.unwrap_err(r)`	Extraer valor del error
`Result.map(r, fn)`	Transformar valor de éxito
`Result.map_err(r, fn)`	Transformar valor de error
`Result.and_then(r, fn)`	Encadenar results
`Result.or_else(r, fn)`	Manejar caso de error
`Result.from_pcall(fn, ...)`	Crear desde llamada protegida

Ejemplo¶

fn divide(a: int, b: int) -> Result<int, str> {
    if b == 0 {
        Result.Err("division by zero")
    } else {
        Result.Ok(a / b)
    }
}

let result = divide(10, 2)
print(Result.unwrap(result))  // 5

let bad = divide(10, 0)
print(Result.is_err(bad))     // true
print(Result.unwrap_or(bad, -1))  // -1

Funciones de Iterator¶

Iteradores perezosos para procesamiento eficiente de datos:

Función	Descripción
`Iter.from(arr)`	Crear desde array
`Iter.range(start, stop, step?)`	Crear iterador de rango
`Iter.map(iter, fn)`	Map perezoso
`Iter.filter(iter, fn)`	Filter perezoso
`Iter.take(iter, n)`	Tomar los primeros n elementos
`Iter.skip(iter, n)`	Saltar los primeros n elementos
`Iter.zip(a, b)`	Zipar dos iteradores
`Iter.enumerate(iter)`	Añadir índices
`Iter.fold(iter, init, fn)`	Reducir a un único valor
`Iter.collect(iter)`	Recolectar en array
`Iter.each(iter, fn)`	Ejecutar para cada elemento
`Iter.count(iter)`	Contar elementos
`Iter.flat_map(iter, fn)`	Flat map perezoso
`Iter.chain(a, b)`	Concatenar iteradores
`Iter.find(iter, fn)`	Encontrar el primero coincidente
`Iter.any(iter, fn)`	Verificar si alguno coincide
`Iter.all(iter, fn)`	Verificar si todos coinciden

Ejemplo¶

let result = Iter.range(0, 100)
    |> Iter.map(|x| x * x)
    |> Iter.filter(|x| x % 2 == 0)
    |> Iter.take(5)
    |> Iter.collect()
// [0, 4, 16, 36, 64]

Funciones Integradas¶

Estas funciones están disponibles globalmente:

Función	Descripción
`print(...)`	Imprimir en stdout
`type(val)`	Obtener tipo como cadena
`tostring(val)`	Convertir a cadena
`tonumber(val)`	Convertir a número
`assert_eq(a, b, msg?)`	Afirmar igualdad
`assert_ne(a, b, msg?)`	Afirmar desigualdad

Soporte a BigInt¶

Zolo tiene soporte nativo a BigInt para enteros arbitrariamente grandes:

let big = BigInt.from("99999999999999999999999")
let zero = BigInt.zero()
let one = BigInt.one()