Introdução
Listas
Uma lista em Gleam é uma coleção imutável de zero ou mais valores. Os valores de uma lista têm de ser todos do mesmo tipo. Como as listas são imutáveis, depois de uma lista ser construída, o seu valor nunca pode mudar. Quaisquer funções ou operadores que pareçam modificar uma lista (como adicionar um elemento) devolvem, na verdade, uma nova lista.
As listas podem ser definidas da seguinte forma:
let empty = []
let singleValue = [5]
let threeValues = ["a", "b", "c"]
A forma mais comum de adicionar um elemento a uma lista é através da sintaxe de espalhamento:
let two_to_four = [2, 3, 4]
let one_to_four = [1, ..two_to_four]
// -> [1, 2, 3, 4]
O módulo gleam/list da biblioteca padrão do Gleam contém muitas funções úteis para trabalhar com listas. Este módulo é muito usado no código em Gleam, por isso é bom conhecê-lo bem.
Os padrões de listas podem ser usados em expressões case para fazer correspondência com listas e atribuir os valores nelas contidos a variáveis:
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"
}
}
Além de fazer correspondência com listas de comprimento exato, a sintaxe de espalhamento pode ser usada para fazer correspondência com listas com pelo menos um certo comprimento:
pub fn describe(list: List(String)) -> String {
case list {
[_, _, ..] -> "List with at least two items"
[_] -> "List with one item"
[] -> "Empty list"
}
}
A sintaxe de espalhamento também pode ser usada para atribuir o resto da lista a uma variável:
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
_ -> []
}
}
As expressões case devem ter um padrão para cada valor possível do tipo com que se está a fazer correspondência, por isso é frequente usar um padrão de descarte (_) no fim para tratar os valores que restarem.
Instruções
Neste exercício vais escrever código para manteres o registo de uma lista de linguagens de programação que queres aprender no Exercism.
Tens seis tarefas, e todas elas envolvem lidar com listas.
1. Cria uma nova lista
Para manteres o registo das linguagens que queres aprender, vais precisar de criar uma nova lista. Define a função new_list, que devolve uma lista nova e vazia.
new_list()
// -> []
2. Define uma lista existente
De momento, tens uma folha de papel com as linguagens que queres aprender: Gleam, Go e TypeScript. Define a função existing_list para devolver esta lista.
existing_list()
// -> ["Gleam", "Go", "TypeScript"]
3. Adiciona uma nova linguagem a uma lista
À medida que exploras o Exercism e encontras linguagens mais interessantes, queres adicioná-las à tua lista. Implementa a função add_language para adicionar uma nova linguagem ao início da tua lista.
add_language(["OCaml", "Elixir"], "Scheme")
// -> ["Scheme", "OCaml", "Elixir"]
4. Conta as linguagens da lista
Contar as linguagens uma a uma é inconveniente. Implementa a função count_languages para contar o número de linguagens da tua lista.
count_languages(["jq", "Elm", "Rust", "Kotlin"])
// -> 4
5. Inverte a lista
A dada altura, dás conta de que a tua lista está, na verdade, ao contrário! Implementa a função reverse_list para inverteres a tua lista.
reverse_list(["Python", "Julia", "Idris", "COBOL"])
// -> ["COBOL", "Idris", "Julia", "Python"]
6. Verifica se a lista é entusiasmante
Embora gostes de todas as linguagens, o Gleam tem um lugar especial no teu coração. Por isso, ficas mesmo entusiasmado com uma lista de linguagens se:
- A primeira da lista for Gleam.
- O segundo item da lista for Gleam e a lista tiver duas ou três linguagens.
Implementa a função exciting_list para verificar se uma lista de linguagens é entusiasmante:
exciting_list(["Lua", "Gleam"])
// -> True
Exercício de aprendizagem
