Rust
tuples

Invoering

Syntaxis

• (A, B, C) // een drie-tupel (een tupel met drie elementen), waarvan het eerste element type A, tweede type B en derde type C heeft
• (A, B) // een twee-tuple, waarvan de twee elementen respectievelijk type A en B hebben
• (A,) // een one-tuple (let op de achterstand , ), die slechts één element van type A bevat
• () // de lege tuple, die zowel een type is als het enige element van dat type

Tuple-typen en tuple-waarden

Roestige tupels zijn, zoals in de meeste andere talen, lijsten met een vaste grootte waarvan de elementen allemaal van verschillende types kunnen zijn.

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

Overeenkomende tuple-waarden

Roestprogramma's gebruiken uitgebreid patroonafstemming om waarden te deconstrueren, of het nu gaat om het match , if let of let patronen. Tuples kunnen worden gedeconstrueerd zoals je zou verwachten bij het gebruik van 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"),
    }
}

of met if let

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

je kunt ook in de tuple binden met let -deconstruction

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

In tupels kijken

Om rechtstreeks toegang te krijgen tot elementen van een tuple, kunt u de indeling .n om toegang te krijgen tot het n element

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

Je kunt ook gedeeltelijk uit een tupel bewegen

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;

Basics

Een tuple is gewoon een aaneenschakeling van meerdere waarden:

• van mogelijk verschillende typen
• waarvan het aantal en de typen statisch bekend zijn

(1, "Hello") is bijvoorbeeld een tuple van 2 elementen, bestaande uit een i32 en een &str , en het type wordt op dezelfde manier aangeduid als (i32, &'static str) als zijn waarde.

Om toegang te krijgen tot een element van een tuple, gebruikt u gewoon de index:

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

Omdat de tuple ingebouwd is, is het ook mogelijk om patroonovereenkomst op tuples te gebruiken:

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

Speciale gevallen

Het element 0 tuple: () wordt ook het type eenheid , eenheid of type singleton genoemd en wordt gebruikt om de afwezigheid van betekenisvolle waarden aan te duiden. Het is het standaard type retourfunctie (wanneer -> niet is opgegeven). Zie ook: Welk type is het "type ()" in Rust? .

De tuple van 1 element: (a,) , met de volgende komma, geeft een tuple van 1 element aan. Het formulier zonder een komma (a) wordt geïnterpreteerd als een uitdrukking tussen haakjes en resulteert in slechts a .

En terwijl we toch bezig zijn, worden volgkomma's altijd geaccepteerd: (1, "Hello",) .

beperkingen

De Rust-taal ondersteunt tegenwoordig geen variadica , behalve tupels. Daarom is het niet mogelijk om eenvoudig een eigenschap voor alle tupels te implementeren en als gevolg hiervan worden de standaardkenmerken alleen geïmplementeerd voor tupels tot een beperkt aantal elementen (vandaag, maximaal 12 inbegrepen). Tuples met meer elementen worden ondersteund, maar implementeren niet de standaardkenmerken (hoewel u uw eigen kenmerken hiervoor kunt implementeren).

Deze beperking wordt hopelijk in de toekomst opgeheven.

Tuples uitpakken

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