Introducción
Listas
Una lista en Gleam es una colección inmutable de cero o más valores. Todos los valores de una lista deben tener el mismo tipo. Como las listas son inmutables, una vez que se construye una lista, su valor nunca puede cambiar. Cualquier función u operador que parezca modificar una lista (como agregar un elemento) en realidad devolverá una lista nueva.
Las listas se pueden definir así:
let empty = []
let singleValue = [5]
let threeValues = ["a", "b", "c"]
La forma más común de agregar un elemento a una lista es mediante la sintaxis de propagación:
let two_to_four = [2, 3, 4]
let one_to_four = [1, ..two_to_four]
// -> [1, 2, 3, 4]
El módulo gleam/list de la biblioteca estándar de Gleam contiene muchas funciones útiles para trabajar con listas. Este módulo se usa mucho en el código de Gleam, así que es bueno estar familiarizado con él.
Los patrones de lista se pueden usar en expresiones case para hacer coincidir con listas y asignar los valores que contienen a variables:
pub fn describe(list: List(String)) -> String {
case list {
[] -> "Empty list"
[x] -> "List with one item: " <> x
[x, y] -> "List with two items: " <> x <> " and " <> y
_ -> "List with three or more items"
}
}
Además de coincidir con listas de longitud exacta, la sintaxis de propagación se puede usar para coincidir con listas de al menos cierta longitud:
pub fn describe(list: List(String)) -> String {
case list {
[_, _, ..] -> "List with at least two items"
[_] -> "List with one item"
[] -> "Empty list"
}
}
La sintaxis de propagación también se puede usar para asignar el resto de la lista a una variable:
pub fn remove_first_item(list: List(String)) -> List(String) {
case list {
// Return the list without the first item
[_, ..rest] -> rest
// There's no first item to remove, return an empty list
_ -> []
}
}
Las expresiones case deben tener un patrón para cada valor posible del tipo con el que se hace coincidir, así que a menudo se usa un patrón de descarte (_) al final para manejar los valores que queden.
Instrucciones
En este ejercicio vas a escribir código para llevar un registro de un array de lenguajes de programación que quieres aprender en Exercism.
Tienes seis tareas, y todas implican trabajar con arrays.
1. Crea un nuevo array
Para llevar un registro de los lenguajes que quieres aprender, necesitarás crear un nuevo array. Define la función new_list que devuelve un nuevo array vacío.
new_list()
// -> []
2. Define un array existente
Por ahora tienes una hoja de papel con los lenguajes que quieres aprender: Gleam, Go y TypeScript. Define la función existing_list para que devuelva este array.
existing_list()
// -> ["Gleam", "Go", "TypeScript"]
3. Agrega un nuevo lenguaje a un array
A medida que exploras Exercism y encuentras lenguajes más interesantes, quieres agregarlos a tu array. Implementa la función add_language para agregar un nuevo lenguaje al principio de tu array.
add_language(["OCaml", "Elixir"], "Scheme")
// -> ["Scheme", "OCaml", "Elixir"]
4. Cuenta los lenguajes del array
Contar los lenguajes uno por uno es incómodo. Implementa la función count_languages para contar cuántos lenguajes hay en tu array.
count_languages(["jq", "Elm", "Rust", "Kotlin"])
// -> 4
5. Invierte el array
En algún momento te das cuenta de que tu array en realidad está ordenado al revés. Implementa la función reverse_list para invertir tu array.
reverse_list(["Python", "Julia", "Idris", "COBOL"])
// -> ["COBOL", "Idris", "Julia", "Python"]
6. Comprueba si el array es emocionante
Aunque amas todos los lenguajes, Gleam ocupa un lugar especial en tu corazón. Por eso, un array de lenguajes te emociona mucho si:
- El primero del array es Gleam.
- El segundo elemento del array es Gleam y el array contiene dos o tres lenguajes.
Implementa la función exciting_list para comprobar si un array de lenguajes es emocionante:
exciting_list(["Lua", "Gleam"])
// -> True
Ejercicio de aprendizaje
