परिचय
टपल एक हल्का-फुल्का तरीका है, जिससे किसी भी तरह के डेटा के एक तय समूह को एक साथ रखा जा सकता है। टपल का कोई खास नाम नहीं होता। किसी डेटा स्ट्रक्चर को नाम दे दिया जाए, तो वह struct बन जाता है। टपल के फील्ड्स के नाम नहीं होते; उन तक डीस्ट्रक्चरिंग के ज़रिए या उनके स्थान के ज़रिए पहुँचा जाता है।
सिंटैक्स
बनाना
टपल हमेशा टपल एक्सप्रेशन से ही बनाए जाते हैं:
// pointless but legal
let unit = ();
// single element
let single_element = ("note the comma",);
// two element
let two_element = (123, "elements can be of differing types");
टपल में किसी भी संख्या में एलिमेंट्स हो सकते हैं।
डीस्ट्रक्चरिंग से पहुँचना
टपल के एलिमेंट्स तक डीस्ट्रक्चरिंग से पहुँचा जा सकता है। इसका मतलब बस इतना है कि टपल के हर एलिमेंट को एक वेरिएबल का नाम दिया जाता है, और ऐसा करने पर वह टपल खर्च हो जाता है।
let (elem1, _elem2) = two_element;
assert_eq!(elem1, 123);
स्थान से पहुँचना
टपल के एलिमेंट्स तक संख्यात्मक स्थान वाले इंडेक्स से भी पहुँचा जा सकता है। इंडेक्सिंग, हमेशा की तरह, 0 से शुरू होती है।
let notation = single_element.0;
assert_eq!(notation, "note the comma");
टपल स्ट्रक्ट
आपसे टपल स्ट्रक्ट के साथ भी काम करने को कहा जाएगा। सामान्य स्ट्रक्ट की तरह इनके भी नाम होते हैं; लेकिन सामान्य स्ट्रक्ट से अलग, इनके फील्ड्स बेनाम होते हैं। इनका सिंटैक्स सामान्य टपल सिंटैक्स से बहुत मिलता-जुलता है। इनमें डीस्ट्रक्चरिंग और स्थान से पहुँचना, दोनों का इस्तेमाल किया जा सकता है।
struct TupleStruct(u8, i32);
let my_tuple_struct = TupleStruct(123, -321);
let neg = my_tuple_struct.1;
let TupleStruct(byte, _) = my_tuple_struct;
assert_eq!(neg, -321);
assert_eq!(byte, 123);
फील्ड्स की विज़िबिलिटी
बेनाम टपल के सारे फील्ड्स हमेशा पब्लिक होते हैं। लेकिन टपल स्ट्रक्ट के फील्ड्स की विज़िबिलिटी अलग-अलग होती है, जो डिफॉल्ट रूप से प्राइवेट रहती है, ठीक वैसे ही जैसे सामान्य स्ट्रक्ट के फील्ड्स की। आप pub मॉडिफायर से फील्ड्स को पब्लिक बना सकते हैं, ठीक वैसे ही जैसे सामान्य स्ट्रक्ट में।
// fails due to private fields
mod tuple { pub struct TupleStruct(u8, i32); }
fn main() { let _my_tuple_struct = tuple::TupleStruct(123, -321); }
// succeeds: fields are public
mod tuple { pub struct TupleStruct(pub u8, pub i32); }
fn main() { let _my_tuple_struct = tuple::TupleStruct(123, -321); }
निर्देश
आप एक ऐसे गेम पर काम कर रहे हैं जो कम बिजली खपत वाले एम्बेडेड सिस्टम के लिए बनाया जा रहा है। आपको कई सुविधाजनक फंक्शन लिखने हैं, जिनका उपयोग गेम के बाकी हिस्से करेंगे।
1. किसी भाग का भागफल और शेषफल निकालिए
भाग देने पर जो आउटपुट मिलता है, उसे भागफल कहते हैं।
fn divmod(dividend: i16, divisor: i16) -> (i16, i16)
उदाहरण:
assert_eq!(divmod(10, 3), (3, 1));
2. एक इटरेटर से सम स्थानों वाले एलिमेंट चुनिए
आपके बॉस का वादा है कि यह स्क्रीन-बफर ऑप्टिमाइज़ेशन को संभव बनाने में मदद करेगा।
इटरेटर ऐसी चीज़ें हैं जिनके पास Iterator ट्रेट में परिभाषित मेथड होते हैं। वह डॉक्युमेंटेशन काफी विस्तृत है, क्योंकि इनमें बहुत सारे मेथड होते हैं; यहाँ सबसे काम की बातें दी गई हैं:
- एक इटरेटर किसी भी लंबाई वाली आइटम की स्ट्रीम होता है
- इनमें एक
enumerate मेथड होता है, जो हर वैल्यू के लिए एक टपल (i, val) लौटाता है
- इनमें एक
filter मेथड होता है, जो क्लोज़र की मदद से तय करता है कि इटरेटर का कोई एलिमेंट देना है या नहीं
- इनमें एक
map मेथड होता है, जो क्लोज़र की मदद से इटरेटर के एलिमेंट बदलता है
चूँकि आपका फंक्शन किसी भी तरह के इटरेटर पर चल सकता है, इसलिए यह impl का उपयोग करके बताता है कि यह किसी साधारण आइटम के बजाय एक ट्रेट इंस्टेंस है। इसी तरह, <Item=T> सिंटैक्स का मतलब बस इतना है कि इससे कोई फर्क नहीं पड़ता कि इटरेटर किस तरह का आइटम बनाता है; आपका फंक्शन किसी भी इटरेटर के सम एलिमेंट बना सकता है।
fn evens<T>(iter: impl Iterator<Item=T>) -> impl Iterator<Item=T>
उदाहरण:
let mut even_ints = evens(0_u8..);
assert_eq!(even_ints.next(), Some(0));
assert_eq!(even_ints.next(), Some(2));
assert_eq!(even_ints.next(), Some(4));
assert_eq!(even_ints.next(), Some(6));
let mut evens_from_odds = evens(1_i16..);
assert_eq!(evens_from_odds.next(), Some(1));
assert_eq!(evens_from_odds.next(), Some(3));
assert_eq!(evens_from_odds.next(), Some(5));
assert_eq!(evens_from_odds.next(), Some(7));
3. मूल बिंदु से किसी स्थान की मैनहट्टन दूरी निकालिए
मैपिंग की सुविधा के लिए आपके पास Position नाम का एक टपल स्ट्रक्चर है:
struct Position(i16, i16);
आपको Position पर एक manhattan मेथड बनाना है, जो उस स्थान की मूल बिंदु (Position(0, 0)) से मैनहट्टन दूरी लौटाता है।
impl Position {
fn manhattan(&self) -> i16
}
उदाहरण:
assert_eq!(Position(3, 4).manhattan(), 7);
सीखने का अभ्यास
