Recherche…
Introduction
Syntaxe
- (A, B, C) // un triplet (un tuple à trois éléments), dont le premier élément a le type A, le deuxième type B et le troisième type C
- (A, B) // un deux tuple, dont les deux éléments ont respectivement les types A et B
- (A,) // un tuple (notez la fin
,
), qui ne contient qu'un seul élément de type A - () // le tuple vide, qui est à la fois un type et le seul élément de ce type
Types de tuple et valeurs de tuple
Les tuples de rouille, comme dans la plupart des autres langues, sont des listes de taille fixe dont les éléments peuvent tous être de types différents.
// 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; };
Correspondance des valeurs de tuple
Programmes de rouille utilisent modèle correspondant largement à déconstruire les valeurs, que ce soit en utilisant match
, if let
, ou déconstruisant let
des motifs. Les tuples peuvent être déconstruits comme vous vous en doutez avec 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"),
}
}
ou avec if let
fn foo(x: (&str, isize, bool)) {
if let (_, 42, _) = x {
println!("it's 42");
} else {
println!("it's something else");
}
}
vous pouvez également lier à l'intérieur du tuple en utilisant let
-deconstruction
fn foo(x: (&str, isize, bool)) {
let (_, n, _) = x;
println!("the number is {}", n);
}
Regarder à l'intérieur des tuples
Pour accéder aux éléments d'un tuple directement, vous pouvez utiliser le format .n
pour accéder au n
élément -ème
let x = ("hello", 42, true);
assert_eq!(x.0, "hello");
assert_eq!(x.1, 42);
assert_eq!(x.2, true);
Vous pouvez également sortir partiellement d'un tuple
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;
Les bases
Un tuple est simplement une concaténation de plusieurs valeurs:
- de types éventuellement différents
- dont le nombre et les types sont connus statiquement
Par exemple, (1, "Hello")
est un tuple à 2 éléments composé d'un i32
et d'un &str
, et son type est noté (i32, &'static str)
de manière similaire à sa valeur.
Pour accéder à un élément d'un tuple, on utilise simplement son index:
let tuple = (1, "Hello");
println!("First element: {}, second element: {}", tuple.0, tuple.1);
Comme le tuple est intégré, il est également possible d'utiliser une correspondance de motif sur les n-uplets:
match (1, "Hello") {
(i, _) if i < 0 => println!("Negative integer: {}", i),
(_, s) => println!("{} World", s),
}
Cas spéciaux
L'élément 0 tuple: ()
est également appelé unité , type d'unité ou type singleton et sert à indiquer l'absence de valeurs significatives. C'est le type de retour par défaut des fonctions (lorsque ->
n'est pas spécifié). Voir aussi: Quel type est le "type ()" dans Rust? .
Le tuple à 1 élément: (a,)
, avec la virgule finale, dénote un tuple à 1 élément. La forme sans virgule (a)
est interprétée comme une expression entre parenthèses et est évaluée à seulement a
.
Et pendant que nous y sommes, les virgules sont toujours acceptées: (1, "Hello",)
.
Limites
Le langage Rust ne supporte pas les variads , à part les tuples. Par conséquent, il n'est pas possible d'implémenter simplement un trait pour tous les tuples et, par conséquent, les traits standard ne sont implémentés que pour un nombre limité d'éléments (aujourd'hui, jusqu'à 12 inclus). Les tuples avec plus d'éléments sont supportés, mais n'implémentent pas les traits standard (bien que vous puissiez implémenter vos propres traits).
Nous espérons que cette restriction sera levée à l'avenir.
Déballage des tuples
// 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);