Arreglos (arrays)

Un array es la colección más básica de Zolo: una lista ordenada de valores accesibles por posición (índice 0). El tipo se infiere como [T] a partir del literal [a, b, c].

La indexación y el tamaño son directos:

Literal, indexación, push/pop, slicing, spread y operaciones funcionales.

01-arrays.zolo

Playground

// Feature: Arrays — 0-indexed ordered collection

// Syntax: `[a, b, c]`, indexing `arr[i]`, slicing `arr[i..j]`

// When to use: list of N values accessible by position, order

// matters, frequent append/pop.


use std::Array

// Literal and 0-based indexing.

let nums = [10, 20, 30, 40, 50]
print(nums[0])  // 10

print(nums[4])  // 50

print(nums.len())  // 5


// Type inferred as `[int]`. Explicit annotation:

let names: [str] = ["Alice", "Bob", "Carol"]
print(names[1])  // Bob


// Mutability: `let mut` + `Array.push/pop` or `.push()`.

let mut bag = [1, 2, 3]
bag.push(4)
bag.push(5)
print(bag)  // [1, 2, 3, 4, 5]


let last = bag.pop()
print(last)  // 5

print(bag)  // [1, 2, 3, 4]


// Slicing by range — creates a new array.

let s = nums[0..3]  // [10, 20, 30]   exclusive

let t = nums[2..=4]  // [30, 40, 50]   inclusive

print(s)
print(t)

// Spread in literals.

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


// Functional operations (see also 05-functions/06-higher-order).

let doubled = Array::map([1, 2, 3], |x| x * 2)
let evens = Array::filter([1, 2, 3, 4], |x| x % 2 == 0)
let total = Array::reduce([1, 2, 3, 4], |acc, x| acc + x, 0)
print(doubled)  // [2, 4, 6]

print(evens)  // [2, 4]

print(total)  // 10


// Sort and reverse — return a new array.

let desc = Array::sort([3, 1, 4, 1, 5, 9, 2]).reverse()
print(desc)  // [9, 5, 4, 3, 2, 1, 1]

Algunos puntos importantes:

Slicing con [i..j] (exclusivo) o [i..=j] (inclusivo) crea un nuevo array.
Spread [...a, ...b] fusiona arrays dentro de un nuevo literal.
Array::map y Array::filter devuelven nuevos arrays sin modificar el original. Array::reduce combina los elementos en un resultado.

Los elementos opcionales mantienen su posición

Un elemento del array puede ser nil: [nil, 8, nil] tiene longitud 3. Asignar nil a una posición existente o llamar a push(nil) mantiene esa posición presente. pop() y remove_at(indice) eliminan posiciones. La iteración visita cada posición, incluso la primera y la última cuando contienen nil.

Conserva valores ausentes durante la construcción, la iteración y un pipeline.

nullable_arrays.zolo

Playground

// Missing values still occupy array slots.

let scores: [int?] = [nil, 8, nil]
scores.push(nil)
print(scores.len()) // 4

for index, score in scores {
    print("{index}: {score ?? 0}")
}

// Mapping to nil preserves the number and order of results.

let optional_scores = Iter.from(scores)
    .map(|score| if (score ?? 0) == 8 { score } else { nil })
    .collect()
print(optional_scores)

map conserva un resultado por entrada aunque el callback devuelva nil. Usa filter para eliminar elementos de forma explícita. Los mapas mantienen otra semántica para las claves: asignar nil elimina la clave.

Desafío

Usa Array::filter para filtrar los números impares de [1, 2, 3, 4, 5, 6] y luego Array::reduce para sumar el resultado. La suma debe ser 9.

Los elementos opcionales mantienen su posición

Encuentra tu camino por Zolo

Empieza aquí