Rust
タプル

前書き

構文

• （A、B、C）// 3タプル（3要素のタプル）、その第1要素はタイプA、第2タイプB、第3タイプC
• （A、B）// 2つのタプル、その2つの要素がそれぞれタイプAとBを持つ
• （A、）// A型の単一の要素だけを保持する1タプル（末尾,注意してください）
• （）//型とその型の唯一の要素の両方である空のタプル

タプルの型とタプルの値

他の多くの言語と同様に、錆タプルは固定長のリストであり、その要素はすべて異なるタイプである可能性があります。

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

一致するタプル値

さびプログラムが使用しているかどうか、値を分解するために広くパターンマッチングを使用してmatch 、 if let 、又は解体letパターン。タプルは、 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"),
    }
}

if let

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

let -deconstructionを使ってタプルの中にバインドすることもできます

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

タプルを見る

タプルの要素に直接アクセスするには、 .n形式を使用してn番目の要素にアクセスします

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

部分的にタプルから移動することもできます

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;

基本

タプルは単純に複数の値を連結したものです。

• おそらく異なる種類の
• その数とタイプは静的に知られている

たとえば、 (1, "Hello")はi32と&strで構成される2要素タプルであり、その型はその値と同様に(i32, &'static str)として表されます。

タプルの要素にアクセスするには、単純にそのインデックスを使用します。

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

タプルは組み込みであるため、タプルでパターンマッチングを使用することもできます。

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

特殊なケース

0要素タプル：（ ()は、 ユニット 、 ユニットタイプ 、またはシングルトンタイプとも呼ばれ、意味のある値が存在しないことを示すために使用されます。これは関数のデフォルトの戻り値の型です（ ->が指定されていない場合）。 参照： どのようなタイプの "type（）"はRustですか？ 。

1要素タプル： (a,)は、末尾のカンマで、1要素タプルを表します。カンマなしの書式(a)は、かっこで囲まれた式として解釈され、 aと評価されます。

そして、私たちがそれにいる間、後続するカンマが常に受け入れられます： (1, "Hello",) 。

制限事項

錆言語は、今日はタプルのほか、variadicsをサポートしていません。したがって、単純にすべてのタプルの特性を実装することはできず、その結果、標準的な特性は、限られた数の要素（今日では最大12個まで）までのタプルに対してのみ実装されます。より多くの要素を持つタプルはサポートされていますが、標準的な特性を実装していません（独自の特性を実装できます）。

この制限は将来的には解消されることでしょう。

タプルのアンパック

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