Un programme Rust s'écrit dans un fichier avec l'extension .rs. Tout programme Rust doit contenir une fonction principale fn main() — c'est le point d'entrée du programme, là où l'exécution commence.
En Rust, une macro est une sorte de "commande spéciale" reconnaissable au ! à la fin de son nom.
Contrairement à une fonction classique, une macro est remplacée par du code avant la compilation — c'est le compilateur qui fait ce travail. Cela permet des choses qu'une fonction normale ne peut pas faire, comme accepter un nombre variable d'arguments.
La macro println! permet d'afficher du texte suivi d'un retour à la ligne tandis que la macro print! ne fais pas ce retour :
fn main() {
println!("Bonjour !");
println!("Je m'appelle {}", "Rust");
}
Les // permettent d'écrire des commentaires — le compilateur les ignore.
Modifiez le code à droite pour afficher exactement votre pokémon préféré parmi les 3 :
""" + self.answer[0] + " " + self.answer[1] + " " + self.answer[2] + """""" def tester(self): self.display("La zone à droite contient :
"
+ self.worker.escape(self.worker.execution_result) + "")
for a in self.answer:
if self.worker.execution_result.strip() == a:
self.display('Et elle contient bien le texte demandé !')
self.next_question()
return
self.display('Elle ne contient pas exactement «' + ", ".join(self.answer) + "»") for b in self.answer: if canonise(b) in canonise(self.worker.execution_result): self.display('
' + 'Auriez-vous mis un caractère en trop ? Un espace en trop ? Ou alors avez-vous oublié une majuscule ?') break def default_answer(self): return """// Une fonction main() est nécessaire pour le bon fonctionnement // d'un programme Rust fn main() { // println!(...) permet d'afficher ce que l'on veut println!("Coucou !"); } """ class Q_variables(Question): """Les variables et les conditions""" age = 0 def question(self): self.age = 15 + millisecs() % 50 return """
En Rust, on déclare une variable avec le mot-clé let :
let age: i32 = 25; // entier let pi: f64 = 3.14; // flottant let vrai: bool = true; // booléen let lettre: char = 'A'; // caractère let prenom: &str = "Alice"; // chaîne de caractères
Rust est un langage typé : chaque variable a un type précis. Rust peut souvent le deviner seul (inférence de type), mais annoter le type explicitement est une bonne habitude.
Si une variable n'est pas utilisée, Rust affiche un warning.
Pour l'éviter, préfixez son nom d'un _ : let _a = 5;
En Rust, une condition s'écrit avec if/else, sans parenthèses autour de la condition :
if date >= 2000 {
println!("récent");
} else {
println!("plus ancien");
}
Déclarez une variable prenom de type &str et une variable age de type i32 valant """ + str(self.age) + """. Affichez-les sur la même ligne avec println! :
println!("{} {}", prenom, age);
Ensuite, en utilisant un if/else, affichez "majeur" si age est supérieur ou égal à 18, sinon affichez "mineur".
""" def tester(self): result = self.worker.execution_result.strip() source = self.worker.source self.display("La zone en bas à droite contient :"
+ self.worker.escape(result) + "")
self.check(
source,
[
[r'let _a|let _b|let _vrai|let _caractere',
'Les variables exemples ignorées (underscore).'],
[r"let prenom: &str",
"Une variable «prenom» de type &str déclarée."],
[r"let age: i32",
"Une variable «age» de type i32 déclarée."],
[r'if ',
'«if» est utilisé pour la condition.'],
[r'else',
'«else» est utilisé pour le cas contraire.'],
])
# Vérifie que prenom et age apparaissent dans le même println!
found = False
for line in source.split('\n'):
if 'println!' in line and 'prenom' in line and 'age' in line:
found = True
self.message(found,
'«prenom» et «age» affichés ensemble dans un println!.')
# Vérifie le bon résultat pour le if/else
expected_word = 'mineur'
if self.age >= 18:
expected_word = 'majeur'
self.message(
expected_word in result,
'Le bon mot («majeur» ou «mineur») est affiché selon l\'âge.'
)
if self.all_tests_are_fine:
self.next_question()
def default_answer(self):
return """fn main() {
// Exemples de types en Rust (à ne pas modifier) :
let _a: i32 = 69; // Entiers
let _b: f64 = 3.14; // Flottants
let _vrai_ou_faux: bool = true; // Booléens
let _caractere: char = 'A'; // Caractère
// À vous : déclarez prenom (&str) et age (i32) ici
println!("Je suis {} et j'ai {} ans", ???, ???);
// À vous : ajoutez le if/else ici
}
"""
class Q_variables_mutables(Question):
"""Les variables mutables"""
answer = 1
def question(self):
return """
Par défaut en Rust, une variable est immuable — on ne peut pas modifier sa valeur après l'avoir déclarée. Si vous essayez, le compilateur vous le signale :
let x = 5;
x = 10; // ERREUR : cannot assign twice to
// immutable variable
Regardez le panneau Compilation en bas — c'est là que Rust vous explique ses erreurs. Ici il dirait quelque chose comme "cannot assign twice to immutable variable".
Pour rendre une variable modifiable, on ajoute mut :
let mut x = 5; x = 10; // OK ! x += 1; // OK !
Modifiez le code pour afficher compteur après qu'il ait été incrémenté de 1.
""" def tester(self): result = self.worker.execution_result.strip() self.display( "La zone en bas à droite contient :"
+ self.worker.escape(result)
+ ""
)
if int(result) == answer:
self.display("Et elle contient bien le texte demandé !")
self.next_question()
return
else:
self.display("Elle ne contient pas le texte demandé.")
def default_answer(self):
return """fn main() {
// Essayez de modifier compteur sans mut... regardez
// ce que dit le panneau Compilation !
let compteur = 0;
compteur += 1;
println!("???");
}
"""
class Q_Loop_Var_Mutables(Question):
"""La boucle loop"""
answer = [1,2,3,4,5,6,7,8,9,10]
def question(self):
return """
loop crée une boucle infinie. On en sort avec break :
let mut i = 0;
loop {
i += 1;
println!("{}", i);
if i == 3 {
break; // on sort de la boucle
}
}
Modifiez le code à droite pour afficher les nombres de 1 à 10. La variable doit afficher les nombres de 1 à 10 uniquement.
""" def tester(self): result = self.worker.execution_result.strip() expected = "\n".join(map(str, self.answer)) self.display( "La zone en bas à droite contient :"
+ self.worker.escape(result)
+ ""
)
if result == expected:
self.display("Et elle contient bien le texte demandé !")
self.next_question()
return
else:
self.display("Elle ne contient pas le texte demandé.")
def default_answer(self):
return """fn main() {
let compteur = 0;
loop {
compteur += 1;
println!("???");
if compteur == 3 {
break;
}
}
}
"""
class Q_tableaux(Question):
"""Les tableaux"""
answer = [10, 20, 30, 40, 50]
def question(self):
return """
En Rust, un tableau a une taille fixe définie à la compilation et est composé de cases de même type.
On le déclare ainsi :
let tab: [type; taille] = [valeur1, valeur2, ...]; // Exemples : let notes: [i32; 3] = [12, 15, 18]; let jours: [&str; 2] = ["Lundi", "Mardi"];
Pour parcourir un tableau, on utilise une boucle for. Avec & on passe une référence du tableau : la fonction le voit mais ne le prend pas, donc le tableau n’est pas perdu après l’appel. :
for element in ¬es {
println!("{}", element);
}
Ce code afficherait :
12 15 18
Déclarez un tableau nombres de 5 entiers contenant les valeurs 10, 20, 30, 40, 50. Affichez chaque élément sur une ligne séparée.
""" def tester(self): result = self.worker.execution_result.strip() expected = "\n".join(map(str, self.answer)) self.display( "La zone en bas à droite contient :"
+ self.worker.escape(result)
+ ""
)
if result == expected:
self.display("Et elle contient bien le texte demandé !")
self.next_question()
else:
self.display("Elle ne contient pas le texte demandé.")
def default_answer(self):
return """fn main() {
let nombres: [i32; 5] = [0, 0, 0, 0, 0]; // À modifier
for element in &nombres {
println!("???");
}
}
"""
class Q_INPUT_WHILE(Question):
"""Input et boucle while"""
def question(self):
return """
Pour avoir accès aux input/output en Rust, il faut utiliser le module io de la bibliothèque standard. Pour lire un input utilisateur il faut donc utiliser std::io::stdin()
.read_line(&mut input); sert à lire jusqu'à ce que l'utilisateur presse la touche Entrée.
let mut input = String::new();
std::io::stdin()
.read_line(&mut input)
.expect("ERREUR");
//Ces lignes permettent d'avoir un input utilisateur
"""
def tester(self):
result = self.worker.execution_result.strip()
self.display(
"La zone en bas à droite contient :"
+ self.worker.escape(result)
+ ""
)
if int(result) == 89:
self.display("Et elle contient bien le texte demandé !")
self.next_question()
else:
self.display("Elle ne contient pas le texte demandé.")
def default_answer(self):
return """use std::io;
fn main() {
let mut input = String::new();
io::stdin().read_line(&mut input).expect("Erreur");
prinln!("Tu as écris : {}",input);
}
"""
class Q_macros(Question):
"""Introduction aux macros Rust"""
answer = [10, 20, 30, 40, 50]
def question(self):
return """
En Rust, une macro est une sorte de "commande spéciale" reconnaissable au ! à la fin de son nom.
Contrairement à une fonction classique, une macro est remplacée par du code avant la compilation — c'est le compilateur qui fait ce travail. Cela permet des choses qu'une fonction normale ne peut pas faire, comme accepter un nombre variable d'arguments.
println!("Bonjour"); // texte simple
println!("{}", variable); // affiche une variable
println!("{} + {} = {}", a, b, a+b);
// plusieurs variables
let texte = format!("Je suis {} et j'ai {} ans.", prenom, age);
println!("{}", texte);
let nombres = vec![1, 2, 3, 4, 5];
// plus souple qu'un tableau fixe
La différence avec un tableau classique [i32; 5] : un vec! peut grandir dynamiquement, un tableau a une taille fixe.
En utilisant la macro vec!, créez un tableau dynamique contenant les valeurs 10, 20, 30, 40, 50 et affichez chaque élément sur une ligne séparée.
""" def tester(self): result = self.worker.execution_result.strip() expected = "\n".join(map(str, self.answer)) self.display( "La zone en bas à droite contient :"
+ self.worker.escape(result)
+ ""
)
self.message(
'let mut nombres = vec![]' in self.worker.source,
'«nombres» est un tableau dynamique vide et mutable.'
)
if result == expected:
self.display("Et elle contient bien le texte demandé !")
self.next_question()
else:
self.display("Elle ne contient pas le texte demandé.")
def default_answer(self):
return """fn main() {
// vec! crée un tableau dynamique
let mut nombres = ???;
let mut compteur = 10;
loop {
// push() ajoute un élément à la fin du tableau
nombres.push();
println!("{}", compteur);
if compteur == 50 {
break;
}
}
}
"""
class Q_if_else(Question):
"""If/else et rappel boucles"""
answer = ''
def question(self):
return """
En Rust, une condition s'écrit avec if/else :
if x > 0 {
println!("positif");
} else {
println!("négatif ou nul");
}
Pas de parenthèses autour de la condition — c'est propre au Rust.
Déclarez une variable nombre avec la valeur de votre choix. Affichez "positif" si elle est supérieure à 0, "négatif" si elle est inférieure à 0, et "nul" si elle est égale à 0.
""" def tester(self): result = self.worker.execution_result.strip() self.display( "La zone en bas à droite contient :"
+ self.worker.escape(result)
+ ""
)
self.check(
self.worker.source,
[
[r'if ',
'«if» est utilisé pour la condition.'],
[r'else',
'«else» est utilisé pour le cas contraire.'],
])
self.message(
result in ('positif', 'négatif', 'nul'),
'Le bon résultat est affiché.'
)
if self.all_tests_are_fine:
self.next_question()
def default_answer(self):
return """fn main() {
let nombre = 0; // changez cette valeur
if ??? {
println!("???");
} else if ??? {
println!("???");
} else {
println!("???");
}
}
"""
class Q_fonctions(Question):
"""Les fonctions"""
def question(self):
return """
En Rust, une fonction se déclare avec fn :
fn addition(a: i32, b: i32) -> i32 {
a + b // retour implicite : pas de ; ni de return
}
fn main() {
let resultat = addition(3, 5);
println!("{}", resultat);
}
Points clés :
let mut i = 0;
while i < 5 {
println!("{}", i);
i += 1;
}
Créez une fonction compter qui prend un entier max en paramètre et affiche tous les nombres de 1 jusqu'à max en utilisant un while. Appelez cette fonction depuis le main avec la valeur 5.
""" answer = '\n'.join(map(str, range(1, 6))) def tester(self): result = self.worker.execution_result.strip() expected = self.answer self.display( "La zone en bas à droite contient :"
+ self.worker.escape(result)
+ ""
)
self.message(
'fn compter' in self.worker.source,
'Une fonction «compter» est déclarée.'
)
self.message(
'fn compter(max: i32)' in self.worker.source,
'La fonction prend bien un paramètre «max» de type i32.'
)
self.message(
'while ' in self.worker.source,
'«while» est utilisé dans la fonction.'
)
self.message(
'compter(5)' in self.worker.source,
'La fonction est appelée avec la valeur 5 depuis le main().'
)
if result == expected:
self.display("Et elle contient bien le texte demandé !")
self.next_question()
else:
self.display("Elle ne contient pas le texte demandé.")
def default_answer(self):
return """fn compter(max: i32) {
let mut i = 1;
while ??? {
println!("???");
i += 1;
}
}
fn main() {
compter(???);
}
"""
class Q_POLYNOME(Question):
"""Racines d'un polynôme du 2nd degré"""
a = 0
b = 0
c = 0
answer = ''
def question(self):
return """
Un polynôme du 2nd degré s'écrit : ax² + bx + c = 0
Pour trouver ses racines, on calcule le discriminant :
delta = b² - 4ac
x1 = (-b + sqrt(delta)) / (2a)
x2 = (-b - sqrt(delta)) / (2a)
x = -b / (2a)
Il y a aussi un cas particulier : si a == 0, ce n'est plus un polynôme du 2nd degré !
Écrivez une fonction racines qui prend a, b, c en paramètres (f64) et affiche les racines du polynôme. Appelez-la depuis le main avec a={}, b={}, c={}.
""" def tester(self): #extract racines from the C5 result def extract_racines(result): vals = [] for line in result.split('\n'): line = line.strip() if '=' in line: parts = line.split('=') val = parts[1].strip() ok = True for c in val: if c not in "0123456789.-": ok = False if ok and len(val) > 0: vals.append(float(val)) return vals result = self.worker.execution_result if result is None: result = "" result = str(result) source = self.worker.source self.display( "La zone en bas à droite contient :"
+ self.worker.escape(result)
+ ""
)
# Some tests to compare the results from both result
racines = compute_racinesTAB(source)
self.display("Racines calculées : " + str(racines))
self.display("a,b,c = " + str(check_args(source)))
extracted = extract_racines(self.worker.execution_result)
self.display("EXTRACTED = " + JSON.stringify(extracted))
self.message( #1. "fn racines" exists
"fn racines" in source,
"Une fonction « racines » est déclarée."
)
self.message( #2. case a != 0.0 handled
"a != 0" in source or "a != 0.0" in source,
"Le cas « a != 0 » est bien traité."
)
self.message( #3. Is there 2 IF in the "a != 0.0" block ?
count_if_in_outer_if(source), # Function created at the beginning of the file
"Il y a 2 if imbriqués dans le bloc de a != 0.0."
)
expected = compute_racinesTAB(self.worker.source)
extracted = extract_racines(self.worker.execution_result)
self.message( #4. Is the result correct
compare_racines(expected, extracted),
'Les bonnes racines sont affichées.'
)
if self.all_tests_are_fine:
self.next_question()
def default_answer(self):
return """fn racines(a: f64, b: f64, c: f64) {
if a != 0.0 {
let delta = b * b - 4.0 * a * c;
if delta >= 0.0 {
if delta > 0.0 {
// deux racines
let x1 = (-b + delta.sqrt()) / (2.0 * a);
let x2 = (-b - delta.sqrt()) / (2.0 * a);
println!("x1 = {}", x1);
println!("x2 = {}", x2);
} else {
// delta == 0
let x = -b / (2.0 * a);
println!("x = {}", x);
}
} else {
println!("Pas de racine réelle");
}
} else {
println!("a est nul, ce n'est pas un polynôme du 2nd degré");
}
}
fn main() {
racines(0.0, 0.0, 0.0);
}
"""
###############################################################################################################################
class Q_carre(Question):
"""La fonction carré"""
n = 0
answer = 0
def question(self):
return """
Créez une fonction carre qui prend un entier n en paramètre et retourne son carré (n * n).
Créez également une fonction main qui appelle carre avec la valeur {} et affiche le résultat avec println!.
""" def tester(self): result = self.worker.execution_result.strip() source = self.worker.source def extract_result(result): return int(result.strip()) def Test_Carre(nombre): return nombre*nombre def check_carre_arg(source): chunks = source.split("carre(") for chunk in chunks[1:]: part = chunk.split(")", 1)[0].strip() if is_number(part): return int(part) return None def has_carre_signature(source): source_lower = source.lower() # Function name if 'fn carre' not in source.lower(): return False parts = source_lower.split('fn carre') if len(parts) < 2: return False after = parts[1].strip() if not after.startswith('('): # 1st parenthesis return False after = after[1:] paren_parts = after.split(')') # parameter type if len(paren_parts) < 2: return False param_part = paren_parts[0] rest = paren_parts[1] colon_parts = param_part.split(':') if len(colon_parts) < 2: return False param_type = colon_parts[1].strip() if param_type != 'i32': return False brace_parts = rest.split('{') # return type rest_before_brace = brace_parts[0] if '->' not in rest_before_brace or 'i32' not in rest_before_brace: return False return True def has_main_signature(source): if 'fn main' not in source: # Nom de la fonction return False parts = source.split('fn main') if len(parts) < 2: return False after = parts[1].strip() if not after.startswith('()'): # No args between the parenthesis return False return True # UNFINISHED # Problèmes sur le check du main: # Je veux 2 cas acceptés : # 1 - println!(...,carre(X)); # 2 - une variable contient le carre(X) et ensuite on affiche cette variable # Cas non acceptés : # - println!(un truc écrit dans le main) # - println!(une variable qui n'a aucun rapport) # - pas de println! dans le main # - pas de carre(X) dans le main # - autre cas non True def calls_carre_in_main(source): source_lower = str(source).lower() if 'fn main' not in source: # Check main self.display("sortie 4") return False main = source_lower.split('fn main')[1] if "carre(" not in main: # carre( and println! in 'main' self.display("sortie 2") return False if "println!" not in main: self.display("sortie 3") return False # take the variable name # Not working var_name = None if "carre(" in main: before = main.split("carre(", 1)[0] if "let" in before: let_part = before.split("let")[-1] var_name = let_part.split("=")[0].strip() var_name = var_name.replace("mut", "").strip() var_name = var_name.split(":")[0].strip() self.display("variable = "+var_name) # 4. analyser chaque println! for part in main.split("println!")[1:]: self.display("part =" + part) start = part.find("(") end = part.find(")") if start == -1 or end == -1 or end < start: continue args = part[start+1:end] # CAS 1 : carre in println!() if "carre(" in args: self.display("Ca marche 1") return True # CAS 2 : variable linked with carre() if var_name and var_name in args: self.display("Ca marche 2") return True self.display("sortie 4") return False self.message( #NOT DONE YET calls_carre_in_main(source), 'Le résultat de «carre» est affiché dans le main.' ) self.display( "La zone en bas à droite contient :"
+ self.worker.escape(result)
+ ""
)
self.message( #DONE
has_carre_signature(self.worker.source),
'La fonction «carre» a un paramètre i32 et retourne un i32.'
)
self.message( #DONE
has_main_signature(source),
'Une fonction «main()» a été créée.'
)
self.display("NBinC5= "+str(check_carre_arg(source)))
self.display("Calcul interne= " + str(Test_Carre(check_carre_arg(source))))
self.display("result extrait= " + str(extract_result(result)))
arg = check_carre_arg(source)
resultC5 = extract_result(result)
self.message( #DONE
Test_Carre(arg) == resultC5,
"Le bon résultat est affiché."
)
def default_answer(self):
self.n = 2
self.answer = self.n * self.n
return """// Créez votre fonction carre ainsi que
// votre fonction main ici
"""
class Q_End(Question):
"""Félicitation vous êtes arrivé au bout !"""
def question(self):
return "Plus de questions, vous êtes libre d'essayer ce que vous souhaitez !"
def tester(self):
self.display('FINI !')
def default_answer(self):
return """fn main(){
}
"""