Rust
Le tuple

introduzione

Sintassi

• (A, B, C) // a tre tupla (una tupla con tre elementi), il cui primo elemento ha tipo A, secondo tipo B e terzo tipo C
• (A, B) // una doppia tupla, i cui due elementi hanno rispettivamente il tipo A e B.
• (A,) // una tupla singola (nota il finale , ), che contiene solo un singolo elemento di tipo A
• () // la tupla vuota, che è sia un tipo, sia l'unico elemento di quel tipo

Tipi di tupla e valori di tupla

Le tuple di ruggine, come nella maggior parte delle altre lingue, sono elenchi di dimensioni fisse i cui elementi possono essere tutti di tipi diversi.

// Tuples in Rust are comma-separated values or types enclosed in parentheses.
let _ = ("hello", 42, true);
// The type of a tuple value is a type tuple with the same number of elements.
// Each element in the type tuple is the type of the corresponding value element.
let _: (i32, bool) = (42, true);
// Tuples can have any number of elements, including one ..
let _: (bool,) = (true,);
// .. or even zero!
let _: () = ();
// this last type has only one possible value, the empty tuple ()
// this is also the type (and value) of the return value of functions
// that do not return a value ..
let _: () = println!("hello");
// .. or of expressions with no value.
let mut a = 0;
let _: () = if true { a += 1; };

Valori di tupla corrispondenti

I programmi ruggine usano estensivamente la corrispondenza dei modelli per decostruire i valori, sia usando la match , if let , o decostruendo let modelli. Le tuple possono essere decostruite come ci si potrebbe aspettare dall'uso della match

fn foo(x: (&str, isize, bool)) {
    match x {
        (_, 42, _) => println!("it's 42"),
        (_, _, false) => println!("it's not true"),
        _ => println!("it's something else"),
    }
}

o con if let

fn foo(x: (&str, isize, bool)) {
    if let (_, 42, _) = x {
        println!("it's 42");
    } else {
        println!("it's something else");
    }
}

puoi anche legare all'interno della tupla usando let -deconstruction

fn foo(x: (&str, isize, bool)) {
    let (_, n, _) = x;
    println!("the number is {}", n);
}

Guardare dentro le tuple

Per accedere direttamente agli elementi di una tupla, puoi usare il formato .n per accedere all'elemento n -esimo

let x = ("hello", 42, true);
assert_eq!(x.0, "hello");
assert_eq!(x.1, 42);
assert_eq!(x.2, true);

Puoi anche spostare parzialmente da una tupla

let x = (String::from("hello"), 42);
let (s, _) = x;
let (_, n) = x;
println!("{}, {}", s, n);
// the following would fail however, since x.0 has already been moved
// let foo = x.0;

Nozioni di base

Una tupla è semplicemente una concatenazione di più valori:

• di tipi possibilmente diversi
• il cui numero e tipi sono noti staticamente

Ad esempio, (1, "Hello") è una tupla di 2 elementi composta da un i32 e un &str , e il suo tipo è denotato come (i32, &'static str) in modo simile al suo valore.

Per accedere a un elemento di una tupla, si usa semplicemente il suo indice:

let tuple =  (1, "Hello");
println!("First element: {}, second element: {}", tuple.0, tuple.1);

Poiché la tupla è integrata, è anche possibile utilizzare la corrispondenza del modello sulle tuple:

match (1, "Hello") {
    (i, _) if i < 0 => println!("Negative integer: {}", i),
    (_, s) => println!("{} World", s),
}

Casi speciali

La tupla dell'elemento 0: () viene anche chiamata unità , tipo di unità o tipo singleton e viene utilizzata per indicare l'assenza di valori significativi. È il tipo di funzione di ritorno predefinito (quando -> non è specificato). Vedi anche: Che tipo è "type ()" in Rust? .

La tupla di 1 elemento: (a,) , con la virgola finale, indica una tupla di 1 elemento. Il modulo senza una virgola (a) è interpretato come un'espressione racchiusa tra parentesi e valuta solo a .

E mentre ci siamo, le virgole finali sono sempre accettate: (1, "Hello",) .

limitazioni

Il linguaggio Rust oggi non supporta variadics , oltre alle tuple. Pertanto, non è possibile implementare semplicemente un tratto per tutte le tuple e di conseguenza i tratti standard vengono implementati solo per le tuple fino a un numero limitato di elementi (oggi, fino a 12 inclusi). Le tuple con più elementi sono supportate, ma non implementano i tratti standard (anche se è possibile implementare le proprie caratteristiche per loro).

Si spera che questa restrizione venga revocata in futuro.

Disimballare le tuple

// It's possible to unpack tuples to assign their inner values to variables
let tup = (0, 1, 2);
// Unpack the tuple into variables a, b, and c
let (a, b, c) = tup;

assert_eq!(a, 0);
assert_eq!(b, 1);

// This works for nested data structures and other complex data types
let complex = ((1, 2), 3, Some(0));

let (a, b, c) = complex;
let (aa, ab) = a;

assert_eq!(aa, 1);
assert_eq!(ab, 2);