रसोई कैलकुलेटर

टपल एलिमेंट का एक सीमित और क्रमबद्ध समूह होता है, जिसे बदला नहीं जा सकता। टपल में हर जगह का टाइप तय होना ज़रूरी है। यानी कंपाइलर को पता रहता है कि किस जगह पर कौन-सा टाइप है। टपल में हर जगह का टाइप अलग हो सकता है, लेकिन टाइप कंपाइल के समय पता होना चाहिए।

टपल बनाना

टपल की वैल्यू के टाइप कंपाइल करते समय पता चलते हैं या नहीं, इसके आधार पर टपल बनाने के अलग-अलग तरीके हैं। अगर वैल्यू कंपाइल के समय पता हों, तो टपल लिटरल सिंटैक्स से टपल बनाया जा सकता है। वरना टाइप साफ-साफ घोषित करना पड़ता है। यह भी ज़रूरी है कि वैल्यू के टाइप टपल में बताए गए टाइप से मेल खाएँ, और वैल्यू की संख्या भी बताए गए टाइप की संख्या के बराबर हो। टपल लिटरल सिंटैक्स से बनाने का एक उदाहरण देखिए:

tuple = {1, "foo", 'c'} # Tuple(Int32, String, Char)

Tuple क्लास की मदद से भी टपल बनाया जा सकता है।

tuple = Tuple(Int32, String, Char).new(1, "foo", 'c')

आप चाहें तो जिस वेरिएबल में टपल रखा है, उसका टाइप भी साफ-साफ लिख सकते हैं।

tuple : Tuple(Int32, String, Char) = {1, "foo", 'c'}

टपल का टाइप साफ-साफ लिखना काम आता है, क्योंकि इससे आप किसी जगह के लिए यूनियन टाइप तय कर सकते हैं। यानी एक जगह पर एक से अधिक टाइप की वैल्यू रखी जा सकती हैं।

tuple : Tuple(Int32 | String, String, Char) = {1, "foo", 'c'}

रूपांतरण

ऐरे से टपल बनाना

Tuple क्लास के from मेथड की मदद से आप ऐरे से टपल बना सकते हैं। इसके लिए टपल का टाइप बताना ज़रूरी है।

array = [1, "foo", 'c']
tuple = Tuple(Int32, String, Char).from(array)

ऐरे में रूपांतरण

to_a मेथड से आप टपल को ऐरे में बदल सकते हैं। नतीजे वाले ऐरे के एलिमेंट का टाइप, टपल की हर फील्ड के टाइप का यूनियन होता है।

tuple = {1, "foo", 'c'}
array = tuple.to_a
array # => [1, "foo", 'c']

एलिमेंट तक पहुँचना

ऐरे की तरह टपल भी शून्य से इंडेक्स होते हैं, यानी पहला एलिमेंट इंडेक्स 0 पर होता है। लेकिन ऐरे से अलग, टपल में हर एलिमेंट का टाइप तय होता है और कंपाइल के समय पता रहता है। इसलिए टपल में इंडेक्स करते समय एलिमेंट का टाइप उसकी जगह के हिसाब से तय होता है। टपल के किसी एलिमेंट तक पहुँचने के लिए आप [] ऑपरेटर इस्तेमाल कर सकते हैं।

array = [1, "foo", 'c']
array[0]         # => 1
typeof(array[0]) # => Int32 | String | Char

tuple = {1, "foo", 'c'}
tuple[0]         # => 1
typeof(tuple[0]) # => Int32

ऐरे से एलिमेंट निकालने और टपल से निकालने में एक और फर्क है। टपल में अगर इंडेक्स साफ लिखा हो, तो कंपाइलर जाँच लेता है कि इंडेक्स टपल की सीमा के अंदर है या नहीं। इसका मतलब है कि आपको रनटाइम एरर की जगह कंपाइल के समय ही एरर मिलती है।

tuple = {1, "foo", 'c'}
tuple[3]
# => Error: index out of bounds for Tuple(Int32, String, Char) (3 not in -3..2)

लेकिन अगर इंडेक्स किसी वेरिएबल में रखा हो, तो कंपाइलर कंपाइल के समय यह जाँच नहीं पाएगा कि इंडेक्स टपल की सीमा में है या नहीं। तब एरर रनटाइम पर मिलती है।

सबटपल

टपल से सबटपल पाने के लिए आप [] ऑपरेटर के साथ रेंज दे सकते हैं। इससे उन एलिमेंट वाला नया टपल लौटता है जो दी गई रेंज में आते हैं। रेंज कंपाइल के समय देनी होती है। वरना कंपाइलर को यह पता नहीं चलेगा कि सबटपल के एलिमेंट किस टाइप के हैं। यानी रेंज एक रेंज लिटरल होनी चाहिए, किसी वेरिएबल में रखी हुई नहीं।

tuple = {1, "foo", 'c'}
subtuple = tuple[0..1] # Tuple(Int32, String)

i = 0..1
tuple[i]
# Error: Tuple#[](Range) can only be called with range literals known at compile-time

टपल का उपयोग कब करें

जब आपको तय संख्या की वैल्यू एक साथ रखनी हों और उन वैल्यू के टाइप कंपाइल के समय पता हों, तब टपल काम आते हैं। ऐसा इसलिए, क्योंकि टपल को कम मेमोरी चाहिए और बदले न जा सकने की वजह से ये ऐरे से तेज़ होते हैं। एक और उपयोग है, मेथड से एक साथ कई वैल्यू लौटाना। यह तब खास तौर पर काम आता है जब वैल्यू के टाइप अलग-अलग हों, क्योंकि टपल में हर जगह का टाइप अलग हो सकता है।

जहाँ ज़रूरत ऐसे डेटा स्ट्रक्चर की हो जिसका आकार बढ़ता-घटता रहे या जिसे बार-बार बदलना पड़े, वहाँ टपल का उपयोग नहीं करना चाहिए।

सिंबल ऐसे नाम वाले आइडेंटिफायर होते हैं जिनसे किसी वैल्यू को दर्शाया जा सकता है। सिंबल सिंबल लिटरल से बनते हैं, यानी किसी नाम के आगे : अक्षर लगाकर, जैसे :foo। इन्हें कोट्स के साथ भी लिखा जा सकता है, जैसे :"foo"। इससे नाम में स्पेस जैसी चीज़ें भी रखी जा सकती हैं।

:foo           # => :foo
:"foo boo"     # => :"foo boo"
:foo == :"foo" # => true

भाषा में सिंबल कई जगह इस्तेमाल होते हैं, जैसे नेम्ड टपल की कीज़ में और मेथड तथा वेरिएबल के नाम दर्शाने में।

Crystal में सिंबल

Crystal में सिंबल Ruby से काफी अलग होते हैं। Crystal में सिंबल एक तरह का कॉन्स्टेंट होता है, इसलिए यह कंपाइल के समय असाइन होता है। इसका मतलब है कि सिंबल चलते-चलते नहीं बनाए जा सकते, जबकि Ruby में यह मुमकिन है।

Crystal में सिंबल Int32 के रूप में रखे जाते हैं, जिससे ये बहुत कुशल बनते हैं।

रूपांतरण

सिंबल को स्ट्रिंग में बदला जा सकता है, लेकिन स्ट्रिंग को सिंबल में नहीं। ऐसा इसलिए, क्योंकि सिंबल कंपाइल के समय बनते हैं और स्ट्रिंग रनटाइम पर।

:foo.to_s # => "foo"