अब तक सिलेबस ने टाइप के बारे में ज़्यादा कुछ नहीं कहा है, लेकिन साफ है कि Julia में ये मौजूद हैं:
julia> vals = (42, 4.3, π, "hello", 'Q')
(42, 4.3, π, "hello", 'Q')
julia> typeof(vals)
Tuple{Int64, Float64, Irrational{:π}, String, Char}
हमने टाइप कभी निर्दिष्ट नहीं किए, फिर भी Julia ने उन्हें असाइन कर दिया।
- Julia में
types हैं, जो इसके डिज़ाइन के केंद्र में हैं।
- Julia आमतौर पर
Type Inference का उपयोग करके टाइप का "अनुमान" लगा सकती है।
JIT कंपाइलर (सारे) कोड को देखता है, यह देखता है कि किसी वेरिएबल का उपयोग कैसे हो रहा है, और उस उपयोग के अनुरूप एक उपयुक्त डिफॉल्ट टाइप का अनुमान लगाता है।
टाइप असाइनमेंट
आसान ट्यूटोरियल अभ्यास हल करने के लिए टाइप इनफेरेंस पर भरोसा करना ठीक है, लेकिन बड़े प्रोग्राम के लिए आपको ज़्यादा सटीक नियंत्रण की ज़रूरत पड़ सकती है।
ज़्यादातर आधुनिक प्रोसेसर पर एक पूर्णांक का डिफॉल्ट Int64 होता है।
हमने Numbers कॉन्सेप्ट में देखा था कि किसी वैल्यू को किसी खास गैर-डिफॉल्ट टाइप में बदला जा सकता है।
julia> x = Int16(42)
42
julia> typeof(x)
Int16
लेकिन वेरिएबल x को किसी दूसरे टाइप की वैल्यू फिर भी असाइन की जा सकती है:
julia> x = "changed"
"changed"
julia> typeof(x)
String
यह type instability है, और इसका मतलब है:
- छोटी स्क्रिप्ट में यह बहुत सुविधाजनक होती है।
- बड़े प्रोग्राम में यह परफ़ॉर्मेंस और भरोसे के लिए नुकसानदेह होती है।
इसके बजाय, हम :: ऑपरेटर का उपयोग करके x का टाइप तय कर सकते हैं:
julia> y::Int16 = 42
42
julia> typeof(y)
Int16
julia> y = "changed"
ERROR: MethodError: Cannot `convert` an object of type String to an object of type Int16
The function `convert` exists, but no method is defined for this combination of argument types.
अब y का टाइप Int16 है, और हमेशा रहेगा।
इसलिए कंपाइलर को पता होता है कि इसके लिए कितने बाइट आरक्षित करने हैं, और वह बाकी कोड को इस तरह ऑप्टिमाइज़ कर सकता है कि वह एक स्थिर टाइप पर भरोसा करे।
इस मायने में यह वेरिएबल C जैसी स्टैटिकली-टाइप्ड भाषा के वेरिएबलो जैसा ही है।
टाइप का पदानुक्रम
Int64, Int16, String, Char: ये टाइप "कहाँ से आते हैं"?
कई ऑब्जेक्ट-ओरिएंटेड (OO) भाषाओं में हर टाइप एक क्लास होता है, सबक्लासिंग उन्हें एक क्लास पदानुक्रम में सजाती है, और क्लास मेथड उनका व्यवहार तय करते हैं।
Java और Ruby इस पैटर्न के साफ उदाहरण हैं, लेकिन अंदरूनी रूप से Python भी ऐसी ही है।
Julia में क्लास नहीं होती।
दस्तावेज़ों में दिया गया कारण यह है कि OO फीचर JIT कंपाइलर में रुकावट डालते हैं और रनटाइम परफ़ॉर्मेंस को नुकसान पहुँचाते हैं।
फिर भी, इस कोड को देखिए:
julia> y::Int16 = 42
42
julia> typeof(y)
Int16
julia> supertype(Int16)
Signed
julia> supertypes(Int16)
(Int16, Signed, Integer, Real, Number, Any)
कुछ बातें स्पष्ट कर लेते हैं:
-
Int16 एक टाइप है, और हम इस टाइप के वेरिएबल बना सकते हैं।
-
Int16, Signed का सबटाइप है, और supertype() फंक्शन हमें यह दिखाता है।
- टाइपो का एक पदानुक्रम है, जो
Integer, Real और Number से होते हुए सबसे ऊपर Any तक जाता है, और subtypes() हमें पदानुक्रम की यह शाखा दिखा देगा।
सारी शाखाएँ Any पर जाकर खत्म होती हैं, और Any इस मायने में अनोखा है कि वह खुद अपना ही सुपरटाइप है।
julia> supertypes(String)
(String, AbstractString, Any)
julia> supertype(Any)
Any
तो Julia में class का पदानुक्रम नहीं है, लेकिन type का पदानुक्रम ज़रूर है।
आगे चलकर हम यह समझने की कोशिश करेंगे कि यह काम कैसे करता है, लेकिन पहले अभी बहुत कुछ खोजना बाकी है।
टाइप की जाँच
हम सामान्य तरीके से बराबरी की जाँच के लिए typeof() का उपयोग कर सकते हैं।
julia> typeof(11)
Int64
julia> typeof(11) == Int64
true
julia> typeof(11) == Number
false
टाइप की बराबरी बिल्कुल सटीक होनी चाहिए, क्योंकि तुलना के इस तरीके को टाइप पदानुक्रम की कोई समझ नहीं होती।
इससे ज़्यादा लचीले ढंग से, isa हमें बताता है कि किसी वैल्यू का टाइप तुलना करने वाले टाइप जैसा ही है या उसका कोई सबटाइप है।
इसका उपयोग फंक्शन रूप में या इनफ़िक्स रूप में, दोनों तरह से किया जा सकता है।
julia> 12 isa Int64
true
julia> 12 isa Number
true
julia> isa(12, Number)
true
julia> 12 isa String
false
ध्यान दीजिए कि isa बाईं ओर एक value की अपेक्षा करता है, type की नहीं।
इस तरह दो टाइपो की तुलना करने पर अनपेक्षित परिणाम मिलेंगे।
सही ऑपरेटर <: है, जिसे हम आगे के कॉन्सेप्ट में और भी बहुत बार देखेंगे।
julia> Int64 isa Number ## Don't do this!
false
julia> Int64 <: Number
true
एब्स्ट्रैक्ट बनाम कॉन्क्रीट टाइप
हमने देखा कि टाइप पदानुक्रम एक पेड़ जैसी संरचना बनाता है (CS के अर्थ में, जिसकी जड़ सबसे ऊपर होती है)।
पेड़ में हर चीज़ एक node होती है, और इन्हें वर्गों में बाँटा जा सकता है:
- जिन
node के सबटाइप होते हैं, उन्हें abstract कहा जाता है।
- बिना सबटाइप वाले पत्ती जैसे
node को concrete कहा जाता है।
julia> subtypes(Integer) # an abstract type
3-element Vector{Any}:
Bool
Signed
Unsigned
julia> subtypes(Int64) # a concrete type
Type[]
यह एक महत्वपूर्ण अंतर है, क्योंकि सिर्फ कॉन्क्रीट टाइप को ही वेरिएबल के रूप में instantiated किया जा सकता है।
julia> a::Int16 = 42
42
julia> typeof(a)
Int16
julia> b::Integer = 42
42
julia> typeof(b)
Int64
ध्यान दीजिए कि एब्स्ट्रैक्ट टाइप इस्तेमाल करने पर (इस मामले में) कोई एरर संदेश नहीं मिलता, लेकिन कंपाइलर एक उपयुक्त कॉन्क्रीट टाइप बना देता है: Integer की जगह Int64।
सीखने का अभ्यास
