Julia Language
प्रकार

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

• अपरिवर्तनीय MyType; खेत; खेत; समाप्त
• टाइप MyType; खेत; खेत; समाप्त

टिप्पणियों

प्रकारों पर प्रेषण

जूलिया पर, आप प्रत्येक फ़ंक्शन के लिए एक से अधिक विधि परिभाषित कर सकते हैं। मान लें कि हम एक ही कार्य के तीन तरीके परिभाषित करते हैं:

foo(x) = 1
foo(x::Number) = 2
foo(x::Int) = 3

निर्णय लेने के लिए किस विधि का उपयोग किया जाता है (जिसे प्रेषण कहा जाता है), जूलिया अधिक विशिष्ट विधि चुनती है जो तर्कों के प्रकारों से मेल खाती है:

julia> foo('one')
1

julia> foo(1.0)
2

julia> foo(1)
3

यह बहुरूपता की सुविधा देता है । उदाहरण के लिए, हम आसानी से दो अपरिवर्तनीय प्रकारों को परिभाषित करके एक लिंक सूची बना सकते हैं, जिनका नाम Nil और Cons । इन नामों को क्रमशः एक खाली सूची और एक गैर-रिक्त सूची का वर्णन करने के लिए उपयोग किया जाता है।

abstract LinkedList
immutable Nil <: LinkedList end
immutable Cons <: LinkedList
    first
    rest::LinkedList
end

हम Nil() और किसी भी अन्य सूचियों को Cons(first, rest) द्वारा खाली सूची का प्रतिनिधित्व करेंगे, जहां first लिंक की गई सूची का पहला तत्व है और rest सभी शेष तत्वों से मिलकर जुड़ी हुई सूची है। उदाहरण के लिए, सूची [1, 2, 3] का प्रतिनिधित्व किया जाएगा

julia> Cons(1, Cons(2, Cons(3, Nil())))
Cons(1,Cons(2,Cons(3,Nil())))

क्या सूची खाली है?

मान लीजिए कि हम मानक पुस्तकालय के isempty कार्य को isempty हैं, जो विभिन्न प्रकार के संग्रह पर काम करता है:

julia> methods(isempty)
# 29 methods for generic function "isempty":
isempty(v::SimpleVector) at essentials.jl:180
isempty(m::Base.MethodList) at reflection.jl:394
...

हम केवल फ़ंक्शन प्रेषण सिंटैक्स का उपयोग कर सकते हैं, और isempty दो अतिरिक्त तरीकों को isempty । चूंकि यह फ़ंक्शन Base मॉड्यूल से है, इसलिए हमें इसका विस्तार करने के लिए इसे Base.isempty रूप में अर्हता प्राप्त करनी होगी।

Base.isempty(::Nil) = true
Base.isempty(::Cons) = false

यहां, हमें यह निर्धारित करने के लिए तर्क मानों की आवश्यकता नहीं थी कि सूची खाली है या नहीं। केवल उस जानकारी की गणना करने के लिए केवल प्रकार ही पर्याप्त होता है। जूलिया हमें केवल उनके प्रकार के एनोटेशन रखते हुए, तर्कों के नामों को छोड़ने की अनुमति देता है, अगर हमें उनके मूल्यों का उपयोग करने की आवश्यकता नहीं है।

हम परीक्षण कर सकते हैं कि हमारी isempty विधियाँ काम करती हैं:

julia> using Base.Test

julia> @test isempty(Nil())
Test Passed
  Expression: isempty(Nil())

julia> @test !isempty(Cons(1, Cons(2, Cons(3, Nil()))))
Test Passed
  Expression: !(isempty(Cons(1,Cons(2,Cons(3,Nil())))))

और वास्तव में isempty लिए तरीकों की संख्या में 2 वृद्धि हुई है:

julia> methods(isempty)
# 31 methods for generic function "isempty":
isempty(v::SimpleVector) at essentials.jl:180
isempty(m::Base.MethodList) at reflection.jl:394

स्पष्ट रूप से, यह निर्धारित करना कि एक लिंक की गई सूची खाली है या नहीं यह एक तुच्छ उदाहरण है। लेकिन यह कुछ और दिलचस्प है:

सूची कब तक है?

मानक पुस्तकालय से length समारोह हमें एक संग्रह या कुछ पुनरावृत्तियों की लंबाई देता है। लिंक की गई सूची के लिए length को लागू करने के कई तरीके हैं। विशेष रूप से, while लूप का उपयोग करने की संभावना सबसे तेज़ और जूलिया में सबसे अधिक मेमोरी-कुशल है। लेकिन समय से पहले अनुकूलन से बचा जाना है, तो चलो एक दूसरे के लिए मान लें कि हमारी लिंक की गई सूची को कुशल होने की आवश्यकता नहीं है। length फ़ंक्शन लिखने का सबसे सरल तरीका क्या है?

Base.length(::Nil) = 0
Base.length(xs::Cons) = 1 + length(xs.rest)

पहली परिभाषा सीधी है: एक खाली सूची की लंबाई 0 । दूसरी परिभाषा को पढ़ना भी आसान है: किसी सूची की लंबाई को गिनने के लिए, हम पहले तत्व को गिनते हैं, फिर बाकी की सूची की लंबाई को गिनते हैं। हम इस पद्धति का परीक्षण उसी तरह से कर सकते हैं जैसे हमने isempty परीक्षण किया isempty :

julia> @test length(Nil()) == 0
Test Passed
  Expression: length(Nil()) == 0
   Evaluated: 0 == 0

julia> @test length(Cons(1, Cons(2, Cons(3, Nil())))) == 3
Test Passed
  Expression: length(Cons(1,Cons(2,Cons(3,Nil())))) == 3
   Evaluated: 3 == 3

अगला कदम

यह खिलौना उदाहरण उन सभी कार्यक्षमता को लागू करने से बहुत दूर है जो एक लिंक की गई सूची में वांछित होंगे। मिसाल के तौर पर यह गायब है। हालांकि, यह दिखाता है कि छोटे और स्पष्ट कोड लिखने के लिए प्रेषण का उपयोग कैसे किया जा सकता है।

अपरिवर्तनीय प्रकार

सबसे सरल मिश्रित प्रकार एक अपरिवर्तनीय प्रकार है। अपरिवर्तनीय प्रकार के उदाहरण की तरह tuples , मान हैं। उनके बनाए जाने के बाद उनके खेतों को नहीं बदला जा सकता है। कई मायनों में, एक अपरिवर्तनीय प्रकार एक Tuple तरह है, जो स्वयं प्रकार और प्रत्येक क्षेत्र के लिए नामों के साथ है।

सिंगलटन प्रकार

समग्र प्रकार, परिभाषा के अनुसार, कई सरल प्रकार होते हैं। जूलिया में, यह संख्या शून्य हो सकती है; अर्थात्, एक अपरिवर्तनीय प्रकार को कोई फ़ील्ड शामिल करने की अनुमति है। यह खाली टपल () बराबर है।

यह उपयोगी क्यों हो सकता है? ऐसे अपरिवर्तनीय प्रकारों को "सिंगलटन प्रकार" के रूप में जाना जाता है, क्योंकि उनमें से केवल एक ही उदाहरण कभी भी मौजूद हो सकता है। इस प्रकार के मूल्यों को "सिंगलटन मान" के रूप में जाना जाता है। मानक लाइब्रेरी Base में कई ऐसे सिंगलटन प्रकार होते हैं। यहाँ एक संक्षिप्त सूची है:

• Void , nothing का प्रकार। हम सत्यापित कर सकते हैं कि Void.instance (जो एक सिंगलटन प्रकार के सिंगलटन मान को पुनः प्राप्त करने के लिए विशेष वाक्यविन्यास है) वास्तव में nothing ।
• कोई भी मीडिया प्रकार, जैसे कि MIME"text/plain" , एकल उदाहरण के साथ एक सिंगलटन प्रकार है, MIME("text/plain") ।
• Irrational{:π} , Irrational{:π} , Irrational{:e} , Irrational{:φ} , और इसी प्रकार के एक प्रकार के सिंगलटन प्रकार हैं, और उनके सिंगलटन के उदाहरण तर्कहीन मूल्य हैं π = 3.1415926535897... , आदि।
• इटरेटर का आकार Base.HasLength , Base.HasShape , Base.IsInfinite , और Base.SizeUnknown सभी सिंगलटन प्रकार के Base.SizeUnknown हैं।

क्योंकि उनके पास कुछ भी नहीं है, सिंगलटन प्रकार अविश्वसनीय रूप से हल्के होते हैं, और उन्हें अक्सर संकलक द्वारा दूर किया जा सकता है जिसमें कोई रनटाइम ओवरहेड न हो। इस प्रकार, वे लक्षण, विशेष टैग मूल्यों और ऐसे कार्यों के लिए एकदम सही हैं जो एक विशेषज्ञ पर करना चाहते हैं।

एक एकल प्रकार को परिभाषित करने के लिए,

julia> immutable MySingleton end

सिंगलटन प्रकार के लिए कस्टम प्रिंटिंग को परिभाषित करने के लिए,

julia> Base.show(io::IO, ::MySingleton) = print(io, "sing")

एकल उदाहरण का उपयोग करने के लिए,

julia> MySingleton.instance
MySingleton()

अक्सर, एक व्यक्ति इसे एक नियत स्थान पर भेजता है:

julia> const sing = MySingleton.instance
MySingleton()

आवरण के प्रकार

यदि शून्य-फ़ील्ड अपरिवर्तनीय प्रकार दिलचस्प और उपयोगी हैं, तो शायद एक-फ़ील्ड अपरिवर्तनीय प्रकार और भी अधिक उपयोगी हैं। ऐसे प्रकारों को आमतौर पर "रैपर प्रकार" कहा जाता है क्योंकि वे कुछ अंतर्निहित डेटा को लपेटते हैं, उक्त डेटा के लिए एक वैकल्पिक इंटरफ़ेस प्रदान करते हैं। Base में एक रैपर प्रकार का एक उदाहरण String । हम String समान प्रकार को परिभाषित करेंगे, जिसका नाम MyString । यह प्रकार बाइट्स ( UInt8 ) के एक वेक्टर (एक आयामी सरणी ) द्वारा समर्थित होगा।

सबसे पहले, प्रकार ही परिभाषा और कुछ अनुकूलित दिखा:

immutable MyString <: AbstractString
    data::Vector{UInt8}
end

function Base.show(io::IO, s::MyString)
    print(io, "MyString: ")
    write(io, s.data)
    return
end

अब हमारा MyString प्रकार उपयोग के लिए तैयार है! हम इसे कुछ कच्चे UTF-8 डेटा को खिला सकते हैं, और जैसा कि हम इसे पसंद करते हैं:

julia> MyString([0x48,0x65,0x6c,0x6c,0x6f,0x2c,0x20,0x57,0x6f,0x72,0x6c,0x64,0x21])
MyString: Hello, World!

जाहिर है, इस स्ट्रिंग प्रकार को बहुत अधिक काम करने की आवश्यकता है क्योंकि यह Base.String प्रकार के रूप में उपयोग करने योग्य हो जाता है।

सही मिश्रित प्रकार

शायद सबसे अधिक, कई अपरिवर्तनीय प्रकारों में एक से अधिक क्षेत्र होते हैं। एक उदाहरण मानक पुस्तकालय है Rational{T} एक: प्रकार है, जो दो fieds शामिल num अंश के लिए क्षेत्र, और एक den भाजक के लिए क्षेत्र। इस प्रकार के डिजाइन का अनुकरण करना काफी सरल है:

immutable MyRational{T}
    num::T
    den::T
    MyRational(n, d) = (g = gcd(n, d); new(n÷g, d÷g))
end
MyRational{T}(n::T, d::T) = MyRational{T}(n, d)

हमने एक निर्माणकर्ता को सफलतापूर्वक लागू किया है जो हमारी तर्कसंगत संख्याओं को सरल करता है:

julia> MyRational(10, 6)
MyRational{Int64}(5,3)