Annexe B : opérateurs et symboles
Cette annexe contient un glossaire d’éléments de syntaxe de Rust, comprenant notamment les opérateurs et les autres symboles qui s’utilisent tout seuls ou dans le cadre de chemins, de génériques, de traits liés, de macros, d’attributs, de commentaires, de tuples et des crochets.
Opérateurs
Le tableau B-1 liste les opérateurs de Rust en indiquant pour chacun un exemple de la manière d’utilisation en situation, une brève explication, et si cet opérateur peut être surchargé. Si un opérateur est surchargeable, le trait à utiliser pour la surcharge est indiqué.
Tableau B-1 : opérateurs
| Opérateur | Exemple | Explication | Surchargeable ? |
|---|---|---|---|
! | ident!(...), ident!{...}, ident![...] | Identificateur de macro | |
! | !expr | Négation binaire ou logique | Not |
!= | expr != expr | Comparaison de non-égalité | PartialEq |
% | expr % expr | Modulo arithmétique | Rem |
%= | var %= expr | Modulo arithmétique et affectation | 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 affectation | BitAndAssign |
&& | expr && expr | Raccourci pour l’opérateur logique ET | |
* | expr * expr | Multiplication arithmétique | Mul |
*= | var *= expr | Multiplication arithmétique et affectation | MulAssign |
* | *expr | Déréférencement | Deref |
* | *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 affectation | 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 affectation | SubAssign |
-> | fn(...) -> type, |…| -> type | Type de retour de fonction et de fermeture | |
. | expr.ident | Accès à un champ | |
. | expr.ident(expr, ...) | Appel de méthode | |
. | expr.0, expr.1 et ainsi de suite | Indexation de tuple | |
.. | .., expr.., ..expr, expr..expr | Littéral d’intervalle exclusif à droite | PartialOrd |
..= | ..=expr, expr..=expr | Littéral d’intervalle inclusif à droite | PartialOrd |
.. | ..expr | Syntaxe de mise à jour de littéraux de structure | |
.. | variant(x, ..), struct_type { x, .. } | Correspondance de motif “Et le reste” | |
... | expr...expr | (Obsolète, utiliser ..= à la place) Dans un motif : motif d’intervalle inclusif | |
/ | expr / expr | Division arithmétique | Div |
/= | var /= expr | Division arithmétique et affectation | DivAssign |
: | pat: type, ident: type | Contraintes | |
: | ident: expr | Initialisateur de champ de structure | |
: | 'a: loop {...} | Étiquette de boucle | |
; | expr; | Fin d’élément et d’instruction | |
; | [...; len] | Partie de la syntaxe de tableau de taille fixe | |
<< | expr << expr | Décalage à gauche | Shl |
<<= | var <<= expr | Décalage à gauche et affectation | ShlAssign |
< | expr < expr | Comparaison “inférieur à” | PartialOrd |
<= | expr <= expr | Comparaison “inférieur ou égal à” | PartialOrd |
= | var = expr, ident = type | Affectation ou équivalence | |
== | expr == expr | Comparaison d’égalité | PartialEq |
=> | pat => expr | Partie de la syntaxe d’une branche de match | |
> | 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 affectation | ShrAssign |
@ | ident @ pat | Correspondance de motif | |
^ | expr ^ expr | OU exclusif binaire | BitXor |
^= | var ^= expr | OU exclusif binaire et affectation | BitXorAssign |
| | pat | pat | Alternatives dans un motif | |
| | expr | expr | OU exclusif binaire | BitOr |
|= | var |= expr | OU exclusif binaire et affectation | BitOrAssign |
|| | expr || expr | Raccourci pour OU logique | |
? | expr? | Propagation d’erreur |
Symboles autres que les opérateurs
Les tableaux suivants listent tous les symboles qui ne fonctionnent pas comme des opérateurs ; autrement dit, ils ne se comportent pas comme un appel de fonction ou de méthode.
Le tableau B-2 liste les symboles qui s’utilisent tout seuls et qui sont valides dans divers contextes.
Tableau B-2 : éléments de syntaxe autonomes
| Symbole | Explication |
|---|---|
'ident | Durée de vie nommée ou étiquette de boucle |
Nombres suivis immédiatement par u8, i32, f64, usize et ainsi de suite | Littéral numérique d’un type déterminé |
"..." | Littéral de chaîne de caractères |
r"...", r#"..."#, r##"..."## et ainsi de suite | Littéral brut de chaîne de caractères ; caractères d’échappement non traités |
b"..." | Littéral de chaîne d’octets ; construit un tableau d’octets au lieu d’une chaîne de caractères |
br"...", br#"..."#, br##"..."## et ainsi de suite | Littéral brut de chaîne d’octets ; combinaison du littéral brut de chaîne et du littéral de chaîne d’octets |
'...' | Littéral de caractère |
b'...' | Littéral d’octet ASCII |
|…| expr | Fermeture |
! | Type “jamais”, toujours vide pour les fonctions divergentes |
_ | Motif “ignoré” ; également utilisé pour rendre lisibles les littéraux d’entiers |
Le tableau B-3 liste les symboles qui s’utilisent dans le contexte d’un chemin dans une hiérarchie de modules pour obtenir un élément.
Tableau B-3 : éléments de syntaxe utilisés pour les chemins
| Symbole | Explication |
|---|---|
ident::ident | Chemin d’espace de nommage |
::path | Chemin relatif à la crate racine (autrement dit, un chemin explicitement absolu) |
self::path | Chemin relatif au module courant (autrement dit, un chemin explicitement relatif) |
super::path | Chemin relatif au parent du module courant |
type::ident, <type as trait>::ident | Constantes, fonctions et types associés |
<type>::... | Élément associé pour un type qui ne peut pas être directement nommé (par exemple, <&T>::..., <[T]>::... et ainsi de suite) |
trait::method(...) | Éviter toute ambiguïté dans un appel de méthode en précisant le trait qui la définit |
type::method(...) | Éviter toute ambiguïté dans un appel de méthode en précisant le type pour lequel elle est définie |
<type as trait>::method(...) | Éviter toute ambiguïté dans un appel de méthode en précisant le trait et le type |
Le tableau B-4 liste les symboles qui apparaissent dans le cadre de l’utilisation de paramètres de type générique
Tableau B-4 : génériques
| Symbole | Explication |
|---|---|
path<...> | Précise les paramètres sur un type générique utilisé dans un type (par exemple, Vec<u8>) |
path::<...>, method::<...> | Précise les paramètres sur un type générique, une fonction ou une méthode dans une expression ; souvent appelé poisson-turbo (turbofish) (par exemple, "42".parse::<i32>())) |
fn ident<...> ... | Définition de fonction générique |
struct ident<...> ... | Définition de structure générique |
enum ident<...> ... | Définition d’énumération générique |
impl<...> ... | Définition d’implémentation générique |
for<...> type | Augmentation de 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 liste les symboles qui s’utilisent pour contraindre des paramètres de types génériques avec des traits liés.
Tableau Bound : 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 devant vivre au moins 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 inférieure à 'a) |
T: 'static | Type générique T ne contenant aucune référence empruntée autre que celles qui sont 'static |
'b: 'a | Durée de vie générique 'b devant vivre au moins aussi longtemps que la durée de vie 'a |
T: ?Sized | Autoriser un paramètre de type générique à être de type à taille dynamique |
'a + trait, trait + trait | Contrainte de type composé |
Le tableau B-4 liste les symboles qui s’utilisent dans le cadre 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 | Métavariable de macro |
$(...)... | Répétition de macro |
ident!(...), ident!{...}, ident![...] | Appel de macro |
Le tableau B-7 liste les symboles pour créer des commentaires.
Tableau B-7 : commentaires
| Symbole | Explication |
|---|---|
// | Ligne de commentaire |
//! | Ligne de commentaire de documentation sur l’élément contenant ce commentaire |
/// | Ligne de commentaire de documentation sur l’élément suivant ce commentaire |
/*...*/ | Bloc de commentaire |
/*!...*/ | Bloc de commentaire de documentation sur l’élément contenant ce commentaire |
/**...*/ | Bloc de commentaire de documentation sur l’élément suivant ce commentaire |
Le tableau B-8 liste les contextes dans lesquels les parenthèses sont utilisées.
Encart 9-3 : Ouverture d’un fichier
| Symbole | Explication |
|---|---|
() | Tuple vide (également appelé unité), littéral et type |
(expr) | Expression entre parenthèses |
(expr,) | Expression de tuple à élément unique |
(type,) | Type de tuple à élément unique |
(expr, ...) | Expression de tuple |
(type, ...) | Type tuple |
expr(expr, ...) | Expression d’appel de fonction ; également utilisé pour initialiser les variantes de struct et d’enum |
Le tableau B-9 liste les contextes dans lesquels les parenthèses sont utilisées.
Tableau B-9 : parenthèses
| Contexte | Explication |
|---|---|
{...} | Bloc d’expression |
Type {...} | Littéral de structure |
Le tableau B-10 liste les contextes dans lesquels les crochets sont utilisés.
Tableau B-10 : crochets
| Contexte | Explication |
|---|---|
[...] | Littéral de tableau |
[expr; len] | Littéral de tableau contenant len copies de expr |
[type; len] | Type de tableau contenant len instances de type |
expr[expr] | Collection indexée ; surchargeable via (Index, IndexMut) |
expr[..], expr[a..], expr[..b], expr[a..b] | Collection indexée se comportant comme une slice de collection, grâce à l’utilisation de Range, RangeFrom, RangeTo, ou de RangeFull comme “indice” |