Introduction
Tableaux
La bibliothèque de base de Cairo implémente un type Array.
Il est similaire aux tableaux que l'on trouve habituellement dans d'autres langages de programmation, mais avec quelques différences importantes :
- On ne peut ajouter des éléments efficacement qu'à la fin du type
Array, et on ne peut les retirer efficacement qu'au début.
- Il est impossible de définir manuellement un élément en utilisant l'indice du tableau.
On peut créer des tableaux avec la fonction ArrayTrait::new et aussi avec la macro array! :
let empty: Array<u32> = ArrayTrait::new();
let one_to_four = array![1, 2, 3, 4];
On peut ajouter des éléments au tableau avec la fonction ArrayTrait::append :
let mut num_array = array![1, 2, 3, 4];
num_array.append(5);
// -> [1, 2, 3, 4, 5]
On peut retirer des éléments du tableau avec la fonction ArrayTrait::pop_front :
let mut one_to_four = array![1, 2, 3, 4];
one_to_four.pop_front();
// -> [2, 3, 4]
Cairo introduit aussi un type Span qui agit comme un « instantané » du Array.
On peut convertir n'importe quel Array en Span avec la fonction ToSpanTrait::span :
let one_to_four = array![1, 2, 3, 4];
let one_to_four_span = one_to_four.span();
// -> [1, 2, 3, 4]
Convertir un tableau en Span est très efficace, car Span n'est qu'une structure de données qui permet à Cairo de « voir » une section du tableau, sans la modifier d'aucune façon.
En convertissant un tableau en Span, Cairo autorise davantage d'opérations que ce qui serait permis directement sur Array, comme retirer un élément au début du 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]
Note qu'on a dû rendre one_to_four_span mutable avec le mot-clé mut pour pouvoir appeler pop_back, qui modifie le span en raccourcissant la section du tableau que le span « voit ».
Instructions
Elyse, apprentie magicienne, doit s'entraîner sur quelques bases.
Elle a une pile de cartes qu'elle veut manipuler.
Pour simplifier un peu les choses, elle n'utilise que les cartes de 1 à 10.
La pile de cartes est représentée par un Array, le bas de la pile se trouvant au début du tableau et le haut de la pile à la fin.
1. Insère une carte au sommet de la pile
Implémente la fonction insert_top qui renvoie une copie de la pile à laquelle la nouvelle carte fournie a été ajoutée au sommet.
let stack = array![5, 9, 7, 1];
insert_top(stack, 8);
// -> [5, 9, 7, 1, 8]
2. Retire la carte du sommet de la pile
Implémente la fonction remove_top_card qui renvoie une copie de la pile dont la carte du sommet a été retirée.
Si la pile donnée est vide, la pile d'origine doit être renvoyée, inchangée.
let stack = array![3, 2, 6, 4, 8];
remove_top_card(stack);
// -> [3, 2, 6, 4]
3. Insère une carte au bas de la pile
Implémente la fonction insert_bottom qui renvoie une copie de la pile à laquelle la nouvelle carte fournie a été ajoutée au bas.
let stack = array![5, 9, 7, 1];
insert_bottom(stack, 8);
// -> [8, 5, 9, 7, 1]
4. Retire une carte du bas de la pile
Implémente la fonction remove_bottom_card qui renvoie une copie de la pile dont la carte du bas a été retirée.
Si la pile donnée est vide, la pile d'origine doit être renvoyée, inchangée.
let stack = array![8, 5, 9, 7, 1];
remove_bottom_card(stack);
// -> [5, 9, 7, 1]
5. Vérifie la taille de la pile
Implémente la fonction check_size_of_stack qui vérifie si la taille de la pile est égale à un stack_size donné ou non.
let stack = array![3, 2, 6, 4, 8];
check_size_of_stack(stack, 4);
// -> false
Pour comprendre pourquoi manipuler des tableaux à Cairo n'est pas aussi simple que dans d'autres langages de programmation, il est utile de garder à l'esprit que Cairo utilise un modèle de mémoire immuable, ce qui signifie qu'une fois qu'on a écrit dans une cellule mémoire, celle-ci ne peut jamais être écrasée et ne peut être que lue.
Le langage fait en partie abstraction de cette particularité, ce qui permet aux développeurs de déclarer et d'utiliser leurs variables comme si elles étaient mutables.
Même si cela rend l'écriture de code un peu plus délicate, en particulier le code qui fait appel au type Array (y compris ByteArray, qui est en interne un « tableau d'octets »), cela permet d'écrire des programmes prouvables qui peuvent être exécutés en toute confiance, même sur des machines non fiables, ce qui fait que le compromis en vaut largement la peine.
Exercice d'apprentissage
