Concepts de base de Rust

Fonction Principale

• La fonction principale est le point de départ de tout programme Rust
• Elle est définie avec fn main() {}

Variables

• Les variables sont déclarées avec le mot-clé let
• Pour rendre une variable mutable (modifiable), utilisez let mut

Types

• Types entiers signés : i8, i16, i32, i64, i128, isize
  • Exemples de littéraux : -10, 0, 1_000, 123_i64
• Types entiers non signés : u8, u16, u32, u64, u128, usize
  • Exemples de littéraux : 0, 123, 10_u16
• Types nombres à virgule flottante : f32, f64
  • Exemples de littéraux : 3.14, -10.0e20, 2_f32
• Type caractère Unicode : char
  • Exemples de littéraux : 'a', 'α', '∞'
• Type booléen : bool
  • Littéraux : true, false
• Largeurs des types:
  • iN, uN et fN ont une largeur de N bits
  • isize et usize ont la largeur d'un pointeur
  • char est de 32 bits de large
  • bool est de 8 bits de large
• Inférer un type de variable est possible, le compilateur affecte le premier type affecté
• Remplacer let par const crée une constante

Fonctions

• Déclaration de fonction : fn nom_fonction (parameter1 : type ,..., parameterN : type ) -> typeRetour { contenu }
• La dernière valeur utilisée dans une fonction est retournée implicitement

Blocs

• Délimités par {...}
• La valeur d'un bloc est la dernière valeur/variable à la fin du bloc
• Terminer un bloc avec un point-virgule ; résulte en une valeur de ()
• Déclarer une variable static la rend utilisable dans tous les blocs

Opérateurs Logiques

• if predicat { ... }: Si le prédicat est vrai, exécuter le bloc
• else if predicat { ... }: Sinon, si le prédicat est vrai, exécuter le bloc
• else { ... }: Sinon, exécuter le bloc
• if let nomVar = ...: Tester si une variable suit un certain pattern
• match nom_variable { ... }: Équivalent de switch
  • Value1 => block1: Si la variable correspond à Value1, exécuter block1
  • _ => block Default: Cas par défaut
  • Des opérateurs/conditions peuvent être ajoutés aux valeurs

Correspondance de Motifs (Structures et Enums)

• match nom_struct { ... }: Tester les valeurs de certains attributs
  • typeStruct{attribute1 : value1, attribute2 : value2, ... attributeN : valueN} => block1: Tester si les attributs correspondent aux valeurs
  • typeStruct{attribute1 : nomVar} => block2: Tester si l'attribut existe et le stocker dans une variable
  • typeStruct{attribute1, attribute2, .. } => block3: Tester si les attributs existent (ignorer le reste)
• typeEnum::attribute(value) => block: Pour les enums
  • Spécifier un nom de variable à la place de value pour tester et utiliser la valeur

Boucles

• while predicat { ... }: Tant que le prédicat est vrai, exécuter le bloc
• for name/value_element in collection { ... }: Pour chaque élément dans la collection
• loop { }: Répéter indéfiniment
• continue: Passe directement à l'itération suivante
• break: Quitte instantanément la boucle
  • Possibilité de nommer une boucle pour extraire des données avec un break

Macros

• Les macros sont des fonctions pouvant prendre un nombre indéfini de paramètres
• Exemple : nomMacro !( param1,param2,...,paramN );

Collections

• Listes :
  • Déclaration : Let mut nomVar : [ type ; tailleListe ] = [ value1,… value_tailleListe ]
  • Initialisation avec une valeur spécifique : [ valueForNumber ; number ]
  • Modification des valeurs : nomVar[ n ] = …
  • Iterating : élément in nomListe
• Tuples :
  • Déclaration : Let nomTuple : ( typeValeur1 , …, typeValeurN ) = ( valeur1 ,…, valeur n )
  • Association de variables: let (var1, …, varN) = tuple
  • Ignorer des valeurs : let (var1, _, var3, …, varN) = tuple
  • Ignorer des plages de valeurs : let (.., varN-1,VarN) = tuple

Références

• Lecture seule (Shared Reference) :
  • Déclaration : let mut nomRef : &type_var_a_referer = &nomVariable ;
  • Accéder à la valeur : *nomRef
• Exclusive Reference :
  • Déclaration : let nomRef = &mut var
  • Permet de modifier la valeur de la variable
  • La référence devient read-only après modification
  • La référence ne peut pas être null ou pointer vers une valeur en dehors du bloc

Tranches (Slices)

• Pointeur vers un ou plusieurs éléments d’une collection :
  • Déclaration : Let slide : &[type_collection] = &collection [i.. n];
  • Indique les éléments de i à n-1
  • &str est une tranche d’octets codés en UTF-8 (&[u8])
  • String est similaire à Vec où T = u8

Structure

• Déclaration: struct Struct_name { attribute1 : type1 ; attribute2 : type2 ; };
• Utilisation : Struct_Name.attribute
• Créer un objet : let mut var_name : struct_name{ attribute_1 : value, … , attribute_n : value }

Mise en Œuvre (Implémentation)

• Ajouter des méthodes à une structure : impl nomStruct { fn nomFunc(&self parameter1 : type ,…, parameterN : type ) ->typeRetour {...} }
• Utiliser self.attribute pour accéder aux attributs de la structure
• &self ne permet pas de modifier la struct (shared read only)
• Utiliser &mut self pour modifier la struct (exclusive read/write)

Constructeur

• Définir un constructeur personnalisé : fn new ( parameter 1 : type1,… ) -> Self{ Self {attribute1 : value, …, attributeN : valueN } //On doit donner une valeur à chaque attribut }
• Terminer la fonction avec Self{…} pour retourner la structure

TupleStruct

• Structure où les noms des attributs ne sont pas importants : struct struct_name (type1,…,typeN);
• Récupérer un attribut : struct_name.k (k est l’index de l’attribut)
• Créer un objet : let var = struct_name(value1,…,value_N)

Traits

• Permet d’ajouter des interfaces implémentables par des structs : trait nomTrait { fn abstractFunc(&self,…) -> typeReturn; }

• Implémenter un trait pour une structure : impl nomTrait for nomStruct{ fn abstractFunc(&self,…) -> typeReturn {…} }

• Héritage avec des traits : trait nomTrait : superTrait {…}

• Associer des types à un trait : trait nomTrait { type typeReturn ; fn abstractFunc(&self,…) -> typeReturn; }

• Implémentation du trait avec association de type : impl nomTrait for nomStruct{ type typeReturn = type ; fn abstractFunc(&self,…) -> typeReturn {…} }

• Utiliser l’annotation ˋ#[derive(trait1, …, traitN)] Struct nomStruct {}` pour prendre en charge certains traits du langage

Enums (Énumérations)

• Type avec un ensemble limité de valeurs possibles : enum name { value1, …, valueN, };
• Utilisation : Enum_name ::value_k
• Permet d’attribuer la valeur numérotée k de l’énumération à une variable

Aliases

• Une fonctionnalité permet de déclarer un nouveau nom de type
• Exemple : type name_type_1 = name_type_2

Fonctions génériques

• Met en œuvre fonctions avec des types modèles (génériques)
• Exemple : fn nomfunc (param1 :type1 ,…, paramk : T,…, paramN : typeN) -> T {}
• T peut être n’importe quel type
• Peut retourner un type défini aussi longtemps que la variable retournée est de ce type
• Obliger un type à implémente un trait : fn nomfunc (param1 :type1 ,…, paramk : T,…, paramN : typeN) -> T {}
• Les paramètres/valeurs de retour de type T doivent avoir un type qui met en œuvre T

Mise en œuvre Générique

• Créer des structures qui mettent en œuvre des types génériques : struct Struct_name { attribute1 : T ; };
• Pour des traits génériques héritant de traits spécifiques, Mettre en œuvre ces traits génériques dans les structures. Impl nomType for Struct_name { … }
• Créer des traits génériques : trait nomTrait { fn abstractFunc(…,T,…) -> typeReturn; }
• Mettre en œuvre des traits génériques : impl nomTrait for nomStruct{ fn abstractFunc(…,abstractFunc:Type,…) -> typeReturn {…} }

Fonctions génériques et dynamiques

• Permet d’utiliser les comportements (méthodes) des types/struct mettant en œuvre le type d’un paramètre en entrée
• fn generic (attribut1: &impl typeA)
•  &impl dans une fonction, Rust crée une version de la fonction pour chaque type qui met en œuvre typeA
• fn generic (attribut1: &dyn typeA)
•  &dyn dans une fonction, Rust ne crée pas de différentes versions de la méthode
• Recherche dynamiquement le bon type dans une vtable (virtual dynamic table) qui contient l’ensemble des types implémentant typeA
• Le paramètre doit être un pointeur

Documentation et annotations

• Utilisé pour documenter le code :
  • /// commentaire
  • //! Inner doc comment
  • /*! Inner doc comment */
• « Inner doc comment » documente un élément
• Exemples : block, struct ou même fonction
• Toutes bibliothèques publiées dans Rust sont automatiquement documentées sur docs.rs (outil rustdoc)

Bibliothèques Standards

• La bibliothèque standard établit un ensemble de règles et de types pour Rust
• Documentation : rustup doc --std ou https://std.rs

Option

• Permet de stocker une valeur (si elle est du bon type) ou rien du tout dans var1 : let mut var1: Option = var2;
• Option peut également être utilisé pour tenter de récupérer la valeur d’une fonction qui pourrait ne rien renvoyer (ex : fonction : find(String s))
• Méthodes :
  • var2.unwrap() : récupère la valeur (plante si var2 est None)
  • var2.expect(« message ») : récupère la valeur ou plante avec un message d’erreur personnalisé
• Si var2 est égal à None, unwrap va « paniquer » et planter
• Si var2 est égal à None, le code va aussi planter, mais renverra le message défini en dans except

Résultat

• Permet de stocker le résultat d’une opération et indiquer si elle a réussi ou non
• Ex: Result = operation(…)
• Résultat contient deux attributs : Ok et Err
• En cas de réussite de l’opération, la valeur peut être récupérée dans Ok
• Exemple : storedResult = Result = operation(…)
• Méthode d’extraction avec : match storedResult{ Ok(mut storedResult) => {…} Err(err) => {…} }
• La message d’erreur renvoyé par l’opération en cas d’échec, est associé à Err

Chaînes de caractères (String)

• Liste des octets codés en UTF-8
• Créer une chaîne vide : let mut var = String::new();
• Ajouter une autre chaîne à la fin : var.push_str(string)
• Ajouter un caractère : var.push(« c »)
• Obtenir la taille de la chaîne : var.len
• Obtenir le nombre de caractères : var.count
• Obtenir le nombre maximal d’éléments de la chaîne : var.capacity

Vecteurs

• Permettent de faire le vecteur
• ex: let mut v1 = Vec::new();
• push, len et capacity des fonctions associées peuvent être utilisées
• v1.retain( condition ): Garde uniquement les éléments de v1 respectant la condition
• v1.dedup();: Supprime les éléments en doubles

HashMap

• Dictionnaire en Rust, associe une valeur à une clé
• let mut hmap = HashMap::new();
• Ajouter une nouvelle donnée au dictionnaire : hmap.insert( Stringkey , Intvalue );
• Vérifie si hmap contient la clé : hmap.containskey( key ) ;
• Nombre de clés dans le dictionnaire : hmap.len()
• Récupèrer la valeur associée à la clé key: hmap.get( key )

Comparaisons

• Il est possible de définir une relation == ou != pour des structures en mettant en œuvre le trait partialeq
• Définir l’égalité : impl PartialEq for typename{ fn eq(&self, other: &Self) -> bool { self.attribute == other.attribute } }
• Définir l’inégalité : impl PartialEq for typename{ fn ne(&self, other: &Self) -> bool { self.attribute != other.attribute } }
• Il est aussi possible de définir une relation d’ordres (,) : impl PartialOrd for typeName { fn partial_cmp(&self, other: &Self) -> Option { match self.attribute1.partial_cmp(&other.attribute1) { Some(Ordering::Equal) => self.attribute2.partial_cmp(&other. attribute2), Attribute1_ord => attribute1_ord, } } }

Opérateurs

• On peut implements des opérateurs sur nos structs avec std::ops::

1. impl std::ops::Add for typename { type Output = Self; fn add(self, other: Self) -> Self { Self <attr1: self.attr1 + other. attr1, attr2: self. attr2 + other. attr2 > } }

From / Into / As

• from() permet d’extraire une valeur d’un type vers unevaleur d’un autre type. Pour cela il faut que la valeur du type entre parenthèse implémente from pour ce type : let one = i16::from(true);
• Into permet de cast lune valeur d’un type vers une valeur d’un autre type : let one: i16 = true.into();
• Implémenter From pour un type revient à implémenter into pour l’autre type.
• As permet d’utiliser une variable comme une variable d’un autre type : var as type
• Il est quand même préférable d’utiliser From et Into plutôt que Cast

Lecture et écriture (Read & Write)

• Read et BufRead permettent d’implémenter des fonctions permettant de lire des données sous format u8 (bytes) tel que des fichiers ou tout juste des chaînes de caractères:

fn reading(reader: R) …{

Let buf_reader = BufReader::new(reader);

… }

• Aussi Write qui permet d’écrire dans un u8

  fn writeSomething(writer: &mut W, toWrite: &str) -> … { writer.write_all(toWrite.as_bytes());

…

}

• Ici, writer est la variable dans laquelle on veut écrire et toWrite est le contenu a écrire

Défaut

• Default est un trait qui permet d’implémenter une valeur par défaut à un type :
• Pour obtenir les valeurs par défaut d’un type : nomType ::default()

Mémoire

• Deux types d’allocation mémoire en Rust: Stack(pile) et Heap(tas)

Pile

• Concernée avec les variables locales
• Les tailles des valeurs sont fixes et connues à la compilation
• Très rapide, Rust déplace simplement un pointeur dans la pile
• Accès rapide à des zones de mémoires couramment utilisées

Tas

• Stocker plus de variables à l'extérieure des appels de fonctions
• La valeur de taille est dynamique déterminé à l’exécution
• Plus lent que la pile
• Pas de garantie pour un accès rapide récurrents aux zones mémoires

Possession (Ownership)

• Chaque variable dans un code a une valeur qu’elle possède ainsi qu’une portée.
• Chaque valeur ne peut avoir qu’un seul propriétaire
• Quand la porté arrive à sa fin, la variable est désallouée et sa valeur détruite dans la mémoire.
• Une fois qu’une variable a été assignée par, la variable initial perd la variable, et la nouvelle devient la valeur.
• Toute tentative de l’accès ou de la modification de la valeur de de la variable initial causera une erreur
• Pour copier la valeur d’une variable dans une autre sans perdre la valeur, il faut d’utiliser la fonction clone:

Var2(var1.clone());

Une référence pointe vers une ressource qui appartient à une autre partie du code.

• Si un type implements le trait copie, une assignement de valeur par fera une copie impl [<derive(Copy)>

Struct nomStruct {}

• Les traits peuvent être utilisés pour exécuter du code lorsqu’une variable est détruite impl [<Drop] for nomStruct { fn drop (<&mut> self) {

    …
  

  }}

Pointeurs

• Voici plus types de pointeurs à Rust:
• < Box > est un pointeur qui montre une valeur dans le « Heap ». Les données sont stockés à l’extérieure des fonctions
• let var 1 = Box : :new
• implémente le trait Deref, ce qui signifie que vous pouvez appeler des méthodes de la structure directement:

Let varBoxStruct = Box : new ( valueStruct ) ; varBoxStruct::methodStruct();

• On peut aussi utiliser Box pour des types non définis dans le langue courante : Box:new(nomStruct <attr1: valAttr1, ATTR2: valAttr2>);
• Rc s’agit d’un type qui contient comme attribut un pointeur et un compteur de nombre des variables qui accèdent aux pointeurs let var2 = Rec::clone(&var1);
• Tout comme Box, les valeurs sont stockées à Heap

Emprunt

• Quand on assigne une valeur dans une autre qui supprime las valeur dans son initiale (principe d’ownership), on ne peut juste passer directement une variable en paramètre de fonction
• Au lieu de cela il faut passé une copie de la variable

fn func(val 1 &typel, val2: &ype2) -> … {

… } let var 1 = valeur1;

Let var2 = valeur1;

Func (« &var1  », « &var2»);

• Il existe quand même des contraintes sur les « emprunts » de valeur:
• On ne peut qu’emprunte une valeur qui se trouve dans la même porté
• Règle des Alias : On ne peut avoir qu’une référence exclusive en écrivant au même temps. Par example, si on déclare une référence comme valeur exclusif avant l’appel de fonction, on ne peut utilsé la valeur dans la fonction.

Cell/RefCell

• Cell permet de créer un pointeur qui obtient/set la variable qui contient:

Let cell = cell:: new(value);

cell.set(value)

dbg!(cell.get());

• Attention ! Cell ne peut-être utiliser qu’à partir d’une variable déclarée en « mutable »

mut let cell = cell:: new(value);

• CellRef marche pareil, mais emprunte ça valeur exclusif dans une autre variable, en lieu d’avoir les getters/setters

let cell = = refCell:: new(value); let mut cell_ref= cell.Borrow_mut(); cell_ref=value

• Attention, on ne peut utiliser en même temps plusieurs cellules.

Durée de vie

• Toute référence possède un temps de vie qui est plus courte que la portée de cette variable.
• Sert à retourne un pointeur.

fn func( var1: &’a typel « ) ->»&’a typel

• Généralement, on préfère passer nos copies dans la valeur, et précise ses temps de vie. Cela sert juste quand la modifier.
• On doit spécifier aussi aussi si on stock dans une expression une valeur.

Struct struct<’lifetime> { attribute 1: &’ lifetime type

}