Introduction à Rust

Notes Générales sur Rust

• L'évaluation aura lieu le 4 avril, sous forme de QCM, portant sur les notions jusqu'au 24, sauf le 18
• Une ressource complète pour Rust est disponible sur https://google.github.io/comprehensive-rust/

Fonction Principale

• La fonction principale en Rust est définie comme suit: fn main() { }

Variables

• Déclaration d'une variable mutable : Let mut nom_variable : type = valeur;
• Le mot-clé mut est nécessaire pour permettre la modification de la variable.

Types de Données et Littéraux

• Les types entiers signés incluent i8, i16, i32, i64, i128, et isize, avec des exemples de littéraux comme -10, 0, 1_000, et 123_i64.
• Les types entiers non signés incluent u8, u16, u32, u64, u128, et usize, avec des littéraux comme 0, 123, et 10_u16.
• Les nombres à virgule flottante sont f32 et f64, avec des littéraux comme 3.14, -10.0e20, et 2_f32.
• Les valeurs scalaires Unicode utilisent le type char, représentées par des littéraux comme 'a', 'α', et '∞'.
• Le type booléen est bool, avec les valeurs true et false.

Largeur des Types

• Les types iN, uN, et fN ont une largeur de N bits.
• isize et usize ont la largeur d'un pointeur.
• char est un type de 32 bits de large.
• bool est un type de 8 bits de large.

Inférence de Type

• Si le type d'une variable n'est pas spécifié, le compilateur détermine le type en fonction de la première opération ou utilisation de la variable.

Fonctions

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

Blocs

• Définition d'un bloc : {...}
• La valeur d'un bloc est la dernière valeur ou variable à la fin du bloc.
• Un bloc terminé par un point-virgule (;) a une valeur de ().
• Le mot-clé static permet de déclarer une variable utilisable dans tous les blocs.

Opérateurs Logiques

• If predicat { ... }: Exécute le bloc si le prédicat est vrai.
• Else if predicat { ... }: Exécute le bloc si le prédicat est vrai, après qu'un if précédent ait échoué.
• Else { ... }: Exécute le bloc si tous les if et else if précédents ont échoué.
• if let nomVar ...: Permet de tester si une variable suit un certain motif.
• Match nom_variable { Value1 => block1 Value2 => block2 Value3 => block3 _ => block Default }: Structure de contrôle équivalente à un switch.

Opérateurs et Conditions de Correspondance

• Les opérateurs et conditions peuvent être ajoutés aux valeurs dans une instruction match.
• Value1 | value2 && value3 => block4
• Value if predicate sur value => block5

Correspondance sur Structures et Enums

• Il est possible d'utiliser les correspondances sur des structures ou des enums et de tester les valeurs de certains de leurs attributs.
• Match nom_struct { typeStruct{attribute1 : value1, attribute2 : value2, … attributeN : valueN} => block1

Enums

• Écriture pour les enums: typeEnum::attribute(value) => block
• Un nom de variable peut être spécifié à la place de value pour tester si l'attribut a une valeur et l'utiliser dans le bloc suivant.

Boucles

• Boucle while:
  • while predicat { } exécute le code tant que le prédicat est vrai.
  • Il existe une variante de l'instruction if let while let.
• Boucle for:
  • For name/value_element in collection { } itère sur chaque élément d'une collection.
• Boucle Loop:
  • Loop { } répète le code indéfiniment.

Contrôle de Boucle

• Continue: Passe directement à l'itération suivante dans une boucle.
• Break: Quitte instantanément une boucle.

Macros

• Définition d'une macro: nomMacro !( param1,param2,...,paramN ) ;

Collections

• URL: https://google.github.io/comprehensive-rust/tuples-and-arrays.html

Listes

• Déclaration d'une liste: Let mut nomVar : [ type ; tailleListe ] = [ value1,… value_tailleListe ]
• Accès à un élément de liste: nomVar[ n ] = …
• Itération à travers une liste: en écrivant élément in nomListe

Tuples

• Déclaration d'un tuple: Let nomTuple : ( typeValeur1 , …, typeValeurN ) = ( valeur1 ,…, valeur n )
• Association des variables aux éléments d'un tuple: let (var1, …, varN) = tuple;
• Ignorer des valeurs dans un tuple: let (var1, _, var3, …, varN) = tuple.
• Ignorer des valeurs au début ou à la fin d'un tuple: let (.., varN-1,VarN) = tuple

Références

• URL: https://google.github.io/comprehensive-rust/references.html
• Référence partagée (lecture seule):
  • let mut nomRef: &type_var_a_referer = &nomVariable ;
  • * nomRef permet de récupérer la valeur de la variable stockée dans la référence.
• Référence exclusive:
  • let nomRef = &mut var
  • Permet de modifier la valeur de la variable.
• Une référence ne peut pas être null, ni pointer sur une valeur n'appartenant pas au même block.

Slices

• Déclaration d'un slice: Let slide: &[type_collection] = &collection [i.. n];
• &str est un slice de bytes encodés en UTF-8 (&[u8])
• String est similaire à un Vec avec T = u8

Structs

• URL: https://google.github.io/comprehensive-rust/user-defined-types.html
• Déclaration :

  • struct Struct_name {
        attribute1 : type1 ;
        attribute2 : type2 ;
    } ;
    

• Utilisation/Modification :
  • Récupérer un attribut : Struct_Name.attribute
  • Créer un 'objet' d'une struct : let mut var_name : struct_name{ attribute_1 : value, … , attribute_n : value }

Implémentation de Méthodes pour une Struct

• On peut implémenter une struct pour y ajouter des méthodes :

  
   impl nomStruct {
  
  fn nomFunc(&self parameter1 : type ,…, parameterN : type ) ->typeRetour {}
  
  //&self ne permet pas de modifier la struct (shared read only). Si on veut modifier son contenu (valeurs des attributs) on utilise &mut self (exclusive read/write)
   }
  

• Pour accéder aux attributs de la struct on utilise le mot clé self : self.attribute

• On peut également définir l’équivalent d’un constructeur :

  ```
  fn new ( parameter 1 : type1,…) -> Self{
       Self {attribute1 : value, ..., attributeN : valueN }
  //On doit donner une valeur à chaque attribut
  }
  ```
  

• Type TupleStruct : struct struct_name (type1,…,typeN); avec l'accès aux attributs via struct_name.k, où k est l'index de l'attribut.

Traits

• URL: https://google.github.io/comprehensive-rust/methods-and-traits/traits.html

• Permet d’ajouter des interfaces implémentables par des structs :

  ```
  trait nomTrait {
       fn abstractFunc(&self,…) -> typeReturn;
  }
  
  impl nomTrait for nomStruct{
       fn abstractFunc(&self,…) -> typeReturn {…}
  }      
  ```
  

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

• Association de types à un trait:

   ```
   trait nomTrait {
        type typeReturn ;
        fn abstractFunc(&self,…) -> typeReturn;
    }
    impl nomTrait for nomStruct{
        type typeReturn = type ;
        fn abstractFunc(&self,…) -> typeReturn {…}
    }
    ```
  

Macros

• Certains traits supportés peuvent être associés à une struct via #[derive(trait1, …, traitN)] Struct nomStruct {}

Enums

• Définition d'un Enum :

enum name {
               value1,
               …,
               valueN,
       } ;

• Utilisation: Enum_name ::value_k donne la valeur numéro k d'une énumération.

Aliases

• Déclaration: type name_type_1 = name_type_2

Fonctions Génériques

• URL: https://google.github.io/comprehensive-rust/generics/generic-functions.html
• Définition: fn nomfunc (param1 :type1 ,…, paramk : T,…, paramN : typeN) -> T {}
• Pour les types inconnus, le mettre entre <> appelant la fonction.

Implémentation Générique

• URL: https://google.github.io/comprehensive-rust/generics/generic-data.html et https://google.github.io/comprehensive-rust/generics/generic-traits.html
• Déclaration:

 struct Struct_name  {
            attribute1 : T ;
            …
        } ;
`
- On peut les implémenter pour des traits génériques héritant de traits spécifiques :

Impl nomType for Struct_name { … }

- Traits génériques:

trait nomTrait { fn abstractFunc(…,T,…) -> typeReturn; }

impl nomTrait for nomStruct{
    fn abstractFunc(…,abstractFunc:Type,…) -> typeReturn {…}
}

### Fonctions Génériques et Dynamiques
- Permettent d’utiliser les comportements (méthodes) des types/struct implémentant le type d’un paramètre en entrée.
- Générique:

fn generic (attribut1: &impl typeA){ //... }

- Dynamique:

fn generic (attribut1: &dyn typeA){ //... }

- L'attribut `&dyn` ne crée pas différentes versions de la méthode, mais recherche dynamiquement le bon type dans une vtable contenant l’ensemble des types implémentant `typeA`.

### Documentation et Commentaires
- Types de commentaires :
    -   `/// commentaire`
    -   `//! Inner doc comment`
    -   `/* Inner doc comment */`
- URL:  https://google.github.io/comprehensive-rust/std-traits.html et https://google.github.io/comprehensive-rust/std-types.html

### Bibliothèque Standard (Standard Library)
- Rust est documentée automatiquement sur docs.rs (outil rustdoc)

### Option
-   `let mut var1: Option<type\> = var2;`
- Option permet de stocker dans `var1` la valeur de `var2` (si elle est du bon type) ou rien du tout.
- Extraction avec `unwrap` et `expect`:
    - `var2.unwrap() ;`
    - `var2.expect(« message ») ;`

### Result
- `Result<TypeValeurRetourné, TypeErreur> = operation(…)` permet de stocker le résultat d’une opération et indiquer si elle réussit ou non.
- Contient Ok et Err :
    ```
    storedResult = Result<TypeValeurRetourné, TypeErreur>= operation(…);

         match storedResult{
                Ok(mut storedResult) => {…}
                Err(err) => {…}
            }
    ```
- err correspond au message d’erreur retourné par l’opération si celle-ci à échouée.

### String
- Liste de caractère encodé en UTF-8
- Déclaration et ajout de string  :

let mut var = String::new(); var.push_str(string)

- Ajout d'un caractere: `var.push(« c »)`
- Taille de chaîne: `var.len`
- Nombre de caractères: `var.count`
- Le nombre d'éléments max de la chaîne est: `var.capacity`

### Vec
- Création d'un vecteur: `let mut v1 = Vec::new();`
- Opérations :
    -   `v1.retain( condition )` Garde uniquement les éléments respectant la condition.
    -   `v1.dedup() ;` Supprime les éléments en doubles.

### HashMap
- Création d'un HashMap : `let mut hmap = HashMap::new();`
- Insertion et vérification :
    -   `hmap.insert( Stringkey , Intvalue );`
    -   `hmap.containskey( key ) ;`
-  `hmap.len()` retourne Le nombre de clés dans le dictionnaire
-  `hmap.get( key )` Récupère la valeur associée à la clé key

### Comparaisons
- impl PartialEq for typename{

 fn eq(&self, other: &Self) -> bool {
    self.attribute == other.attribute

} fn ne(&self, other: &Self) -> bool { self.attribute != other.attribute }

- Pour les ordres (<, >) :

impl PartialOrd for typeName { fn partial_cmp(&self, other: &Self) -> Option<Ordering&gt { match self.attribute1.partial_cmp(&other.attribute1) { Some(Ordering::Equal) => self.attribute2.partial_cmp(&other. attribute2), Attribute1_ord => attribute1_ord, }

### Operators
- Pour implémenter les opérateurs avec `std::ops`:

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()` extrait une valeur d’un type vers une valeur d’un autre type.
- `Into` permet de cast lune valeur d’un type vers une valeur d’un autre type.
- `As` permet d’utiliser une variable comme une variable d’un autre type
- Read et BufRead permettent d’implémenter des fonctions permettant de lire des données sous format `u8` (bytes) tel que des fichiers ou juste des chaînes de caractères :

### Read and Write
-  Implémentation

fn reading(reader: R) …{ let buf_reader = BufReader::new(reader); … }

### Default
- `Default` est un trait permettant d’implémenter une valeur par défaut à un type :

impl Default for type1 { fn default() -> type1{ valAttr1, valAttr2,… valAttrN } }

### Memoire
- URL: https://google.github.io/comprehensive-rust/memory-management.html
- Types d’allocation mémoire en Rust :
    -   Allocation dans le `Stack` (pile) :
        -   Variables locales.
        -  Tailles des valeurs fixes et connues à la compilation.
    -  Allocation dans le `Heap` (tas) :
        -   Stockage de valeurs en dehors des appels de fonctions.
        -   Valeur de taille dynamique déterminée à l’exécution.
     ### Ownership
     -  Chaque variable dans un code possède une valeur dont elle est propriétaire, et un scope.
     -  Quand le scope arrive à sa fin (fin du block, fin de fonction), alors la variable est désallouée et sa valeur est supprimée de la mémoire.
### Pointeurs
- URL: https://google.github.io/comprehensive-rust/smart-pointers.html
- Différents types de pointeurs incluent `Box` (allocation sur le heap), `Rc` (reference counted shared pointer).

### Borrowing
URL: https://google.github.io/comprehensive-rust/borrowing.html
### Cell / RefCell
- Utilisé pour créer un pointeur avec un getter/setter sur la variable :
    -  Il existe cependant des contraintes sur les ‘emprunts’ de valeurs .
    - `Cell` ne peut être utilisé dans une variable déclarée comme mutable
### Lifetimes
- URL : https://google.github.io/comprehensive-rust/lifetimes.html
- La durée de vie de toute référence doit être inférieure à la durée de vie (scope) de la variable.