Rust
튜플

소개

통사론

• (A, B, C) // 첫 번째 요소가 A 타입, 두 번째 유형이 B, 세 번째 유형이 C 인 세 튜플 (세 요소가있는 튜플)
• (A, B) // 두 개의 원소가 각각 타입 A와 B 인 2- 튜플
• (A는)은 하나의 튜플 (트레일 유의 // , 타입 A의 단일 요소를 유지),
• () // 비어있는 튜플, 타입과 그 타입의 유일한 엘리먼트이다

튜플 유형 및 튜플 값

대부분의 다른 언어에서와 마찬가지로, 녹 튜플은 요소가 모두 다른 유형 일 수있는 고정 크기 목록입니다.

// 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 ()"유형은 무엇입니까? .

1 요소 터플 : (a,) 는 뒤에 오는 쉼표와 함께 1 요소 터플을 나타냅니다. 콤마없는 형태 (a) 괄호 안에 발현 해석, 단지 평가된다 . a

그리고 우리가 그것에있는 동안, 뒤에 오는 쉼표는 항상 받아 들여진다 : (1, "Hello",) .

제한 사항

Rust 언어는 오늘날 튜플과 같은 가변성을 지원하지 않습니다. 따라서 모든 튜플에 대한 특성을 구현하는 것이 불가능하므로 표준 특성은 제한된 수의 요소 (오늘날에는 최대 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);