// lección 8

Listas y mapas

Listas [T] y mapas [K: V] con sus métodos.

Listas

Una lista guarda valores del mismo tipo, en orden. Se escribe [T]. Los índices empiezan en 0: notas[0] es el primero y se puede reasignar (notas[0] = 8).

var notas = [7, 9, 6]
notas.agregar(10)
notas[0] = 8

var nombres [cadena] = []      // una lista vacía necesita su tipo
nombres.agregar("Ana")

Leer con notas[i] fuera de rango es un error en tiempo de ejecución. Cuando el índice puede no existir, usa obtener, que devuelve un opcional (lección 7), y da un valor por defecto con o:

imprimir(notas.obtener(10) o 0)     // 0, no falla

Para recorrer una lista se usa repetir; una segunda variable recibe el índice:

repetir (notas) |nota|
	imprimir(nota)

repetir (nombres) |nombre, i|
	imprimir("${i}: ${nombre}")

Método	Resultado	Qué hace
`longitud()` / `esta_vacia()`	`entero` / `bool`	Tamaño de la lista
`contiene(v)`	`bool`	¿Está el valor?
`buscar_indice(v)`	`entero?`	Primer índice, o `.Ninguno`
`obtener(i)`	`T?`	Elemento, o `.Ninguno` si `i` no es válido
`primero()` / `ultimo()`	`T?`	Elementos de los extremos
`agregar(v)`	—	Añade al final
`extender(otra)`	—	Añade todos los elementos de otra lista
`insertar(i, v)`	`bool`	Inserta antes de `i`; `falso` si el índice no es válido
`eliminar(i)`	`bool`	Quita el elemento en `i`
`copiar()`	`[T]`	Copia independiente
`invertir()`	—	Da la vuelta a la lista
`ordenar()`	—	Ordena de menor a mayor una lista de números o de cadenas
`ordenar_por(claves)`	—	Ordena cualquier lista según una lista paralela de claves

Las listas se comparten como los objetos: si pasas una lista a una función y esta le agrega o le quita elementos, tú ves el cambio. Usa copiar() cuando necesites una lista independiente.

Mapas

Un mapa relaciona claves (cadena, entero o bool) con valores. Se escribe [clave: valor], y [:] es el mapa vacío. Leer devuelve un opcional, porque la clave puede no existir:

var edades = ["Ana": 12, "Luis": 14]
edades["Marta"] = 11
imprimir(edades["Pedro"] o 0)

var conteo [cadena: entero] = [:]     // vacío: necesita su tipo
conteo["el"] += 1                     // contar: una clave ausente empieza en 0

repetir (edades) |edad, nombre|     // valor primero, clave después; sin orden fijo
	imprimir("${nombre}: ${edad}")

Método	Resultado	Qué hace
`longitud()` / `esta_vacia()`	`entero` / `bool`	Cantidad de entradas
`contiene(k)`	`bool`	¿Existe la clave?
`obtener(k)`	`V?`	Igual que `mapa[k]`
`eliminar(k)`	`bool`	Quita la entrada; dice si existía
`claves()` / `valores()`	lista	Todas las claves / valores
`copiar()`	mapa	Copia superficial e independiente
`vaciar()`	—	Borra todas las entradas

Los mapas se comparten igual que las listas: si pasas un mapa a una función y esta lo cambia, tú ves el cambio. Usa copiar() para evitarlo. El ejemplo de listas completo está en examples/basico/06_listas.cometa.

Ejemplo de mapas

07_mapas.cometa

// Mapas: relacionan una clave con un valor, como un diccionario.

fn inicio()
	var edades = [
		"Ana": 12,
		"Luis": 14,
	]

	// Agregar o cambiar un valor.
	edades["Marta"] = 11
	edades["Ana"] = 13

	// Leer puede fallar si la clave no existe: usa o para dar un valor por defecto.
	imprimir(edades["Ana"] o 0)
	imprimir(edades["Pedro"] o 0)

	imprimir("¿Está Luis? ${edades.contiene("Luis")}")
	imprimir("Personas: ${edades.longitud()}")

	// El recorrido da primero el valor y luego la clave.
	// El orden no está garantizado.
	repetir (edades) |edad, nombre|
		imprimir("${nombre} tiene ${edad} años")

	// Contar palabras. Con += una clave que aún no existe empieza en 0.
	var conteo [cadena: entero] = [:]
	repetir ("el gato y el perro y el pez".dividir(" ")) |palabra|
		conteo[palabra] += 1
	imprimir("'el' aparece ${conteo["el"] o 0} veces")