Introducción
Arrays
Un array en Gleam es una colección inmutable de cero o más valores. Todos los valores de un array deben tener el mismo tipo. Como los arrays son inmutables, una vez que se ha construido un array, su valor nunca puede cambiar. Cualquier función u operador que parezca modificar un array (como añadir un elemento) en realidad devolverá un array nuevo.
Los arrays se pueden definir así:
let empty = []
let singleValue = [5]
let threeValues = ["a", "b", "c"]
La forma más habitual de añadir un elemento a un array 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 arrays. Este módulo se usa muchísimo en el código de Gleam, así que es buena idea conocerlo bien.
Los patrones de array se pueden usar en expresiones case para hacer coincidir arrays y asignar a variables los valores que contienen:
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 hacer coincidir arrays de longitud exacta, la sintaxis de propagación se puede usar para hacer coincidir arrays 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 del array 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, por lo que a menudo se usa un patrón de descarte final (_) para gestionar 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, todas ellas relacionadas con arrays.
1. Crea un array nuevo
Para llevar un registro de los lenguajes que quieres aprender, necesitarás crear un array nuevo. Define la función new_list que devuelva un array nuevo y vacío.
new_list()
// -> []
2. Define un array existente
Actualmente tienes un trozo 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. Añade un lenguaje nuevo a un array
A medida que exploras Exercism y encuentras lenguajes más interesantes, quieres añadirlos a tu array. Implementa la función add_language para añadir un lenguaje nuevo al principio de tu array.
add_language(["OCaml", "Elixir"], "Scheme")
// -> ["Scheme", "OCaml", "Elixir"]
4. Cuenta los lenguajes del array
Contar los lenguajes uno a uno es incómodo. Implementa la función count_languages para contar el número de lenguajes de 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 un array es emocionante
Aunque te encantan todos los lenguajes, Gleam ocupa un lugar especial en tu corazón. Por eso, un array de lenguajes te entusiasma 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
