Rust
Tuples

Einführung

Syntax

• (A, B, C) // ein Doppeltupel (ein Tupel mit drei Elementen), dessen erstes Element vom Typ A, vom zweiten Typ B und vom dritten Typ C ist
• (A, B) // ein Zwei-Tupel, dessen zwei Elemente vom Typ A bzw. B sind
• (A,) // ein Ein-Tupel (beachten Sie das nachgestellte , ), das nur ein einzelnes Element vom Typ A enthält
• () // das leere Tupel, das sowohl ein Typ als auch das einzige Element dieses Typs ist

Tupel-Typen und Tupel-Werte

Rust-Tupel sind, wie in den meisten anderen Sprachen, Listen mit fester Größe, deren Elemente unterschiedliche Typen haben können.

// 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; };

Übereinstimmende Tupelwerte

Rust-Programme verwenden den Pattern-Matching weitgehend, um Werte zu dekonstruieren, egal ob match , if let oder let Muster dekonstruiert werden. Tupel können dekonstruiert werden, wie Sie es vielleicht mit einem match erwarten würden

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

oder mit if let

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

Sie können auch mit let -deconstruction im Tupel binden

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

Einblicke in Tupel

Um auf Elemente eines Tupels direkt zuzugreifen, können Sie mit dem Format .n auf das n te Element zugreifen

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

Sie können sich auch teilweise aus einem Tupel herausbewegen

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;

Grundlagen

Ein Tupel ist einfach eine Verkettung mehrerer Werte:

• möglicherweise verschiedener Typen
• deren Anzahl und Typen statisch bekannt sind

Zum Beispiel ist (1, "Hello") ein 2-Elemente-Tupel, das aus i32 und a &str , und sein Typ wird auf ähnliche Weise als (i32, &'static str) als Wert bezeichnet.

Um auf ein Element eines Tupels zuzugreifen, verwendet man einfach seinen Index:

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

Da das Tupel integriert ist, ist es auch möglich, Musterabgleich für Tupel zu verwenden:

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

Sonderfälle

Das 0-Element-Tupel: () wird auch als Einheit , Einheitentyp oder Singleton-Typ bezeichnet und bezeichnet das Fehlen sinnvoller Werte. Dies ist der Standardrückgabetyp von Funktionen (wenn -> nicht angegeben ist). Siehe auch: Welcher Typ ist der "Typ ()" in Rust? .

Das 1-Element-Tupel: (a,) mit dem nachgestellten Komma bezeichnet ein 1-Element-Tupel. Das Formular ohne Komma (a) wird als in Klammern eingeschlossener Ausdruck interpretiert und nur als a ausgewertet.

Und wenn wir gerade dabei sind, werden nachfolgende Kommas immer akzeptiert: (1, "Hello",) .

Einschränkungen

Die Sprache Rust unterstützt heutzutage keine Variadics , abgesehen von Tupeln. Daher ist es nicht möglich, ein Merkmal einfach für alle Tupel zu implementieren. Daher werden die Standardmerkmale nur für Tupel bis zu einer begrenzten Anzahl von Elementen implementiert (heute sind bis zu 12 enthalten). Tupel mit mehr Elementen werden unterstützt, implementieren jedoch nicht die Standardmerkmale (Sie können jedoch auch eigene Merkmale implementieren).

Diese Einschränkung wird in Zukunft hoffentlich aufgehoben.

Tupel auspacken

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