Appendice B: Operatori e Simboli
Questa appendice contiene un glossario della sintassi di Rust, compresi gli operatori e altri simboli che appaiono da soli o nel contesto di percorsi, generics, traits, macro, attributi, commenti, tuple e parentesi.
Operatori
La Tabella B-1 contiene gli operatori in Rust, un esempio di come l’operatore appare nel contesto, una breve spiegazione e se l’operatore in questione è sovrascrivibile. Se un operatore è sovrascrivibile, viene elencato il relativo trait da utilizzare per sovrascriverlo.
Tabella B-1: Operatori
| Operatore | Esempio | Spiegazione | Sovrascrivibile |
|---|---|---|---|
! | ident!(...), ident!{...}, ident![...] | Espansione delle macro | |
! | !expr | Complemento logico o bit per bit | Not |
!= | expr != expr | Differente | PartialEq |
% | expr % expr | Resto aritmetico | Rem |
%= | var %= expr | Resto aritmetico con assegnazione | RemAssign |
& | &expr, &mut expr | Prestito (Borrow) | |
& | &type, &mut type, &'a type, &'a mut type | Type Puntatore a Prestito | |
& | expr & expr | AND Bit per Bit | BitAnd |
&= | var &= expr | AND Bit per Bit con assegnazione | BitAndAssign |
&& | expr && expr | AND logico | |
* | expr * expr | Moltiplicazione aritmetica | Mul |
*= | var *= expr | Moltiplicazione aritmetica con assegnazione | MulAssign |
* | *expr | De-referenziazione | Deref |
* | *const type, *mut type | Puntatore grezzo (Raw pointer) | |
+ | trait + trait, 'a + trait | Vincolo per type composto | |
+ | expr + expr | Addizione aritmentica | Add |
+= | var += expr | Addizione aritmentica con assegnazione | AddAssign |
, | expr, expr | Separatore di argomenti ed elementi | |
- | - expr | Negazione aritmetica | Neg |
- | expr - expr | Sottrazione aritmetica | Sub |
-= | var -= expr | Sottrazione aritmetica con assegnazione | SubAssign |
-> | fn(...) -> type, |…| -> type | Type di ritorno per funzioni e chiusure | |
. | expr.ident | Accesso a campo | |
. | expr.ident(expr, ...) | Chiamata a metodo | |
. | expr.0, expr.1, etc. | Indicizzazione tupla | |
.. | .., expr.., ..expr, expr..expr | Range esclusivo | PartialOrd |
..= | ..=expr, expr..=expr | Range inclusivo | PartialOrd |
.. | ..expr | Aggiornamento struct | |
.. | variant(x, ..), struct_type { x, .. } | “E il resto” con assrgnazione tramite pattern | |
... | expr...expr | (Non più utilizzabile, usa ..=) In un pattern: range inclusivo | |
/ | expr / expr | Divisione aritmetica | Div |
/= | var /= expr | Divisione aritmetica con assegnazione | DivAssign |
: | pat: type, ident: type | Vincoli | |
: | ident: expr | Inizializzazione campo di struct | |
: | 'a: loop {...} | Etichetta loop | |
; | expr; | Terminatore di dichiarazioni ed elementi | |
; | [...; len] | Parte della sintassi per vettori a grandezza fissa | |
<< | expr << expr | Shift a sinistra | Shl |
<<= | var <<= expr | Shift a sinistra con assegnazione | ShlAssign |
< | expr < expr | Minore | PartialOrd |
<= | expr <= expr | Minore o uguale | PartialOrd |
= | var = expr, ident = type | Assegnazione/equivalenza | |
== | expr == expr | Comparazione di egualità | PartialEq |
=> | pat => expr | Parte della sintassi del ramo di match | |
> | expr > expr | Maggiore | PartialOrd |
>= | expr >= expr | Maggiore o uguale | PartialOrd |
>> | expr >> expr | Shift a destra | Shr |
>>= | var >>= expr | Shift a destra con assegnazione | ShrAssign |
@ | ident @ pat | Vincolo di Pattern | |
^ | expr ^ expr | OR esclusivo Bit per Bit | BitXor |
^= | var ^= expr | OR esclusivo Bit per Bit con assegnazione | BitXorAssign |
| | pat | pat | Pattern alternativi | |
| | expr | expr | OR Bit per Bit | BitOr |
|= | var |= expr | OR Bit per Bit con assegnazione | BitOrAssign |
|| | expr || expr | OR logico | |
? | expr? | Propagazione errore |
Simboli
L’elenco seguente contiene tutti i simboli che non funzionano come operatori, cioè non si comportano come una funzione o una chiamata di metodo.
La Tabella B-2 mostra i simboli che appaiono da soli e sono validi in diverse posizioni.
Tabella B-2: Sintassi stand alone
| Simbolo | Spiegazione |
|---|---|
'ident | Lifetime nominale o etichetta loop |
Numeri immediatamente seguiti da u8, i32, f64, usize, ecc. | Letterale numerico di un type specifico |
"..." | Letterale stringa |
r"...", r#"..."#, r##"..."##, etc. | Letterale stringa grezzo, senza elaborazione dei caratteri di escape |
b"..." | Letterale byte di stringa; costituisce un vettore di byte anzichè una stringa |
br"...", br#"..."#, br##"..."##, etc. | Letterale byte di stringa grezzo |
'...' | Letterale carattere |
b'...' | Letterale byte ASCII |
|…| expr | Chiusure |
! | Type vuoto per funzioni divergenti |
_ | Pattern “Ignorato” nel ramo di match; usato anche per rendere i letterali più leggibili |
La Tabella B-3 mostra i simboli che venmgonb usati nel contesto dei percorosi di un elemento nella gerarchia dei moduli.
Tabella B-3: Sintassi relativa ai Percorsi
| Simbolo | Spiegazione |
|---|---|
ident::ident | Nomenclatura percorso |
::path | Percorso relativo al preludio esterno, dove sono tutti gli altri crate (es., un percorso assoluto esplicito che include il nome del crate) |
self::path | Percorso relativo al modulo corrente (es., un percorso relativo esplicito). |
super::path | Percorso relativo al genitore del modulo corrente |
type::ident, <type as trait>::ident | Costanti, funzioni o type associati |
<type>::... | Elemento associato per un type generico (es, <&T>::..., <[T]>::..., etc.) |
trait::method(...) | Disambiguare una chiamata a un metodi specificando il trait che lo definisce |
type::method(...) | Disambiguare una chiamata a un metodo specificando il type in cui per cui è definito |
<type as trait>::method(...) | Disambiguare una chiamata a un metodo specificando il trait e il type |
La Tabella B-4 mostra i simboli che appaiono quando si usano type generici come parametri.
Table B-4: Generici
| Simbolo | Spiegazione |
|---|---|
percorso<...> | Specifica parametri a type generici in u n type (es., Vec<u8>) |
percorso::<...>, metodo::<...> | Specifica parametri a type, funzioni, metodi genirici in un’espressione; spesso chiamato operatore turbofish (e.g., "42".parse::<i32>()) |
fn ident<...> ... | Definizione di funzione generica |
struct ident<...> ... | Definizione di struct generica |
enum ident<...> ... | Definizione di enum generica |
impl<...> ... | Definizione di implementazione generica |
for<...> type | Vincolo di lifetime prioritario |
type<ident=type> | Un type generico dove uno o più type associati hanno assegnazioni specifiche (es., Iteratore<Elemento=T>) |
La Tabella B-5 mostra i simboli che appaiono nel contesto della dichiarazioni di type generici come paramentri e dei corrispettivi vincoli di trait.
Table B-5: Vincoli di Trait
| Simbolo | Spiegazione |
|---|---|
T: U | Paramentro generico T vincolato a type che implementano U |
T: 'a | Type generico type T con longevità 'a (implica cxhe non possa conteenre reference con lifetime inferiore ad 'a) |
T: 'static | Type generico T contenente solo reference con longevità infinita |
'b: 'a | Lifetime generica 'b deve essere maggiore di lifetime 'a |
T: ?Sized | Consente a parametri con type generico di essere type a dimensione dimamica |
'a + trait, trait + trait | Definizione di vincolo multiplo |
La Tabella B-6 mostra i simboli utilizzati nell’ambito della invocazione o definizione di macro e degli attributi di un dato elemento.
Table B-6: Macro e Attributi
| Simbolo | Spiegazione |
|---|---|
#[meta] | Attributo esterno |
#![meta] | Attributo interno |
$ident | Sostituzione macro |
$ident:kind | Metavariabile macro |
$(...)... | Ripetizione macro |
ident!(...), ident!{...}, ident![...] | Invocazione macro |
La Tabella B-7 mostra i simboli che creano commenti.
Tabella B-7: Commenti
| Simbolo | Spiegazione |
|---|---|
// | Commento in linea |
//! | Linea interna commento documentazione |
/// | Linea esterna commento documentazione |
/*...*/ | Blocco di commento, commento multilinea |
/*!...*/ | Blocco interno commento documentazione |
/**...*/ | Blocco esterno commento documentazione |
La Tablella B-8 mostra i contesti in cui sono usate le parentesi tonde.
Table B-8: Parentesi Tonde
| Simbolo | Spiegazione |
|---|---|
() | Tupla vuota (unit), sia letterale che type |
(expr) | Espressione tra parentesi |
(expr,) | Espressione di tupla con singolo elemento |
(type,) | Tupla con singolo type |
(expr, ...) | Espressione tupla |
(type, ...) | Type tupla |
expr(expr, ...) | Espressione di chiamata di funzione; usato anche per inizializzare le varianti struct tupla e enum tupla |
La Tabella B-9 mostra i contesti di utilizzo delle parentesi graffe.
Tabella B-9: Parentesi Graffe
| Contesto | Spiegazione |
|---|---|
{...} | Blocco di codice |
Type {...} | Struct letterali |
La Tabella B-10 mostra i contesti in cui vengono utilizzate le parentesi quadre.
Tabella B-10: Parentesi Quadre
| Contesto | Spiegazione |
|---|---|
[...] | Vettore letterale |
[x; n] | Vettore letterale contenente n copie di x |
[type; n] | Vettore tipizzato contenente n istanze di type |
collezione[i] | Indicizzazione di una collezione. Sovraccaricabile (Index, IndexMut) |
expr[..], expr[a..], expr[..b], expr[a..b] | Indicizzazione in collezioni per estrazione slice, usando Range, RangeFrom, RangeTo, o RangeFull come “indici” |