types जूलिया कस्टम प्रकार असाइनमेंट




iterator julia-lang (2)

मुझे पता नहीं है कि असाइनमेंट ऑपरेटर को कैसे ओवरलोड करना है, लेकिन आप इस फ़ंक्शन के साथ सभी फ़ील्ड वापस कर सकते हैं:

all_fields(x) = [x.(i) for i = 1:nfields(x)]

तो आप कर सकते हैं

(a,b) = all_fields(foo(1,2))

मैं जूलिया में एक कस्टम प्रकार से कई तत्व निर्दिष्ट करने का प्रयास करता हूं हालांकि मुझे नहीं पता कि यह कैसे करना है। या अन्य शब्दों में मैं असाइनमेंट ऑपरेटर को ओवरलोड करना चाहूंगा क्योंकि प्रकार में निहित सभी तत्वों का ट्यूपल वापस करना होगा।

यहां वांछित व्यवहार है:

type foo
    a
    b
end

(a,b) = foo(1,2)
a
> 1

और यहां त्रुटि संदेश है:

ERROR: LoadError: MethodError: `start` has no method matching start(::foo)

मेरा यह मानना ​​है कि मुझे असाइनमेंट की देखभाल करने वाले किसी प्रकार के इटरेटर को लागू करने की आवश्यकता है, लेकिन मुझे नहीं पता कि यह कैसे करना है।

संपादित करें

मैंने "प्रारंभ (), किया (), अगले ()" कार्य कार्यान्वित किया अब मुझे इस बात का चिंतन था कि मैं अभी भी किस प्रकार के तत्वों को निर्दिष्ट करने की अनुमति देता हूं

लिख रहे हैं:

a, b = foo(1,2)
a

# returns
> 1

तथापि:

a = foo(1,2)
a
# returns
> foo(1,2)

जो शानदार है इसलिए जूलिया यह स्वीकार करता है कि समीकरण के बाएं हाथ की तरफ (एलएचएस) एक तत्व को दाहिनी ओर वापस लौटाएगा और 'एन' तत्वों को एलएचएस पर 'एन' तत्व प्रकार से आवंटित करेगा। इसलिए यदि आप संपूर्ण प्रकार असाइन करना चाहते हैं तो आपको एलएचएस पर एक तत्व को टाइप करना होगा। बस।


असाइनमेंट इटरेटर प्रोटोकॉल का उपयोग करता है और इसलिए start , काम done और next प्रकार के लिए कार्यान्वित किए जाने की आवश्यकता है।

शैली के बारे में एक टिप्पणी, टाइप नामों को कैपिटल कैरेक्टर के साथ शुरू किया जाना चाहिए और फ़ील्ड को प्रदर्शन के लिए कंक्रीट प्रकार होना चाहिए। निम्नलिखित में मैंने Foo में एक प्रकार पैरामीटर T किया है। टी किसी भी प्रकार का हो सकता है, लेकिन फू के क्षेत्र में एक ही प्रकार का है। यदि यह प्रतिबंधात्मक अतिरिक्त प्रकार के पैरामीटरों के लिए है, तो शुरू किया जा सकता है या प्रत्येक फ़ील्ड को एक ठोस प्रकार सौंपा जा सकता है

नीचे दिए गए उदाहरण, Foo के प्रकार के लिए start और done गए हैं, लागू होते हैं

type Foo{T}
    x::T
    y::T 
    z::T
end
Base.start(foo::Foo) = 1
Base.done(foo::Foo, i) = nfields(foo) < i
Base.next(foo::Foo, i) = getfield(foo, i), i+1

उपरोक्त के साथ फू की सामग्री को अलग-अलग चर में विभाजित किया जा सकता है:

x, y, z = Foo(1, 2, 3)

एक बोनस के रूप में, फ़ू को अब तक के रूप में निम्न प्रकार से किया जा सकता है:

for i in Foo(1, 2, 3)
    println(i)
end




julia-lang