टिसबरी खज़ाने की खोज

Tuple कई मामलों में Vector (1-D array) से काफी मिलता-जुलता है। लेकिन दोनों में कुछ ज़रूरी अंतर भी हैं।

• टपल चौकोर ब्रैकेट [ ] की जगह गोल ब्रैकेट ( ) में लिखे जाते हैं, हालाँकि जहाँ अर्थ स्पष्ट हो वहाँ गोल ब्रैकेट छोड़े जा सकते हैं।
• टपल के सारे एलिमेंट एक ही टाइप के होना ज़रूरी नहीं है: हर एलिमेंट का टाइप अलग से संग्रहीत किया जाता है।
• टपल अपरिवर्तनीय होते हैं।

अपरिवर्तनीयता की वजह से कंपाइलर ज़्यादा ऑप्टिमाइज़ेशन कर पाता है। इससे टपल, वेक्टर के मुकाबले बेहतर प्रदर्शन देते हैं। इसलिए जहाँ बदलाव की ज़रूरत न हो, वहाँ टपल को प्राथमिकता देनी चाहिए।

julia> t = (3, 5.2, "xyz")
(3, 5.2, "xyz")

# Non-homogeneous:
julia> dump(t)
Tuple{Int64, Float64, String}
  1: Int64 3
  2: Float64 5.2
  3: String "xyz"

julia> t[2]
5.2

# Immutable:
julia> t[2] = 7.3
ERROR: MethodError: no method matching setindex!(::Tuple{Int64, Float64, String})

एक Tuple() कंस्ट्रक्टर भी है, जो किसी भी इटरेबल कलेक्शन को टपल में बदल देता है। काम की बात यह है कि यह स्ट्रिंग को अक्षरों के एक इटरेबल कलेक्शन की तरह मानता है।

julia> Tuple("Julia")
('J', 'u', 'l', 'i', 'a')

किसी भी टपल में आप इंडेक्स के ज़रिए एलिमेंट ऐक्सेस कर सकते हैं या उन पर लूप चला सकते हैं।

जिस टपल में सिर्फ संख्याएँ हों, उसे sum() जैसे गणितीय फंक्शन में भी इस्तेमाल किया जा सकता है, बिल्कुल ऐरे की तरह।

अनपैकिंग

मल्टीपल असाइनमेंट की मदद से एक टपल को अलग-अलग एलिमेंट में बाँटा जा सकता है। जिन एलिमेंटों की ज़रूरत न हो, उनके लिए डमी वेरिएबल के तौर पर अंडरस्कोर _ इस्तेमाल कीजिए।

julia> tup = (1, "Julia", true)
(1, "Julia", true)

julia> num, name, _ = tup
(1, "Julia", true)

julia> uppercase(name), 2num
("JULIA", 2)

Python प्रोग्रामर इस मल्टीपल-असाइनमेंट सिंटैक्स से भली-भाँति परिचित होंगे।

नेम्ड टपल

Tuple में सिर्फ वैल्यू होती हैं। NamedTuple हर वैल्यू के साथ एक नाम जोड़ता है।

इसके बाद हर फील्ड को "डॉट" नोटेशन से ऐक्सेस किया जा सकता है:

julia> nt = (a = 1, b = 7.3)
(a = 1, b = 7.3)

julia> dump(nt)
@NamedTuple{a::Int64, b::Float64}
  a: Int64 1
  b: Float64 7.3

julia> nt.b
7.3

नाम को अंदर ही अंदर Symbol के रूप में संग्रहीत किया जाता है (Symbol एक अपरिवर्तनीय टाइप है, जिसके आगे कोलन : लगाया जाता है), इसलिए एक और सिंटैक्स भी उपलब्ध है:

julia> nt[:b]
7.3

नाम (जिन्हें "की" भी कहा जाता है) या वैल्यू, दोनों को अलग-अलग निकालना आसान है:

julia> nt
(a = 1, b = 7.3)

julia> keys(nt)
(:a, :b)

julia> values(nt)
(1, 7.3)

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

टपल (नेम्ड हों या न हों) फंक्शन को स्ट्रक्चर्ड डेटा भेजने और फंक्शन से वापस लाने का बहुत आम तरीका है। ऐसे इस्तेमाल में अपरिवर्तनीयता फायदेमंद है, क्योंकि इससे डेटा सुरक्षित रहता है और कंपाइलर ज़्यादा आक्रामक ऑप्टिमाइज़ेशन कर पाता है।