Rust
Tuples

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);