🚧 B - les opérateurs et les symboles - Le langage de programmation Rust

🚧 Attention, peinture fraîche !

Cette page a été traduite par une seule personne et n'a pas été relue et vérifiée par quelqu'un d'autre ! Les informations peuvent par exemple être erronées, être formulées maladroitement, ou contenir d'autres types de fautes.

Vous pouvez contribuer à l'amélioration de cette page sur sa Pull Request.

Annexe B : les opérateurs et les symboles

Cette annexe contient un glossaire de syntaxes Rust, comprenant les opérateurs et les autres symboles qui s'utilisent tout seuls ou alors dans le cadre de chemins, de génériques, de traits liés, de macros, d'attributs, de commentaires, de tuples, de crochets ou d'accolades.

Opérateurs

Le tableau B-1 contient une liste d'opérateurs en Rust, un exemple de comment l'opérateur devrait être utilisé dans ce contexte, une petite explication, et si cet opérateur est surchargeable. Si un opérateur est surchargeable, le trait concerné à utiliser pour la surcharge est indiqué.

Tableau B-1 : les opérateurs

Opérateur	Exemple	Explication	Surchargeable ?
`!`	`ident!(...)`, `ident!{...}`, `ident![...]`	Identificateur de macro
`!`	`!expr`	Négation binaire ou logique	`Not`
`!=`	`var != expr`	Comparaison de non-égalité	`PartialEq`
`%`	`expr % expr`	Reste arithmétique	`Rem`
`%=`	`var %= expr`	Reste arithmétique et assignation	`RemAssign`
`&`	`&expr`, `&mut expr`	Emprunt
`&`	`&type`, `&mut type`, `&'a type`, `&'a mut type`	Type de pointeur emprunté
`&`	`expr & expr`	ET binaire	`BitAnd`
`&=`	`var &= expr`	ET binaire et assignation	`BitAndAssign`
`&&`	`expr && expr`	ET logique
`*`	`expr * expr`	Multiplication arithmétique	`Mul`
`*=`	`var *= expr`	Multiplication arithmétique et assignation	`MulAssign`
`*`	`*expr`	Déréférencement
`*`	`const type`, `mut type`	Pointeur brut
`+`	`trait + trait`, `'a + trait`	Contrainte de type composé
`+`	`expr + expr`	Addition arithmétique	`Add`
`+=`	`var += expr`	Addition arithmétique et assignation	`AddAssign`
`,`	`expr, expr`	Séparateur d'arguments et d'éléments
`-`	`- expr`	Négation arithmétique	`Neg`
`-`	`expr - expr`	Soustraction arithmétique	`Sub`
`-=`	`var -= expr`	Soustraction arithmétique et assignation	`SubAssign`
`->`	`fn(...) -> type`, `\|...\| -> type`	Type de retour de fonction et de fermeture
`.`	`expr.ident`	Accès à un membre
`..`	`..`, `expr..`, `..expr`, `expr..expr`	Littéral d'intervalle d'exclusion
`..=`	`..=expr`, `expr..=expr`	Littéral d'intervalle d'inclusion
`..`	`..expr`	Syntaxe de mise à jour de litéraux de structure
`..`	`variant(x, ..)`, `struct_type { x, .. }`	Motif “ainsi que la suite”
`...`	`expr...expr`	Dans un motif : motif d'intervalle inclusif
`/`	`expr / expr`	Division arithmétique	`Div`
`/=`	`var /= expr`	Division arithmétique et assignation	`DivAssign`
`:`	`pat: type`, `ident: type`	Contrainte
`:`	`ident: expr`	Initialisateur de champ de structure
`:`	`'a: loop {...}`	Une identification de boucle
`;`	`expr;`	Fin d'élément et d'instruction
`;`	`[...; len]`	Syntaxe désignant une partie d'un tableau à taille finie
`<<`	`expr << expr`	Décalage à gauche	`Shl`
`<<=`	`var <<= expr`	Décalage à gauche et assignation	`ShlAssign`
`<`	`expr < expr`	Comparaison "inférieur à"	`PartialOrd`
`<=`	`expr <= expr`	Comparaison "inférieur ou égal à"	`PartialOrd`
`=`	`var = expr`, `ident = type`	Assignation ou équivalence
`==`	`expr == expr`	Comparaison d'égalité	`PartialEq`
`=>`	`pat => expr`	Syntaxe d'une partie d'une branche correspondante
`>`	`expr > expr`	Comparaison "supérieur à"	`PartialOrd`
`>=`	`expr >= expr`	Comparaison "supérieur ou égal à"	`PartialOrd`
`>>`	`expr >> expr`	Décalage à droite	`Shr`
`>>=`	`var >>= expr`	Décalage à droite et assignation	`ShrAssign`
`@`	`ident @ pat`	Création d'un identificateur à partir du motif
`^`	`expr ^ expr`	OU exclusif binaire	`BitXor`
`^=`	`var ^= expr`	OU exclusif binaire et assignation	`BitXorAssign`
`\|`	`pat \| pat`	Alternatives à un motif
`\|`	`expr \| expr`	OU binaire	`BitOr`
`\|=`	`var \|= expr`	OU binaire et assignation	`BitOrAssign`
`\|\|`	`expr \|\| expr`	OU logique
`?`	`expr?`	Propagation d'erreur

Les symboles non-opérateurs

La liste suivante contient tout ce qui n'est pas une lettre et qui ne fonctionne pas comme un opérateur ; autrement dit tout ce qui ne se comporte pas comme un appel de fonction ou de méthode.

Le tableau B-2 montre des symboles qui s'utilisent tout seuls et qui sont valables dans plusieurs situations.

Tableau B-2 : syntaxes autonomes

Symbole	Explication
`'ident`	Nom d'une durée de vie ou nom boucle
`...u8`, `...i32`, `...f64`, `...usize`, etc.	Nombre littéral d'un type spécifique
`"..."`	Chaîne de caractère littérale
`r"..."`, `r#"..."#`, `r##"..."##`, etc.	Chaîne de caractères brute littérale, les caractères d'échappement ne sont pas traités
`b"..."`	Chaîne d'octet littéral ; construit un `[u8]` au lieu d'une chaîne de caractères
`br"..."`, `br#"..."#`, `br##"..."##`, etc.	Chaîne d'octets brute littérale, combinaison de la chaîne d'octets brute et de la chaîne d'octets littérale
`'...'`	Caractère littéral
`b'...'`	Octet ASCII littéral
`\|...\| expr`	Une fermeture
`!`	Le type “jamais", toujours vide pour les fonctions divergentes
`_`	Le motif “ignoré" ; aussi utilisé pour rendre lisibles les nombres entiers littéraux

Le tableau B-3 montre des symboles qui s'utilisent dans le contexte d'un chemin dans une structure de modules pour obtenir un élément.

Tableau B-3 : syntaxes utilisés pour les chemins

Symbole	Explication
`ident::ident`	Chemin d'un espace de nom
`::path`	Chemin relatif à la crate racine (c'est à dire un chemin explicitement absolu)
`self::path`	Chemin relatif au module courant (c'est à dire un chemin explicitement relatif)
`super::path`	Chemin relatif au parent du module courant
`type::ident`, `<type as trait>::ident`	Des constantes, fonctions et types associées
`<type>::...`	Un élément associé pour un type qui ne peut pas être directement nommé (par exemple, `<&T>::...`, `<[T]>::...`, etc)
`trait::method(...)`	Clarifier l'appel d'une méthode en nommant le trait qui le définit
`type::method(...)`	Clarifier l'appel d'une fonction en nommant le type pour laquelle elle est définie
`<type as trait>::method(...)`	Clarifier l'appel d'une méthode en nommant le trait et le type

Le tableau B-4 montre des symboles qui apparaissent dans le contexte d'utilisation de paramètres de type génériques.

Tableau B-4 : génériques

Symbole	Explication
`path<...>`	Précise des paramètres sur un type générique utilisé dans un type (par exemple, `Vec<u8>`)
`path::<...>`, `method::<...>`	Précise des paramètres sur un type générique, une fonction, ou une méthode dans une expression ; parfois appelé turbofish (par exemple, `"42".parse::<i32>()`)
`fn ident<...> ...`	Définit une fonction générique
`struct ident<...> ...`	Définit une structure générique
`enum ident<...> ...`	Définit une énumération générique
`impl<...> ...`	Définit une implémentation générique
`for<...> type`	Augmente la durée de vie
`type<ident=type>`	Un type générique sur lequel un ou plusieurs types associés ont des affectations spécifiques (par exemple, `Iterator<Item=T>`)

Le tableau B-5 montre des symboles qui s'utilisent pour contraindre des paramètres de type génériques avec des traits liés.

Tableau B-5 : contraintes de trait lié

Symbole	Explication
`T: U`	Paramètre générique `T` contraint aux types qui implémentent `U`
`T: 'a`	Type générique `T` doit vivre aussi longtemps que la durée de vie `'a` (ce qui signifie que le type ne peut pas contenir temporairement de références avec une durée de vie plus petite que `'a`)
`T : 'static`	Type générique `T` qui ne contient pas d'autres références empruntées autres que des `'static`
`'b: 'a`	La durée de vie générique `'b` doit vivre aussi longtemps que `'a`
`T: ?Sized`	Permet aux paramètres de type génériques d'être de type à taille dynamique
`'a + trait`, `trait + trait`	Contrainte de type composé

Le tableau B-6 montre des symboles qui s'utilisent lors de l'appel ou de la définition de macros et pour spécifier des attributs sur un élément.

Tableau B-6 : macros et attributs

Symbole	Explication
`#[meta]`	Attribut externe
`#![meta]`	Attribut interne
`$ident`	Substitution de macro
`$ident:kind`	Capture de macro
`$(…)…`	Répétition de macro
`ident!(...)`, `ident!{...}`, `ident![...]`	Appel d'une macro

Le tableau B-7 montre des symboles pour créer des commentaires.

Tableau B-7 : commentaires

Symbole	Explication
`//`	Ligne commentée
`//!`	Commentaire de documentation sur l'élément contenant actuel
`///`	Commentaire de documentation sur l'élément suivant ce commentaire
`/.../`	Bloc de commentaire
`/!.../`	Bloc de commentaire de documentation sur l'élément contenant actuel
`/*.../`	Bloc de commentaire de documentation sur l'élément suivant ce commentaire

Le tableau B-8 montre des symboles utilisés avec les tuples.

Tableau B-8 : les tuples

Symbole	Explication
`()`	Un tuple vide (aussi appelé unitaire), à la fois un type et un litéral
`(expr)`	Une expression entre parenthèses
`(expr,)`	Un tuple d'un seul élement qui est une expression
`(type,)`	Un tuple d'un seul élement qui est un type
`(expr, ...)`	Une expression dans un tuple
`(type, ...)`	Un type dans un tuple
`expr(expr, ...)`	Une expression d'appel à une fonction ; aussi utilisé pour initialiser une structure tuple ou une variante d'énumération tuple
`expr.0`, `expr.1`, etc.	Utilisation d'indices sur un tuple

Le tableau B-9 montre les contextes d'utilisation des accolades.

Tableau B-9 : accolades

Symbole	Explication
`{...}`	Bloc d'expression
`Type {...}`	Un littéral de `struct`

Le tableau B-10 montre les contextes d'utilisation des crochets.

Tableau B-10 : crochets

Symbole	Explication
`[...]`	Un littéral de tableau
`[expr; len]`	Un littéral de tableau qui contient `len` copies de `expr`
`[type; len]`	Un type de tableau qui contient `len` instances de `type`
`expr[expr]`	Une collection indexée. C'est surchargeable (via `Index` et `IndexMut`)
`expr[..]`, `expr[a..]`, `expr[..b]`, `expr[a..b]`	Une collection indexée qui se comporte comme une slice de collection, grâce à l'utilisation de `Range`, `RangeFrom`, `RangeTo`, ou de `RangeFull` comme “indice”