Introduzione
Array
La libreria core di Cairo implementa un tipo Array.
È simile ai tipi array che si trovano di solito negli altri linguaggi di programmazione, ma con alcune differenze fondamentali:
- Gli elementi possono essere aggiunti in modo efficiente solo in fondo al tipo
Array, e possono essere rimossi in modo efficiente solo dalla parte iniziale.
- È impossibile impostare manualmente un elemento usando l'indice dell'array.
Gli array possono essere creati con la funzione ArrayTrait::new ed anche con la macro array!:
let empty: Array<u32> = ArrayTrait::new();
let one_to_four = array![1, 2, 3, 4];
Gli elementi possono essere aggiunti all'array con la funzione ArrayTrait::append:
let mut num_array = array![1, 2, 3, 4];
num_array.append(5);
// -> [1, 2, 3, 4, 5]
Gli elementi possono essere rimossi dall'array con la funzione ArrayTrait::pop_front:
let mut one_to_four = array![1, 2, 3, 4];
one_to_four.pop_front();
// -> [2, 3, 4]
Cairo introduce anche un tipo Span che si comporta come una «istantanea» dell'Array.
Ogni Array può essere convertito in uno Span con la funzione ToSpanTrait::span:
let one_to_four = array![1, 2, 3, 4];
let one_to_four_span = one_to_four.span();
// -> [1, 2, 3, 4]
Convertire un array in uno Span è molto efficiente: Span è solo una struttura dati che permette a Cairo di «vedere» una sezione dell'array, non la modifica in alcun modo.
Convertendo un array in uno Span, Cairo permette di eseguire più operazioni di quante ne sarebbero consentite direttamente su Array, come rimuovere un elemento dall'inizio dello 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]
Nota che abbiamo dovuto rendere one_to_four_span mutabile con la parola chiave mut per chiamare pop_back, che modifica lo span accorciando la sezione dell'array che lo span sta «vedendo».
Istruzioni
Come aspirante maga, Elyse deve esercitarsi con le basi.
Ha una pila di carte che vuole manipolare.
Per rendere le cose un po' più semplici, usa solo le carte dall'1 al 10.
La pila di carte è rappresentata da un Array, con il fondo della pila all'inizio dell'array e la cima della pila alla fine.
1. Inserire una carta in cima alla pila
Implementa la funzione insert_top che restituisce una copia della pila con la nuova carta fornita aggiunta in cima alla pila.
let stack = array![5, 9, 7, 1];
insert_top(stack, 8);
// -> [5, 9, 7, 1, 8]
2. Rimuovere la carta in cima alla pila
Implementa la funzione remove_top_card che restituisce una copia della pila a cui è stata rimossa la carta in cima.
Se la pila fornita è vuota, va restituita la pila originale, invariata.
let stack = array![3, 2, 6, 4, 8];
remove_top_card(stack);
// -> [3, 2, 6, 4]
3. Inserire una carta in fondo alla pila
Implementa la funzione insert_bottom che restituisce una copia della pila con la nuova carta fornita aggiunta in fondo alla pila.
let stack = array![5, 9, 7, 1];
insert_bottom(stack, 8);
// -> [8, 5, 9, 7, 1]
4. Rimuovere una carta dal fondo della pila
Implementa la funzione remove_bottom_card che restituisce una copia della pila a cui è stata rimossa la carta in fondo.
Se la pila fornita è vuota, va restituita la pila originale, invariata.
let stack = array![8, 5, 9, 7, 1];
remove_bottom_card(stack);
// -> [5, 9, 7, 1]
5. Controllare la dimensione della pila
Implementa la funzione check_size_of_stack che controlla se la dimensione della pila è uguale a un dato stack_size oppure no.
let stack = array![3, 2, 6, 4, 8];
check_size_of_stack(stack, 4);
// -> false
Per capire perché lavorare con gli array in Cairo non è così semplice come in altri linguaggi di programmazione, è utile tenere a mente che Cairo usa un modello di memoria immutabile: una volta che una cella di memoria viene scritta, non può più essere sovrascritta, ma solo letta.
Il linguaggio astrae in parte questa caratteristica, consentendo agli sviluppatori di dichiarare e usare le proprie variabili come se fossero mutabili.
Anche se questo rende la scrittura del codice un po' più impegnativa, specialmente il codice che fa uso del tipo Array (incluso ByteArray, che sotto è un «array di byte»), consente di scrivere programmi dimostrabili che possono essere eseguiti con sicurezza anche su macchine non attendibili, rendendo il compromesso più che vantaggioso.
Esercizio di apprendimento
