Concepts de base de Rust

Fonction Principale

• La source d'information est google.github.io/comprehensive-rust/
• Syntaxe: fn main() {}

Variables

• Syntaxe: let mut nom_variable: type = valeur;
• mut est requis si la variable doit être modifiée.

Types et Littéraux

• Entiers signés : i8, i16, i32, i64, i128, isize avec des littéraux comme -10, 0, 1_000, 123_i64.
• Entiers non signés : u8, u16, u32, u64, u128, usize avec des littéraux comme 0, 123, 10_u16.
• Nombres à virgule flottante : f32, f64 avec des littéraux comme 3.14, -10.0e20, 2_f32.
• Valeurs scalaires Unicode : char avec des littéraux comme 'a', 'α', '∞'.
• Booléens : bool avec des littéraux true, false.
• Largeur des types :
  • iN, uN et fN ont une largeur de N bits.
  • isize et usize ont la largeur d'un pointeur.
  • char a une largeur de 32 bits.
  • bool a une largeur de 8 bits.
• Inférance de type : Le compilateur détermine le type d'une variable si non spécifié.
• let peut être remplacé par const pour définir une constante.

Fonctions

• Définition : fn nom_fonction (parameter1 : type ,…, parameterN : type ) -> typeRetour { contenu }
• Pas besoin de return ; la dernière valeur utilisée est renvoyée.
• Voir la section sur les blocs pour plus de détails.

Blocs

• Définition : {…}
• La valeur du bloc est la dernière valeur/variable du bloc:
  • {7} a une valeur de 7.
• Un bloc terminé par un point-virgule a une valeur de ().
• Une variable static peut être déclarée pour être utilisée dans tous les blocs.

Opérateurs Logiques

• if predicat { … }: Exécute si predicat est vrai.
• else if predicat { … }: Exécute si le predicat précédent est faux et predicat est vrai.
• else { … }: Exécute si tous les predicat précédents sont faux.
• if let nomVar: teste si une variable correspond à un pattern.

Correspondance de Motifs (Pattern Matching)

• Syntaxe:

    Match nom_variable {
        Value1 => block1,
        Value2 => block2,
        Value3 => block3,
        _ => block Default
    }
  

• Equivalent de switch.
• Des opérateurs/conditions peuvent être ajoutés aux valeurs.
  • Value1 | value2 && value3 => block4
  • Value if predicate sur value => block5
• Peut être utilisé avec des structures ou des énumérations pour tester leurs attributs.

Correspondance de structures (Struct Matching)

Match nom_struct {
    typeStruct{attribute1 : value1, attribute2 : value2,… attributeN : valueN} => block1,
    typeStruct{attribute1 : nomVar} => block2,
    typeStruct{attribute1,attribute2,.. } => block3
}

• Teste si les attributs d'une structure correspondent à des valeurs spécifiques.

Correspondance d'Énumérations (Enum Matching)

• Syntaxe: typeEnum::attribute(value) => block
• Un nom de variable peut être spécifié à la place de value pour tester et utiliser la valeur de l'attribut.

Boucles

• while predicat { }: Exécute la boucle tant que le predicat est vrai.
• for name/value_element in collection { }: Boucle à travers chaque élément d'une collection.
• Loop { }: Boucle infinie.
• continue: Passe directement à l'itération suivante dans une boucle.
• break: Quitte immédiatement une boucle.
• Il est possible de nommer une boucle pour l'extraire avec break.

Fonctions Constantes

• const devant la déclaration d'une fonction indique qu'elle ne peut utiliser que des variables constantes, est inline et son résultat est calculé à la compilation.

Macros

• Définition :nomMacro !( param1,param2,…,paramN ) ;
• Fonction pouvant prendre un nombre indéfini de paramètres.

Collections

• Type liste et tuple

Listes

• Syntaxe: Let mut nomVar : [ type ; tailleListe ] = [ value1,… value_tailleListe ]
• NomVar[ n ] = Change la valeur à la case n
• Syntaxe itération: élément in nomListe

Tuples

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

Références

• Informations de référence

Référence Partagée

• Lecture seule
• Définition let mut nomRef: &type_var_a_referer = &nomVariable ;
• Utiliser * nomRef pour récupérer la valeur stockée

Référence Exclusive

• Permet de modifier la valeur
• Définition: let nomRef = &mut var
• Une seule référence exclusive par variable est autorisée.
• Devient read-only si la variable est modifiée après sa déclaration.
• Ne peut être null ou pointer vers une valeur hors du bloc.

Slices

• Pointeur vers un ou plusieurs éléments d'une collection.
• Définition Let slide: &[type_collection] = &collection [i.. n];
• Pointe vers les éléments d'indice k appartenant à [i, n-1].
• Type &str est un slice de bytes encodés en UTF-8 (&[u8]).
• String est similaire à Vec avec T = u8.

Structures

• Informations générales sur les structures.

Définition de Structure (Struct)

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

Utilisation et Modification de Structure

• Accéder à un attribut: Struct_Name.attribute

let mut var_name : struct_name{ attribute_1 : value,… , attribute_n : value }

Méthodes de Structure

impl nomStruct {
    fn nomFunc(&self parameter1 : type ,…, parameterN : type ) ->typeRetour{

    }
}

• &self empêche la modification (lecture seule partagée) ; &mut self permet la modification (lecture/écriture exclusive).

Constructeurs de Structures

fn new ( parameter 1 : type1,… ) -> Self{
    Self {attribute1 : value,…, attributeN : valueN }
}

• Nécessite une valeur pour chaque attribut.
• Toujours finir par Self{…} pour retourner la structure.

TupleStruct

• Structure dont les attributs n'ont pas de noms.

struct struct_name (type1,…,typeN);
``` Utilisation et Modification:

- Accéder à un attribut: `struct_name.k` (k est un index).

### Traits
- Permettent d'ajouter des interfaces à des structures.
- Traits implémentation
```rust
trait nomTrait {
    fn abstractFunc(&self,…) -> typeReturn;
}

• La méthode est abstraite et doit être implémentée par une structure.

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

Héritage et Association de Types

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

Traits Supportés

#[derive(trait1, …, traitN)]
Struct nomStruct {}

Énumérations (Enums)

• Type avec des valeurs limitées définies à la création.

enum name {
    value1,
    …,
    valueN,
};

Utilisation

Enum_name ::value_k pour donner une valeur à une variable de ce type.

Alias

• Déclaration d'un nouveau nom de type.
• Syntaxe: type name_type_1 = name_type_2

Fonctions Génériques

• Implémente des fonctions avec des types génériques (patrons).

fn nomfunc (param1 :type1 ,…, paramk : T,…, paramN : typeN) -> T {}

• Les éléments de type T peuvent être de n'importe quel type.
• Un type peut être retourné tant que la variable retournée est de ce type.
• Utiliser <> après le nom de la fonction pour identifier un type inconnu.
• Implémentation d'un trait:

fn nomfunc (param1 :type1 ,…, paramk : T,…, paramN : typeN) -> T {}

Implémentation Générique

• Structures implémentant des types génériques.

struct Struct_name  {
    attribute1 : T ;
};

Traits Génériques Héritant de Traits Spécifiques

Impl nomType for Struct_name {

}

• Utiliser des attributs héritant d'un trait spécifique, implémenter les méthodes pour notre struct.

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 des types/struct implémentant le type du paramètre en entrée.

fn generic (attribut1: &impl typeA){

}

Impl Trait Compilation

• &impl permet à la compilation de créer une version pour chaque type implémentant typeA.

 fn generic (attribut1: &dyn typeA){

}

Dyn Trait Compilation

• &dyn ne crée pas de différentes versions, mais recherche dynamiquement le bon type dans une vtable.
• La variable passée en paramètre doit être un pointeur.

Documentation

• Documenter le code avec les annotations suivantes :

• /// commentaire

• //! Inner doc comment

• Le commentaire Doc inner documente un élément à l’intérieur d’un bloc, d’une structure ou d’une fonction.

• Toute bibliothèque publiée dans Rust est automatiquement documentée sur docs.rs (outil rustdoc)

Bibliothèque Standard

• Liens vers les traits STD
• Informations générales sur la STD

Option

• Utiliser std

let mut var1: Option<type> = var2;

• Stocker une valeur ou rien du tout.
• Utiliser pour les fonctions pouvant ne rien renvoyer (find(String s)).

Déballage de l'Option

• Utiliser unwrap ou expect pour récupérer la valeur dans l'option.

var2.unwrap();
var2.expect(« message ») ;

• unwrap panique si var2 est None.
• expect panique aussi, mais renvoie un message d'erreur personnalisé.

Result

• Permet de stocker le résultat d’une opération et d’indiquer si elle réussit ou non.

Result<TypeValeurRetourné, TypeErreur> = operation(…)

• Contient deux attributs : Ok, Err. Si l’opération réussit, la valeur se trouve dans Ok

Obtention de la Valeur de Resut

storedResult = Result<TypeValeurRetourné, TypeErreur> = operation(…)
match storedResult{
    Ok(mut storedResult) => {…}
    Err(err) => {…}
}

• err correspont au message d’erreur si l'opération échoue.

String

• Liste de caractères encodée en UTF-8.

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

String Functionality

• Ajouter un autre string à la fin : var.push_str(string)
• Ajouter un character : var.push(« c »)
• Obtenir la longueur de la chained : var.len
• Obtenir le nombre de caractères : var.count
• Obtenir le nombre d’éléments maximal de la chaîne : var.capacity

Vecteur

• Définition:

 let mut v1 = Vec::new();

• Fonctions push, len et capacity
• Garde que ceux qui répondent à la conditions : v1.retain( condition )
• Suppression des doubles v1.dedup();

HashMap

let mut hmap = HashMap::new();

• Dictiionaire associant une valeur à une clé

Inserter une nouvelle données

hmap.insert( Stringkey , Intvalue );

• Contenu de la clé renvoie true si elle existe.

hmap.containskey( key ) ;

• Nombre de clés hmap.len()

Récupération de la valeur associé à la clé

hmap.get( key )

Comparaisons

• Surcharger != ou ==en implémentant le trait partialeq

impl PartialEq for typename{
   fn eq(&self, other: &Self) -> bool {
        self.attribute == other.attribute
    }
   fn ne(&self, other: &Self) -> bool {
        self.attribute != other.attribute
}
}

Surchargement des opérateurs de comparaison

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

Operators

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 }
        }
}

Conversion

• Implémenter from () permet d’extraire une valeur d’un type vers un autre

let one = i16::from(true);
Implémenter from pour un type va implémenter  into pour un autre type.

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

Lecture et Écriture de Fichiers (Read and Write)

• Lecture les données d'un fichier au format bytes

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

Fonctions utiles à la lecture et l'écriture

• Lire des bytes et permet aux types qu'on lisent implémentent la fonctions

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

Default

• Trait représentant la valeur par défaut

Default trait exemple

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

• Pour les valeurs par défaut utiliser nomType ::default()

Mémoire

• Informations générales

Type d'allocation de la mémoire

• Le stack et le heap

Stack

• Varibales locales
• Allocation très rapide
• Limité
• Cache localité

Heap

• Allocation lente
• En dehors des appels de fonctions
• Allocation dynamique déterminée à l'exécution

Ownership

• Chaque valeur ne peut avoir qu'un propriétaire
• L'attributions par ""="" change leur propriété
• Les accès causent une erreur

Copier, cloner

• Pour faire une copie pour clonage : var2(var1.clone()) ;
• Pour faire une copie par value

#[derive(Copy)]
struct nomStruct {…}

Drop trait

• Déterminer le code à exécuter à la libération de la mémoire

impl Drop for nomStruct {
  fn drop(&mut self) {
}

Pointeurs

• Informations générales sur les pointeurs

Les pointeurs de rust

Box

• Direction d’allocation et structure de données

let var 1 = Box::new(value) ;

Trait

• Box implémente le trait Deref, ce qui signifie que si une box contient une instance d’une structure, on peut appeler les méthodes de cette structure directement avec :

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

On peut aussi utiliser Box pour des types non définis dans la STD ou le langage avec
des références dynamiques :
Box::new(nomStruct { attr1 : valAttr1, attr2 : valAttr2, … }),

Rc

• Pointeurs partagés avec compteur

let var1 = Rc::new(value);
let var2 = Rc::clone(&var1);

Borrowing

• Informations sur le borrowing

Assignations

• fn func(val1: &type1, val2: &type2) -> … {…}
• Limitations de la durée de vie lifeimeset les emprunts

Cell

• Permet de créer un pointeur avec un getter/setter.

let cell = Cell::new(value);
cell.set(value);
dbg!(cell.get());
Cell ne peut être utilisé mut let cell = Cell::new(value);

RefCell

• Utiliser la références exclusives.

let cell = RefCell::new(value);
let mut cell_ref = cell.borrow_mut();   
- cell_ref = value

• Attention on ne peut avoir qu’une celle référence dans le même bloc.

Lifetimes

• Toute dépendance nécessite une durée de vie
• Détermimer des durées des vies inférieures au scopé générale

Linter

fn func  &'a type1
De même les structures ont besoin d'une durée de vie ou liftime
struct struct<'lifetime> {
 Attribute 1: &'lifetime type,
}