Introduction
Les génériques permettent d'écrire du code qui fonctionne avec plusieurs types sans duplication. Définis des types génériques en utilisant des chevrons <T>, où T est un espace réservé pour n'importe quel type.
fn largest_list<T>(l1: Array<T>, l2: Array<T>) -> Array<T> {
if l1.len() > l2.len() {
l1
} else {
l2
}
}
Cairo exige des bornes de trait pour spécifier quelles opérations le type générique doit prendre en charge. Tu peux ajouter des contraintes avec la syntaxe + :
fn process_data<T, +Drop<T>, +Copy<T>>(value: T) -> T {
// Function body
}
Les structures peuvent aussi être génériques :
#[derive(Drop)]
struct Container<T> {
value: T,
}
Les traits peuvent aussi être génériques, ce qui leur permet de fonctionner avec différents types :
trait Processor<T> {
fn process(self: @T) -> ByteArray;
}
impl MyProcessor<T, +Drop<T>> of Processor<T> {
fn process(self: @T) -> ByteArray {
"processed"
}
}
Les fonctions peuvent accepter des paramètres génériques avec des bornes de trait, ce qui leur permet de fonctionner avec tout type qui implémente le trait requis :
fn use_processor<T, +Processor<T>, +Drop<T>>(item: T) -> ByteArray {
item.process()
}
Instructions
Le nouvel aéroport de Berlin t'a recruté comme développeur pour son laboratoire de robots.
Ils ont des robots un peu patauds, à l'allure vaguement humanoïde, qu'ils essaient d'utiliser pour améliorer le service client.
Ta première mission est de programmer le robot pour qu'il salue les gens dans leur langue maternelle après qu'ils ont scanné leur passeport à la borne d'enregistrement automatique.
Le robot est fier de ses capacités, il annonce donc toujours d'abord la langue qu'il parle, puis il salue la personne.
Par exemple, si quelqu'un scanne un passeport allemand, le robot dit :
I can speak German: Hallo Dietrich!
1. Crée la fonctionnalité abstraite de salutation
Tu dois structurer ton code pour qu'il soit facile, pour toi comme pour les autres développeurs, d'ajouter des langues.
Pour commencer, définis un trait Greeter avec deux fonctions.
-
language_name, qui renvoie la langue (un ByteArray) que le robot utilisera pour saluer le visiteur.
-
greet, qui prend le nom d'un visiteur (un ByteArray) et renvoie le message de salutation dans une langue donnée (un ByteArray).
Ensuite, implémente une fonction say_hello qui prend le nom du visiteur et quelque chose qui implémente le trait Greeter, et qui renvoie la salutation voulue (un ByteArray).
Par exemple, imagine une implémentation allemande de Greeter pour laquelle language_name renvoie "German" et greet renvoie "Hallo {name}!" :
say_hello("Dietrich", germanGreeter)
// => "I can speak German: Hallo Dietrich!"
2. Implémente l'italien
Maintenant, fais en sorte que le robot fonctionne pour les personnes qui scannent un passeport italien.
Crée une structure Italian et implémente les deux fonctions pour répondre au trait Greeter de la tâche 1.
Tu peux saluer quelqu'un en italien avec "Ciao {name}!".
3. Implémente le français
Avant de conclure la journée, tu es censé ajouter la fonctionnalité qui permet de saluer les gens en français.
Crée une structure French et implémente les deux fonctions pour répondre au trait Greeter.
Tu peux saluer quelqu'un en français avec "Bonjour {name}!".
Exercice d'apprentissage
