Dhghomon / easy_rust: Rust expliqué en anglais simple

Mises à jour

23 mai 2021: Désormais disponible en indonésien grâce à Ariandy / 1kb.

2 avril 2021: Ajout du lien BuyMeACoffee pour ceux qui voudraient m’acheter un café.

1er février 2021: désormais disponible sur YouTube! Deux mois plus tard: tout est fait au 1er avril 2021 pour 186 vidéos au total (un peu plus de 23 heures).

22 décembre 2020: mdBook peut être trouvé ici.

28 novembre 2020: Désormais également disponible en chinois simplifié grâce à kumakichi!

introduction

Rust est une nouvelle langue qui a déjà de bons manuels. Mais parfois, ses manuels sont difficiles car ils sont destinés à des anglophones natifs. De nombreuses entreprises et personnes apprennent maintenant Rust, et ils pourraient apprendre plus rapidement avec un livre en anglais facile. Ce manuel est destiné à ces entreprises et à ces personnes pour apprendre Rust avec un anglais simple.

Rust est un langage assez récent, mais déjà très populaire. Il est populaire car il vous donne la vitesse et le contrôle du C ou du C ++, mais aussi la sécurité de la mémoire d’autres langages plus récents comme Python. Il le fait avec de nouvelles idées parfois différentes des autres langues. Cela signifie qu’il y a de nouvelles choses à apprendre et que vous ne pouvez pas simplement «comprendre au fur et à mesure». Rust est un langage auquel il faut réfléchir pendant un moment pour le comprendre. Mais cela semble toujours assez familier si vous connaissez un autre langage et il est fait pour vous aider à écrire du bon code.

Qui suis je?

Je suis un Canadien qui habite en Corée et j’ai écrit Easy Rust en réfléchissant à la manière de permettre aux entreprises d’ici de commencer à l’utiliser. J’espère que d’autres pays qui n’utilisent pas l’anglais comme première langue pourront également l’utiliser.

Écrire Rust en anglais simple

Rust dans un anglais facile a été écrit de juillet à août 2020 et compte plus de 400 pages. Vous pouvez me contacter ici ou sur LinkedIn ou sur Twitter si vous avez des questions. Si vous voyez quelque chose de mal ou avez une demande d’extraction à faire, continuez. Plus de 20 personnes ont déjà aidé en corrigeant les fautes de frappe et les problèmes dans le code, vous pouvez donc aussi. Je ne suis pas le meilleur expert de Rust au monde, donc j’aime toujours entendre de nouvelles idées ou voir où je peux améliorer le livre.

Ce livre comprend deux parties. Dans la partie 1, vous apprendrez autant de Rust que possible dans votre navigateur. Vous pouvez en fait apprendre presque tout ce que vous devez savoir sans installer Rust, donc la première partie est très longue. Puis à la fin se trouve la partie 2. Elle est beaucoup plus courte et concerne Rust sur votre ordinateur. C’est là que vous apprendrez tout ce dont vous avez besoin de savoir que vous ne pouvez faire qu’en dehors d’un navigateur. Quelques exemples sont: travailler avec des fichiers, prendre des entrées utilisateur, des graphiques et des paramètres personnels. Espérons qu’à la fin de la première partie, vous aimerez suffisamment Rust pour l’installer. Et si vous ne le faites pas, pas de problème – la partie 1 vous en apprend tellement que cela ne vous dérangera pas.

Aire de jeux de rouille

Voir ce chapitre sur YouTube

Peut-être que vous ne voulez pas encore installer Rust, et ce n’est pas grave. Vous pouvez aller sur https://play.rust-lang.org/ et commencer à écrire Rust sans quitter votre navigateur. Vous pouvez y écrire votre code et cliquer sur Exécuter pour voir les résultats. Vous pouvez exécuter la plupart des exemples de ce livre dans le Playground de votre navigateur. Seulement vers la fin, vous verrez des échantillons qui vont au-delà de ce que vous pouvez faire dans le Playground (comme ouvrir des fichiers).

Voici quelques conseils lors de l’utilisation du Rust Playground:

• Exécutez votre code avec Run
• Remplacez Debug par Release si vous souhaitez que votre code soit plus rapide. Débogage: compile plus rapidement, s’exécute plus lentement, contient des informations de débogage. Release: compile plus lentement, s’exécute beaucoup plus rapidement, supprime les informations de débogage.
• Cliquez sur Partager pour obtenir un lien URL. Vous pouvez l’utiliser pour partager votre code si vous avez besoin d’aide. Après avoir cliqué sur partager, vous pouvez cliquer sur Open a new thread in the Rust user forum pour demander de l’aide aux gens là-bas tout de suite.
• Outils: Rustfmt formatera votre code correctement.
• Outils: Clippy vous donnera des informations supplémentaires sur la façon d’améliorer votre code.
• Config: ici, vous pouvez changer votre thème en mode sombre afin de pouvoir travailler la nuit, et de nombreuses autres configurations.

Si vous souhaitez installer Rust, allez ici https://www.rust-lang.org/tools/install et suivez les instructions. Habituellement, vous utiliserez rustup pour installer et mettre à jour Rust.

? et ⚠️

Parfois, les exemples de code dans le livre ne fonctionnent pas. Si un exemple ne fonctionne pas, il aura un ? ou un ⚠️ dedans. ? c’est comme « en construction »: cela signifie que le code n’est pas complet. La rouille a besoin d’un fn main() (une fonction principale) à exécuter, mais parfois nous voulons juste regarder de petits morceaux de code pour qu’il n’y ait pas de fn main(). Ces exemples sont corrects, mais nécessitent un fn main() pour que vous les exécutiez. Et quelques exemples de code vous montrent un problème que nous allons résoudre. Ceux-là pourraient avoir un fn main() mais génèrent une erreur, et ainsi ils auront un ⚠️.

commentaires

Voir ce chapitre sur YouTube

Les commentaires sont faits pour que les programmeurs les lisent, pas pour l’ordinateur. Il est bon d’écrire des commentaires pour aider d’autres personnes à comprendre votre code. Il est également utile de vous aider à comprendre votre code plus tard. (Beaucoup de gens écrivent du bon code mais oublient ensuite pourquoi ils l’ont écrit.) Pour écrire des commentaires dans Rust, vous utilisez habituellement //:

fn main() {
    // Rust programs start with fn main()
    // You put the code inside a block. It starts with { and ends with }
    let some_number = 100; // We can write as much as we want here and the compiler won't look at it
}

Lorsque vous faites cela, le compilateur ne regardera rien à droite du //.

Il y a un autre type de commentaire avec lequel vous écrivez /* pour commencer et */ finir. Celui-ci est utile pour écrire au milieu de votre code.

fn main() {
    let some_number/*: i16*/ = 100;
}

Au compilateur, let some_number/*: i16*/ = 100; ressemble à let some_number = 100;.

le /* */ form est également utile pour les commentaires très longs sur plus d’une ligne. Dans cet exemple, vous pouvez voir que vous devez écrire // pour chaque ligne. Mais si vous tapez /*, ça ne s’arrêtera pas tant que tu n’auras pas fini avec */.

fn main() {
    let some_number = 100; /* Let me tell you
    a little about this number.
    It's 100, which is my favourite number.
    It's called some_number but actually I think that... */

    let some_number = 100; // Let me tell you
    // a little about this number.
    // It's 100, which is my favourite number.
    // It's called some_number but actually I think that...
}

Les types

Rust a de nombreux types qui vous permettent de travailler avec des nombres, des caractères, etc. Certains sont simples, d’autres plus compliqués et vous pouvez même créer les vôtres.

Types primitifs

Voir ce chapitre sur YouTube

Rust a des types simples qui sont appelés types primitifs (primitif = très basique). Nous commencerons par des entiers et char (personnages). Les entiers sont des nombres entiers sans point décimal. Il existe deux types d’entiers:

• Entiers signés,
• Entiers non signés.

Signé signifie + (signe plus) et - (signe moins), donc les entiers signés peuvent être positifs ou négatifs (par exemple +8, -8). Mais les entiers non signés ne peuvent être que positifs, car ils n’ont pas de signe.

Les entiers signés sont: i8, i16, i32, i64, i128, et isize.
Les entiers non signés sont: u8, u16, u32, u64, u128, et usize.

Le nombre après le i ou le u signifie le nombre de bits pour le nombre, donc les nombres avec plus de bits peuvent être plus grands. 8 bits = un octet, donc i8 est un octet, i64 est de 8 octets, et ainsi de suite. Les types de nombres avec des tailles plus grandes peuvent contenir des nombres plus grands. Par exemple, un u8 peut contenir jusqu’à 255, mais un u16 peut contenir jusqu’à 65535. Et un u128 peut contenir jusqu’à 340282366920938463463374607431768211455.

Donc qu’est-ce isize et usize? Cela signifie le nombre de bits sur votre type d’ordinateur. (Le nombre de bits sur votre ordinateur est appelé le architecture de votre ordinateur.) Donc isize et usize sur un ordinateur 32 bits, c’est comme i32 et u32, et isize et usize sur un ordinateur 64 bits, c’est comme i64 et u64.

Il existe de nombreuses raisons expliquant les différents types d’entiers. Une des raisons est la performance de l’ordinateur: un plus petit nombre d’octets est plus rapide à traiter. Par exemple, le nombre -10 en tant que i8 est 11110110, mais comme un i128 c’est 11111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111110110. Mais voici quelques autres utilisations:

Les personnages de Rust sont appelés char. Tous char a un nombre: la lettre A est le numéro 65, tandis que le caractère 友 (« ami » en chinois) est le numéro 21451. La liste des nombres s’appelle « Unicode ». Unicode utilise des nombres plus petits pour les caractères qui sont plus utilisés, comme A à Z, ou les chiffres de 0 à 9 ou l’espace.

fn main() {
    let first_letter = 'A';
    let space = ' '; // A space inside ' ' is also a char
    let other_language_char = 'Ꮔ'; // Thanks to Unicode, other languages like Cherokee display just fine too
    let cat_face = '?'; // Emojis are chars too
}

Les caractères les plus utilisés ont des nombres inférieurs à 256 et peuvent tenir dans un u8. Rappelez-vous, un u8 est 0 plus tous les nombres jusqu’à 255, pour 256 au total. Cela signifie que Rust peut en toute sécurité jeter une u8 dans une char, utilisant as. (« Jeter u8 comme char« signifie » faire semblant u8 est un char« )

Casting avec as est utile car Rust est très strict. Il a toujours besoin de connaître le type et ne vous permettra pas d’utiliser deux types différents ensemble, même s’ils sont tous les deux des entiers. Par exemple, cela ne fonctionnera pas:

fn main() { // main() is where Rust programs start to run. Code goes inside {} (curly brackets)

    let my_number = 100; // We didn't write a type of integer,
                         // so Rust chooses i32. Rust always
                         // chooses i32 for integers if you don't
                         // tell it to use a different type

    println!("{}", my_number as char); // ⚠️
}

Voici la raison:

Heureusement, nous pouvons facilement résoudre ce problème avec as. Nous ne pouvons pas lancer i32 comme un char, mais nous pouvons lancer un i32 comme un u8. Et puis nous pouvons faire la même chose de u8 à char. Donc, en une seule ligne, nous utilisons as faire de mon_nombre un u8, et encore pour en faire un char. Maintenant, il va compiler:

fn main() {
    let my_number = 100;
    println!("{}", my_number as u8 as char);
}

Il imprime d parce que c’est le char en place 100.

Le moyen le plus simple, cependant, est simplement de dire à Rust que my_number est un u8. Voici comment procéder:

fn main() {
    let my_number: u8 = 100; //  change my_number to my_number: u8
    println!("{}", my_number as char);
}

Ce sont donc deux raisons pour tous les types de nombres différents dans Rust. Voici une autre raison: usize est la taille que Rust utilise pour indexage. (L’indexation signifie « quel élément est le premier », « quel élément est le deuxième », etc.) usize est la meilleure taille pour l’indexation car:

• Un index ne peut pas être négatif, il doit donc s’agir d’un nombre avec un u
• Il devrait être gros, car parfois vous devez indexer beaucoup de choses, mais
• Il ne peut pas s’agir d’un u64 car les ordinateurs 32 bits ne peuvent pas utiliser u64.

Donc Rust utilise usize afin que votre ordinateur puisse obtenir le plus grand nombre d’indexation qu’il puisse lire.

Apprenons-en plus sur char. Vous avez vu qu’un char est toujours un caractère et utilise '' à la place de "".

Tout chars utilisez 4 octets de mémoire, car 4 octets suffisent pour contenir tout type de caractère:

• Les lettres et symboles de base nécessitent généralement 1 octet sur 4: a b 1 2 + - = $ @
• D’autres lettres comme les trémas ou les accents allemands nécessitent 2 octets sur 4: ä ö ü ß è é à ñ
• Les caractères coréens, japonais ou chinois nécessitent 3 ou 4 octets: 国 안 녕

Lorsque vous utilisez des caractères dans le cadre d’une chaîne, la chaîne est codée pour utiliser le moins de mémoire nécessaire pour chaque caractère.

On peut utiliser .len() pour voir cela par nous-mêmes:

fn main() {
    println!("Size of a char: {}", std::mem::size_of::<char>()); // 4 bytes
    println!("Size of string containing 'a': {}", "a".len()); // .len() gives the size of the string in bytes
    println!("Size of string containing 'ß': {}", "ß".len());
    println!("Size of string containing '国': {}", "国".len());
    println!("Size of string containing '?': {}", "?".len());
}

Cela imprime:

Size of a char: 4
Size of string containing 'a': 1
Size of string containing 'ß': 2
Size of string containing '国': 3
Size of string containing '?': 4

Tu peux voir ça a est un octet, l’allemand ß c’est deux, le japonais 国 est trois, et l’ancien égyptien ? est de 4 octets.

fn main() {
    let slice = "Hello!";
    println!("Slice is {} bytes.", slice.len());
    let slice2 = "안녕!"; // Korean for "hi"
    println!("Slice2 is {} bytes.", slice2.len());
}

Cela imprime:

Slice is 6 bytes.
Slice2 is 7 bytes.

slice a une longueur de 6 caractères et 6 octets, mais slice2 est de 3 caractères et 7 octets.

Si .len() donne la taille en octets, qu’en est-il de la taille en caractères? Nous en apprendrons plus sur ces méthodes plus tard, mais vous pouvez simplement vous rappeler que .chars().count() le fera. .chars().count() transforme ce que vous avez écrit en caractères et compte ensuite combien il y en a.

fn main() {
    let slice = "Hello!";
    println!("Slice is {} bytes and also {} characters.", slice.len(), slice.chars().count());
    let slice2 = "안녕!";
    println!("Slice2 is {} bytes but only {} characters.", slice2.len(), slice2.chars().count());
}

Cela imprime:

Slice is 6 bytes and also 6 characters.
Slice2 is 7 bytes but only 3 characters.

Inférence de type

Voir ce chapitre sur YouTube

L’inférence de type signifie que si vous ne dites pas au compilateur le type, mais qu’il peut décider par lui-même, il décidera. Le compilateur a toujours besoin de connaître le type des variables, mais vous n’avez pas toujours besoin de le dire. En fait, vous n’avez généralement pas besoin de le dire. Par exemple, pour let my_number = 8, my_number sera un i32. C’est parce que le compilateur choisit i32 pour les entiers si vous ne le dites pas. Mais si tu dis let my_number: u8 = 8, cela fera my_number une u8, parce que tu l’as dit u8.

Donc, généralement, le compilateur peut deviner. Mais parfois, vous devez le dire, pour deux raisons:

1. Vous faites quelque chose de très complexe et le compilateur ne connaît pas le type que vous voulez.
2. Vous voulez un type différent (par exemple, vous voulez un i128, pas un i32).

Pour spécifier un type, ajoutez deux points après le nom de la variable.

fn main() {
    let small_number: u8 = 10;
}

Pour les nombres, vous pouvez dire le type après le nombre. Vous n’avez pas besoin d’espace – tapez-le juste après le nombre.

fn main() {
    let small_number = 10u8; // 10u8 = 10 of type u8
}

Vous pouvez également ajouter _ si vous souhaitez rendre le numéro facile à lire.

fn main() {
    let small_number = 10_u8; // This is easier to read
    let big_number = 100_000_000_i32; // 100 million is easy to read with _
}

le _ ne change pas le nombre. Ce n’est que pour vous faciliter la lecture. Et peu importe combien _ tu utilises:

fn main() {
    let number = 0________u8;
    let number2 = 1___6______2____4______i32;
    println!("{}, {}", number, number2);
}

Cette imprime 0, 1624.

Flotteurs

Les flottants sont des nombres avec des points décimaux. 5.5 est un flottant et 6 est un entier. 5.0 est également un flotteur, et même 5. est un flotteur.

fn main() {
    let my_float = 5.; // Rust sees . and knows that it is a float
}

Mais les types ne sont pas appelés float, ils s’appellent f32 et f64. C’est la même chose que les entiers: le nombre après f indique le nombre de bits. Si vous n’écrivez pas le type, Rust choisira f64.

Bien entendu, seuls les flotteurs du même type peuvent être utilisés ensemble. Donc, vous ne pouvez pas ajouter un f32 à un f64.

fn main() {
    let my_float: f64 = 5.0; // This is an f64
    let my_other_float: f32 = 8.5; // This is an f32

    let third_float = my_float + my_other_float; // ⚠️
}

Lorsque vous essayez d’exécuter ceci, Rust dira:

Le compilateur écrit « attendu (type), trouvé (type) » lorsque vous utilisez le mauvais type. Il lit votre code comme ceci:

fn main() {
    let my_float: f64 = 5.0; // The compiler sees an f64
    let my_other_float: f32 = 8.5; // The compiler sees an f32. It is a different type.
    let third_float = my_float + // You want to add my_float to something, so it must be an f64 plus another f64. Now it expects an f64...
    let third_float = my_float + my_other_float;  // ⚠️ but it found an f32. It can't add them.
}

Ainsi, lorsque vous voyez « attendu (type), trouvé (type) », vous devez trouver pourquoi le compilateur attendait un type différent.

Bien sûr, avec des nombres simples, il est facile à corriger. Vous pouvez lancer le f32 à un f64 avec as:

fn main() {
    let my_float: f64 = 5.0;
    let my_other_float: f32 = 8.5;

    let third_float = my_float + my_other_float as f64; // my_other_float as f64 = use my_other_float like an f64
}

Ou encore plus simplement, supprimez les déclarations de type. (« pour déclarer un type » = « pour dire à Rust d’utiliser le type ») Rust choisira les types qui peuvent s’additionner.

fn main() {
    let my_float = 5.0; // Rust will choose f64
    let my_other_float = 8.5; // Here again it will choose f64

    let third_float = my_float + my_other_float;
}

Le compilateur Rust est intelligent et ne choisira pas f64 si vous avez besoin de f32:

fn main() {
    let my_float: f32 = 5.0;
    let my_other_float = 8.5; // Usually Rust would choose f64,

    let third_float = my_float + my_other_float; // but now it knows that you need to add it to an f32. So it chooses f32 for my_other_float too
}

Impression « bonjour, monde! »

Voir ce chapitre sur YouTube: Vidéo 1, Vidéo 2

Lorsque vous démarrez un nouveau programme Rust, il a toujours ce code:

fn main() {
    println!("Hello, world!");
}

• fn signifie fonction,
• main est la fonction qui lance le programme,
• () signifie que nous n’avons donné aucune variable à la fonction pour démarrer.

{} s’appelle un bloc de code. C’est l’espace où vit le code.

println! est un macro qui imprime sur la console. UNE macro est comme une fonction qui écrit du code pour vous. Les macros ont un ! après eux. Nous en apprendrons plus sur la création de macros plus tard. Pour l’instant, souviens-toi que ! signifie que c’est une macro.

Pour en savoir plus sur le ;, nous allons créer une autre fonction. Premier arrivé main nous imprimerons un chiffre 8:

fn main() {
    println!("Hello, world number {}!", 8);
}

le {} dans println! signifie « mettre la variable à l’intérieur ici ». Cette imprime Hello, world number 8!.

Nous pouvons en mettre plus, comme nous l’avons fait auparavant:

fn main() {
    println!("Hello, worlds number {} and {}!", 8, 9);
}

Cette imprime Hello, worlds number 8 and 9!.

Créons maintenant la fonction.

Cela imprime également Hello, world number 8!. Quand Rust regarde number() il voit une fonction. Cette fonction:

• Ne prend rien (car il a ())
• Renvoie un i32. le -> (appelée « flèche maigre ») montre ce que la fonction renvoie.

À l’intérieur de la fonction est juste 8. Parce qu’il n’y a pas ;, c’est la valeur qu’il renvoie. S’il y avait un ;, il ne renverrait rien (il renverrait un ()). Rust ne compilera pas ceci s’il a un ;, parce que le retour est i32 et ; Retour (), ne pas i32:

fn main() {
    println!("Hello, world number {}", number());
}

fn number() -> i32 {
    8;  // ⚠️
}

Cela signifie « vous m’avez dit que number() renvoie un i32, mais vous avez ajouté un ; donc il ne renvoie rien. »Le compilateur suggère donc de supprimer le point-virgule.

Vous pouvez également écrire return 8; mais dans Rust, il est normal de supprimer simplement le ; à return.

Lorsque vous souhaitez donner des variables à une fonction, placez-les dans le (). Vous devez leur donner un nom et écrire le type.

fn multiply(number_one: i32, number_two: i32) { // Two i32s will enter the function. We will call them number_one and number_two.
    let result = number_one * number_two;
    println!("{} times {} is {}", number_one, number_two, result);
}

fn main() {
    multiply(8, 9); // We can give the numbers directly
    let some_number = 10; // Or we can declare two variables
    let some_other_number = 2;
    multiply(some_number, some_other_number); // and put them in the function
}

Nous pouvons également retourner un i32. Retirez simplement le point-virgule à la fin:

Déclaration de variables et de blocs de code

Utiliser let pour déclarer une variable (déclarer une variable = dire à Rust de créer une variable).

fn main() {
    let my_number = 8;
    println!("Hello, number {}", my_number);
}

Les variables commencent et se terminent dans un bloc de code {}. Dans cet exemple, my_number se termine avant d’appeler println!, car il se trouve dans son propre bloc de code.

fn main() {
    {
        let my_number = 8; // my_number starts here
                           // my_number ends here!
    }

    println!("Hello, number {}", my_number); // ⚠️ there is no my_number and
                                             // println!() can't find it
}

Vous pouvez utiliser un bloc de code pour renvoyer une valeur:

fn main() {
    let my_number = {
    let second_number = 8;
        second_number + 9 // No semicolon, so the code block returns 8 + 9.
                          // It works just like a function
    };

    println!("My number is: {}", my_number);
}

Si vous ajoutez un point-virgule à l’intérieur du bloc, il retournera () (rien):

fn main() {
    let my_number = {
    let second_number = 8; // declare second_number,
        second_number + 9; // add 9 to second_number
                           // but we didn't return it!
                           // second_number dies now
    };

    println!("My number is: {:?}", my_number); // my_number is ()
}

Alors pourquoi avons-nous écrit {:?} et pas {}? Nous en parlerons maintenant.

Affichage et débogage

Voir ce chapitre sur YouTube

Les variables simples dans Rust peuvent être imprimées avec {} à l’intérieur println!. Mais certaines variables ne peuvent pas, et vous devez impression de débogage. L’impression de débogage est en cours d’impression pour le programmeur, car elle affiche généralement plus d’informations. Le débogage n’est parfois pas joli, car il contient des informations supplémentaires pour vous aider.

Comment savez-vous si vous avez besoin {:?} et pas {}? Le compilateur vous le dira. Par example:

fn main() {
    let doesnt_print = ();
    println!("This will not print: {}", doesnt_print); // ⚠️
}

Lorsque nous exécutons ceci, le compilateur dit:

C’est beaucoup d’informations. Mais la partie importante est: you may be able to use {:?} (or {:#?} for pretty-print) instead. Cela signifie que vous pouvez essayer {:?}, et aussi {:#?} {:#?} s’appelle «jolie impression». C’est comme {:?} mais imprime avec un formatage différent sur plus de lignes.

Donc Display signifie imprimer avec {}, et Debug signifie imprimer avec {:?}.

Encore une chose: vous pouvez également utiliser print! sans pour autant ln si vous ne voulez pas de nouvelle ligne.

fn main() {
    print!("This will not print a new line");
    println!(" so this will be on the same line");
}

Cette imprime This will not print a new line so this will be on the same line.

Les plus petits et les plus grands nombres

Si vous voulez voir les nombres les plus petits et les plus grands, vous pouvez utiliser MIN et MAX. std signifie « bibliothèque standard » et a toutes les fonctions principales, etc. pour Rust. Nous en apprendrons plus sur la bibliothèque standard plus tard. Mais en attendant, vous pouvez vous rappeler que c’est ainsi que vous obtenez le plus petit et le plus grand nombre pour un type.

fn main() {
    println!("The smallest i8 is {} and the biggest i8 is {}.", std::i8::MIN, std::i8::MAX); // hint: printing std::i8::MIN means "print MIN inside of the i8 section in the standard library"
    println!("The smallest u8 is {} and the biggest u8 is {}.", std::u8::MIN, std::u8::MAX);
    println!("The smallest i16 is {} and the biggest i16 is {}.", std::i16::MIN, std::i16::MAX);
    println!("The smallest u16 is {} and the biggest u16 is {}.", std::u16::MIN, std::u16::MAX);
    println!("The smallest i32 is {} and the biggest i32 is {}.", std::i32::MIN, std::i32::MAX);
    println!("The smallest u32 is {} and the biggest u32 is {}.", std::u32::MIN, std::u32::MAX);
    println!("The smallest i64 is {} and the biggest i64 is {}.", std::i64::MIN, std::i64::MAX);
    println!("The smallest u64 is {} and the biggest u64 is {}.", std::u64::MIN, std::u64::MAX);
    println!("The smallest i128 is {} and the biggest i128 is {}.", std::i128::MIN, std::i128::MAX);
    println!("The smallest u128 is {} and the biggest u128 is {}.", std::u128::MIN, std::u128::MAX);

}

Cela imprimera:

The smallest i8 is -128 and the biggest i8 is 127.
The smallest u8 is 0 and the biggest u8 is 255.
The smallest i16 is -32768 and the biggest i16 is 32767.
The smallest u16 is 0 and the biggest u16 is 65535.
The smallest i32 is -2147483648 and the biggest i32 is 2147483647.
The smallest u32 is 0 and the biggest u32 is 4294967295.
The smallest i64 is -9223372036854775808 and the biggest i64 is 9223372036854775807.
The smallest u64 is 0 and the biggest u64 is 18446744073709551615.
The smallest i128 is -170141183460469231731687303715884105728 and the biggest i128 is 170141183460469231731687303715884105727.
The smallest u128 is 0 and the biggest u128 is 340282366920938463463374607431768211455.

Mutabilité (changement)

Voir ce chapitre sur YouTube

Lorsque vous déclarez une variable avec let, il est immuable (ne peut pas être modifié).

Cela ne fonctionnera pas:

fn main() {
    let my_number = 8;
    my_number = 10; // ⚠️
}

Le compilateur dit: error[E0384]: cannot assign twice to immutable variable my_number. C’est parce que les variables sont immuables si vous n’écrivez que let.

Mais parfois, vous souhaitez modifier votre variable. Pour créer une variable que vous pouvez modifier, ajoutez mut après let:

fn main() {
    let mut my_number = 8;
    my_number = 10;
}

Il n’y a plus de problème maintenant.

Cependant, vous ne pouvez pas changer le type: même mut ne vous laisse pas faire ça. Cela ne fonctionnera pas:

fn main() {
    let mut my_variable = 8; // it is now an i32. That can't be changed
    my_variable = "Hello, world!"; // ⚠️
}

Vous verrez le même message «attendu» du compilateur: expected integer, found &str. &str est un type de chaîne que nous apprendrons bientôt.

Ombrage

Voir ce chapitre sur YouTube

L’observation signifie utiliser let pour déclarer une nouvelle variable avec le même nom qu’une autre variable. Cela ressemble à de la mutabilité, mais c’est complètement différent. L’observation ressemble à ceci:

fn main() {
    let my_number = 8; // This is an i32
    println!("{}", my_number); // prints 8
    let my_number = 9.2; // This is an f64 with the same name. But it's not the first my_number - it is completely different!
    println!("{}", my_number) // Prints 9.2
}

Ici, nous disons que nous avons « ombragé » my_number avec un nouveau « let binding ».

Ainsi est le premier my_number détruit? Non, mais quand on appelle my_number nous obtenons maintenant my_number les f64. Et parce qu’ils sont dans le même bloc de portée (le même {}), on ne voit pas le premier my_number plus.

Mais s’ils sont dans des blocs différents, nous pouvons voir les deux. Par example:

fn main() {
    let my_number = 8; // This is an i32
    println!("{}", my_number); // prints 8
    {
        let my_number = 9.2; // This is an f64. It is not my_number - it is completely different!
        println!("{}", my_number) // Prints 9.2
                                  // But the shadowed my_number only lives until here.
                                  // The first my_number is still alive!
    }
    println!("{}", my_number); // prints 8
}

Ainsi, lorsque vous observez une variable, vous ne la détruisez pas. Toi bloquer il.

Alors, quel est l’avantage de l’observation? L’observation est utile lorsque vous devez beaucoup modifier une variable. Imaginez que vous vouliez faire beaucoup de calculs simples avec une variable:

Sans l’ombre, vous devriez penser à des noms différents, même si vous ne vous souciez pas de x:

En général, vous voyez des ombres dans Rust dans ce cas. Cela se produit là où vous voulez rapidement prendre une variable, y faire quelque chose et refaire quelque chose d’autre. Et vous l’utilisez généralement pour des variables rapides dont vous ne vous souciez pas trop.

La pile, le tas et les pointeurs

La pile, le tas et les pointeurs sont très importants dans Rust.

La pile et le tas sont deux emplacements pour conserver la mémoire dans les ordinateurs. Les différences importantes sont:

• La pile est très rapide, mais le tas n’est pas si rapide. Ce n’est pas super lent non plus, mais la pile est toujours plus rapide. Mais vous ne pouvez pas simplement utiliser la pile tout le temps, car:
• Rust a besoin de connaître la taille d’une variable au moment de la compilation. Des variables si simples comme i32 aller sur la pile, car nous connaissons leur taille exacte. Vous savez toujours qu’un i32 va faire 4 octets, car 32 bits = 4 octets. Donc i32 peut toujours aller sur la pile.
• Mais certains types ne connaissent pas la taille au moment de la compilation. Mais la pile doit connaître la taille exacte. Donc que fais-tu? Commencez par placer les données dans le tas, car le tas peut avoir n’importe quelle taille de données. Et puis pour le trouver, un pointeur va sur la pile. C’est bien car nous connaissons toujours la taille d’un pointeur. Ainsi, l’ordinateur va d’abord dans la pile, lit le pointeur et le suit jusqu’au tas où se trouvent les données.

Les pointeurs semblent compliqués, mais ils sont faciles. Les pointeurs sont comme une table des matières dans un livre. Imaginez ce livre:

MY BOOK

TABLE OF CONTENTS

Chapter                        Page
Chapter 1: My life              1
Chapter 2: My cat               15
Chapter 3: My job               23
Chapter 4: My family            30
Chapter 5: Future plans         43

Donc, c’est comme cinq pointeurs. Vous pouvez les lire et trouver les informations dont ils parlent. Où est le chapitre « Ma vie »? C’est à la page 1 (il points à la page 1). Où se trouve le chapitre «Mon métier»? C’est à la page 23.

Le pointeur que vous voyez habituellement dans Rust s’appelle un référence. C’est la partie importante à savoir: une référence pointe vers la mémoire d’une autre valeur. Une référence signifie que vous emprunter la valeur, mais vous ne la possédez pas. C’est la même chose que notre livre: la table des matières ne possède pas l’information. Ce sont les chapitres qui possèdent l’information. Dans Rust, les références ont un & devant eux. Donc:

• let my_variable = 8 crée une variable régulière, mais
• let my_reference = &my_variable fait une référence.

Tu lis my_reference = &my_variable comme ceci: « ma_référence est une référence à ma_variable ». Ou: « ma_référence fait référence à ma_variable ».

Cela signifie que my_reference ne regarde que les données de my_variable. my_variable possède toujours ses données.

Vous pouvez également avoir une référence à une référence, ou n’importe quel nombre de références.

fn main() {
    let my_number = 15; // This is an i32
    let single_reference = &my_number; //  This is a &i32
    let double_reference = &single_reference; // This is a &&i32
    let five_references = &&&&&my_number; // This is a &&&&&i32
}

Ce sont tous des types différents, de la même manière que « un ami d’un ami » est différent de « un ami ».

En savoir plus sur l’impression

Dans Rust, vous pouvez imprimer des éléments de presque toutes les manières que vous voulez. Voici quelques autres choses à savoir sur l’impression.

Ajouter n fera une nouvelle ligne, et t fera un onglet:

fn main() {
    // Note: this is print!, not println!
    print!("t Start with a tabnand move to a new line");
}

Cela imprime:

         Start with a tab
and move to a new line

À l’intérieur "" vous pouvez écrire sur plusieurs lignes sans problème, mais faites attention à l’espacement:

fn main() {
    // Note: After the first line you have to start on the far left.
    // If you write directly under println!, it will add the spaces
    println!("Inside quotes
you can write over
many lines
and it will print just fine.");

    println!("If you forget to write
    on the left side, the spaces
    will be added when you print.");
}

Cela imprime:

Inside quotes
you can write over
many lines
and it will print just fine.
If you forget to write
    on the left side, the spaces
    will be added when you print.

Si vous souhaitez imprimer des caractères comme n (appelés « caractères d’échappement »), vous pouvez ajouter un supplément :

fn main() {
    println!("Here are two escape characters: \n and \t");
}

Cela imprime:

Here are two escape characters: n and t

Parfois tu en as trop " et les personnages d’échappement, et veulent que Rust ignore tout. Pour ce faire, vous pouvez ajouter r# au début et # jusqu’à la fin.

fn main() {
    println!("He said, "You can find the file at c:\files\my_documents\file.txt." Then I found the file."); // We used  five times here
    println!(r#"He said, "You can find the file at c:filesmy_documentsfile.txt." Then I found the file."#)
}

Cela imprime la même chose, mais en utilisant r# facilite la lecture pour les humains.

He said, "You can find the file at c:filesmy_documentsfile.txt." Then I found the file.
He said, "You can find the file at c:filesmy_documentsfile.txt." Then I found the file.

Si vous devez imprimer avec un # à l’intérieur, alors vous pouvez commencer par r## et terminer par ##. Et si vous en avez besoin de plus d’un, vous pouvez en ajouter un de plus de chaque côté.

Voici quatre exemples:

fn main() {

    let my_string = "'Ice to see you,' he said."; // single quotes
    let quote_string = r#""Ice to see you," he said."#; // double quotes
    let hashtag_string = r##"The hashtag #IceToSeeYou had become very popular."##; // Has one # so we need at least ##
    let many_hashtags = r####""You don't have to type ### to use a hashtag. You can just use #.""####; // Has three ### so we need at least ####

    println!("{}n{}n{}n{}n", my_string, quote_string, hashtag_string, many_hashtags);

}

Cela imprimera:

'Ice to see you,' he said.
"Ice to see you," he said.
The hashtag #IceToSeeYou had become very popular.
"You don't have to type ### to use a hashtag. You can just use #."

r# a une autre utilité: avec lui, vous pouvez utiliser un mot-clé (des mots comme let, fn, etc.) comme nom de variable.

fn main() {
    let r#let = 6; // The variable's name is let
    let mut r#mut = 10; // This variable's name is mut
}

r# a cette fonction car les anciennes versions de Rust avaient moins de mots-clés que Rust maintenant. Donc avec r# vous pouvez éviter les erreurs avec des noms de variables qui n’étaient pas des mots-clés auparavant.

Ou peut-être pour une raison quelconque vraiment besoin d’une fonction pour avoir un nom comme return. Ensuite, vous pouvez écrire ceci:

Cela imprime:

Vous n’en aurez probablement pas besoin, mais si vous avez vraiment besoin d’utiliser un mot-clé pour une variable, vous pouvez utiliser r#.

Si vous souhaitez imprimer les octets d’un &str ou un char, tu peux juste écrire b avant la chaîne. Cela fonctionne pour tous les caractères ASCII. Ce sont tous les caractères ASCII:

Donc, lorsque vous imprimez ceci:

fn main() {
    println!("{:?}", b"This will look like numbers");
}

Voici le résultat:

[84, 104, 105, 115, 32, 119, 105, 108, 108, 32, 108, 111, 111, 107, 32, 108, 105, 107, 101, 32, 110, 117, 109, 98, 101, 114, 115]

Pour un char cela s’appelle un octet, et pour un &str ça s’appelle un chaîne d’octets.

Vous pouvez également mettre b et r ensemble si vous devez:

fn main() {
    println!("{:?}", br##"I like to write "#"."##);
}

Qui imprimera [73, 32, 108, 105, 107, 101, 32, 116, 111, 32, 119, 114, 105, 116, 101, 32, 34, 35, 34, 46].

Il existe également un échappement Unicode qui vous permet d’imprimer n’importe quel caractère Unicode à l’intérieur d’une chaîne: u{}. Un nombre hexadécimal entre dans le {} pour l’imprimer. Here is a short example of how to get the Unicode number, and how to print it again.

fn main() {
    println!("{:X}", '행' as u32); // Cast char as u32 to get the hexadecimal value
    println!("{:X}", 'H' as u32);
    println!("{:X}", '居' as u32);
    println!("{:X}", 'い' as u32);

    println!("u{D589}, u{48}, u{5C45}, u{3044}"); // Try printing them with unicode escape u
}

We know that println! can print with {} (for Display) and {:?} (for Debug), plus {:#?} for pretty printing. But there are many other ways to print.

For example, if you have a reference, you can use {:p} to print the pointer address. Pointer address means the location in your computer’s memory.

fn main() {
    let number = 9;
    let number_ref = &number;
    println!("{:p}", number_ref);
}

This prints 0xe2bc0ffcfc or some other address. It might be different every time, depending on where your computer stores it.

Or you can print binary, hexadecimal and octal:

fn main() {
    let number = 555;
    println!("Binary: {:b}, hexadecimal: {:x}, octal: {:o}", number, number, number);
}

This prints Binary: 1000101011, hexadecimal: 22b, octal: 1053.

Or you can add numbers to change the order. The first variable will be in index 0, the next in index 1, and so on.

fn main() {
    let father_name = "Vlad";
    let son_name = "Adrian Fahrenheit";
    let family_name = "Țepeș";
    println!("This is {1} {2}, son of {0} {2}.", father_name, son_name, family_name);
}

father_name is in position 0, son_name is in position 1, and family_name is in position 2. So it prints This is Adrian Fahrenheit Țepeș, son of Vlad Țepeș.

Maybe you have a very complex string to print with too many variables inside the {} curly brackets. Or maybe you need to print a variable more than one time. Then it can help to add names to the {}:

fn main() {
    println!(
        "{city1} is in {country} and {city2} is also in {country},
but {city3} is not in {country}.",
        city1 = "Seoul",
        city2 = "Busan",
        city3 = "Tokyo",
        country = "Korea"
    );
}

That will print:

Seoul is in Korea and Busan is also in Korea,
but Tokyo is not in Korea.

Very complex printing is also possible in Rust if you want to use it. Here is how to do it:

{variable:padding alignment minimum.maximum}

To understand this, look at the

1. Do you want a variable name? Write that first, like when we wrote {country} above.
   (Then add a : after it if you want to do more things)
2. Do you want a padding character? For example, 55 with three « padding zeros » looks like 00055.
3. What alignment (left / middle / right) for the padding?
4. Do you want a minimum length? (just write a number)
5. Do you want a maximum length? (write a number with a . in front)

For example, if I want to write « a » with five ㅎ characters on the left and five ㅎ characters on the right:

fn main() {
    let letter = "a";
    println!("{:ㅎ^11}", letter);
}

This prints ㅎㅎㅎㅎㅎaㅎㅎㅎㅎㅎ. Let’s look at 1) to 5) for this to understand how the compiler reads it.

• Do you want a variable name? {:ㅎ^11} There is no variable name. There is nothing before :.
• Do you want a padding character? {:ㅎ^11} Oui. ㅎ comes after the : and has a ^. < means padding with the character on the left, > means on the right, and ^ means in the middle.
• Do you want a minimum length? {:ㅎ^11} Yes: there is an 11 after.
• Do you want a maximum length? {:ㅎ^11} No: there is no number with a . before.

Here is an example of many types of formatting.

fn main() {
    let title = "TODAY'S NEWS";
    println!("{:-^30}", title); // no variable name, pad with -, put in centre, 30 characters long
    let bar = "|";
    println!("{: <15}{: >15}", bar, bar); // no variable name, pad with space, 15 characters each, one to the left, one to the right
    let a = "SEOUL";
    let b = "TOKYO";
    println!("{city1:-<15}{city2:->15}", city1 = a, city2 = b); // variable names city1 and city2, pad with -, one to the left, one to the right
}

It prints:

---------TODAY'S NEWS---------
|                            |
SEOUL--------------------TOKYO

Strings

See this chapter on YouTube

Rust has two main types of strings: String et &str. What is the difference?

• &str is a simple string. When you write let my_variable = "Hello, world!", you create a &str. UNE &str is very fast.
• String is a more complicated string. It is a bit slower, but it has more functions. UNE String is a pointer, with data on the heap.

Also note that &str has the & in front of it because you need a reference to use a str. That's because of the reason we saw above: the stack needs to know the size. So we give it a & that it knows the size of, and then it is happy. Also, because you use a & to interact with a str, you don't own it. But a String is an owned type. We will soon learn why that is important to know.

Tous les deux &str et String are UTF-8. For example, you can write:

fn main() {
    let name = "서태지"; // This is a Korean name. No problem, because a &str is UTF-8.
    let other_name = String::from("Adrian Fahrenheit Țepeș"); // Ț and ș are no problem in UTF-8.
}

You can see in String::from("Adrian Fahrenheit Țepeș") that it is easy to make a String from a &str. The two types are very closely linked together, even though they are different.

You can even write emojis, thanks to UTF-8.

fn main() {
    let name = "?";
    println!("My name is actually {}", name);
}

On your computer that will print My name is actually ? unless your command line can't print it. Then it will show My name is actually �. But Rust has no problem with emojis or any other Unicode.

Let's look at the reason for using a & pour strs again to make sure we understand.

• str is a dynamically sized type (dynamically sized = the size can be different). For example, the names "서태지" and "Adrian Fahrenheit Țepeș" are not the same size:

fn main() {

    println!("A String is always {:?} bytes. It is Sized.", std::mem::size_of::<String>()); // std::mem::size_of::() gives you the size in bytes of a type
    println!("And an i8 is always {:?} bytes. It is Sized.", std::mem::size_of::<i8>());
    println!("And an f64 is always {:?} bytes. It is Sized.", std::mem::size_of::<f64>());
    println!("But a &str? It can be anything. '서태지' is {:?} bytes. It is not Sized.", std::mem::size_of_val("서태지")); // std::mem::size_of_val() gives you the size in bytes of a variable
    println!("And 'Adrian Fahrenheit Țepeș' is {:?} bytes. It is not Sized.", std::mem::size_of_val("Adrian Fahrenheit Țepeș"));
}

This prints:

A String is always 24 bytes. It is Sized.
And an i8 is always 1 bytes. It is Sized.
And an f64 is always 8 bytes. It is Sized.
But a &str? It can be anything. '서태지' is 9 bytes. It is not Sized.
And 'Adrian Fahrenheit Țepeș' is 25 bytes. It is not Sized.

That is why we need a &, because & makes a pointer, and Rust knows the size of the pointer. So the pointer goes on the stack. If we wrote str, Rust wouldn't know what to do because it doesn't know the size.

There are many ways to make a String. Here are some:

• String::from("This is the string text"); This a method for String that takes text and creates a String.
• "This is the string text".to_string(). This is a method for &str that makes it a String.
• le format! macro. This is like println! except it creates a String instead of printing. So you can do this:

fn main() {
    let my_name = "Billybrobby";
    let my_country = "USA";
    let my_home = "Korea";

    let together = format!(
        "I am {} and I come from {} but I live in {}.",
        my_name, my_country, my_home
    );
}

Now we have a String named ensemble, but did not print it yet.

One other way to make a String is called .into() but it is a bit different because .into() isn't just for making a String. Some types can easily convert to and from another type using From et .into(). And if you have From, then you also have .into(). From is clearer because you already know the types: you know that String::from("Some str") is a String from a &str. But with .into(), sometimes the compiler doesn't know:

fn main() {
    let my_string = "Try to make this a String".into(); // ⚠️
}

Rust doesn't know what type you want, because many types can be made from a &str. It says, "I can make a &str into a lot of things. Which one do you want?"

error[E0282]: type annotations needed
 --> srcmain.rs:2:9
  |
2 |     let my_string = "Try to make this a String".into();
  |         ^^^^^^^^^ consider giving `my_string` a type

So you can do this:

fn main() {
    let my_string: String = "Try to make this a String".into();
}

And now you get a String.

const and static

See this chapter on YouTube

There are two other ways to declare values, not just with let. Ceux-ci sont const et static. Also, Rust won't use type inference: you need to write the type for them. These are for values that don't change (const means constant). The difference is that:

• const is for values that don't change, the name is replaced with the value when it's used,
• static is similar to const, but has a fixed memory location and can act as a global variable.

So they are almost the same. Rust programmers almost always use const.

You write them with ALL CAPITAL LETTERS, and usually outside of main so that they can live for the whole program.

Two examples are: const NUMBER_OF_MONTHS: u32 = 12; et static SEASONS: [&str; 4] = ["Spring", "Summer", "Fall", "Winter"];

More on references

See this chapter on YouTube

References are very important in Rust. Rust uses references to make sure that all memory access is safe. We know that we use & to create a reference:

fn main() {
    let country = String::from("Austria");
    let ref_one = &country;
    let ref_two = &country;

    println!("{}", ref_one);
}

This prints Austria.

In the code, country is a String. We then created two references to country. They have the type &String, which you say is a "reference to a String". We could create three references or one hundred references to country and it would be no problem.

But this is a problem:

fn return_str() -> &str {
    let country = String::from("Austria");
    let country_ref = &country;
    country_ref // ⚠️
}

fn main() {
    let country = return_str();
}

The function return_str() creates a String, then it creates a reference to the String. Then it tries to return the reference. But the String country only lives inside the function, and then it dies. Once a variable is gone, the computer will clean up the memory and use it for something else. So after the function is over, country_ref is referring to memory that is already gone, and that's not okay. Rust prevents us from making a mistake with memory here.

This is the important part about the "owned" type that we talked about above. Because you own a String, you can pass it around. But a &String will die if its String dies, so you don't pass around "ownership" with it.

Mutable references

See this chapter on YouTube

If you want to use a reference to change data, you can use a mutable reference. For a mutable reference, you write &mut à la place de &.

fn main() {
    let mut my_number = 8; // don't forget to write mut here!
    let num_ref = &mut my_number;
}

So what are the two types? my_number is an i32, et num_ref est &mut i32 (we say a "mutable reference to an i32").

So let's use it to add 10 to my_number. But you can't write num_ref += 10, because num_ref is not the i32 value, it is a &i32. The value is actually inside the i32. To reach the place where the value is, we use *. * means "I don't want the reference, I want the value behind the reference". In other words, one * is the opposite of &. Also, one * erases one &.

fn main() {
    let mut my_number = 8;
    let num_ref = &mut my_number;
    *num_ref += 10; // Use * to change the i32 value.
    println!("{}", my_number);

    let second_number = 800;
    let triple_reference = &&&second_number;
    println!("Second_number = triple_reference? {}", second_number == ***triple_reference);
}

This prints:

18
Second_number = triple_reference? true

Because using & is called "referencing", using * is called "dereferencing".

Rust has two rules for mutable and immutable references. They are very important, but also easy to remember because they make sense.

• Rule 1: If you have only immutable references, you can have as many as you want. 1 is fine, 3 is fine, 1000 is fine. Aucun problème.
• Rule 2: If you have a mutable reference, you can only have one. Also, you can't have an immutable reference et a mutable reference together.

This is because mutable references can change the data. You could get problems if you change the data when other references are reading it.

A good way to understand is to think of a Powerpoint presentation.

Situation one is about only one mutable reference.

Situation one: An employee is writing a Powerpoint presentation. He wants his manager to help him. The employee gives his login information to his manager, and asks him to help by making edits. Now the manager has a "mutable reference" to the employee's presentation. The manager can make any changes he wants, and give the computer back later. This is fine, because nobody else is looking at the presentation.

Situation two is about only immutable references.

Situation two: The employee is giving the presentation to 100 people. All 100 people can now see the employee's data. They all have an "immutable reference" to the employee's presentation. This is fine, because they can see it but nobody can change the data.

Situation three is the problem situation.

Situation three: The Employee gives his manager his login information. His manager now has a "mutable reference". Then the employee went to give the presentation to 100 people, but the manager can still login. This is not fine, because the manager can log in and do anything. Maybe his manager will log into the computer and start typing an email to his mother! Now the 100 people have to watch the manager write an email to his mother instead of the presentation. That's not what they expected to see.

Here is an example of a mutable borrow with an immutable borrow:

fn main() {
    let mut number = 10;
    let number_ref = &number;
    let number_change = &mut number;
    *number_change += 10;
    println!("{}", number_ref); // ⚠️
}

The compiler prints a helpful message to show us the problem.

error[E0502]: cannot borrow `number` as mutable because it is also borrowed as immutable
 --> srcmain.rs:4:25
  |
3 |     let number_ref = &number;
  |                      ------- immutable borrow occurs here
4 |     let number_change = &mut number;
  |                         ^^^^^^^^^^^ mutable borrow occurs here
5 |     *number_change += 10;
6 |     println!("{}", number_ref);
  |                    ---------- immutable borrow later used here

However, this code will work. Why?

fn main() {
    let mut number = 10;
    let number_change = &mut number; // create a mutable reference
    *number_change += 10; // use mutable reference to add 10
    let number_ref = &number; // create an immutable reference
    println!("{}", number_ref); // print the immutable reference
}

It prints 20 with no problem. It works because the compiler is smart enough to understand our code. It knows that we used number_change to change number, but didn't use it again. So here there is no problem. We are not using immutable and mutable references together.

Earlier in Rust this kind of code actually generated an error, but the compiler is smarter now. It can understand not just what we type, but how we use everything.

Shadowing again

Remember when we said that shadowing doesn't détruire a value but blocks it? Now we can use references to see this.

fn main() {
    let country = String::from("Austria");
    let country_ref = &country;
    let country = 8;
    println!("{}, {}", country_ref, country);
}

Does this print Austria, 8 ou alors 8, 8? It prints Austria, 8. First we declare a String appelé country. Then we create a reference country_ref to this string. Then we shadow country with 8, which is an i32. But the first country was not destroyed, so country_ref still says "Austria", not "8". Here is the same code with some comments to show how it works:

fn main() {
    let country = String::from("Austria"); // Now we have a String called country
    let country_ref = &country; // country_ref is a reference to this data. It's not going to change
    let country = 8; // Now we have a variable called country that is an i8. But it has no relation to the other one, or to country_ref
    println!("{}, {}", country_ref, country); // country_ref still refers to the data of String::from("Austria") that we gave it.
}

Giving references to functions

See this chapter on YouTube: immutable references and mutable references

References are very useful for functions. The rule in Rust on values is: a value can only have one owner.

This code will not work:

fn print_country(country_name: String) {
    println!("{}", country_name);
}

fn main() {
    let country = String::from("Austria");
    print_country(country); // We print "Austria"
    print_country(country); // ⚠️ That was fun, let's do it again!
}

It does not work because country is destroyed. Here's how:

• Step 1: We create the String appelé country. country is the owner.
• Step 2: We give country à print_country. print_country doesn't have an ->, so it doesn't return anything. Après print_country finishes, our String is now dead.
• Step 3: We try to give country à print_country, but we already did that. We don't have country to give anymore.

We can make print_country give the String back, but it is a bit awkward.

fn print_country(country_name: String) -> String {
    println!("{}", country_name);
    country_name // return it here
}

fn main() {
    let country = String::from("Austria");
    let country = print_country(country); // we have to use let here now to get the String back
    print_country(country);
}

Now it prints:

The much better way to fix this is by adding &.

fn print_country(country_name: &String) {
    println!("{}", country_name);
}

fn main() {
    let country = String::from("Austria");
    print_country(&country); // We print "Austria"
    print_country(&country); // That was fun, let's do it again!
}

Now print_country() is a function that takes a reference to a String: a &String. Also, we give it a reference to country by writing &country. This says "you can look at it, but I will keep it".

Now let's do something similar with a mutable reference. Here is an example of a function that uses a mutable variable.

fn add_hungary(country_name: &mut String) { // first we say that the function takes a mutable reference
    country_name.push_str("-Hungary"); // push_str() adds a &str to a String
    println!("Now it says: {}", country_name);
}

fn main() {
    let mut country = String::from("Austria");
    add_hungary(&mut country); // we also need to give it a mutable reference.
}

This prints Now it says: Austria-Hungary.

So to conclude:

• fn function_name(variable: String) takes a String and owns it. If it doesn't return anything, then the variable dies inside the function.
• fn function_name(variable: &String) borrows a String and can look at it
• fn function_name(variable: &mut String) borrows a String and can change it

Here is an example that looks like a mutable reference, but it is different.

fn main() {
    let country = String::from("Austria"); // country is not mutable, but we are going to print Austria-Hungary. How?
    adds_hungary(country);
}

fn adds_hungary(mut country: String) { // Here's how: adds_hungary takes the String and declares it mutable!
    country.push_str("-Hungary");
    println!("{}", country);
}

How is this possible? It is because mut country is not a reference: adds_hungary owns country à présent. (Remember, it takes String and not &String). The moment you call adds_hungary, it becomes the full owner. country has nothing to do with String::from("Austria") anymore. So adds_hungary can take country as mutable, and it is perfectly safe to do so.

Remember our employee Powerpoint and manager situation above? In this situation it is like the employee just giving his whole computer to the manager. The employee won't ever touch it again, so the manager can do anything he wants to it.

Copy types

Some types in Rust are very simple. They are called copy types. These simple types are all on the stack, and the compiler knows their size. That means that they are very easy to copy, so the compiler always copies when you send it to a function. It always copies because they are so small and easy that there is no reason not to copy. So you don't need to worry about ownership for these types.

These simple types include: integers, floats, booleans (true et false), and char.

How do you know if a type implements copy? (implements = can use) You can check the documentation. For example, here is the documentation for char:

https://doc.rust-lang.org/std/primitive.char.html

On the left you can see Trait Implementations. You can see for example Copie, Debug, et Display. So you know that a char:

• is copied when you send it to a function (Copie)
• peut utiliser {} to print (Display)
• peut utiliser {:?} to print (Debug)

fn prints_number(number: i32) { // There is no -> so it's not returning anything
                             // If number was not copy type, it would take it
                             // and we couldn't use it again
    println!("{}", number);
}

fn main() {
    let my_number = 8;
    prints_number(my_number); // Prints 8. prints_number gets a copy of my_number
    prints_number(my_number); // Prints 8 again.
                              // No problem, because my_number is copy type!
}

But if you look at the documentation for String, it is not copy type.

https://doc.rust-lang.org/std/string/struct.String.html

On the left in Trait Implementations you can look in alphabetical order. A, B, C... there is no Copie in C. But there is Clone. Clone is similar to Copie, but usually needs more memory. Also, you have to call it with .clone() - it won't clone just by itself.

In this example, prints_country() prints the country name, a String. We want to print it two times, but we can't:

fn prints_country(country_name: String) {
    println!("{}", country_name);
}

fn main() {
    let country = String::from("Kiribati");
    prints_country(country);
    prints_country(country); // ⚠️
}

But now we understand the message.

error[E0382]: use of moved value: `country`
 --> srcmain.rs:4:20
  |
2 |     let country = String::from("Kiribati");
  |         ------- move occurs because `country` has type `std::string::String`, which does not implement the `Copy` trait
3 |     prints_country(country);
  |                    ------- value moved here
4 |     prints_country(country);
  |                    ^^^^^^^ value used here after move

The important part is which does not implement the Copy trait. But in the documentation we saw that String implements the Clone trait. So we can add .clone() to our code. This creates a clone, and we send the clone to the function. Now country is still alive, so we can use it.

fn prints_country(country_name: String) {
    println!("{}", country_name);
}

fn main() {
    let country = String::from("Kiribati");
    prints_country(country.clone()); // make a clone and give it to the function. Only the clone goes in, and country is still alive
    prints_country(country);
}

Of course, if the String is very large, .clone() can use a lot of memory. Une String can be a whole book in length, and every time we call .clone() it will copy the book. So using & for a reference is faster, if you can. For example, this code pushes a &str onto a String and then makes a clone every time it gets used in a function:

fn get_length(input: String) { // Takes ownership of a String
    println!("It's {} words long.", input.split_whitespace().count()); // splits to count the number of words
}

fn main() {
    let mut my_string = String::new();
    for _ in 0..50 {
        my_string.push_str("Here are some more words "); // push the words on
        get_length(my_string.clone()); // gives it a clone every time
    }
}

It prints:

It's 5 words long.
It's 10 words long.
...
It's 250 words long.

That's 50 clones. Here it is using a reference instead, which is better:

fn get_length(input: &String) {
    println!("It's {} words long.", input.split_whitespace().count());
}

fn main() {
    let mut my_string = String::new();
    for _ in 0..50 {
        my_string.push_str("Here are some more words ");
        get_length(&my_string);
    }
}

Instead of 50 clones, it's zero.

Variables without values

A variable without a value is called an "uninitialized" variable. Uninitialized means "hasn't started yet". They are simple: just write let and the variable name:

fn main() {
    let my_variable; // ⚠️
}

But you can't use it yet, and Rust won't compile if anything is uninitialized.

But sometimes they can be useful. A good example is when:

• You have a code block and the value for your variable is inside it, and
• The variable needs to live outside of the code block.

fn loop_then_return(mut counter: i32) -> i32 {
    loop {
        counter += 1;
        if counter % 50 == 0 {
            break;
        }
    }
    counter
}

fn main() {
    let my_number;

    {
        // Pretend we need to have this code block
        let number = {
            // Pretend there is code here to make a number
            // Lots of code, and finally:
            57
        };

        my_number = loop_then_return(number);
    }

    println!("{}", my_number);
}

This prints 100.

You can see that my_number was declared in the main() function, so it lives until the end. But it gets its value from inside a loop. However, that value lives as long as my_number, because my_number has the value. And if you wrote let my_number = loop_then_return(number) inside the block, it would just die right away.

It helps to imagine if you simplify the code. loop_then_return(number) gives the result 100, so let's delete it and write 100 instead. Also, now we don't need number so we will delete it too. Now it looks like this:

fn main() {
    let my_number;
    {
        my_number = 100;
    }

    println!("{}", my_number);
}

So it's almost like saying let my_number = { 100 };.

Also note that my_number is not mut. We didn't give it a value until we gave it 50, so it never changed its value. In the end, the real code for my_number is just let my_number = 100;.

Collection types

Rust has a lot of types for making a collection. Collections are for when you need more than one value in one spot. For example, you could have information on all the cities in your country inside one variable. We will start with arrays, which are fastest but also have the least functionality. They are kind of like &str in that way.

Arrays

An array is data inside square brackets: []. Arrays:

• must not change their size,
• must only contain the same type.

They are very fast, however.

The type of an array is: [type; number]. For example, the type of ["One", "Two"] est [&str; 2]. This means that even these two arrays have different types:

fn main() {
    let array1 = ["One", "Two"]; // This one is type [&str; 2]
    let array2 = ["One", "Two", "Five"]; // But this one is type [&str; 3]. Different type!
}

Here is a good tip: to know the type of a variable, you can "ask" the compiler by giving it bad instructions. For example:

fn main() {
    let seasons = ["Spring", "Summer", "Autumn", "Winter"];
    let seasons2 = ["Spring", "Summer", "Fall", "Autumn", "Winter"];
    seasons.ddd(); // ⚠️
    seasons2.thd(); // ⚠️ as well
}

The compiler says, "What? There's no .ddd() method for seasons and no .thd() method for seasons 2 either!!" as you can see:

error[E0599]: no method named `ddd` found for array `[&str; 4]` in the current scope
 --> srcmain.rs:4:13
  |
4 |     seasons.ddd(); // 
  |             ^^^ method not found in `[&str; 4]`

error[E0599]: no method named `thd` found for array `[&str; 5]` in the current scope
 --> srcmain.rs:5:14
  |
5 |     seasons2.thd(); // 
  |              ^^^ method not found in `[&str; 5]`

So it tells you method not found in `[&str; 4]`, which is the type.

If you want an array with all the same value, you can declare it like this:

fn main() {
    let my_array = ["a"; 10];
    println!("{:?}", my_array);
}

This prints ["a", "a", "a", "a", "a", "a", "a", "a", "a", "a"].

This method is used a lot to create buffers. Par example, let mut buffer = [0; 640] creates an array of 640 zeroes. Then we can change zero to other numbers in order to add data.

You can index (get) entries in an array with []. The first entry is [0], the second is [1], and so on.

fn main() {
    let my_numbers = [0, 10, -20];
    println!("{}", my_numbers[1]); // prints 10
}

You can get a slice (a piece) of an array. First you need a &, because the compiler doesn't know the size. Then you can use .. to show the range.

For example, let's use this array: [1, 2, 3, 4, 5, 6, 7, 8, 9, 10].

fn main() {
    let array_of_ten = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10];

    let three_to_five = &array_of_ten[2..5];
    let start_at_two = &array_of_ten[1..];
    let end_at_five = &array_of_ten[..5];
    let everything = &array_of_ten[..];

    println!("Three to five: {:?}, start at two: {:?}, end at five: {:?}, everything: {:?}", three_to_five, start_at_two, end_at_five, everything);
}

Remember that:

• Index numbers start at 0 (not 1)
• Index ranges are exclusive (they do not include the last number)

So [0..2] means the first index and the second index (0 and 1). Or you can call it the "zeroth and first" index. It doesn't have the third item, which is index 2.

You can also have an inclusive range, which means it includes the last number too. To do this, add = to write ..= à la place de ... So instead of [0..2] you can write [0..=2] if you want the first, second, and third item.

Vectors

See this chapter on YouTube

In the same way that we have &str et String, we have arrays and vectors. Arrays are faster with less functionality, and vectors are slower with more functionality. (Of course, Rust is always very fast so vectors are not slow, just slower than arrays.) The type is written Vec, and you can also just call it a "vec".

There are two main ways to declare a vector. One is like with String using new:

fn main() {
    let name1 = String::from("Windy");
    let name2 = String::from("Gomesy");

    let mut my_vec = Vec::new();
    // If we run the program now, the compiler will give an error.
    // It doesn't know the type of vec.

    my_vec.push(name1); // Now it knows: it's Vec
    my_vec.push(name2);
}

You can see that a Vec always has something else inside it, and that's what the <> (angle brackets) are for. UNE Vec is a vector with one or more Strings. You can also have more types inside. For example:

• Vec<(i32, i32)> this is a Vec where each item is a tuple: (i32, i32).
• Vec> this is a Vec that has Vecs of Strings. Say for example you wanted to save your favourite book as a Vec. Then you do it again with another book, and get another Vec. To hold both books, you would put them into another Vec and that would be a Vec>.

Instead of using .push() to make Rust decide the type, you can just declare the type.

fn main() {
    let mut my_vec: Vec<String> = Vec::new(); // The compiler knows the type
                                              // so there is no error.
}

You can see that items in vectors must have the same type.

Another easy way to create a vector is with the vec! macro. It looks like an array declaration, but has vec! in front of it.

fn main() {
    let mut my_vec = vec![8, 10, 10];
}

The type is Vec. You call it a "Vec of i32s". Et un Vec is a "Vec of strings". Et un Vec> is a "Vec of a vec of strings".

You can slice a vector too, just like in an array.

fn main() {
    let vec_of_ten = vec![1, 2, 3, 4, 5, 6, 7, 8, 9, 10];
    // Everything is the same as above except we added vec!.
    let three_to_five = &vec_of_ten[2..5];
    let start_at_two = &vec_of_ten[1..];
    let end_at_five = &vec_of_ten[..5];
    let everything = &vec_of_ten[..];

    println!("Three to five: {:?},
start at two: {:?}
end at five: {:?}
everything: {:?}", three_to_five, start_at_two, end_at_five, everything);
}

Because a vec is slower than an array, we can use some methods to make it faster. A vec has a capacité, which means the space given to the vector. When you push a new item on the vector, it gets closer and closer to the capacity. Then if you go past the capacity, it will make its capacity double and copy the items into the new space. This is called reallocation. We'll use a method called .capacity() to look at the capacity of a vector as we add items to it.

For example:

fn main() {
    let mut num_vec = Vec::new();
    println!("{}", num_vec.capacity()); // 0 elements: prints 0
    num_vec.push('a'); // add one character
    println!("{}", num_vec.capacity()); // 1 element: prints 4. Vecs with 1 item always start with capacity 4
    num_vec.push('a'); // add one more
    num_vec.push('a'); // add one more
    num_vec.push('a'); // add one more
    println!("{}", num_vec.capacity()); // 4 elements: still prints 4.
    num_vec.push('a'); // add one more
    println!("{}", num_vec.capacity()); // prints 8. We have 5 elements, but it doubled 4 to 8 to make space
}

This prints:

So this vector has two reallocations: 0 to 4, and 4 to 8. We can make it faster:

fn main() {
    let mut num_vec = Vec::with_capacity(8); // Give it capacity 8
    num_vec.push('a'); // add one character
    println!("{}", num_vec.capacity()); // prints 8
    num_vec.push('a'); // add one more
    println!("{}", num_vec.capacity()); // prints 8
    num_vec.push('a'); // add one more
    println!("{}", num_vec.capacity()); // prints 8.
    num_vec.push('a'); // add one more
    num_vec.push('a'); // add one more // Now we have 5 elements
    println!("{}", num_vec.capacity()); // Still 8
}

This vector has 0 reallocations, which is better. So if you think you know how many elements you need, you can use Vec::with_capacity() to make it faster.

You remember that you can use .into() to make a &str dans une String. You can also use it to make an array into a Vec. You have to tell .into() that you want a Vec, but you don't have to choose the type of Vec. If you don't want to choose, you can write Vec<_>.

fn main() {
    let my_vec: Vec<u8> = [1, 2, 3].into();
    let my_vec2: Vec<_> = [9, 0, 10].into(); // Vec<_> means "choose the Vec type for me"
                                             // Rust will choose Vec
}

Tuples

See this chapter on YouTube

Tuples in Rust use (). We have seen many empty tuples already, because rien in a function actually means an empty tuple:

is actually short for:

fn do_something() -> () {}

That function gets nothing (an empty tuple), and returns nothing (an empty tuple). So we have been using tuples a lot already. When you don't return anything in a function, you actually return an empty tuple.

fn just_prints() {
    println!("I am printing"); // Adding ; means we return an empty tuple
}

fn main() {}

But tuples can hold many things, and can hold different types too. Items inside a tuple are also indexed with numbers 0, 1, 2, and so on. But to access them, you use a . instead of a []. Let's put a whole bunch of types into a single tuple.

fn main() {
    let random_tuple = ("Here is a name", 8, vec!['a'], 'b', [8, 9, 10], 7.7);
    println!(
        "Inside the tuple is: First item: {:?}
Second item: {:?}
Third item: {:?}
Fourth item: {:?}
Fifth item: {:?}
Sixth item: {:?}",
        random_tuple.0,
        random_tuple.1,
        random_tuple.2,
        random_tuple.3,
        random_tuple.4,
        random_tuple.5,
    )
}

This prints:

Inside the tuple is: First item: "Here is a name"
Second item: 8
Third item: ['a']
Fourth item: 'b'
Fifth item: [8, 9, 10]
Sixth item: 7.7

That tuple is of type (&str, i32, Vec, char, [i32; 3], f64).

You can use a tuple to create multiple variables. Take a look at this code:

fn main() {
    let str_vec = vec!["one", "two", "three"];
}

str_vec has three items in it. What if we want to pull them out? That's where we can use a tuple.

fn main() {
    let str_vec = vec!["one", "two", "three"];

    let (a, b, c) = (str_vec[0], str_vec[1], str_vec[2]); // call them a, b, and c
    println!("{:?}", b);
}

That prints "two", which is what b est. This is called destructuring. That is because first the variables are inside a structure, but then we made a, b, et c that are not inside a structure.

If you need to destructure but don't want all the variables, you can use _.

fn main() {
    let str_vec = vec!["one", "two", "three"];

    let (_, _, variable) = (str_vec[0], str_vec[1], str_vec[2]);
}

Now it only creates a variable called variable but doesn't make a variable for the others.

There are many more collection types, and many more ways to use arrays, vecs, and tuples. We will learn more about them too, but first we will learn control flow.

Control flow

See this chapter on YouTube: Part 1 and Part 2

Control flow means telling your code what to do in different situations. The simplest control flow is if.

fn main() {
    let my_number = 5;
    if my_number == 7 {
        println!("It's seven");
    }
}

Also note that you use == and not =. == is to compare, = est de assign (to give a value). Also note that we wrote if my_number == 7 and not if (my_number == 7). You don't need brackets with if in Rust.

else if et else give you more control:

fn main() {
    let my_number = 5;
    if my_number == 7 {
        println!("It's seven");
    } else if my_number == 6 {
        println!("It's six")
    } else {
        println!("It's a different number")
    }
}

This prints It's a different number because it's not equal to 7 or 6.

You can add more conditions with && (and) and || (or).

fn main() {
    let my_number = 5;
    if my_number % 2 == 1 && my_number > 0 { // % 2 means the number that remains after diving by two
        println!("It's a positive odd number");
    } else if my_number == 6 {
        println!("It's six")
    } else {
        println!("It's a different number")
    }
}

This prints It's a positive odd number because when you divide it by 2 you have a remainder of 1, and it's greater than 0.

You can see that too much if, else, et else if can be difficult to read. In this case you can use match instead, which looks much cleaner. But you must match for every possible result. For example, this will not work:

fn main() {
    let my_number: u8 = 5;
    match my_number {
        0 => println!("it's zero"),
        1 => println!("it's one"),
        2 => println!("it's two"),
        // ⚠️
    }
}

The compiler says:

error[E0004]: non-exhaustive patterns: `3u8..=std::u8::MAX` not covered
 --> srcmain.rs:3:11
  |
3 |     match my_number {
  |           ^^^^^^^^^ pattern `3u8..=std::u8::MAX` not covered

This means "you told me about 0 to 2, but u8s can go up to 255. What about 3? What about 4? What about 5?" And so on. So you can add _ which means "anything else".

fn main() {
    let my_number: u8 = 5;
    match my_number {
        0 => println!("it's zero"),
        1 => println!("it's one"),
        2 => println!("it's two"),
        _ => println!("It's some other number"),
    }
}

That prints It's some other number.

Remember this for match:

• You write match and then make a {} code block.
• Write the schéma on the left and use a => fat arrow to say what to do when it matches.
• Each line is called an "arm".
• Put a comma between the arms (not a semicolon).

You can declare a value with a match:

fn main() {
    let my_number = 5;
    let second_number = match my_number {
        0 => 0,
        5 => 10,
        _ => 2,
    };
}

second_number will be 10. Do you see the semicolon at the end? That is because, after the match is over, we actually told the compiler this: let second_number = 10;

You can match on more complicated things too. You use a tuple to do it.

fn main() {
    let sky = "cloudy";
    let temperature = "warm";

    match (sky, temperature) {
        ("cloudy", "cold") => println!("It's dark and unpleasant today"),
        ("clear", "warm") => println!("It's a nice day"),
        ("cloudy", "warm") => println!("It's dark but not bad"),
        _ => println!("Not sure what the weather is."),
    }
}

This prints It's dark but not bad because it matches "cloudy" and "warm" for sky et temperature.

You can even put if inside of match. This is called a "match guard":

fn main() {
    let children = 5;
    let married = true;

    match (children, married) {
        (children, married) if married == false => println!("Not married with {} children", children),
        (children, married) if children == 0 && married == true => println!("Married but no children"),
        _ => println!("Married? {}. Number of children: {}.", married, children),
    }
}

This will print Married? true. Number of children: 5.

You can use _ as many times as you want in a match. In this match on colours, we have three but only check one at a time.

fn match_colours(rbg: (i32, i32, i32)) {
    match rbg {
        (r, _, _) if r < 10 => println!("Not much red"),
        (_, b, _) if b < 10 => println!("Not much blue"),
        (_, _, g) if g < 10 => println!("Not much green"),
        _ => println!("Each colour has at least 10"),
    }
}

fn main() {
    let first = (200, 0, 0);
    let second = (50, 50, 50);
    let third = (200, 50, 0);

    match_colours(first);
    match_colours(second);
    match_colours(third);

}

This prints:

Not much blue
Each colour has at least 10
Not much green

This also shows how match statements work, because in the first example it only printed Not much blue. Mais first also has not much green. UNE match statement always stops when it finds a match, and doesn't check the rest. This is a good example of code that compiles well but is not the code you want.

You can make a really big match statement to fix it, but it is probably better to use a for loop. We will talk about loops soon.

A match has to return the same type. So you can't do this:

fn main() {
    let my_number = 10;
    let some_variable = match my_number {
        10 => 8,
        _ => "Not ten", // ⚠️
    };
}

The compiler tells you that:

error[E0308]: `match` arms have incompatible types
  --> srcmain.rs:17:14
   |
15 |       let some_variable = match my_number {
   |  _________________________-
16 | |         10 => 8,
   | |               - this is found to be of type `{integer}`
17 | |         _ => "Not ten",
   | |              ^^^^^^^^^ expected integer, found `&str`
18 | |     };
   | |_____- `match` arms have incompatible types

This will also not work, for the same reason:

fn main() {
    let some_variable = if my_number == 10 { 8 } else { "something else "}; // ⚠️
}

But this works, because it's not a match so you have a different let statement each time:

fn main() {
    let my_number = 10;

    if my_number == 10 {
        let some_variable = 8;
    } else {
        let some_variable = "Something else";
    }
}

You can also use @ to give a name to the value of a match expression, and then you can use it. In this example we match an i32 input in a function. If it's 4 or 13 we want to use that number in a println! statement. Otherwise, we don't need to use it.

fn match_number(input: i32) {
    match input {
    number @ 4 => println!("{} is an unlucky number in China (sounds close to 死)!", number),
    number @ 13 => println!("{} is unlucky in North America, lucky in Italy! In bocca al lupo!", number),
    _ => println!("Looks like a normal number"),
    }
}

fn main() {
    match_number(50);
    match_number(13);
    match_number(4);
}

This prints:

Looks like a normal number
13 is unlucky in North America, lucky in Italy! In bocca al lupo!
4 is an unlucky number in China (sounds close to 死)!

Structs

See this chapter on YouTube: Part 1 and Part 2

With structs, you can create your own type. You will use structs all the time in Rust because they are so convenient. Structs are created with the keyword struct. The name of a struct should be in UpperCamelCase (capital letter for each word, no spaces). If you write a struct in all lowercase, the compiler will tell you.

There are three types of structs. One is a "unit struct". Unit means "doesn't have anything". For a unit struct, you just write the name and a semicolon.

struct FileDirectory;
fn main() {}

The next is a tuple struct, or an unnamed struct. It is "unnamed" because you only need to write the types, not the field names. Tuple structs are good when you need a simple struct and don't need to remember names.

struct Colour(u8, u8, u8);

fn main() {
    let my_colour = Colour(50, 0, 50); // Make a colour out of RGB (red, green, blue)
    println!("The second part of the colour is: {}", my_colour.1);
}

This prints The second part of the colour is: 0.

The third type is the named struct. This is probably the most common struct. In this struct you declare field names and types inside a {} code block. Note that you don't write a semicolon after a named struct, because there is a whole code block after it.

struct Colour(u8, u8, u8); // Declare the same Colour tuple struct

struct SizeAndColour {
    size: u32,
    colour: Colour, // And we put it in our new named struct
}

fn main() {
    let my_colour = Colour(50, 0, 50);

    let size_and_colour = SizeAndColour {
        size: 150,
        colour: my_colour
    };
}

You separate fields by commas in a named struct too. For the last field you can add a comma or not - it's up to you. SizeAndColour had a comma after colour:

struct Colour(u8, u8, u8); // Declare the same Colour tuple struct

struct SizeAndColour {
    size: u32,
    colour: Colour, // And we put it in our new named struct
}

fn main() {}

but you don't need it. But it can be a good idea to always put a comma, because sometimes you will change the order of the fields:

struct Colour(u8, u8, u8); // Declare the same Colour tuple struct

struct SizeAndColour {
    size: u32,
    colour: Colour // No comma here
}

fn main() {}

Then we decide to change the order...

struct SizeAndColour {
    colour: Colour // ⚠️ Whoops! Now this doesn't have a comma.
    size: u32,
}

fn main() {}

But it is not very important either way so you can choose whether to use a comma or not.

Let's create a Country struct to give an example. le Country struct has the fields population, capital, et leader_name.

struct Country {
    population: u32,
    capital: String,
    leader_name: String
}

fn main() {
    let population = 500_000;
    let capital = String::from("Elista");
    let leader_name = String::from("Batu Khasikov");

    let kalmykia = Country {
        population: population,
        capital: capital,
        leader_name: leader_name,
    };
}

Did you notice that we wrote the same thing twice? We wrote population: population, capital: capital, et leader_name: leader_name. Actually, you don't need to do that. If the field name and variable name are the same, you don't have to write it twice.

struct Country {
    population: u32,
    capital: String,
    leader_name: String
}

fn main() {
    let population = 500_000;
    let capital = String::from("Elista");
    let leader_name = String::from("Batu Khasikov");

    let kalmykia = Country {
        population,
        capital,
        leader_name,
    };
}

Enums

See this chapter on YouTube: Part 1, Part 2, Part 3 and Part 4

Un enum is short for enumerations. They look very similar to a struct, but are different. Here is the difference:

• Use a struct when you want one thing AND another thing.
• Use an enum when you want one thing OU ALORS another thing.

So structs are for many things together, while enums are for many choices together.

To declare an enum, write enum and use a code block with the options, separated by commas. Just like a struct, the last part can have a comma or not. We will create an enum called ThingsInTheSky:

enum ThingsInTheSky {
    Sun,
    Stars,
}

fn main() {}

This is an enum because you can either see the sun, ou alors the stars: you have to choose one. These are called variants.

// create the enum with two choices
enum ThingsInTheSky {
    Sun,
    Stars,
}

// With this function we can use an i32 to create ThingsInTheSky.
fn create_skystate(time: i32) -> ThingsInTheSky {
    match time {
        6..=18 => ThingsInTheSky::Sun, // Between 6 and 18 hours we can see the sun
        _ => ThingsInTheSky::Stars, // Otherwise, we can see stars
    }
}

// With this function we can match against the two choices in ThingsInTheSky.
fn check_skystate(state: &ThingsInTheSky) {
    match state {
        ThingsInTheSky::Sun => println!("I can see the sun!"),
        ThingsInTheSky::Stars => println!("I can see the stars!")
    }
}

fn main() {
    let time = 8; // it's 8 o'clock
    let skystate = create_skystate(time); // create_skystate returns a ThingsInTheSky
    check_skystate(&skystate); // Give it a reference so it can read the variable skystate
}

This prints I can see the sun!.

You can add data to an enum too.

enum ThingsInTheSky {
    Sun(String), // Now each variant has a string
    Stars(String),
}

fn create_skystate(time: i32) -> ThingsInTheSky {
    match time {
        6..=18 => ThingsInTheSky::Sun(String::from("I can see the sun!")), // Write the strings here
        _ => ThingsInTheSky::Stars(String::from("I can see the stars!")),
    }
}

fn check_skystate(state: &ThingsInTheSky) {
    match state {
        ThingsInTheSky::Sun(description) => println!("{}", description), // Give the string the name description so we can use it
        ThingsInTheSky::Stars(n) => println!("{}", n), // Or you can name it n. Or anything else - it doesn't matter
    }
}

fn main() {
    let time = 8; // it's 8 o'clock
    let skystate = create_skystate(time); // create_skystate returns a ThingsInTheSky
    check_skystate(&skystate); // Give it a reference so it can read the variable skystate
}

This prints the same thing: I can see the sun!

You can also "import" an enum so you don't have to type so much. Here's an example where we have to type Mood:: every time we match on our mood:

enum Mood {
    Happy,
    Sleepy,
    NotBad,
    Angry,
}

fn match_mood(mood: &Mood) -> i32 {
    let happiness_level = match mood {
        Mood::Happy => 10, // Here we type Mood:: every time
        Mood::Sleepy => 6,
        Mood::NotBad => 7,
        Mood::Angry => 2,
    };
    happiness_level
}

fn main() {
    let my_mood = Mood::NotBad;
    let happiness_level = match_mood(&my_mood);
    println!("Out of 1 to 10, my happiness is {}", happiness_level);
}

It prints Out of 1 to 10, my happiness is 7. Let's import so we can type less. To import everything, write *. Note: it's the same key as * for dereferencing but is completely different.

enum Mood {
    Happy,
    Sleepy,
    NotBad,
    Angry,
}

fn match_mood(mood: &Mood) -> i32 {
    use Mood::*; // We imported everything in Mood. Now we can just write Happy, Sleepy, etc.
    let happiness_level = match mood {
        Happy => 10, // We don't have to write Mood:: anymore
        Sleepy => 6,
        NotBad => 7,
        Angry => 2,
    };
    happiness_level
}

fn main() {
    let my_mood = Mood::Happy;
    let happiness_level = match_mood(&my_mood);
    println!("Out of 1 to 10, my happiness is {}", happiness_level);
}

Parts of an enum can also be turned into an integer. That's because Rust gives each arm of an enum a number that starts with 0 for its own use. You can do things with it if your enum doesn't have any other data in it.

enum Season {
    Spring, // If this was Spring(String) or something it wouldn't work
    Summer,
    Autumn,
    Winter,
}

fn main() {
    use Season::*;
    let four_seasons = vec![Spring, Summer, Autumn, Winter];
    for season in four_seasons {
        println!("{}", season as u32);
    }
}

This prints:

Though you can give it a different number, if you want - Rust doesn't care and can use it in the same way. Just add an = and your number to the variant that you want to have a number. You don't have to give all of them a number. But if you don't, Rust will just add 1 from the arm before to give it a number.

enum Star {
    BrownDwarf = 10,
    RedDwarf = 50,
    YellowStar = 100,
    RedGiant = 1000,
    DeadStar, // Think about this one. What number will it have?
}

fn main() {
    use Star::*;
    let starvec = vec![BrownDwarf, RedDwarf, YellowStar, RedGiant];
    for star in starvec {
        match star as u32 {
            size if size <= 80 => println!("Not the biggest star."), // Remember: size doesn't mean anything. It's just a name we chose so we can print it
            size if size >= 80 => println!("This is a good-sized star."),
            _ => println!("That star is pretty big!"),
        }
    }
    println!("What about DeadStar? It's the number {}.", DeadStar as u32);
}

This prints:

Not the biggest star.
Not the biggest star.
This is a good-sized star.
This is a good-sized star.
What about DeadStar? It's the number 1001.

DeadStar would have been number 4, but now it's 1001.

Enums to use multiple types

You know that items in a Vec, array, etc. all need the same type (only tuples are different). But you can actually use an enum to put different types in. Imagine we want to have a Vec avec u32s or i32s. Of course, you can make a Vec<(u32, i32)> (a vec with (u32, i32) tuples) but we only want one each time. So here you can use an enum. Here is a simple example:

enum Number {
    U32(u32),
    I32(i32),
}

fn main() {}

So there are two variants: the U32 variant with a u32 inside, and the I32 variant with i32 à l'intérieur. U32 et I32 are just names we made. They could have been UThirtyTwo ou alors IThirtyTwo or anything else.

Now, if we put them into a Vec we just have a Vec, and the compiler is happy because it's all the same type. The compiler doesn't care that we have either u32 ou alors i32 because they are all inside a single type called Number. And because it's an enum, you have to pick one, which is what we want. We will use the .is_positive() method to pick. If it's true then we will choose U32, and if it's false then we will choose I32.

Now the code looks like this:

enum Number {
    U32(u32),
    I32(i32),
}

fn get_number(input: i32) -> Number {
    let number = match input.is_positive() {
        true => Number::U32(input as u32), // change it to u32 if it's positive
        false => Number::I32(input), // otherwise just give the number because it's already i32
    };
    number
}


fn main() {
    let my_vec = vec![get_number(-800), get_number(8)];

    for item in my_vec {
        match item {
            Number::U32(number) => println!("It's a u32 with the value {}", number),
            Number::I32(number) => println!("It's an i32 with the value {}", number),
        }
    }
}

This prints what we wanted to see:

It's an i32 with the value -800
It's a u32 with the value 8

Loops

With loops you can tell Rust to continue something until you want it to stop. You use loop to start a loop that does not stop, unless you tell it when to break.

fn main() { // This program will never stop
    loop {

    }
}

So let's tell the compiler when it can break.

fn main() {
    let mut counter = 0; // set a counter to 0
    loop {
        counter +=1; // increase the counter by 1
        println!("The counter is now: {}", counter);
        if counter == 5 { // stop when counter == 5
            break;
        }
    }
}

This will print:

The counter is now: 1
The counter is now: 2
The counter is now: 3
The counter is now: 4
The counter is now: 5

If you have a loop inside of a loop, you can give them names. With names, you can tell Rust which loop to break out of. Utiliser ' (called a "tick") and a : to give it a name:

fn main() {
    let mut counter = 0;
    let mut counter2 = 0;
    println!("Now entering the first loop.");

    'first_loop: loop {
        // Give the first loop a name
        counter += 1;
        println!("The counter is now: {}", counter);
        if counter > 9 {
            // Starts a second loop inside this loop
            println!("Now entering the second loop.");

            'second_loop: loop {
                // now we are inside 'second_loop
                println!("The second counter is now: {}", counter2);
                counter2 += 1;
                if counter2 == 3 {
                    break 'first_loop; // Break out of 'first_loop so we can exit the program
                }
            }
        }
    }
}

This will print:

Now entering the first loop.
The counter is now: 1
The counter is now: 2
The counter is now: 3
The counter is now: 4
The counter is now: 5
The counter is now: 6
The counter is now: 7
The counter is now: 8
The counter is now: 9
The counter is now: 10
Now entering the second loop.
The second counter is now: 0
The second counter is now: 1
The second counter is now: 2

UNE while loop is a loop that continues while something is still true. Each loop, Rust will check if it is still true. If it becomes false, Rust will stop the loop.

fn main() {
    let mut counter = 0;

    while counter < 5 {
        counter +=1;
        println!("The counter is now: {}", counter);
    }
}

UNE for loop lets you tell Rust what to do each time. But in a for loop, the loop stops after a certain number of times. for loops use ranges very often. You use .. et ..= to create a range.

• .. creates an exclusive range: 0..3 creates 0, 1, 2.
• ..= creates an inclusive range: 0..=3 = 0, 1, 2, 3.

fn main() {
    for number in 0..3 {
        println!("The number is: {}", number);
    }

    for number in 0..=3 {
        println!("The next number is: {}", number);
    }
}

This prints:

The number is: 0
The number is: 1
The number is: 2
The next number is: 0
The next number is: 1
The next number is: 2
The next number is: 3

Also notice that number becomes the variable name for 0..3. We could have called it n, ou alors ntod_het___hno_f, or anything. We can then use that name in println!.

If you don't need a variable name, use _.

fn main() {
    for _ in 0..3 {
        println!("Printing the same thing three times");
    }
}

This prints:

Printing the same thing three times
Printing the same thing three times
Printing the same thing three times

because we didn't give it any number to print each time.

And actually, if you give a variable name and don't use it, Rust will tell you:

fn main() {
    for number in 0..3 {
        println!("Printing the same thing three times");
    }
}

This prints the same thing as above. The program compiles fine, but Rust will remind you that you didn't use number:

warning: unused variable: `number`
 --> srcmain.rs:2:9
  |
2 |     for number in 0..3 {
  |         ^^^^^^ help: if this is intentional, prefix it with an underscore: `_number`

Rust suggests writing _number à la place de _. Putting _ in front of a variable name means "maybe I will use it later". But using just _ means "I don't care about this variable at all". So you can put _ in front of variable names if you will use them later and don't want the compiler to tell you about them.

You can also use break to return a value. You write the value right after break and use a ;. Here is an example with a loop and a break that gives my_number its value.

fn main() {
    let mut counter = 5;
    let my_number = loop {
        counter +=1;
        if counter % 53 == 3 {
            break counter;
        }
    };
    println!("{}", my_number);
}

This prints 56. break counter; means "break and return the value of counter". And because the whole block starts with let, my_number gets the value.

Now that we know how to use loops, here is a better solution to our match problem with colours from before. It is a better solution because we want to compare everything, and a for loop looks at every item.

fn match_colours(rbg: (i32, i32, i32)) {
    println!("Comparing a colour with {} red, {} blue, and {} green:", rbg.0, rbg.1, rbg.2);
    let new_vec = vec![(rbg.0, "red"), (rbg.1, "blue"), (rbg.2, "green")]; // Put the colours in a vec. Inside are tuples with the colour names
    let mut all_have_at_least_10 = true; // Start with true. We will set it to false if one colour is less than 10
    for item in new_vec {
        if item.0 < 10 {
            all_have_at_least_10 = false; // Now it's false
            println!("Not much {}.", item.1) // And we print the colour name.
        }
    }
    if all_have_at_least_10 { // Check if it's still true, and print if true
        println!("Each colour has at least 10.")
    }
    println!(); // Add one more line
}

fn main() {
    let first = (200, 0, 0);
    let second = (50, 50, 50);
    let third = (200, 50, 0);

    match_colours(first);
    match_colours(second);
    match_colours(third);
}

This prints:

Comparing a colour with 200 red, 0 blue, and 0 green:
Not much blue.
Not much green.

Comparing a colour with 50 red, 50 blue, and 50 green:
Each colour has at least 10.

Comparing a colour with 200 red, 50 blue, and 0 green:
Not much green.

Implementing structs and enums

This is where you can start to give your structs and enums some real power. To call functions on a struct or an enum, use an impl block. These functions are called methods. There are two kinds of methods in an impl block.

• Regular methods: these take soi (or &self ou alors &mut self). Regular methods use a . (a period). .clone() is an example of a regular method.
• Associated methods (or "static" methods): these do not take self. Associated means "related to". They are written differently, using ::. String::from() is an associated method, and so is Vec::new(). You usually see associated methods used to create new variables.

In our example we are going to create animals and print them.

For a new struct ou alors enum, you need to give it Debug if you want to use {:?} to print, so we will do that. If you write #[derive(Debug)] above the struct or enum then you can print it with {:?}. These messages with #[] are called attributes. You can sometimes use them to tell the compiler to give your struct an ability like Debug. There are many attributes and we will learn about them later. Mais derive is probably the most common and you see it a lot above structs and enums.

#[derive(Debug)]
struct Animal {
    age: u8,
    animal_type: AnimalType,
}

#[derive(Debug)]
enum AnimalType {
    Cat,
    Dog,
}

impl Animal {
    fn new() -> Self {
        // Self means Animal.
        //You can also write Animal instead of Self

        Self {
            // When we write Animal::new(), we always get a cat that is 10 years old
            age: 10,
            animal_type: AnimalType::Cat,
        }
    }

    fn change_to_dog(&mut self) { // because we are inside Animal, &mut self means &mut Animal
                                  // use .change_to_dog() to change the cat to a dog
                                  // with &mut self we can change it
        println!("Changing animal to dog!");
        self.animal_type = AnimalType::Dog;
    }

    fn change_to_cat(&mut self) {
        // use .change_to_cat() to change the dog to a cat
        // with &mut self we can change it
        println!("Changing animal to cat!");
        self.animal_type = AnimalType::Cat;
    }

    fn check_type(&self) {
        // we want to read self
        match self.animal_type {
            AnimalType::Dog => println!("The animal is a dog"),
            AnimalType::Cat => println!("The animal is a cat"),
        }
    }
}



fn main() {
    let mut new_animal = Animal::new(); // Associated method to create a new animal
                                        // It is a cat, 10 years old
    new_animal.check_type();
    new_animal.change_to_dog();
    new_animal.check_type();
    new_animal.change_to_cat();
    new_animal.check_type();
}

This prints:

The animal is a cat
Changing animal to dog!
The animal is a dog
Changing animal to cat!
The animal is a cat

Remember that Self (the type Self) and self (the variable self) are abbreviations. (abbreviation = short way to write)

So in our code, Self = Animal. Also, fn change_to_dog(&mut self) moyens fn change_to_dog(&mut Animal).

Here is one more small example. This time we will use impl on an enum:

enum Mood {
    Good,
    Bad,
    Sleepy,
}

impl Mood {
    fn check(&self) {
        match self {
            Mood::Good => println!("Feeling good!"),
            Mood::Bad => println!("Eh, not feeling so good"),
            Mood::Sleepy => println!("Need sleep NOW"),
        }
    }
}

fn main() {
    let my_mood = Mood::Sleepy;
    my_mood.check();
}

This prints Need sleep NOW.

Destructuring

Let's look at some more destructuring. You can get the values from a struct or enum by using let backwards. We learned that this is destructuring, because you get variables that are not part of a structure. Now you have the values separately. First a simple example:

struct Person { // make a simple struct for a person
    name: String,
    real_name: String,
    height: u8,
    happiness: bool
}

fn main() {
    let papa_doc = Person { // create variable papa_doc
        name: "Papa Doc".to_string(),
        real_name: "Clarence".to_string(),
        height: 170,
        happiness: false
    };

    let Person { // destructure papa_doc
        name: a,
        real_name: b,
        height: c,
        happiness: d
    } = papa_doc;

    println!("They call him {} but his real name is {}. He is {} cm tall and is he happy? {}", a, b, c, d);
}

This prints: They call him Papa Doc but his real name is Clarence. He is 170 cm tall and is he happy? false

You can see that it's backwards. First we say let papa_doc = Person { fields } to create the struct. Then we say let Person { fields } = papa_doc to destructure it.

You don't have to write name: a - you can just write name. But here we write name: a because we want to use a variable with the name a.

Now a bigger example. In this example we have a City struct. We give it a new function to make it. Then we have a process_city_values function to do things with the values. In the function we just create a Vec, but you can imagine that we can do much more after we destructure it.

struct City {
    name: String,
    name_before: String,
    population: u32,
    date_founded: u32,
}

impl City {
    fn new(name: String, name_before: String, population: u32, date_founded: u32) -> Self {
        Self {
            name,
            name_before,
            population,
            date_founded,
        }
    }
}

fn process_city_values(city: &City) {
    let City {
        name,
        name_before,
        population,
        date_founded,
    } = city;
        // now we have the values to use separately
    let two_names = vec![name, name_before];
    println!("The city's two names are {:?}", two_names);
}

fn main() {
    let tallinn = City::new("Tallinn".to_string(), "Reval".to_string(), 426_538, 1219);
    process_city_values(&tallinn);
}

This prints The city's two names are ["Tallinn", "Reval"].

References and the dot operator

We learned that when you have a reference, you need to use * to get to the value. A reference is a different type, so this won't work:

fn main() {
    let my_number = 9;
    let reference = &my_number;

    println!("{}", my_number == reference); // ⚠️
}

The compiler prints:

error[E0277]: can't compare `{integer}` with `&{integer}`
 --> srcmain.rs:5:30
  |
5 |     println!("{}", my_number == reference);
  |                              ^^ no implementation for `{integer} == &{integer}`

So we change line 5 to println!("{}", my_number == *reference); and now it prints true because it's now i32 == i32, not i32 == &i32. This is called dereferencing.

But when you use a method, Rust will dereference for you. le . in a method is called the dot operator, and it does dereferencing for free.

First, let's make a struct with one u8 field. Then we will make a reference to it and try to compare. It will not work:

struct Item {
    number: u8,
}

fn main() {
    let item = Item {
        number: 8,
    };

    let reference_number = &item.number; // reference number type is &u8

    println!("{}", reference_number == 8); // ⚠️ &u8 and u8 cannot be compared
}

To make it work, we need to dereference: println!("{}", *reference_number == 8);.

But with the dot operator, we don't need *. For example:

struct Item {
    number: u8,
}

fn main() {
    let item = Item {
        number: 8,
    };

    let reference_item = &item;

    println!("{}", reference_item.number == 8); // we don't need to write *reference_item.number
}

Now let's create a method for Item that compares number to another number. We don't need to use * anywhere:

struct Item {
    number: u8,
}

impl Item {
    fn compare_number(&self, other_number: u8) { // takes a reference to self
        println!("Are {} and {} equal? {}", self.number, other_number, self.number == other_number);
            // We don't need to write *self.number
    }
}

fn main() {
    let item = Item {
        number: 8,
    };

    let reference_item = &item; // This is type &Item
    let reference_item_two = &reference_item; // This is type &&Item

    item.compare_number(8); // the method works
    reference_item.compare_number(8); // it works here too
    reference_item_two.compare_number(8); // and here

}

So just remember: when you use the . operator, you don't need to worry about *.

Generics

In functions, you write what type to take as input:

fn return_number(number: i32) -> i32 {
    println!("Here is your number.");
    number
}

fn main() {
    let number = return_number(5);
}

But what if you want to take more than just i32? You can use generics for this. Generics means "maybe one type, maybe another type".

For generics, you use angle brackets with the type inside, like this: This means "any type you put into the function". Usually, generics uses types with one capital letter (T, U, V, etc.), though you don't have to just use one letter.

This is how you change the function to make it generic:

fn return_number(number: T) -> T {
    println!("Here is your number.");
    number
}

fn main() {
    let number = return_number(5);
}

The important part is the after the function name. Without this, Rust will think that T is a concrete (concrete = not generic) type, like String ou alors i8.

This is easier to understand if we write out a type name. See what happens when we change T à MyType:

fn return_number(number: MyType) -> MyType { // ⚠️
    println!("Here is your number.");
    number
}

As you can see, MyType is concrete, not generic. So we need to write this and so now it works:

fn return_number(number: MyType) -> MyType {
    println!("Here is your number.");
    number
}

fn main() {
    let number = return_number(5);
}

So the single letter T is for human eyes, but the part after the function name is for the compiler's "eyes". Without it, it's not generic.

Now we will go back to type T, because Rust code usually uses T.

You will remember that some types in Rust are Copie, some are Clone, some are Display, some are Debug, and so on. Avec Debug, we can print with {:?}. So now you can see that we have a problem if we want to print T:

fn print_number(number: T) {
    println!("Here is your number: {:?}", number); // ⚠️
}

fn main() {
    print_number(5);
}

print_number needs Debug to print number, but is T a type with Debug? Maybe not. Maybe it doesn't have #[derive(Debug)], who knows. The compiler doesn't know either, so it gives an error:

error[E0277]: `T` doesn't implement `std::fmt::Debug`
  --> srcmain.rs:29:43
   |
29 |     println!("Here is your number: {:?}", number);
   |                                           ^^^^^^ `T` cannot be formatted using `{:?}` because it doesn't implement `std::fmt::Debug`

T doesn't implement Debug. So do we implement Debug for T? No, because we don't know what T is. But we can tell the function: "Don't worry, because any type T for this function will have Debug".

use std::fmt::Debug; // Debug is located at std::fmt::Debug. So now we can just write 'Debug'.

fn print_number(number: T) { //  is the important part
    println!("Here is your number: {:?}", number);
}

fn main() {
    print_number(5);
}

So now the compiler knows: "Okay, this type T is going to have Debug". Now the code works, because i32 has Debug. Now we can give it many types: String, &str, and so on, because they all have Debug.

Now we can create a struct and give it Debug with #[derive(Debug)], so now we can print it too. Our function can take i32, the struct Animal, and more:

use std::fmt::Debug;

#[derive(Debug)]
struct Animal {
    name: String,
    age: u8,
}

fn print_item(item: T) {
    println!("Here is your item: {:?}", item);
}

fn main() {
    let charlie = Animal {
        name: "Charlie".to_string(),
        age: 1,
    };

    let number = 55;

    print_item(charlie);
    print_item(number);
}

This prints:

Here is your item: Animal { name: "Charlie", age: 1 }
Here is your item: 55

Sometimes we need more than one type in a generic function. We have to write out each type name, and think about how we want to use it. In this example, we want two types. First we want to print a statement for type T. Printing with {} is nicer, so we will require Display pour T.

Next is type U, and the two variables num_1 et num_2 have type U (U is some sort of number). We want to compare them, so we need PartialOrd. That trait lets us use things like <, >, ==, and so on. We want to print them too, so we require Display pour U ainsi que.

use std::fmt::Display;
use std::cmp::PartialOrd;

fn compare_and_displayPartialOrd>(statement: T, num_1: U, num_2: U) {
    println!("{}! Is {} greater than {}? {}", statement, num_1, num_2, num_1 > num_2);
}

fn main() {
    compare_and_display("Listen up!", 9, 8);
}

This prints Listen up!! Is 9 greater than 8? true.

So fn compare_and_display(statement: T, num_1: U, num_2: U) says:

• The function name is compare_and_display,
• The first type is T, and it is generic. It must be a type that can print with {}.
• The next type is U, and it is generic. It must be a type that can print with {}. Also, it must be a type that can compare (use >, <, et ==).

Now we can give compare_and_display different types. statement can be a String, a &str, anything with Display.

To make generic functions easier to read, we can also write it like this with where right before the code block:

use std::cmp::PartialOrd;
use std::fmt::Display;

fn compare_and_display(statement: T, num_1: U, num_2: U)
where
    T: Display,
    U: Display + PartialOrd,
{
    println!("{}! Is {} greater than {}? {}", statement, num_1, num_2, num_1 > num_2);
}

fn main() {
    compare_and_display("Listen up!", 9, 8);
}

Using where is a good idea when you have many generic types.

Also note:

• If you have one type T and another type T, they must be the same.
• If you have one type T and another type U, they can be different. But they can also be the same.

For example:

use std::fmt::Display;

fn say_two(statement_1: T, statement_2: U) { // Type T needs Display, type U needs Display
    println!("I have two things to say: {} and {}", statement_1, statement_2);
}

fn main() {

    say_two("Hello there!", String::from("I hate sand.")); // Type T is a &str, but type U is a String.
    say_two(String::from("Where is Padme?"), String::from("Is she all right?")); // Both types are String.
}

This prints:

I have two things to say: Hello there! and I hate sand.
I have two things to say: Where is Padme? and Is she all right?

Option and Result

We understand enums and generics now, so we can understand Option et Result. Rust uses these two enums to make code safer.

We will start with Option.

Option

You use Option when you have a value that might exist, or might not exist. When a value exists it is Some(value) and when it doesn't it's just None, Here is an example of bad code that can be improved with Option.

    // ⚠️
fn take_fifth(value: Vec<i32>) -> i32 {
    value[4]
}

fn main() {
    let new_vec = vec![1, 2];
    let index = take_fifth(new_vec);
}

When we run the code, it panics. Here is the message:

thread 'main' panicked at 'index out of bounds: the len is 2 but the index is 4', srcmain.rs:34:5

Panic means that the program stops before the problem happens. Rust sees that the function wants something impossible, and stops. It "unwinds the stack" (takes the values off the stack) and tells you "sorry, I can't do that".

So now we will change the return type from i32 à Option. This means "give me a Some(i32) if it's there, and give me None if it's not". We say that the i32 is "wrapped" in an Option, which means that it's inside an Option. You have to do something to get the value out.

fn take_fifth(value: Vec<i32>) -> Option<i32> {
    if value.len() < 5 { // .len() gives the length of the vec.
                         // It must be at least 5.
        None
    } else {
        Some(value[4])
    }
}

fn main() {
    let new_vec = vec![1, 2];
    let bigger_vec = vec![1, 2, 3, 4, 5];
    println!("{:?}, {:?}", take_fifth(new_vec), take_fifth(bigger_vec));
}

This prints None, Some(5). This is good, because now we don't panic anymore. But how do we get the value 5?

We can get the value inside an option with .unwrap(), but be careful with .unwrap(). It's just like unwrapping a present: maybe there's something good inside, or maybe there's an angry snake inside. You only want to .unwrap() if you are sure. If you unwrap a value that is None, the program will panic.

// ⚠️
fn take_fifth(value: Vec<i32>) -> Option<i32> {
    if value.len() < 5 {
        None
    } else {
        Some(value[4])
    }
}

fn main() {
    let new_vec = vec![1, 2];
    let bigger_vec = vec![1, 2, 3, 4, 5];
    println!("{:?}, {:?}",
        take_fifth(new_vec).unwrap(), // this one is None. .unwrap() will panic!
        take_fifth(bigger_vec).unwrap()
    );
}

The message is:

thread 'main' panicked at 'called `Option::unwrap()` on a `None` value', srcmain.rs:14:9

But we don't have to use .unwrap(). We can use a match. Then we can print the value we have Some, and not touch it if we have None. For example:

fn take_fifth(value: Vec<i32>) -> Option<i32> {
    if value.len() < 5 {
        None
    } else {
        Some(value[4])
    }
}

fn handle_option(my_option: Vec<Option<i32>>) {
  for item in my_option {
    match item {
      Some(number) => println!("Found a {}!", number),
      None => println!("Found a None!"),
    }
  }
}

fn main() {
    let new_vec = vec![1, 2];
    let bigger_vec = vec![1, 2, 3, 4, 5];
    let mut option_vec = Vec::new(); // Make a new vec to hold our options
                                     // The vec is type: Vec>. That means a vec of Option.

    option_vec.push(take_fifth(new_vec)); // This pushes "None" into the vec
    option_vec.push(take_fifth(bigger_vec)); // This pushes "Some(5)" into the vec

    handle_option(option_vec); // handle_option looks at every option in the vec.
                               // It prints the value if it is Some. It doesn't touch it if it is None.
}

This prints:

Because we know generics, we are able to read the code for Option. Cela ressemble à ceci:

enum Option {
    None,
    Some(T),
}

fn main() {}

The important point to remember: with Some, you have a value of type T (any type). Also note that the angle brackets after the enum name around T is what tells the compiler that it's generic. It has no trait like Display or anything to limit it, so it can be anything. But with None, you don't have anything.

So in a match statement for Option you can't say:

// ?
Some(value) => println!("The value is {}", value),
None(value) => println!("The value is {}", value),

car None is just None.

Of course, there are easier ways to use Option. In this code, we will use a method called .is_some() to tell us if it is Some. (Yes, there is also a method called .is_none().) In this easier way, we don't need handle_option() anymore. We also don't need a vec for the Options.

fn take_fifth(value: Vec<i32>) -> Option<i32> {
    if value.len() < 5 {
        None
    } else {
        Some(value[4])
    }
}

fn main() {
    let new_vec = vec![1, 2];
    let bigger_vec = vec![1, 2, 3, 4, 5];
    let vec_of_vecs = vec![new_vec, bigger_vec];
    for vec in vec_of_vecs {
        let inside_number = take_fifth(vec);
        if inside_number.is_some() {
            // .is_some() returns true if we get Some, false if we get None
            println!("We got: {}", inside_number.unwrap()); // now it is safe to use .unwrap() because we already checked
        } else {
            println!("We got nothing.");
        }
    }
}

This prints:

We got nothing.
We got: 5

Résultat

Result is similar to Option, but here is the difference:

• Option is about Some ou alors None (value or no value),
• Result is about Ok ou alors Err (okay result, or error result).

So Option is if you are thinking: "Maybe there will be something, and maybe there won't." Mais Result is if you are thinking: "Maybe it will fail."

To compare, here are the signatures for Option and Result.

enum Option {
    None,
    Some(T),
}

enum Result {
    Ok(T),
    Err(E),
}

fn main() {}

So Result has a value inside of Ok, and a value inside of Err. That is because errors usually contain information that describes the error.

Result means you need to think of what you want to return for Ok, and what you want to return for Err. Actually, you can decide anything. Even this is okay:

fn check_error() -> Result<(), ()> {
    Ok(())
}

fn main() {
    check_error();
}

check_error says "return () if we get Ok, and return () if we get Err". Then we return Ok avec un ().

The compiler gives us an interesting warning:

warning: unused `std::result::Result` that must be used
 --> srcmain.rs:6:5
  |
6 |     check_error();
  |     ^^^^^^^^^^^^^^
  |
  = note: `#[warn(unused_must_use)]` on by default
  = note: this `Result` may be an `Err` variant, which should be handled

This is true: we only returned the Result but it could have been an Err. So let's handle the error a bit, even though we're still not really doing anything.

fn give_result(input: i32) -> Result<(), ()> {
    if input % 2 == 0 {
        return Ok(())
    } else {
        return Err(())
    }
}

fn main() {
    if give_result(5).is_ok() {
        println!("It's okay, guys")
    } else {
        println!("It's an error, guys")
    }
}

This prints It's an error, guys. So we just handled our first error.

Remember, the four methods to easily check are .is_some(), is_none(), is_ok(), et is_err().

Sometimes a function with Result will use a String for the Err value. This is not the best method to use, but it is a little better than what we've done so far.

fn check_if_five(number: i32) -> Result<i32, String> {
    match number {
        5 => Ok(number),
        _ => Err("Sorry, the number wasn't five.".to_string()), // This is our error message
    }
}

fn main() {
    let mut result_vec = Vec::new(); // Create a new vec for the results

    for number in 2..7 {
        result_vec.push(check_if_five(number)); // push each result into the vec
    }

    println!("{:?}", result_vec);
}

Our vec prints:

[Err("Sorry, the number wasn't five."), Err("Sorry, the number wasn't five."), Err("Sorry, the number wasn't five."), Ok(5),
Err("Sorry, the number wasn't five.")]

Just like Option, .unwrap() au Err will panic.

    // ⚠️
fn main() {
    let error_value: Result<i32, &str> = Err("There was an error"); // Create a Result that is already an Err
    println!("{}", error_value.unwrap()); // Unwrap it
}

The program panics, and prints:

thread 'main' panicked at 'called `Result::unwrap()` on an `Err` value: "There was an error"', srcmain.rs:30:20

This information helps you fix your code. srcmain.rs:30:20 means "inside main.rs in directory src, on line 30 and column 20". So you can go there to look at your code and fix the problem.

You can also create your own error types. Result functions in the standard library and other people's code usually do this. For example, this function from the standard library:

// ?
pub fn from_utf8(vec: Vec<u8>) -> Result<String, FromUtf8Error>

This function takes a vector of bytes (u8) and tries to make a String. So the success case for the Result is a String and the error case is FromUtf8Error. You can give your error type any name you want.

Using a match avec Option et Result sometimes requires a lot of code. For example, the .get() method returns an Option on a Vec.

fn main() {
    let my_vec = vec![2, 3, 4];
    let get_one = my_vec.get(0); // 0 to get the first number
    let get_two = my_vec.get(10); // Returns None
    println!("{:?}", get_one);
    println!("{:?}", get_two);
}

This prints

So now we can match to get the values. Let's use a range from 0 to 10 to see if it matches the numbers in my_vec.

fn main() {
    let my_vec = vec![2, 3, 4];

    for index in 0..10 {
      match my_vec.get(index) {
        Some(number) => println!("The number is: {}", number),
        None => {}
      }
    }
}

This is good, but we don't do anything for None because we don't care. Here we can make the code smaller by using if let. if let means "do something if it matches, and don't do anything if it doesn't". if let is when you don't care about matching for everything.

fn main() {
    let my_vec = vec![2, 3, 4];

    for index in 0..10 {
      if let Some(number) = my_vec.get(index) {
        println!("The number is: {}", number);
      }
    }
}

Important to remember: if let Some(number) = my_vec.get(index) means "if you get Some(number) de my_vec.get(index)".

Also note: it uses one =. It is not a boolean.

while let is like a while loop for if let. Imagine that we have weather station data like this:

["Berlin", "cloudy", "5", "-7", "78"]
["Athens", "sunny", "not humid", "20", "10", "50"]

We want to get the numbers, but not the words. For the numbers, we can use a method called parse::(). parse() is the method, and :: is the type. It will try to turn the &str into an i32, and give it to us if it can. It returns a Result, because it might not work (like if you wanted it to parse "Billybrobby" - that's not a number).

We will also use .pop(). This takes the last item off of the vector.

fn main() {
    let weather_vec = vec![
        vec!["Berlin", "cloudy", "5", "-7", "78"],
        vec!["Athens", "sunny", "not humid", "20", "10", "50"],
    ];
    for mut city in weather_vec {
        println!("For the city of {}:", city[0]); // In our data, every first item is the city name
        while let Some(information) = city.pop() {
            // This means: keep going until you can't pop anymore
            // When the vector reaches 0 items, it will return None
            // and it will stop.
            if let Ok(number) = information.parse::<i32>() {
                // Try to parse the variable we called information
                // This returns a result. If it's Ok(number), it will print it
                println!("The number is: {}", number);
            }  // We don't write anything here because we do nothing if we get an error. Throw them all away
        }
    }
}

This will print:

For the city of Berlin:
The number is: 78
The number is: -7
The number is: 5
For the city of Athens:
The number is: 50
The number is: 10
The number is: 20

Other collections

Rust has many more types of collections. You can see them at https://doc.rust-lang.org/beta/std/collections/ in the standard library. That page has good explanations for why to use one type, so go there if you don't know what type you want. These collections are all inside std::collections in the standard library. The best way to use them is with a use statement, like we did with our enums. We will start with HashMap, which is very common.

HashMap (and BTreeMap)

A HashMap is a collection made out of keys et values. You use the key to look up the value that matches the key. You can create a new HashMap with just HashMap::new() and use .insert(key, value) to insert items.

UNE HashMap is not in order, so if you print every key in a HashMap together it will probably print differently. We can see this in an example:

use std::collections::HashMap; // This is so we can just write HashMap instead of std::collections::HashMap every time

struct City {
    name: String,
    population: HashMap<u32, u32>, // This will have the year and the population for the year
}

fn main() {

    let mut tallinn = City {
        name: "Tallinn".to_string(),
        population: HashMap::new(), // So far the HashMap is empty
    };

    tallinn.population.insert(1372, 3_250); // insert three dates
    tallinn.population.insert(1851, 24_000);
    tallinn.population.insert(2020, 437_619);


    for (year, population) in tallinn.population { // The HashMap is HashMap so it returns a two items each time
        println!("In the year {} the city of {} had a population of {}.", year, tallinn.name, population);
    }
}

This prints:

In the year 1372 the city of Tallinn had a population of 3250.
In the year 2020 the city of Tallinn had a population of 437619.
In the year 1851 the city of Tallinn had a population of 24000.

or it might print:

In the year 1851 the city of Tallinn had a population of 24000.
In the year 2020 the city of Tallinn had a population of 437619.
In the year 1372 the city of Tallinn had a population of 3250.

You can see that it's not in order.

If you want a HashMap that you can sort, you can use a BTreeMap. Actually they are very similar to each other, so we can quickly change our HashMap to a BTreeMap to see. You can see that it is almost the same code.

use std::collections::BTreeMap; // Just change HashMap to BTreeMap

struct City {
    name: String,
    population: BTreeMap<u32, u32>, // Just change HashMap to BTreeMap
}

fn main() {

    let mut tallinn = City {
        name: "Tallinn".to_string(),
        population: BTreeMap::new(), // Just change HashMap to BTreeMap
    };

    tallinn.population.insert(1372, 3_250);
    tallinn.population.insert(1851, 24_000);
    tallinn.population.insert(2020, 437_619);

    for (year, population) in tallinn.population {
        println!("In the year {} the city of {} had a population of {}.", year, tallinn.name, population);
    }
}

Now it will always print:

In the year 1372 the city of Tallinn had a population of 3250.
In the year 1851 the city of Tallinn had a population of 24000.
In the year 2020 the city of Tallinn had a population of 437619.

Now we will go back to HashMap.

You can get a value in a HashMap by just putting the key in [] square brackets. In this next example we will bring up the value for the key Bielefeld, which is Germany. But be careful, because the program will crash if there is no key. If you write println!("{:?}", city_hashmap["Bielefeldd"]); for example then it will crash, because Bielefeldd doesn't exist.

If you are not sure that there will be a key, you can use .get() which returns an Option. If it exists it will be Some(value), and if not you will get None instead of crashing the program. That's why .get() is the safer way to get a value from a HashMap.

use std::collections::HashMap;

fn main() {
    let canadian_cities = vec!["Calgary", "Vancouver", "Gimli"];
    let german_cities = vec!["Karlsruhe", "Bad Doberan", "Bielefeld"];

    let mut city_hashmap = HashMap::new();

    for city in canadian_cities {
        city_hashmap.insert(city, "Canada");
    }
    for city in german_cities {
        city_hashmap.insert(city, "Germany");
    }

    println!("{:?}", city_hashmap["Bielefeld"]);
    println!("{:?}", city_hashmap.get("Bielefeld"));
    println!("{:?}", city_hashmap.get("Bielefeldd"));
}

This prints:

"Germany"
Some("Germany")
None

This is because Bielefeld exists, but Bielefeldd does not exist.

If a HashMap already has a key when you try to put it in, it will overwrite its value:

use std::collections::HashMap;

fn main() {
    let mut book_hashmap = HashMap::new();

    book_hashmap.insert(1, "L'Allemagne Moderne");
    book_hashmap.insert(1, "Le Petit Prince");
    book_hashmap.insert(1, "섀도우 오브 유어 스마일");
    book_hashmap.insert(1, "Eye of the World");

    println!("{:?}", book_hashmap.get(&1));
}

This prints Some("Eye of the World"), because it was the last one you used .insert() for.

It is easy to check if an entry exists, because you can check with .get() which gives an Option:

use std::collections::HashMap;

fn main() {
    let mut book_hashmap = HashMap::new();

    book_hashmap.insert(1, "L'Allemagne Moderne");

    if book_hashmap.get(&1).is_none() { // is_none() returns a bool: true if it's None, false if it's Some
        book_hashmap.insert(1, "Le Petit Prince");
    }

    println!("{:?}", book_hashmap.get(&1));
}

This prints Some("L'Allemagne Moderne") because there was already a key for 1, so we didn't insert Le Petit Prince.

HashMap has a very interesting method called .entry() that you definitely want to try out. With it you can try to make an entry and use another method like .or_insert() to insert the value if there is no key. The interesting part is that it also gives a mutable reference so you can change it if you want. First is an example where we just insert true every time we insert a book title into the HashMap.

Let's pretend that we have a library and want to keep track of our books.

use std::collections::HashMap;

fn main() {
    let book_collection = vec!["L'Allemagne Moderne", "Le Petit Prince", "Eye of the World", "Eye of the World"]; // Eye of the World appears twice

    let mut book_hashmap = HashMap::new();

    for book in book_collection {
        book_hashmap.entry(book).or_insert(true);
    }
    for (book, true_or_false) in book_hashmap {
        println!("Do we have {}? {}", book, true_or_false);
    }
}

This prints:

Do we have Eye of the World? true
Do we have Le Petit Prince? true
Do we have L'Allemagne Moderne? true

But that's not exactly what we want. Maybe it would be better to count the number of books so that we know that there are two copies of Eye of the World. First let's look at what .entry() does, and what .or_insert() does. .entry() actually returns an enum appelé Entry:

pub fn entry(&mut self, key: K) -> Entry // ?

Here is the page for Entry. Here is a simple version of its code. K means key and V means value.

// ?
use std::collections::hash_map::*;

enum Entry {
    Occupied(OccupiedEntry<K, V>),
    Vacant(VacantEntry<K, V>),
}

Then when we call .or_insert(), it looks at the enum and decides what to do.

fn or_insert(self, default: V) -> &mut V { // ?
    match self {
        Occupied(entry) => entry.into_mut(),
        Vacant(entry) => entry.insert(default),
    }
}

The interesting part is that it returns a mut reference: &mut V. That means you can use let to attach it to a variable, and change the variable to change the value in the HashMap. So for every book we will insert a 0 if there is no entry. And if there is one, we will use += 1 on the reference to increase the number. Now it looks like this:

use std::collections::HashMap;

fn main() {
    let book_collection = vec!["L'Allemagne Moderne", "Le Petit Prince", "Eye of the World", "Eye of the World"];

    let mut book_hashmap = HashMap::new();

    for book in book_collection {
        let return_value = book_hashmap.entry(book).or_insert(0); // return_value is a mutable reference. If nothing is there, it will be 0
        *return_value +=1; // Now return_value is at least 1. And if there was another book, it will go up by 1
    }

    for (book, number) in book_hashmap {
        println!("{}, {}", book, number);
    }
}

The important part is let return_value = book_hashmap.entry(book).or_insert(0);. If you take out the let, you get book_hashmap.entry(book).or_insert(0). Sans let it does nothing: it inserts 0, and nobody takes the mutable reference to 0. So we bind it to return_value so we can keep the 0. Then we increase the value by 1, which gives at least 1 for every book in the HashMap. Then when .entry() looks at Eye of the World again it doesn't insert anything, but it gives us a mutable 1. Then we increase it to 2, and that's why it prints this:

L'Allemagne Moderne, 1
Le Petit Prince, 1
Eye of the World, 2

You can also do things with .or_insert() like insert a vec and then push into the vec. Let's pretend that we asked men and women on the street what they think of a politician. They give a rating from 0 to 10. Then we want to put the numbers together to see if the politician is more popular with men or women. It can look like this:

use std::collections::HashMap;

fn main() {
    let data = vec![ // This is the raw data
        ("male", 9),
        ("female", 5),
        ("male", 0),
        ("female", 6),
        ("female", 5),
        ("male", 10),
    ];

    let mut survey_hash = HashMap::new();

    for item in data { // This gives a tuple of (&str, i32)
        survey_hash.entry(item.0).or_insert(Vec::new()).push(item.1); // This pushes the number into the Vec inside
    }

    for (male_or_female, numbers) in survey_hash {
        println!("{:?}: {:?}", male_or_female, numbers);
    }
}

This prints:

"female", [5, 6, 5]
"male", [9, 0, 10]

The important line is: survey_hash.entry(item.0).or_insert(Vec::new()).push(item.1); So if it sees "female" it will check to see if there is "female" already in the HashMap. If not, it will insert a Vec::new(), then push the number in. If it sees "female" already in the HashMap, it will not insert a new Vec, and will just push the number into it.

HashSet and BTreeSet

UNE HashSet is actually a HashMap that only has keys. On the page for HashSet it explains this on the top:

A hash set implemented as a HashMap where the value is (). So it's a HashMap with keys, no values.

You often use a HashSet if you just want to know if a key exists, or doesn't exist.

Imagine that you have 100 random numbers, and each number between 1 and 100. If you do this, some numbers will appear more than once, while some won't appear at all. If you put them into a HashSet then you will have a list of all the numbers that appeared.

use std::collections::HashSet;

fn main() {
    let many_numbers = vec![
        94, 42, 59, 64, 32, 22, 38, 5, 59, 49, 15, 89, 74, 29, 14, 68, 82, 80, 56, 41, 36, 81, 66,
        51, 58, 34, 59, 44, 19, 93, 28, 33, 18, 46, 61, 76, 14, 87, 84, 73, 71, 29, 94, 10, 35, 20,
        35, 80, 8, 43, 79, 25, 60, 26, 11, 37, 94, 32, 90, 51, 11, 28, 76, 16, 63, 95, 13, 60, 59,
        96, 95, 55, 92, 28, 3, 17, 91, 36, 20, 24, 0, 86, 82, 58, 93, 68, 54, 80, 56, 22, 67, 82,
        58, 64, 80, 16, 61, 57, 14, 11];

    let mut number_hashset = HashSet::new();

    for number in many_numbers {
        number_hashset.insert(number);
    }

    let hashset_length = number_hashset.len(); // The length tells us how many numbers are in it
    println!("There are {} unique numbers, so we are missing {}.", hashset_length, 100 - hashset_length);

    // Let's see what numbers we are missing
    let mut missing_vec = vec![];
    for number in 0..100 {
        if number_hashset.get(&number).is_none() { // If .get() returns None,
            missing_vec.push(number);
        }
    }

    print!("It does not contain: ");
    for number in missing_vec {
        print!("{} ", number);
    }
}

This prints:

There are 66 unique numbers, so we are missing 34.
It does not contain: 1 2 4 6 7 9 12 21 23 27 30 31 39 40 45 47 48 50 52 53 62 65 69 70 72 75 77 78 83 85 88 97 98 99

UNE BTreeSet is similar to a HashSet in the same way that a BTreeMap is similar to a HashMap. If we print each item in the HashSet, we don't know what the order will be:

for entry in number_hashset { // ?
    print!("{} ", entry);
}

Maybe it will print this: 67 28 42 25 95 59 87 11 5 81 64 34 8 15 13 86 10 89 63 93 49 41 46 57 60 29 17 22 74 43 32 38 36 76 71 18 14 84 61 16 35 90 56 54 91 19 94 44 3 0 68 80 51 92 24 20 82 26 58 33 55 96 37 66 79 73. But it will almost never print it in the same way again.

Here as well, it is easy to change your HashSet to a BTreeSet if you decide you need ordering. In our code, we only need to make two changes to switch from a HashSet to a BTreeSet.

use std::collections::BTreeSet; // Change HashSet to BTreeSet

fn main() {
    let many_numbers = vec![
        94, 42, 59, 64, 32, 22, 38, 5, 59, 49, 15, 89, 74, 29, 14, 68, 82, 80, 56, 41, 36, 81, 66,
        51, 58, 34, 59, 44, 19, 93, 28, 33, 18, 46, 61, 76, 14, 87, 84, 73, 71, 29, 94, 10, 35, 20,
        35, 80, 8, 43, 79, 25, 60, 26, 11, 37, 94, 32, 90, 51, 11, 28, 76, 16, 63, 95, 13, 60, 59,
        96, 95, 55, 92, 28, 3, 17, 91, 36, 20, 24, 0, 86, 82, 58, 93, 68, 54, 80, 56, 22, 67, 82,
        58, 64, 80, 16, 61, 57, 14, 11];

    let mut number_btreeset = BTreeSet::new(); // Change HashSet to BTreeSet

    for number in many_numbers {
        number_btreeset.insert(number);
    }
    for entry in number_btreeset {
        print!("{} ", entry);
    }
}

Now it will print in order: 0 3 5 8 10 11 13 14 15 16 17 18 19 20 22 24 25 26 28 29 32 33 34 35 36 37 38 41 42 43 44 46 49 51 54 55 56 57 58 59 60 61 63 64 66 67 68 71 73 74 76 79 80 81 82 84 86 87 89 90 91 92 93 94 95 96.

BinaryHeap

UNE BinaryHeap is an interesting collection type, because it is mostly unordered but has a bit of order. It keeps the largest item in the front, but the other items are in any order.

We will use another list of items for an example, but this time smaller.

use std::collections::BinaryHeap;

fn show_remainder(input: &BinaryHeap<i32>) -> Vec<i32> { // This function shows the remainder in the BinaryHeap. Actually an iterator would be
                                                         // faster than a function - we will learn them later.
    let mut remainder_vec = vec![];
    for number in input {
        remainder_vec.push(*number)
    }
    remainder_vec
}

fn main() {
    let many_numbers = vec![0, 5, 10, 15, 20, 25, 30]; // These numbers are in order

    let mut my_heap = BinaryHeap::new();

    for number in many_numbers {
        my_heap.push(number);
    }

    while let Some(number) = my_heap.pop() { // .pop() returns Some(number) if a number is there, None if not. It pops from the front
        println!("Popped off {}. Remaining numbers are: {:?}", number, show_remainder(&my_heap));
    }
}

This prints:

Popped off 30. Remaining numbers are: [25, 15, 20, 0, 10, 5]
Popped off 25. Remaining numbers are: [20, 15, 5, 0, 10]
Popped off 20. Remaining numbers are: [15, 10, 5, 0]
Popped off 15. Remaining numbers are: [10, 0, 5]
Popped off 10. Remaining numbers are: [5, 0]
Popped off 5. Remaining numbers are: [0]
Popped off 0. Remaining numbers are: []

You can see that the number in the 0 index is always largest: 25, 20, 15, 10, 5, then 0. But the other ones are all different.

A good way to use a BinaryHeap is for a collection of things to do. Here we create a BinaryHeap<(u8, &str)> where the u8 is a number for the importance of the task. le &str is a description of what to do.

use std::collections::BinaryHeap;

fn main() {
    let mut jobs = BinaryHeap::new();

    // Add jobs to do throughout the day
    jobs.push((100, "Write back to email from the CEO"));
    jobs.push((80, "Finish the report today"));
    jobs.push((5, "Watch some YouTube"));
    jobs.push((70, "Tell your team members thanks for always working hard"));
    jobs.push((30, "Plan who to hire next for the team"));

    while let Some(job) = jobs.pop() {
        println!("You need to: {}", job.1);
    }
}

This will always print:

You need to: Write back to email from the CEO
You need to: Finish the report today
You need to: Tell your team members thanks for always working hard
You need to: Plan who to hire next for the team
You need to: Watch some YouTube

VecDeque

UNE VecDeque is a Vec that is good at popping items both off the front and the back. Rust has VecDeque because a Vec is great for popping off the back (the last item), but not so great off the front. When you use .pop() on a Vec, it just takes off the last item on the right and nothing else is moved. But if you take it off another part, all the items to the right are moved over one position to the left. You can see this in the description for .remove():

Removes and returns the element at position index within the vector, shifting all elements after it to the left.

So if you do this:

fn main() {
    let mut my_vec = vec![9, 8, 7, 6, 5];
    my_vec.remove(0);
}

it will remove 9. 8 in index 1 will move to index 0, 7 in index 2 will move to index 1, and so on. Imagine a big parking lot where every time one car leaves all the cars on the right side have to move over.

This, for example, is a parcelle of work for the computer. In fact, if you run it on the Playground it will probably just give up because it's too much work.

fn main() {
    let mut my_vec = vec![0; 600_000];
    for i in 0..600000 {
        my_vec.remove(0);
    }
}

This is a Vec of 600,000 zeros. Every time you use remove(0) on it, it moves each zero left one space to the left. And then it does it 600,000 times.

You don't have to worry about that with a VecDeque. It is usually a bit slower than a Vec, but if you have to do things on both ends then it is much faster. You can just use VecDeque::from avec un Vec to make one. Our code above then looks like this:

use std::collections::VecDeque;

fn main() {
    let mut my_vec = VecDeque::from(vec![0; 600000]);
    for i in 0..600000 {
        my_vec.pop_front(); // pop_front is like .pop but for the front
    }
}

It is now much faster, and on the Playground it finishes in under a second instead of giving up.

In this next example we have a Vec of things to do. Then we make a VecDeque and use .push_front() to put them at the front, so the first item we added will be on the right. But each item we push is a (&str, bool): &str is the description and false means it's not done yet. We use our done() function to pop an item off the back, but we don't want to delete it. Instead, we change false à true and push it at the front so that we can keep it.

Cela ressemble à ceci:

use std::collections::VecDeque;

fn check_remaining(input: &VecDeque<(&str, bool)>) { // Each item is a (&str, bool)
    for item in input {
        if item.1 == false {
            println!("You must: {}", item.0);
        }
    }
}

fn done(input: &mut VecDeque<(&str, bool)>) {
    let mut task_done = input.pop_back().unwrap(); // pop off the back
    task_done.1 = true;                            // now it's done - mark as true
    input.push_front(task_done);                   // put it at the front now
}

fn main() {
    let mut my_vecdeque = VecDeque::new();
    let things_to_do = vec!["send email to customer", "add new product to list", "phone Loki back"];

    for thing in things_to_do {
        my_vecdeque.push_front((thing, false));
    }

    done(&mut my_vecdeque);
    done(&mut my_vecdeque);

    check_remaining(&my_vecdeque);

    for task in my_vecdeque {
        print!("{:?} ", task);
    }
}

This prints:

You must: phone Loki back
("add new product to list", true) ("send email to customer", true) ("phone Loki back", false)

The ? operator

There is an even shorter way to deal with Result (and Option), shorter than match and even shorter than if let. It is called the "question mark operator", and is just ?. After a function that returns a result, you can add ?. This will:

• return what is inside the Result if it is Ok
• pass the error back if it is Err

In other words, it does almost everything for you.

We can try this with .parse() again. We will write a function called parse_str that tries to turn a &str dans une i32. Cela ressemble à ceci:

use std::num::ParseIntError;

fn parse_str(input: &str) -> Result<i32, ParseIntError> {
    let parsed_number = input.parse::<i32>()?; // Here is the question mark
    Ok(parsed_number)
}

fn main() {}

This function takes a &str. If it is Ok, it gives an i32 wrapped in Ok. If it is an Err, it returns a ParseIntError. Then we try to parse the number, and add ?. That means "check if it is an error, and give what is inside the Result if it is okay". If it is not okay, it will return the error and end. But if it is okay, it will go to the next line. On the next line is the number inside of Ok(). We need to wrap it in Ok because the return is Result, not i32.

Now, we can try out our function. Let's see what it does with a vec of &strs.

fn parse_str(input: &str) -> Result<i32, std::num::ParseIntError> {
    let parsed_number = input.parse::<i32>()?;
    Ok(parsed_number)
}

fn main() {
    let str_vec = vec!["Seven", "8", "9.0", "nice", "6060"];
    for item in str_vec {
        let parsed = parse_str(item);
        println!("{:?}", parsed);
    }
}

This prints:

Err(ParseIntError { kind: InvalidDigit })
Ok(8)
Err(ParseIntError { kind: InvalidDigit })
Err(ParseIntError { kind: InvalidDigit })
Ok(6060)

How did we find std::num::ParseIntError? One easy way is to "ask" the compiler again.

fn main() {
    let failure = "Not a number".parse::<i32>();
    failure.rbrbrb(); // ⚠️ Compiler: "What is rbrbrb()???"
}

The compiler doesn't understand, and says:

error[E0599]: no method named `rbrbrb` found for enum `std::result::Result` in the current scope
 --> srcmain.rs:3:13
  |
3 |     failure.rbrbrb();
  |             ^^^^^^ method not found in `std::result::Result`

So std::result::Result is the signature we need.

We don't need to write std::result::Result car Result is always "in scope" (in scope = ready to use). Rust does this for all the types we use a lot so we don't have to write std::result::Result, std::collections::Vec, etc.

We aren't working with things like files yet, so the ? operator doesn't look too useful yet. But here is a useless but quick example that shows how you can use it on a single line. Instead of making an i32 avec .parse(), we'll do a lot more. We'll make an u16, then turn it to a String, then a u32, then to a String again, and finally to a i32.

use std::num::ParseIntError;

fn parse_str(input: &str) -> Result<i32, ParseIntError> {
    let parsed_number = input.parse::<u16>()?.to_string().parse::<u32>()?.to_string().parse::<i32>()?; // Add a ? each time to check and pass it on
    Ok(parsed_number)
}

fn main() {
    let str_vec = vec!["Seven", "8", "9.0", "nice", "6060"];
    for item in str_vec {
        let parsed = parse_str(item);
        println!("{:?}", parsed);
    }
}

This prints the same thing, but this time we handled three Results in a single line. Later on we will do this with files, because they always return Results because many things can go wrong.

Imagine the following: you want to open a file, write to it, and close it. First you need to successfully find the file (that's a Result). Then you need to successfully write to it (that's a Result). Avec ? you can do that on one line.

When panic and unwrap are good

Rust has a panic! macro that you can use to make it panic. It is easy to use:

fn main() {
    panic!("Time to panic!");
}

The message "Time to panic!" displays when you run the program: thread 'main' panicked at 'Time to panic!', srcmain.rs:2:3

You will remember that srcmain.rs is the directory and file name, and 2:3 is the line and column name. With this information, you can find the code and fix it.

panic! is a good macro to use to make sure that you know when something changes. For example, this function called prints_three_things always prints index [0], [1], et [2] from a vector. It is okay because we always give it a vector with three items:

fn prints_three_things(vector: Vec<i32>) {
    println!("{}, {}, {}", vector[0], vector[1], vector[2]);
}

fn main() {
    let my_vec = vec![8, 9, 10];
    prints_three_things(my_vec);
}

It prints 8, 9, 10 and everything is fine.

But imagine that later on we write more and more code, and forget that my_vec can only be three things. Now my_vec in this part has six things:

fn prints_three_things(vector: Vec<i32>) {
  println!("{}, {}, {}", vector[0], vector[1], vector[2]);
}

fn main() {
  let my_vec = vec![8, 9, 10, 10, 55, 99]; // Now my_vec has six things
  prints_three_things(my_vec);
}

No error happens, because [0] et [1] et [2] are all inside this longer Vec. But what if it was really important to only have three things? We wouldn't know that there was a problem because the program doesn't panic. We should have done this instead:

fn prints_three_things(vector: Vec<i32>) {
    if vector.len() != 3 {
        panic!("my_vec must always have three items") // will panic if the length is not 3
    }
    println!("{}, {}, {}", vector[0], vector[1], vector[2]);
}

fn main() {
    let my_vec = vec![8, 9, 10];
    prints_three_things(my_vec);
}

Now we will know if the vector has six items because it panics as it should:

    // ⚠️
fn prints_three_things(vector: Vec<i32>) {
    if vector.len() != 3 {
        panic!("my_vec must always have three items")
    }
    println!("{}, {}, {}", vector[0], vector[1], vector[2]);
}

fn main() {
    let my_vec = vec![8, 9, 10, 10, 55, 99];
    prints_three_things(my_vec);
}

This gives us thread 'main' panicked at 'my_vec must always have three items', srcmain.rs:8:9. Thanks to panic!, we now remember that my_vec should only have three items. So panic! is a good macro to create reminders in your code.

There are three other macros that are similar to panic! that you use a lot in testing. They are: assert!, assert_eq!, et assert_ne!.

Here is what they mean:

• assert!(): if the part inside () is not true, the program will panic.
• assert_eq!(): the two items inside () must be equal.
• assert_ne!(): the two items inside () must not be equal. (ne means not equal)

Some examples:

fn main() {
    let my_name = "Loki Laufeyson";

    assert!(my_name == "Loki Laufeyson");
    assert_eq!(my_name, "Loki Laufeyson");
    assert_ne!(my_name, "Mithridates");
}

This will do nothing, because all three assert macros are okay. (This is what we want)

You can also add a message if you want.

fn main() {
    let my_name = "Loki Laufeyson";

    assert!(
        my_name == "Loki Laufeyson",
        "{} should be Loki Laufeyson",
        my_name
    );
    assert_eq!(
        my_name, "Loki Laufeyson",
        "{} and Loki Laufeyson should be equal",
        my_name
    );
    assert_ne!(
        my_name, "Mithridates",
        "You entered {}. Input must not equal Mithridates",
        my_name
    );
}

These messages will only display if the program panics. So if you run this:

fn main() {
    let my_name = "Mithridates";

    assert_ne!(
        my_name, "Mithridates",
        "You enter {}. Input must not equal Mithridates",
        my_name
    );
}

It will display:

thread 'main' panicked at 'assertion failed: `(left != right)`
  left: `"Mithridates"`,
 right: `"Mithridates"`: You entered Mithridates. Input must not equal Mithridates', srcmain.rs:4:5

So it is saying "you said that left != right, but left == right". And it displays our message that says You entered Mithridates. Input must not equal Mithridates.

unwrap is also good when you are writing your program and you want it to crash when there is a problem. Later, when your code is finished it is good to change unwrap to something else that won't crash.

You can also use expect, which is like unwrap but a bit better because you give it your own message. Textbooks usually give this advice: "If you use .unwrap() a lot, at least use .expect() for better error messages."

This will crash:

   // ⚠️
fn get_fourth(input: &Vec<i32>) -> i32 {
    let fourth = input.get(3).unwrap();
    *fourth
}

fn main() {
    let my_vec = vec![9, 0, 10];
    let fourth = get_fourth(&my_vec);
}

The error message is thread 'main' panicked at 'called Option::unwrap() on a None value', srcmain.rs:7:18.

Now we write our own message with expect:

   // ⚠️
fn get_fourth(input: &Vec<i32>) -> i32 {
    let fourth = input.get(3).expect("Input vector needs at least 4 items");
    *fourth
}

fn main() {
    let my_vec = vec![9, 0, 10];
    let fourth = get_fourth(&my_vec);
}

It crashes again, but the error is better: thread 'main' panicked at 'Input vector needs at least 4 items', srcmain.rs:7:18. .expect() is a little better than .unwrap() because of this, but it will still panic on None. Now here is an example of a bad practice, a function that tries to unwrap two times. It takes a Vec>, so maybe each part will have a Some or maybe a None.

fn try_two_unwraps(input: Vec<Option<i32>>) {
    println!("Index 0 is: {}", input[0].unwrap());
    println!("Index 1 is: {}", input[1].unwrap());
}

fn main() {
    let vector = vec![None, Some(1000)]; // This vector has a None, so it will panic
    try_two_unwraps(vector);
}

The message is: thread 'main' panicked at 'called `Option::unwrap()` on a `None` value', srcmain.rs:2:32. We're not sure if it was the first .unwrap() or the second .unwrap() until we check the line. It would be better to check the length and also to not unwrap. But with .expect() at least it will be a peu better. Here it is with .expect():

fn try_two_unwraps(input: Vec<Option<i32>>) {
    println!("Index 0 is: {}", input[0].expect("The first unwrap had a None!"));
    println!("Index 1 is: {}", input[1].expect("The second unwrap had a None!"));
}

fn main() {
    let vector = vec![None, Some(1000)];
    try_two_unwraps(vector);
}

So that is a bit better: thread 'main' panicked at 'The first unwrap had a None!', srcmain.rs:2:32. We have the line number as well so we can find it.

You can also use unwrap_or if you want to always have a value that you want to choose. If you do this it will never panic. That's:

• 1. good because your program won't panic, but
• 2. maybe not good if you want the program to panic if there's a problem.

But usually we don't want our program to panic, so unwrap_or is a good method to use.

fn main() {
    let my_vec = vec![8, 9, 10];

    let fourth = my_vec.get(3).unwrap_or(&0); // If .get doesn't work, we will make the value &0.
                                              // .get returns a reference, so we need &0 and not 0
                                              // You can write "let *fourth" with a * if you want fourth to be
                                              // a 0 and not a &0, but here we just print so it doesn't matter

    println!("{}", fourth);
}

This prints 0 car .unwrap_or(&0) gives a 0 even if it is a None.

Traits

We have seen traits before: Debug, Copy, Clone are all traits. To give a type a trait, you have to implement it. Because Debug and the others are so common, we have attributes that automatically do it. That's what happens when you write #[derive(Debug)]: you are automatically implementing Debug.

#[derive(Debug)]
struct MyStruct {
    number: usize,
}

fn main() {}

But other traits are more difficult, so you need to implement them manually with impl. Par example, Add (found at std::ops::Add) is used to add two things. But Rust doesn't know exactly how you want to add things, so you have to tell it.

struct ThingsToAdd {
    first_thing: u32,
    second_thing: f32,
}

fn main() {}

We can add first_thing et second_thing, but we need to give more information. Maybe we want an f32, so something like this:

// ?
let result = self.second_thing + self.first_thing as f32

But maybe we want an integer, so like this:

// ?
let result = self.second_thing as u32 + self.first_thing

Or maybe we want to just put self.first_thing à côté de self.second_thing and say that this is how we want to add. So if we add 55 to 33.4, we want to see 5533.4, not 88.4.

So first let's look at how to make a trait. The important thing to remember about traits is that they are about behaviour. To make a trait, write trait and then create some functions.

struct Animal { // A simple struct - an Animal only has a name
    name: String,
}

trait Dog { // The dog trait gives some functionality
    fn bark(&self) { // It can bark
        println!("Woof woof!");
    }
    fn run(&self) { // and it can run
        println!("The dog is running!");
    }
}

impl Dog for Animal {} // Now Animal has the trait Dog

fn main() {
    let rover = Animal {
        name: "Rover".to_string(),
    };

    rover.bark(); // Now Animal can use bark()
    rover.run();  // and it can use run()
}

This is okay, but we don't want to print "The dog is running". You can change the methods that a trait gives you if you want, but you have to have the same signature. That means that it needs to take the same things, and return the same things. For example, we can change the method .run(), but we have to follow the signature. The signature says:

// ?
fn run(&self) {
    println!("The dog is running!");
}

fn run(&self) means "fn run() takes &self, and returns nothing". So you can't do this:

fn run(&self) -> i32 { // ⚠️
    5
}

Rust will say:

   = note: expected fn pointer `fn(&Animal)`
              found fn pointer `fn(&Animal) -> i32`

But we can do this:

struct Animal { // A simple struct - an Animal only has a name
    name: String,
}

trait Dog { // The dog trait gives some functionality
    fn bark(&self) { // It can bark
        println!("Woof woof!");
    }
    fn run(&self) { // and it can run
        println!("The dog is running!");
    }
}

impl Dog for Animal {
    fn run(&self) {
        println!("{} is running!", self.name);
    }
}

fn main() {
    let rover = Animal {
        name: "Rover".to_string(),
    };

    rover.bark(); // Now Animal can use bark()
    rover.run();  // and it can use run()
}

Now it prints Rover is running!. This is okay because we are returning (), or nothing, which is what the trait says.

When you are writing a trait, you can just write the function signature. But if you do that, the user will have to write the function. Let's try that. Now we change bark() et run() to just say fn bark(&self); et fn run(&self);. This is not a full function, so the user must write it.

struct Animal {
    name: String,
}

trait Dog {
    fn bark(&self); // bark() says it needs a &self and returns nothing
    fn run(&self); // run() says it needs a &self and returns nothing.
                   // So now we have to write them ourselves.
}

impl Dog for Animal {
    fn bark(&self) {
        println!("{}, stop barking!!", self.name);
    }
    fn run(&self) {
        println!("{} is running!", self.name);
    }
}

fn main() {
    let rover = Animal {
        name: "Rover".to_string(),
    };

    rover.bark();
    rover.run();
}

So when you create a trait, you must think: "Which functions should I write? And which functions should the user write?" If you think the user should use the function the same way every time, then write out the function. If you think the user will use it differently, then just write the function signature.

So let's try implementing the Display trait for our struct. First we will make a simple struct: