Introdução
Arrays
A biblioteca central do Cairo implementa um tipo Array.
É semelhante aos tipos de array habituais noutras linguagens de programação, mas com algumas diferenças importantes:
- Só é possível adicionar elementos de forma eficiente ao fim do tipo
Array, e só é possível removê-los de forma eficiente do início.
- É impossível definir um item manualmente através do índice do array.
Os arrays podem ser criados com a função ArrayTrait::new e também com a macro array!:
let empty: Array<u32> = ArrayTrait::new();
let one_to_four = array![1, 2, 3, 4];
É possível adicionar elementos ao array com a função ArrayTrait::append:
let mut num_array = array![1, 2, 3, 4];
num_array.append(5);
// -> [1, 2, 3, 4, 5]
É possível remover elementos do array com a função ArrayTrait::pop_front:
let mut one_to_four = array![1, 2, 3, 4];
one_to_four.pop_front();
// -> [2, 3, 4]
O Cairo também introduz um tipo Span que funciona como um «instantâneo» do Array.
Todos os Array podem ser convertidos num Span com a função ToSpanTrait::span:
let one_to_four = array![1, 2, 3, 4];
let one_to_four_span = one_to_four.span();
// -> [1, 2, 3, 4]
Converter um array num Span é muito eficiente, porque Span é apenas uma estrutura de dados que permite ao Cairo «ver» uma secção do array, sem o modificar de modo algum.
Ao converter um array num Span, o Cairo permite realizar mais operações do que as que seriam permitidas diretamente no Array, como remover um item do início do span.
let one_to_four = array![1, 2, 3, 4];
let mut one_to_four_span = one_to_four.span();
one_to_four_span.pop_back();
// -> [2, 3, 4]
Repara que tivemos de tornar one_to_four_span mutável com a palavra-chave mut para podermos invocar pop_back, que modifica o span ao encurtar a secção do array que o span está a «ver».
Instruções
Como aspirante a maga, a Elyse precisa de praticar o básico.
Tem uma pilha de cartas que quer manipular.
Para facilitar um pouco as coisas, só usa as cartas de 1 a 10.
A pilha de cartas é representada por um Array, com a base da pilha na frente do array e o topo da pilha na parte de trás.
1. Insere uma carta no topo da pilha
Implementa a função insert_top, que devolve uma cópia da pilha com a nova carta fornecida adicionada ao topo da pilha.
let stack = array![5, 9, 7, 1];
insert_top(stack, 8);
// -> [5, 9, 7, 1, 8]
2. Remove a carta do topo da pilha
Implementa a função remove_top_card, que devolve uma cópia da pilha sem a carta do topo.
Se a pilha dada estiver vazia, a pilha original deve ser devolvida, sem alterações.
let stack = array![3, 2, 6, 4, 8];
remove_top_card(stack);
// -> [3, 2, 6, 4]
3. Insere uma carta na base da pilha
Implementa a função insert_bottom, que devolve uma cópia da pilha com a nova carta fornecida adicionada à base da pilha.
let stack = array![5, 9, 7, 1];
insert_bottom(stack, 8);
// -> [8, 5, 9, 7, 1]
4. Remove uma carta da base da pilha
Implementa a função remove_bottom_card, que devolve uma cópia da pilha sem a carta da base.
Se a pilha dada estiver vazia, a pilha original deve ser devolvida, sem alterações.
let stack = array![8, 5, 9, 7, 1];
remove_bottom_card(stack);
// -> [5, 9, 7, 1]
5. Verifica o tamanho da pilha
Implementa a função check_size_of_stack, que verifica se o tamanho da pilha é igual a um dado stack_size ou não.
let stack = array![3, 2, 6, 4, 8];
check_size_of_stack(stack, 4);
// -> false
Para perceber porque trabalhar com arrays em Cairo não é tão simples como noutras linguagens de programação, é útil ter em conta que Cairo usa um modelo de memória imutável, ou seja, depois de uma célula de memória ser escrita, esta nunca pode ser sobrescrita, apenas lida.
A linguagem abstrai um pouco esta característica, permitindo aos programadores declarar e usar as suas variáveis como se fossem mutáveis.
Embora isto torne escrever código um pouco mais desafiante, especialmente código que faz uso do tipo Array (incluindo ByteArray, que, por baixo, é um "array de bytes"), permite escrever programas demonstráveis que podem ser executados com confiança mesmo em máquinas não fidedignas, o que faz com que esta troca valha bem a pena.
Exercício de aprendizagem
