Rust
Krotki

Wprowadzenie

Składnia

• (A, B, C) // trójka (krotka z trzema elementami), której pierwszy element ma typ A, drugi typ B i trzeci typ C
• (A, B) // podwójna krotka, której dwa elementy mają odpowiednio typ A i B.
• (A,) // jeden krotek (zwróć uwagę na końcowe , ), który zawiera tylko jeden element typu A.
• () // pusta krotka, która jest zarówno typem, jak i jedynym elementem tego typu

Typy i wartości krotek

Krotki rdzy, jak w większości innych języków, są listami o stałym rozmiarze, których elementy mogą być różnych typów.

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

Dopasowywanie krotek

Programy rdzy intensywnie używają dopasowywania wzorców do dekonstrukcji wartości, bez względu na to, czy używają match , if let , czy dekonstruują wzorce let . Krotki można zdekonstruować tak, jak można się spodziewać po 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"),
    }
}

lub z if let

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

możesz także powiązać wewnątrz krotki za pomocą let -deconstruction

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

Zaglądanie do krotek

Aby uzyskać bezpośredni dostęp do elementów krotki, możesz użyć formatu .n aby uzyskać dostęp do n elementu

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

Możesz także częściowo wyjść z krotki

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;

Podstawy

Krotka to po prostu połączenie wielu wartości:

• możliwie różnych typów
• których liczba i typy są znane statycznie

Na przykład (1, "Hello") to krotka składająca się z 2 elementów składająca się z i32 oraz a &str , a jej typ jest oznaczony jako (i32, &'static str) w podobny sposób, jak jego wartość.

Aby uzyskać dostęp do elementu krotki, wystarczy użyć jego indeksu:

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

Ponieważ krotka jest wbudowana, możliwe jest również użycie dopasowania wzorca dla krotek:

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

Przypadki specjalne

Krotka z 0 elementami: () jest również nazywana jednostką , typem jednostki lub typem singletonu i jest używana do oznaczania braku znaczących wartości. Jest to domyślny typ zwracanych funkcji (gdy nie podano -> ). Zobacz także: Jakim typem jest „type ()” w Rust? .

Krotka 1-elementowa: (a,) , z przecinkiem końcowym, oznacza krotkę 1-elementową. Postać nie przecinek (a) interpretowane jest jako wyraz w nawiasie i ocenia się po prostu . a

I kiedy już nad tym pracujemy, przecinki końcowe są zawsze akceptowane: (1, "Hello",) .

Ograniczenia

Dzisiejszy język Rust nie obsługuje variadics , oprócz krotek. Dlatego nie można po prostu zaimplementować cechy dla wszystkich krotek, w wyniku czego standardowe cechy są implementowane tylko dla krotek o ograniczonej liczbie elementów (obecnie łącznie do 12). Obsługiwane są krotki z większą liczbą elementów, ale nie implementuj standardowych cech (chociaż możesz zaimplementować dla nich własne cechy).

Mam nadzieję, że to ograniczenie zostanie zniesione w przyszłości.

Rozpakowywanie krotek

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