Écriture de notre fonction

Nous allons écrire le code d’une fonction qui calcule le périmètre d’un carré.

Nous devons d’abord apprendre comment s’organise un projet (crate) Rust : il se compose d’une librairie (ou API) et / ou d’un programme exécutable.

Librairie, programme

Dans un projet (crate) Rust, nous disposons généralement d’une partie API (librairie) et d’une partie programme.

Par convention, Cargo s’attend à trouver :

• le code source d’un programme dans src/main.rs et / ou
• le code source d’une librairie dans src/lib.rs.

Ceci est le comportement simple par défaut. Nous verrons par la suite comment donner des indications au compilateur pour utiliser d’autres fichiers et / ou comment ajouter des composants internes et externes au projet.

Mise en application

Nous créons un nouveau projet mon_api_maths en dehors de tout autre projet (dans ~/mesprojets dans mon cas).

Nous y créons le fichier src/lib.rs et écrivons notre code source, à commencer par la fonction souhaitée.

Code source sans documentation

Note au sujet des notations

Je m’assure ici et pendant quelques temps d’utiliser des notations de typage complètes et strictes.
Cela garantit une parfaite lisibilité EXPLICITE des codes afin que vous distinguiez mieux les types utilisés. ¹
Ceci vous permet également d’apprendre ces conventions d’écriture.

Rassurez-vous, Rust pratique couramment l’inférence de type et nous pourrons nous passer de cette rigueur par la suite.
Ce d’autant plus que, comme nous le verrons, le compilateur Rust nous prémunit de toute erreur de typage à la compilation : si le code compile, c’est que nos types correspondent bien ou ont bien été inférés par le compilateur. Nous n’aurons pas de mauvaise surprise sur ce plan lors de l’exécution de nos programmes.

Les notations cote_u64: u64 = et 4_u64 ci-après ne sont absolument pas indispensables grâce à l’inférence de type. Il est toutefois utile de les connaître et de prendre l’habitude de « mentaliser » le type d’une valeur littérale lorsque nous l’écrivons ou la lisons dans nos codes Rust.

Code de notre fonction

#![allow(unused)]
fn main() {
pub fn calculer_perimetre(cote: u32) -> u64 {
    cote_u64: u64 = cote as u64;
    cote_u64 * 4_u64
}
}

Apprentissages

Cette fonction nous permet d’apprendre quelques notions de base essentielles :

• Nous déclarons une fonction avec le mot-clef fn suivi du nom de la fonction calculer_perimetre ;
  • les conventions de nommage Rust recommandent le snake_case (mots séparés par un _) pour les noms de variables et de fonctions ;
• (cote: u32) est la partie paramètres d’entrée de la fonction. Notre fonction a besoin d’un paramètre cote, de type u32.
  • u32 est le type entier non signé (positif ou nul) de 32 bits.
• -> u64 est le type du retour de notre fonction.
  • u64 est le type entier non signé (positif ou nul) de 64 bits.
    • J’utilise cette astuce pour éviter un éventuel dépassement du maximum possible en u32. ¹
• {} les accolades délimitent ici le corps de notre fonction. Plus généralement, nous pouvons définir des blocs par des accolades à tout endroit dans nos codes Rust.
• cote_u64 * 4 est une expression qui calcule ET constitue le retour de notre fonction.
  • Dans une fonction Rust, la dernière expression non suivie d’un ; est, par convention, le retour de cette fonction.
• pub indique que nous souhaitons rendre la fonction disponible et accessible à tout programme qui le souhaite.

Nous le verrons, Rust n’autorise pas les opérations sur des variables de types différents.
C’est la raison pour laquelle, si je souhaite renvoyer un résultat de type u64 , je dois d’abord convertir l’argument passé à ma fonction dans une variable du même type.
Je le fais avant le calcul. Si je le faisais sur une valeur calculée qui serait (cote * 4) en u32, je perdrais tout l’intérêt de cette astuce préventive. ¹

#![allow(unused)]
fn main() {
pub fn calculer_perimetre(cote: u32) -> u64 {
    (cote as u64) * 4_u64
}
}

1. Oui, je suis taquin et pointilleux. ↩ ↩2 ↩3