Introduzione
Liste
Una lista in Gleam è una collezione immutabile di zero o più valori. I valori di una lista devono avere tutti lo stesso tipo. Dato che le liste sono immutabili, una volta costruita una lista il suo valore non può più cambiare. Qualsiasi funzione o operatore che sembri modificare una lista (come aggiungere un elemento) in realtà restituisce una nuova lista.
Le liste si possono definire così:
let empty = []
let singleValue = [5]
let threeValues = ["a", "b", "c"]
Il modo più comune per aggiungere un elemento a una lista è la sintassi spread:
let two_to_four = [2, 3, 4]
let one_to_four = [1, ..two_to_four]
// -> [1, 2, 3, 4]
Il modulo gleam/list nella libreria standard di Gleam contiene molte funzioni utili per lavorare con le liste. Questo modulo è usatissimo nel codice Gleam, quindi è bene conoscerlo.
I pattern delle liste si possono usare nelle espressioni case per confrontare le liste e assegnare a delle variabili i valori che contengono:
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"
}
}
Oltre a confrontare liste di lunghezza esatta, la sintassi spread si può usare per confrontare liste con almeno una certa lunghezza:
pub fn describe(list: List(String)) -> String {
case list {
[_, _, ..] -> "List with at least two items"
[_] -> "List with one item"
[] -> "Empty list"
}
}
La sintassi spread si può usare anche per assegnare a una variabile il resto della lista:
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
_ -> []
}
}
Le espressioni case dovrebbero avere un pattern per ogni possibile valore del tipo su cui si sta facendo il confronto, quindi spesso si usa un pattern di scarto finale (_) per gestire i valori rimanenti.
Istruzioni
In questo esercizio scriverai del codice per tenere traccia di un array di linguaggi di programmazione che vuoi imparare su Exercism.
Hai sei attività e tutte quante avranno a che fare con gli array.
1. Crea un nuovo array
Per tenere traccia dei linguaggi che vuoi imparare, dovrai creare un nuovo array. Definisci la funzione new_list, che restituisce un nuovo array vuoto.
new_list()
// -> []
2. Definisci un array esistente
Al momento hai un foglio di carta con l'elenco dei linguaggi che vuoi imparare: Gleam, Go e TypeScript. Definisci la funzione existing_list in modo che restituisca questo array.
existing_list()
// -> ["Gleam", "Go", "TypeScript"]
3. Aggiungi un nuovo linguaggio a un array
Mentre esplori Exercism e trovi linguaggi sempre più interessanti, vorrai aggiungerli al tuo array. Implementa la funzione add_language per aggiungere un nuovo linguaggio all'inizio del tuo array.
add_language(["OCaml", "Elixir"], "Scheme")
// -> ["Scheme", "OCaml", "Elixir"]
4. Conta i linguaggi nell'array
Contare i linguaggi uno per uno non è comodo. Implementa la funzione count_languages per contare quanti linguaggi ci sono nel tuo array.
count_languages(["jq", "Elm", "Rust", "Kotlin"])
// -> 4
5. Inverti l'array
A un certo punto ti accorgi che il tuo array è in realtà ordinato al contrario! Implementa la funzione reverse_list per invertire il tuo array.
reverse_list(["Python", "Julia", "Idris", "COBOL"])
// -> ["COBOL", "Idris", "Julia", "Python"]
6. Controlla se un array è entusiasmante
Anche se ami tutti i linguaggi, Gleam occupa un posto speciale nel tuo cuore. Per questo, un array di linguaggi ti entusiasma davvero se:
- Il primo elemento dell'array è Gleam.
- Il secondo elemento dell'array è Gleam e l'array contiene due o tre linguaggi.
Implementa la funzione exciting_list per controllare se un array di linguaggi è entusiasmante:
exciting_list(["Lua", "Gleam"])
// -> True
Esercizio di apprendimento
