Rust
tuples

परिचय

वाक्य - विन्यास

• (ए, बी, सी) // एक तीन-टपल (तीन तत्वों के साथ एक टपल), जिसका पहला तत्व टाइप ए, दूसरा प्रकार बी और तीसरा प्रकार सी है।
• (ए, बी) // एक टू-टपल, जिनके दो तत्वों में क्रमशः ए और बी टाइप होते हैं
• (ए,) // एक टपल (अनुगामी ध्यान दें , ) है, जो केवल ग्रुप ए के एक भी तत्व रखती है
• () // खाली टपल, जो दोनों एक प्रकार है, और उस प्रकार का एकमात्र तत्व है

टपल प्रकार और टुपल मान

अधिकांश अन्य भाषाओं की तरह, रस्ट टुपल्स, निश्चित आकार की सूचियाँ हैं जिनके तत्व सभी विभिन्न प्रकार के हो सकते हैं।

// 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 का उपयोग कर रहे 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);
}

टुपल्स के अंदर देखना

सीधे एक tuple के तत्वों तक पहुंचने के लिए, आप n -th तत्व तक पहुंचने के लिए प्रारूप .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 और a &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 तत्व टपल: () को इकाई , यूनिट प्रकार या सिंगलटन प्रकार भी कहा जाता है और इसका उपयोग सार्थक मूल्यों की अनुपस्थिति को दर्शाने के लिए किया जाता है। यह फ़ंक्शन का डिफ़ॉल्ट रिटर्न प्रकार है (जब -> निर्दिष्ट नहीं है)। यह भी देखें: जंग में "प्रकार ()" क्या है? ।

1 तत्व टपल: (a,) , अनुगामी अल्पविराम के साथ, 1 तत्व टपल को दर्शाता है। अल्पविराम (a) बिना फॉर्म को कोष्ठकों में संलग्न अभिव्यक्ति के रूप में व्याख्या की जाती है, और केवल a लिए मूल्यांकन करता a ।

और जब हम उस पर होते हैं, अनुगामी अल्पविराम हमेशा स्वीकार किए जाते हैं: (1, "Hello",) ।

सीमाएं

रस्ट भाषा आज टुपल्स के अलावा, वैरेडिक्स का समर्थन नहीं करती है। इसलिए, सभी टुपल्स के लिए केवल एक विशेषता को लागू करना संभव नहीं है और परिणामस्वरूप मानक लक्षण केवल सीमित संख्या में तत्वों (आज, 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);