Julia: ओवर फील्ड एक्सेस सिंटैक्स की ओवरलोडिंग की अनुमति दें

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

+1

मेरे पास इसे लागू करने का एक बहुत ही बढ़िया तरीका है।

इसके बारे में बात करने में दिलचस्पी है? मुझे पता है कि टॉम शॉर्ट वास्तव में डेटाफ्रैम के लिए ऐसा करने में रुचि रखता है, हालांकि मैं इस सुविधा का उपयोग करने के ज्ञान के बारे में तेजी से संदेह करता हूं।

यह अजगर कोड (PyCall के माध्यम से) काफी अच्छे बुला कर के बाद से वर्तमान में मैं ऐसा करने के लिए मजबूर कर रहा हूँ होगा a[:b] के बजाय a.b ।

@JeffBezanson , 0.3 के लिए यह होने का कोई भी मौका? अंतर-भाषा इंटरोप के लिए बहुत अच्छा होगा, दोनों PyCall के लिए और JavaCall (cc @aviks) के लिए।

@JeffBezanson अगर _not_, तो क्या कोई मौका है कि आप इसे लागू करने के बारे में कुछ दिशा दे सकें? ( I have an absolutely awesome way to implement this. )

मेरे अनुभव में, जेफ़ को पाने के लिए इससे तेज़ और न ही कोई बेहतर तरीका है कि वह इसके एक संस्करण को लागू करने की तुलना में कुछ ऐसा करे कि वह ;-);

मूल विचार यह है कि आप लागू करते हैं

getfield(x::MyType, ::Field{:name}) = ...

ताकि आप इसे प्रति क्षेत्र अधिभारित कर सकें। यह पारदर्शी तरीके से काम करने के लिए "वास्तविक" क्षेत्रों तक पहुंच की अनुमति देता है। उपयुक्त कमियों के साथ getfield(::MyType, ::Symbol) भी काम करता है।

सबसे बड़ा मुद्दा यह है कि मॉड्यूल में . संबंध में विशेष व्यवहार है। सिद्धांत रूप में, यह केवल getfield का एक और तरीका होगा, लेकिन समस्या यह है कि हमें मॉड्यूल संदर्भों को हल करने की आवश्यकता है _earlier_ क्योंकि वे मूल रूप से वैश्विक चर की तरह व्यवहार करते हैं। मुझे लगता है कि हमें . के व्यवहार में इसे एक विशेष मामला रखना होगा। विश्लेषण (# प्रकार) * (# फ़ील्ड) अतिरिक्त फ़ंक्शन परिभाषाओं के कारण एक संकलक दक्षता चिंता का एक सा भी है। लेकिन इसके लिए हम बस वही देखेंगे जो होता है।

@JeffBezanson क्या आप मॉड्यूल में const व्यवहार का भी उल्लेख करते हैं? एक मॉड्यूल का अनुकरण करने वाले उपयोगकर्ता प्रकार के लिए उपयोगी होगा और एक गतिशील क्षेत्र लुकअप का परिणाम निरंतर होने पर कंपाइलर को बताने में सक्षम होगा। (एक अन्य दृष्टिकोण एक वास्तविक मॉड्यूल के साथ शुरू होगा और एक असफल jl_get_global "ट्रैप" करने में सक्षम होगा और मांग पर नए बाइंडिंग को इंजेक्ट करेगा)

मुझे लगता है कि यह # 5395 के संयोजन में बहुत उपयोगी होगा। फिर एक अपरिभाषित समारोह या विधि MyMod.newfunction(new signature) को कॉल करने में सक्षम हो और मांग पर एक (संभवतः बड़े) एपीआई के लिए बाइंडिंग उत्पन्न करने में सक्षम हो। इसके बाद मुझे लगता है कि हमेशा की तरह बाँध के रूप में कैश किया जाएगा।

मुझे, एक साधारण जूलिया नौसिखिया, थोड़ा चिंता पेश करें: मुझे लगता है कि डॉट ऑपरेटर को अधिभारित करने की संभावना का मतलब यह हो सकता है कि फ़ील्ड एक्सेस "शुद्धता" किसी तरह खो गई है।

उपयोगकर्ता आम तौर पर ज्ञान खो देगा अगर एब करना केवल एक संदर्भ / मूल्य तक पहुंच है या यदि कोई बड़ी फ़ंक्शन मशीनरी हो सकती है जिसे पीछे बुलाया जा रहा है। मुझे यकीन नहीं है कि यह कैसे बुरा हो सकता है, यह सिर्फ एक भावना है ...

दूसरी ओर, मैं देखता हूं कि वास्तव में यह कई मामलों (PyCall, Dataframes ...) के लिए सिंटैक्स शुगर की एक बड़ी इच्छा है, जो पूरी तरह से समझ में आता है।
शायद यह समय के लिए है .. # 2614?

मैं ऐसा करने का समर्थन करता हूं।

लेकिन पवित्रता इसके लिए कहने के लिए कुछ है, भले ही कोई names(Foo) करके यह पता लगा सके कि Foo के वास्तविक घटक क्या हैं।

पवित्रता का तर्क मेरे पास मुख्य व्यावहारिक चिंता से जुड़ा हुआ है, जो कि कैसे नाम का विरोध करता है जब प्रकार के क्षेत्र उन नामों के साथ हस्तक्षेप करते हैं जिन्हें आप उपयोग करने की उम्मीद कर सकते हैं। DataFrames में, मुझे लगता है कि हम कॉलम नामों के रूप में columns और colindex के उपयोग पर प्रतिबंध लगाकर इसे हल करेंगे, लेकिन जानना चाहते थे कि इसके लिए लोगों की योजना क्या थी।

मुझे लगता है कि getfield(x::MyType, ::Field{:foo}) = ... को तब मना करना होगा जब MyType पास एक फ़ील्ड foo , अन्यथा वास्तविक फ़ील्ड तक पहुंच खो जाएगी (या फ़ील्ड को एक्सेस करने के लिए बाध्य करने का एक तरीका है) उपलब्ध होगा)।
लेकिन तब getfield को केवल ठोस प्रकारों के लिए परिभाषित किया जा सकता था, क्योंकि अमूर्त लोग खेतों के बारे में कुछ भी नहीं जानते हैं।

(इस बीच, मैं सी ++ के बारे में इस पर ठोकर खाई।)

यह कोई बड़ी समस्या नहीं है। हम वास्तविक क्षेत्रों तक पहुंच को बाध्य करने के लिए Core.getfield(x, :f) जैसी कोई चीज प्रदान कर सकते हैं।

ठीक है, शायद मैं बेच रहा हूँ। लेकिन तब Core.getfield(x, :f) (जैसे, x..f ) का शॉर्टकट परिभाषित करना अच्छा होगा, अन्यथा सभी प्रतीकों के लिए . अधिक लोड करने वाले आंतरिक कोड (डेटाफ़्रेम, संभवतः शब्दकोशों) Core.getfield s के साथ भीड़ हो।

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

यह पहले से ही # 4935 में इंगित किया गया था, लेकिन चलो इसे यहां तक ​​खींच लें: डॉट ओवरलोडिंग शास्त्रीय जूलियन मल्टीपल डिस्पैच के साथ थोड़ा ओवरलैप कर सकती है यदि ठीक से उपयोग नहीं किया जाता है, क्योंकि हम करना शुरू कर सकते हैं

getfield (x :: MyType, :: Field {: size}) = .........
i = 1 के लिए: y.size .....

के बजाय

आकार (x :: MyType) = ..........
i = 1 के लिए: आकार (y) ...।

हालांकि, संग्रह में डेटा तक पहुंचने के लिए डॉट बहुत अच्छा होगा (डेटाफ्रेम, डायट्स, प्योब्जेक्ट्स), यह किसी भी तरह से ऑब्जेक्ट गुण (फ़ील्ड नहीं) तक पहुंच को बदल सकता है।

मुझे लगता है कि विचार करने वाली एक बात यह है कि यदि आप एक्सेसिंग फ़ील्ड को अधिभारित कर सकते हैं, तो आपको _setting_ फ़ील्ड को ओवरलोड करने में भी सक्षम होना चाहिए। इसके अलावा यह असंगत और निराशाजनक होगा। क्या आप अभी तक जाने के लिए ठीक हैं?

@nalimilan, एक पूरी तरह से की जरूरत है एक setfield! के अलावा getfield । ( setindex! बनाम getindex [] )। मुझे नहीं लगता कि यह विवादास्पद है।

@Stevengj से सहमत: DataFrames निश्चित रूप से कॉलम के लिए setfield! लागू कर रहा होगा।

मैं इसका समर्थन करता हूं।

अन्य भाषाओं (जैसे C # और पायथन) के साथ अनुभव बताता है कि डॉट सिंटैक्स में बहुत अधिक व्यावहारिक मूल्य है। विशेष विधियों के माध्यम से इसे लागू करने का तरीका मोटे तौर पर प्रदर्शन प्रतिगमन की चिंता को संबोधित करता है।

हालाँकि, यह सुनिश्चित करना महत्वपूर्ण है कि किसी विधि का _inlineability_ इस परिवर्तन से गंभीर रूप से प्रभावित नहीं होगा। उदाहरण के लिए, इस भूमि के बाद f(x) = g(x.a) + h(x.b) जैसा कुछ अचानक अप्राप्य नहीं हो जाएगा।

यदि हम ऐसा करने का निर्णय लेते हैं, तो संपत्ति की परिभाषा को आसान बनाने के लिए मैक्रोज़ प्रदान करना भी उपयोगी है, जो इस तरह दिख सकता है:

# let A be a type, and foo a property name
<strong i="10">@property</strong> (a::A).foo = begin
    # compute the return the property value
end

# for simpler cases, this can be simplified to
<strong i="11">@property</strong> (a::A).foo2 = (2 * a.foo)

# set property 
<strong i="12">@setproperty</strong> (a::A).foo v::V begin
    # codes for setting value v to a property a.foo
end

दृश्य के पीछे, इन सभी का अनुवाद विधि परिभाषाओं में किया जा सकता है।

मुझे यकीन नहीं है कि <strong i="5">@property</strong> (a::A).foo = यह सब getproperty(a::A, ::Field{foo}) = तुलना में बहुत आसान है ...

किसी भी मामले में, बेहतर सिंटैक्टिक शुगर एक ऐसी चीज है जिसे बुनियादी कार्यक्षमता वाली भूमि के बाद जोड़ा जा सकता है।

इनलाइनिंग के बारे में, जब तक कि निर्णय से पहले फील्ड एक्सेस इनबिल्ड न हो जाए कि क्या आसपास के फंक्शन को इनलाइन कर दिया जाए, तब मैं यह नहीं देखता कि इसका असर क्यों होगा। लेकिन शायद यह वह क्रम नहीं है जिसमें वर्तमान में इनलाइनिंग की जाती है?

getproperty(a::A, ::Field{:foo}) = मुझ पर हमला करता है क्योंकि बहुत सारे कॉलोन हैं :-) मैं मानता हूं कि यह एक मामूली बात है, और शायद हमें अभी इस बारे में चिंता करने की आवश्यकता नहीं है।

मेरी चिंता यह है कि क्या इससे प्रदर्शन प्रतिगमन होगा। मैं आंतरिक कोड पीढ़ी तंत्र के बारे में बहुत स्पष्ट नहीं हूं। @JeffBezanson शायद इस बारे में कुछ कहे?

फ़ील्ड पहुंच बहुत निम्न-स्तर है, इसलिए मैं यह सुनिश्चित करने के बिना ऐसा नहीं करूंगा कि प्रदर्शन सुरक्षित है।

आखिरकार मैं आश्वस्त नहीं हूं कि ओवरलोडिंग फील्ड एक अच्छा विचार है। इस प्रस्ताव के साथ, संपत्ति सेट करने के हमेशा दो तरीके होंगे: x.property = value और property!(x, value) । यदि फ़ील्ड ओवरलोडिंग को लागू किया जाता है, तो हमें कुल गड़बड़ी को समाप्त करने से बचने के लिए एक बहुत मजबूत स्टाइल गाइड की आवश्यकता होगी जहां आप पहले से कभी नहीं जानते कि लेखक ने किसी दिए गए प्रकार के लिए कौन सा समाधान चुना है।

और फिर यह सवाल होगा कि क्षेत्र सार्वजनिक हैं या निजी हैं। फील्ड को ओवरलोडिंग की अनुमति नहीं देने से प्रकार प्रणाली स्पष्ट हो जाएगी: फ़ील्ड हमेशा निजी होगी। तरीके सार्वजनिक होंगे, और प्रकार वे घोषणा करने में सक्षम होंगे कि वे इंटरफेस / प्रोटोकॉल / लक्षण लागू करते हैं, अर्थात वे विधियों का एक सेट प्रदान करते हैं। यह @stevengj की https://github.com/JuliaLang/julia/issues/1974#issuecomment -12083268 के खिलाफ जाना होगा ताकि एपीआई को तोड़ने के तरीकों से बचने के तरीकों के साथ खेतों को ओवरलोड करने के बारे में: केवल एपीआई के हिस्से के रूप में विधियां हों, और कभी भी फ़ील्ड नहीं ।

एकमात्र जगह जहां मुझे पछतावा होता है कि फ़ील्ड ओवरलोडिंग DataFrames , क्योंकि df[:a] df.a रूप में अच्छा नहीं है। लेकिन ऐसा नहीं लगता कि इसके लिए अकेले ही इतना बड़ा बदलाव चाहिए। अन्य उपयोग का मामला PyCall प्रतीत होता है, जो यह संकेत दे सकता है कि फ़ील्ड ओवरलोडिंग की अनुमति दी जानी चाहिए, लेकिन केवल अत्यधिक विशिष्ट, गैर-जूलियन उपयोग मामलों के लिए। लेकिन एक बार उपलब्ध होने के बाद लोगों को एक सुविधा के दुरुपयोग से कैसे रोका जाए? इसे एक विशेष मॉड्यूल में छिपाएं?

@nalimilan , मैं कहूंगा कि वरीयता x.property जितना हो सके .. ऑपरेटर के लिए एक अच्छा उपयोग मामला है: निजी _real_ फ़ील्ड एक्सेस ऑपरेटर।

मुझे वास्तव में लगता है कि यह परिवर्तन चीजों को कम के बजाय अधिक स्पष्ट और अधिक सुसंगत बना सकता है। श्रेणियों पर विचार करें - वर्तमान में step(r) r.step शैलियों का एक प्रकार का घृणित मिश्रण अभी है। खासकर जब से मैंने FloatRange शुरुआत की है यह खतरनाक है क्योंकि केवल step(r) का उपयोग करने वाला कोड सही है। मिश्रण का कारण यह है कि श्रेणियों के कुछ गुणों को संग्रहीत किया जाता है और कुछ की गणना की जाती है - लेकिन वे समय के साथ बदल गए हैं और वास्तव में विभिन्न प्रकार की श्रेणियों के लिए भिन्न हैं। यह बेहतर शैली हो सकता है अगर हर पहुँच का था step(r) की परिभाषा को छोड़कर शैली step(r) ही। लेकिन उस के खिलाफ कुछ मनोवैज्ञानिक बाधाएं हैं। यदि हम r.step एक विधि कॉल करते हैं जो r..step लिए डिफॉल्ट करता है, तो लोग बस वही कर सकते हैं जो वे स्वाभाविक रूप से करने के लिए इच्छुक हैं।

शैतान के वकील की भूमिका निभाने के लिए (क्या हमें) r.length या length(r) लिखना चाहिए? सामान्य कार्यों और विधियों के बीच असंगतता एक ऐसी समस्या है जिसने पाइथन को पीड़ित किया है, जबकि रूबी ने r.length शैली के लिए पूरी तरह से प्रतिबद्ध किया।

+1 .. Core.getfield !

@StefanKarpinski समझ में आता है, लेकिन फिर आपको निजी क्षेत्रों के लिए वाक्यविन्यास जोड़ना होगा, और इंटरफेस को दोनों तरीकों और सार्वजनिक क्षेत्रों को निर्दिष्ट करना होगा। और वास्तव में आपको कुछ स्थिरता सुनिश्चित करने के लिए एक स्टाइल गाइड की आवश्यकता है; length का मामला एक कठिन है, लेकिन फिर size , जो बहुत समान है लेकिन एक आयाम सूचकांक की आवश्यकता है। इस फैसले ने कीड़ा खोल दिया ...

उस स्थिति में, मैं भी वास्तविक क्षेत्रों तक पहुँचने के लिए .. का समर्थन करता हूं, और खेतों तक पहुंचने के लिए . , वे तरीके या वास्तविक मूल्य हैं।

शैतान के वकील की भूमिका निभाने के लिए (क्या हमें) r.length या length(r) लिखना चाहिए? जेनेरिक कार्यों और विधियों के बीच असंगतता एक ऐसी समस्या है जिसने पाइथन को पीड़ित किया है, जबकि रूबी ने r.length शैली के लिए पूरी तरह से प्रतिबद्ध किया।

इस मुद्दे के लिए महत्वपूर्ण कारक जो अव्यवस्थित हो सकता है, वह यह है कि क्या आप किसी उच्च क्रम फ़ंक्शन के रूप में कुछ का उपयोग करने में सक्षम होना चाहते हैं या नहीं। यानी f f(x) कुछ ऐसा है जो आप एक संग्रह पर map कर सकते हैं, जबकि f x.f में नहीं है (लेखन की कमी) x -> x.f ) - जो एकल-प्रेषण भाषाओं में सभी विधियों के लिए समान स्थिति है।

फ़ील्ड एक्सेस पर रोक क्यों? x.foo(args...) getfield(x::MyType, ::Field{:foo}, args...) = ... बराबर होने के बारे में क्या? तब हम पहले आयाम के साथ x.size(1) आकार के लिए हो सकते थे। (मुझे यकीन नहीं है कि मैं अपने सुझाव का पक्षधर हूं, लेकिन शायद कुछ विचार करने के लिए। या शायद नहीं, क्योंकि लोग सिर्फ OO लुक-एक जैसे कोड लिखेंगे?)

यह इस कार्यक्षमता के साथ संभव होगा। कौन सी ऐसी चीजें हैं जो मुझे विराम देती हैं। मुझे उस तरह के oo स्टाइल कोड की कोई समस्या नहीं है - जैसा कि मैंने कहा, यह काफी सुखद है और लोग इसे वास्तव में पसंद करते हैं - लेकिन यह उन चीजों को लिखने के तरीके में पर्याप्त विकल्प पेश करता है जिन्हें हमें _really_ के बारे में एक मजबूत नीति की आवश्यकता है कि आपको क्या करना चाहिए चूँकि आप जो कर सकते हैं, उससे आप बहुत मुक्त होंगे।

जब मैंने जूलिया को सीखना शुरू किया, तो नो-डॉट सिंटैक्स ने मुझे मानसिक रूप से ओओ-प्रोग्रामिंग शैली को जाने देने में बहुत मदद की। तो अकेले इस कारण से, मुझे लगता है कि मेरा सुझाव बुरा है।

इसके अलावा, सरल अधिभार के लिए (यानी सिर्फ a.b sans (args...) ), मैं @nalimilan की टिप्पणी से ऊपर सहमत हूं। अंक # ४ ९ ३५ में सर्वसम्मति से लगता है कि खेतों को एपीआई का हिस्सा नहीं होना चाहिए बल्कि केवल विधियाँ होनी चाहिए; फलस्वरूप ऐसा लगता है कि यह मुद्दा बंद हो जाएगा। . -वर लोडिंग सिंटैक्स यह बहुत कम स्पष्ट कर देगा कि सामान्य-फ़ील्ड API का हिस्सा नहीं होना चाहिए और संभवतः फ़ील्ड को API का हिस्सा बनाने के लिए प्रोत्साहित करेगा।

लेकिन हाँ, . सिंटैक्स सुविधाजनक है ...

कैसे के बारे में: एकल . _only_ getfield(x::MyType, ::Field{:name}) = ... लिए सिंटैक्टिक शुगर होना चाहिए और .. (यानी क्या . अब है) के माध्यम से _only_ है।

यह स्पष्ट भेद करने की अनुमति देगा:

• . सार्वजनिक एपीआई के लिए प्रकार-उदाहरणों की मूल्य-जैसी चीजों तक पहुंचने के लिए है
• .. क्षेत्र पहुंच के लिए है और आम तौर पर सार्वजनिक एपीआई में इसका उपयोग नहीं किया जाना चाहिए

बेशक, यह एक ब्रेकिंग बदलाव होगा।

मूल रूप से यही मैं प्रस्ताव कर रहा था, सिवाय इसके कि . डिफॉल्ट से लेकर .. ताकि यह टूट न जाए।

क्षमा करें, मुझे फिर से पढ़ना चाहिए!

लेकिन मुझे लगता है कि . .. डिफ़ॉल्ट रूप से डिफ़ॉल्ट रूप से अच्छा नहीं हो सकता है (इसके अलावा यह टूट रहा है), क्योंकि यह डेवलपर पर एक निर्णय लेने के लिए मजबूर करेगा कि सार्वजनिक एपीआई क्या है और क्या नहीं। इसके अलावा, अगर उपयोगकर्ता .. का उपयोग करता है तो वह अपेक्षा कर सकता है कि उसका कोड टूट सकता है, जबकि . नहीं होना चाहिए।

ये एक अच्छा बिंदु है। हम a.b डिफ़ॉल्ट a..b एक अवमूल्यन चेतावनी के साथ उस मार्ग पर जा सकते हैं।

शैली के नजरिए से, मुझे लगता है कि मैं बहुत कुछ देखना पसंद करूंगा

a = [1:10]
a.length()
a.size()

से

a.length
a.size

मुझे लगता है कि यह इस विचार को बनाए रखने में मदद करता है कि किसी संपत्ति को केवल किसी संपत्ति को वापस प्राप्त करने के बजाय बुलाया जा रहा है जो किसी प्रकार से संग्रहीत है (ऊपर "शुद्धता" चिंता के पीछे)। मुझे आश्चर्य है कि अगर इस तरह की शैली को सुनिश्चित करने में मदद करने का कोई तरीका है तो चीजें उतनी गन्दी नहीं होती हैं जितनी कि कुछ अन्य भाषाओं में।

मैं वास्तव में पसंद नहीं है

a.length()

तब से मैं यह नहीं बता सकता कि मूल प्रकार में कोई फ़ंक्शन फ़ील्ड था या नहीं। यदि . कभी भी खेतों तक नहीं पहुंचते हैं, तो जाहिर है कि यह कोई मुद्दा नहीं है। अन्यथा, यह मुझे भ्रमित लगता है।

एक प्राथमिकता, मुझे लगता है कि हमें a.length() या a.length नहीं करना चाहिए। लेकिन सवाल यह है कि क्यों? क्या r.step r.length से अलग है? क्या यह अलग है? यदि वे अलग नहीं हैं, तो क्या हमें step(r) और length(r) या r.step और r.length ?

स्टीफन द्वारा सुझाए गए शब्दार्थ और मेरे द्वारा जोड़ के साथ यह स्पष्ट होगा कि . हमेशा एक फ़ंक्शन कॉल है (जैसे + भी), जबकि .. हमेशा एक फ़ील्ड है पहुंच।

इस मुद्दे पर कि क्या a.length , आदि एक अच्छा विचार है: कैसे . उपयोग केवल प्रकार में वास्तविक डेटा तक पहुंचने के लिए किया जाना चाहिए, कमोबेश एक के रूप में एक प्रतिष्ठित की प्रविष्टियों का उपयोग करेगा । जबकि हम बिना डेटा वाले गुणों के लिए कार्य करते हैं, जैसे size , length , step आदि क्योंकि उनमें से कुछ को अतिरिक्त मापदंडों की आवश्यकता होगी और, मुझे लगता है, a.size(1) प्रकार का सिंटैक्स खराब है।

यहाँ मेरा इस विषय पर ले रहा है:

• डॉट सिंटैक्स का उपयोग केवल एक प्रकार / वर्ग की विशेषताओं के लिए किया जाना चाहिए। कृपया ध्यान रखें कि यह केवल गेटर्स के बारे में नहीं है, बल्कि बसने वाला भी है और a.property() = ... जैसा कुछ पूरी तरह से गलत लगता है।
• यद्यपि मुझे वर्तमान स्थिति पसंद है जहां फ़ंक्शन सार्वजनिक API को परिभाषित करता है और फ़ील्ड निजी होते हैं, मैं स्टीफ़न्स की राय साझा करता हूं कि सार्वजनिक एपीआई के लिए डॉट सिंटैक्स बहुत अच्छा है। लेकिन कृपया इसे सरल विशेषताओं तक सीमित रखें। a.length एक अच्छा उदाहरण है, a.size(1) नहीं क्योंकि इसे एक अतिरिक्त तर्क की आवश्यकता है।
• कृपया . डिफ़ॉल्ट को .. । जूलिया को एक बॉयलरप्लेट भाषा के रूप में नहीं जाना जाता है। इसे इस तरह से बनाए रखें

कृपया . डिफ़ॉल्ट को .. । जूलिया को एक बॉयलरप्लेट भाषा के रूप में नहीं जाना जाता है। इसे इस तरह से बनाए रखें

मैं इससे सहमत हूं। एक सिंथेटिक संपत्ति की स्थापना के लिए वाक्यविन्यास सिर्फ a.property = b , a.property() = b ।

निश्चित रूप से, मैं सिर्फ यह स्पष्ट करना चाहता था कि वाक्यविन्यास के रूप में a.property() अच्छा क्यों नहीं है

या अधिक स्पष्ट रूप से: डॉट सिंटैक्स के बारे में महत्वपूर्ण बात यह नहीं है कि कोई फ़ंक्शंस को प्रकार / वर्गों के साथ जोड़ सकता है, लेकिन इसकी गेटर्स / राइटर्स को अच्छे तरीके से लिखने की क्षमता है। और डेटा इनकैप्सुलेशन के लिए गेटर्स / सेटर महत्वपूर्ण हैं (इंटरफ़ेस को स्थिर रखें लेकिन कार्यान्वयन को बदलें)

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

यह रूबी को dsl की तरह सक्षम करेगा ...

amt = 1.dollar + 2.dollars + 3.dollars.20.cents 

लेकिन पागलों की तरह जावा के लिए तैयार रहें:

object.propert1.property2.property3 ....

बस कुछ विचार:

• मैं सबसे अधिक कुंजी के रूप में प्रतीक के साथ Dicts के लिए . सिंटैक्स चाहता हूं। d.key तब d[:key] का उपयोग करने के लिए इसका सिर्फ अच्छा है। लेकिन अंत में यह महत्वपूर्ण नहीं है।
• मुझे लगता है कि a->property a..property से बेहतर पढ़ता है। लेकिन फिर से यह उतना बड़ा सौदा नहीं है और मुझे नहीं पता कि यह जूलिया सिंटैक्स के साथ काम करेगा या नहीं।

@ याकूबपार्टमैन मैं असहमत हूं। एक शब्दकोश एक कंटेनर वस्तु है, कंटेनर वस्तुओं के लिए एपीआई obj [सूचकांक] या obj [कुंजी] है। अभी हमारे पास जूलिया में संपत्तियां नहीं होने के कारण, PyCall और OpenCL जैसी पुस्तकालयों में यह कार्यक्षमता प्रदान करने के लिए कंटेनर API ओवरलोडेड है। यह परिवर्तन कंटेनर API के भेद को मजबूत करने में मदद करता है क्योंकि यह अतिरिक्त कार्यक्षमता प्रदान करने के लिए अतिभारित नहीं होगा।

निजी क्षेत्रों के लिए a->property का उपयोग करना जूलिया; सी; से हैकर को दूर रखने का एक अच्छा तरीका होगा;

मुझे .. सिंटैक्स पसंद है।

a->property सिंटैक्स के लिए पहले से ही बोली जाती है - यह एक अनाम फ़ंक्शन है। हालांकि, a..b ऑपरेटर को कुछ समय के लिए पकड़ लिया गया है। कुछ ऐसे मामले हैं जहां आप कुछ ऐसा चाहते हैं जो तानाशाह जैसा हो लेकिन वैकल्पिक क्षेत्र बहुत सारे हों। इसके लिए गेटटर / सेटर सिंटैक्स का उपयोग करना तानाशाह इंडेक्सिंग सिंटैक्स की तुलना में अच्छा होगा।

"A-> प्रॉपर्टी सिंटैक्स के लिए पहले से ही बात की जाती है - यह एक गुमनाम फ़ंक्शन है।"

हां बिल्कुल। यह -> आसपास रिक्त स्थान के बिना ऐसा नहीं दिखता था।

एक स्टाइल गाइडलाइन के रूप में, उस संपत्ति (x) को केवल-पढ़ने के लिए उपयोग किए जाने वाले गुणों के लिए अनुशंसित करने के बारे में और x.property को पढ़ने / लिखने के गुणों के लिए कैसे उपयोग किया जाए?

लिखने योग्य गुणों के लिए, x.foo = बार वास्तव में set_foo की तुलना में बहुत अच्छा है! (X, बार)।

पढ़ने के लिए foo(x) होने और लिखने के लिए x.foo काफी भ्रामक है। वास्तव में यही वह गुण है जो इतना आकर्षक बनाता है। पढ़ने और लिखने के लिए एक ही वाक्यविन्यास होने, यानी सबसे सरल वाक्यविन्यास (गेटर्स और सेटर्स के लिए) मिल सकता है

शैली के बारे में बड़ा सवाल है कि क्या हम दोनों x.length और length(x) यदि यह सुविधा लागू हो जाती है या बाद के फ़ॉर्म को हटा दिया जाना चाहिए या हटा दिया जाना चाहिए।

मेरी राय है कि हमें इसे करने का केवल एक तरीका होना चाहिए और भविष्य में केवल x.length का उपयोग करना चाहिए। और शैली के बारे में मुझे लगता है कि यह काफी सरल है। फ़ील्ड सिंटैक्स का उपयोग करके वह सब कुछ जो एक प्रकार की एक साधारण संपत्ति है, को लागू किया जाना चाहिए। कार्यों के साथ सब कुछ। मैंने C # में बहुत से गुणों का उपयोग किया है और शायद ही कभी ऐसा मामला पाया गया जहां मैं अनिश्चित था कि कुछ संपत्ति होनी चाहिए या नहीं।

मैं 1-तर्क कार्यों के यादृच्छिक रूप से चुने गए सेट को x.f सिंटैक्स में बदलने के खिलाफ हूं। मुझे लगता है कि @ मौरो 3 ने एक अच्छी बात की कि ऐसा करने से भाषा की प्रकृति

a.b , कम से कम नेत्रहीन, एक स्कूपिंग निर्माण का प्रकार है। b विश्व स्तर पर दृश्यमान पहचानकर्ता होने की आवश्यकता नहीं है। यह एक महत्वपूर्ण अंतर है। उदाहरण के लिए, ऊपरी हिस्से के साथ मैट्रिक्स फैक्टरिज़ेशन में .U संपत्ति होती है, लेकिन यह वास्तव में एक सामान्य बात नहीं है --- हम एक वैश्विक फ़ंक्शन U नहीं चाहते हैं। बेशक यह थोड़ा व्यक्तिपरक है, खासकर जब से आप U(x) = x.U आसानी से परिभाषित कर सकते हैं। लेकिन length एक अलग तरह की चीज है। प्रथम श्रेणी (जैसे map(length, lst) ) होना इसके लिए अधिक उपयोगी है।

यहां वे दिशानिर्देश हैं जो मैं सुझाऊंगा। foo.bar अंकन उचित है जब:

1. foo वास्तव में bar नाम वाला क्षेत्र है। उदाहरण: (1:10).start ।
2. foo संबंधित प्रकारों के समूह का एक उदाहरण है, जिनमें से कुछ का वास्तव में .bar नाम का क्षेत्र है; यहां तक ​​कि अगर foo वास्तव में bar फ़ील्ड नहीं है, तो उस फ़ील्ड का मूल्य इस प्रकार से निहित है। उदाहरण: (1:10).step , (0.1:0.1:0.3).step ।
3. यद्यपि foo स्पष्ट रूप से bar स्टोर नहीं करता है, यह समान जानकारी को अधिक कॉम्पैक्ट या कुशल रूप में संग्रहीत करता है जो उपयोग करने के लिए कम सुविधाजनक है। उदाहरण: lufact(rand(5,5)).U ।
4. आप पायथन या जावा जैसे किसी अन्य से एक एपीआई का अनुकरण कर रहे हैं।

यह bar प्रॉपर्टी के लिए 1 और 3 मामलों में असाइन करने योग्य हो सकता है, लेकिन 2 नहीं। केस 2 में, चूंकि आप मूल्य के प्रकार को नहीं बदल सकते हैं, आप bar प्रॉपर्टी को म्यूट नहीं कर सकते हैं यह उस प्रकार से निहित है। ऐसे मामलों में, आप संभवतः bar अन्य संबंधित प्रकारों की संपत्ति को अस्वीकार करना चाहते हैं, या तो उन्हें अपरिवर्तनीय बनाकर या स्पष्ट रूप से foo.bar = baz एक त्रुटि बनाकर।

@tknopp , मैं लिखने के लिए x.foo का उपयोग करने का सुझाव नहीं दे रहा था और पढ़ने के लिए foo(x) । मेरा सुझाव था कि _if_ एक संपत्ति पठनीय और लिखने योग्य है, तो शायद आप _both_ को x.foo साथ पढ़ना और लिखना चाहते हैं।

@StefanKarpinski : लेकिन length का मामला नहीं है। 3. जहाँ आकार आमतौर पर संग्रहीत होते हैं और length आकारों का उत्पाद होता है?

मैं जेफ को इस बिंदु पर देखता हूं कि यह परिवर्तन इन कार्यों को प्रथम श्रेणी में नहीं लाएगा।

@stevengj : मैं देख रहा हूं। यह भ्रमित करने के लिए क्षमा करें।

@ टेकनोप - लंबाई आकारों से ली गई है, लेकिन उनके समकक्ष नहीं है। यदि आप आकार जानते हैं तो आप लंबाई की गणना कर सकते हैं लेकिन इसके विपरीत नहीं। बेशक, यह एक धुंधली रेखा का एक सा है। यह lufact लिए स्वीकार्य है इसका मुख्य कारण यह है कि हमने इससे बेहतर एपीआई का पता नहीं लगाया है। एक और दृष्टिकोण upper और lower सामान्य कार्यों को परिभाषित करना होगा जो सामान्य मैट्रिक्स के ऊपरी-त्रिकोणीय और निचले-त्रिकोणीय भागों को देते हैं। हालांकि, यह दृष्टिकोण उदाहरण के लिए, क्यूआर फैक्टरशिप के लिए सामान्यीकृत नहीं है।

यह बता रहा है कि कुछ ही मामले हैं जो _really_ इस सिंटैक्स के लिए पूछते हैं: pycall, factorifications, और शायद डेटाफ्रेम।
मैं f(x) बनाम x.f यादृच्छिक रंबल के साथ समाप्त होने के बारे में काफी चिंतित हूं; यह प्रणाली को सीखने के लिए बहुत कठिन बना देगा।

क्या @StefanKarpinski की सूची का 1 मतलब यह नहीं है कि किसी प्रकार का कोई भी क्षेत्र स्वतः ही सार्वजनिक एपीआई से संबंधित है?

फिलहाल मैं बता सकता हूं कि एक मॉड्यूल का सार्वजनिक एपीआई क्या है: सभी निर्यात किए गए कार्य और प्रकार (लेकिन उनके क्षेत्र नहीं)। इस परिवर्तन के बाद, यह बताना संभव नहीं होगा कि कौन से क्षेत्र सार्वजनिक एपीआई से संबंधित हैं और कौन से नहीं। हम निजी क्षेत्रों को a._foo या तो नाम देना शुरू कर सकते हैं, जैसे कि अजगर में, लेकिन यह इतना अच्छा नहीं लगता है।

व्यक्तिगत रूप से मुझे लगता है कि डेटाफ्रेम का मामला थोड़ा बहुत कम है। यदि हम ऐसा करते हैं, तो मैं DataFrames में कार्यक्षमता जोड़ूंगा, लेकिन मुझे कुछ वर्णों को सहेजने की तुलना में स्थिरता की हानि अधिक परेशान करती है।

मैं यह निर्णय डेटाफ्रेम, PyCall (और Gtk यह भी चाहता है) पर निर्भर नहीं करेगा। या तो हम यह चाहते हैं क्योंकि हमें लगता है कि खेतों को एक सार्वजनिक इंटरफ़ेस का हिस्सा होना चाहिए (क्योंकि यह "अच्छा लग रहा है") या हम इसे नहीं चाहते हैं।

... pycall ...

और JavaCall

इसके लिए मुख्य उपयोग के मामले गैर जूलिया प्रणाली, क्या प्रस्तावित उपयोग के बारे में के साथ बातचीत हो रहा है के बाद से .. ऑपरेटर के बजाय अधिक भार . ?

मुझे आश्चर्य है कि अगर यहां एक सरल समाधान OO के लिए एक अधिक सामान्य हैट-टिप है:

#we already do
A[b] => getindex(A,b)
#we could have
A.b(args...) => b(A, args...)
# while
A..b => getfield(A,::Field{:b})
# with default
getfield(A, ::Field{:b}) = getfield(A, :b)

ऐसा लगता है कि यह JavaCall / PyCall को "परिभाषाओं" को "कक्षाओं" में करने की अनुमति देगा, जबकि एक सामान्य शैली की अनुमति भी यदि लोग कुछ OO प्रकार का कोड चाहते हैं, हालांकि यह बहुत पारदर्शी A.b() केवल एक पुनर्लेखन है। मुझे लगता है कि OO से आने वाले लोगों के लिए यह बहुत स्वाभाविक होगा।
ओवरलोडिंग की अनुमति देने के लिए नए getfield A..b , हालांकि यहां ओवरलोडिंग को दृढ़ता से हतोत्साहित किया जाता है और केवल फ़ील्ड-जैसे / गुणों के लिए उपयोग किया जाता है (मुझे संदेह है कि यह बहुत व्यापक रूप से उपयोग नहीं किया जाएगा। getfield(A, ::Field{:field}) की ओवरलोडिंग की थोड़ी-सी कमी के कारण।

@ मौरो 3 :

क्या @StefanKarpinski की सूची का 1 मतलब यह नहीं है कि किसी प्रकार का कोई भी क्षेत्र स्वतः ही सार्वजनिक एपीआई से संबंधित है?

यह एक सूची थी जब foo.bar संकेतन का उपयोग करना ठीक है, जब यह आवश्यक न हो। आप "निजी" फ़ील्ड के लिए foo.bar नोटेशन को अक्षम कर सकते हैं, जो तब foo..bar माध्यम से सुलभ होगा।

@karbarcca : आप यहां जो प्रस्ताव दे रहे हैं, मैं उस पर स्पष्ट नहीं हूं।

fwiw, मैं कंसेंट-एडल्ट्स-बाय-कन्वेंशन अप्रोच लेने और . पूरी तरह से ओवरलोड करने का प्रशंसक हूं। मुझे लगता है कि डबल-डॉट प्रस्ताव कम होने के बजाय अधिक भ्रम पैदा करेगा।

@ आईनॉर्टन - जैसा कि आप फील्ड एक्सेस के लिए a..b ( a..b का उपयोग करने के खिलाफ हैं?

जूलिया की सबसे अच्छी विशेषताओं में से एक इसकी सादगी है। ओवरलोडिंग x.y सड़क पर सी ++ के पहले कदम की तरह लगता है।

@StefanKarpinski लेकिन तब इसका मतलब होता है डिफ़ॉल्ट निजी क्षेत्रों से डिफ़ॉल्ट सार्वजनिक क्षेत्रों के प्रतिमान में बदलाव।

एक अहसास जो मुझे अभी हुआ था, शायद यह दूसरों के साथ स्पष्ट था। पूर्ण OO- शैली की प्रोग्रामिंग मूल . -प्रभार के साथ की जा सकती है (यद्यपि यह बदसूरत है)। परिभाषित

getfield(x::MyType, ::Field{:foo}) = args -> foofun(x, args...) # a method, i.e. returns a function
getfield(x::MyType, ::Field{:bar}) = x..bar+2                  # field access, i.e. returns a value

तब x.foo(a,b) और x.bar काम। तो इस बात पर चर्चा कि क्या x.size(1) लागू होना चाहिए या केवल x.size मूट है।

@StefanKarpinski आमतौर पर अधिभार a..b और गुनगुना a..b -> Core.getfield(a,b) खिलाफ।

मैं यहां एक और ऑपरेटर की आवश्यकता को देखना शुरू करता हूं, लेकिन a..b काफी आश्वस्त नहीं है। दो पात्रों की आवश्यकता बहुत महसूस होती है ... द्वितीय श्रेणी। हो सकता है कि a@b , a$b , या a|b (बिटवाइज़ ऑपरेटर्स बस अक्सर उपयोग नहीं किए जाते हैं)। एक बाहरी संभावना भी a b` है, जो शायद पार्सर आदेशों से अलग कर सकता है।

मैं आदिम क्षेत्र पहुंच के लिए "बदसूरत" ऑपरेटर का उपयोग करके ठीक होगा। मुझे लगता है कि अनुभव से पता चला है कि चूंकि यह एक ठोस ऑपरेशन है, यह शायद ही कभी उपयोग किया जाता है, और वास्तव में उपयोग करने के लिए कुछ हद तक खतरनाक है।

मैं सुझाव दे रहा हूं कि सम्मेलन / पुनर्लेखन द्वारा OO एकल प्रेषण का अनुकरण करने की अनुमति:

type Type end
# I can define methods with my Type as 1st argument
method(T, args...) = # method body
t = Type()
# then I can call that method, exactly like Java/Python methods, via:
t.method(args...)
# so
t.method(args...) 
# is just a rewrite to
method(t, args...)

यहाँ औचित्य है कि हम पहले से ही getindex / setindex के लिए इसी तरह के सिंटैक्स रीराइट करते हैं!, तो चलिए इसके साथ पूर्ण OO सिंटैक्स की अनुमति देते हैं। इस तरह, PyCall और JavaCall को नहीं करना है

my_dna[:find]("ACT")
# they can do
my_dna.find("ACT")
# by defining the appropriate find( ::PyObject, args...) method when importing modules from Python/Java

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

मैं तब ओवरलोड करने के विकल्प के साथ, फ़ील्ड एक्सेस के लिए .. ऑपरेटर के उपयोग का सुझाव दे रहा था। यहाँ उपयोग PyCall / JavaCall को .. से अधिक कॉल द्वारा फ़ील्ड एक्सेस का अनुकरण करने की अनुमति देगा, DataFrames को कॉलम एक्सेस के लिए .. अधिभार की अनुमति देगा, यह भी नया डिफ़ॉल्ट फ़ील्ड एक्सेस होगा। किसी भी प्रकार के लिए सामान्य।

मेरे पास शुद्ध वाक्यविन्यास पुनर्लेखन के लिए एक नरम स्थान है। यकीनन यह एक बुरी बात है कि आप a.f(x) अभी लिख सकते हैं और यह काम कर सकता है लेकिन इसका मतलब है कि अधिकांश OO भाषाओं की तुलना में कुछ अलग है।

बेशक उस सिक्के का दूसरा पहलू भयानक शैली का विखंडन है, और यह तथ्य कि a.f a.f() साथ आम तौर पर कुछ भी नहीं है, जिससे भ्रम जल्दी से टूट जाता है।

जूलिया की सबसे अच्छी विशेषताओं में से एक इसकी सादगी है। ओवरलोडिंग x.y सड़क पर सी ++ के पहले कदम की तरह लगता है।

यहाँ वही महसूस कर रहा है। मैं विचार कर रहा था, अगर इसके लिए वास्तविक आवश्यकता सीमित संख्या में इंटरोप प्रकारों के लिए है, तो केवल स्पष्ट रूप से टाइप घोषणा में पूछे जाने पर इसे वैध बनाने के बारे में क्या? उदाहरण के लिए type और immutable ootype या कुछ और हो सकता है।

और यह तथ्य कि af के साथ कुछ भी सामान्य नहीं है (), जिससे भ्रम जल्दी टूट जाता है।

क्या आप स्पष्ट कर सकते हैं कि इसका मतलब @JeffBezanson क्या है?

मैं उम्मीद थी कि a.f विधि वस्तु है, तो किसी तरह का है a.f() काम करता है।

आह, समझ गया। हाँ, आप निश्चित रूप से map(t.method,collection) जैसा कुछ नहीं कर पाएंगे।

मैं @ mauro3 के साथ सहमत होने जा रहा हूं कि obj.method(...) अनुमति देकर, एक जोखिम है कि नए उपयोगकर्ता जूलिया को केवल एक अन्य ऑब्जेक्ट-ओरिएंटेड भाषा के रूप में देख सकते हैं जो अजगर, रूबी आदि के साथ प्रतिस्पर्धा करने की कोशिश कर रहा है, और पूरी तरह से सराहना नहीं करता है। बहु-प्रेषण जो अशुभ है। अन्य जोखिम यह है कि मानक ऊ शैली तब प्रमुख हो जाती है, क्योंकि यह वही है जिससे उपयोगकर्ता अधिक परिचित होते हैं, क्योंकि अब तक विकसित अधिक जूलियन शैली के विपरीत।

चूंकि उपयोग का मामला, डेटाफ्रैम्स के अलावा, ओओ भाषाओं के साथ अंतर-ऑप तक सीमित है, क्या यह सब मैक्रोज़ द्वारा नियंत्रित किया जा सकता है? यानी <strong i="8">@oo</strong> obj.method(a) method(obj,a) हो जाता है?

@karbarcca का अर्थ यह होगा कि स्वचालित रूप से सब कुछ दो तरह से लिखा जा सकता है:

x = 3
x.sin()
sin(x)
x + 2
x.+(2) # ?!

@karbarcca https://github.com/JuliaLang/julia/issues/1974#issuecomment -38830330

t.method (args ...)
# बस फिर से लिखना है
विधि (टी, आर्ग ...)

PyCall के लिए यह आवश्यक नहीं होगा क्योंकि अधिभार डॉट को सिर्फ pyobj[:func] pyobj.func कॉल करने के लिए उपयोग किया जा सकता है। तब pyobj.func() वास्तव में (pyobj.func)() ।

a.foo(x) foo(a, x) के रूप में पुनर्व्यवस्थित करने से PyCall के लिए समस्या का समाधान नहीं होगा, क्योंकि foo नहीं है और एक जूलिया विधि नहीं हो सकती है, यह कुछ ऐसा है जो मुझे रनटाइम के दौरान गतिशील रूप से देखने की आवश्यकता है । मुझे a.foo(x) getfield(a, Field{:foo})(x) या getfield(a, Field{:foo}, x) ] के रूप में फिर से लिखना होगा ताकि मेरा getfield{S}(::PyObject, ::Type{Field{S}}) सही काम कर सके।

@JeffBezanson https://github.com/JuliaLang/julia/issues/1974#issuecomment -38837755

मैं यहां एक और ऑपरेटर की आवश्यकता को देखना शुरू करता हूं, लेकिन a..b काफी आश्वस्त नहीं है। दो पात्रों की आवश्यकता बहुत महसूस होती है ... द्वितीय श्रेणी

मैं कहूंगा कि, दूसरी तरफ, .. $ , @ या | तुलना में बहुत तेज़ी से टाइप किया जाता है क्योंकि किसी भी शिफ्ट कुंजी को दबाने की आवश्यकता नहीं है। , और दो अक्षर होते हुए भी उंगली एक ही कुंजी पर रहती है: मुस्कान:

@stevengj आह, मैं देख रहा हूं। लेकिन मेरी बात अब भी कायम है, कि पुनर्लेखन एक स्थूल के साथ किया जा सकता है।

JavaCall के लिए, मुझे वास्तव में केवल अज्ञात रूप से हैंडलर की आवश्यकता है। मुझे वास्तव में मौजूदा संपत्ति को पढ़ने या लिखने के लिए फिर से लिखने या अवरोधन करने की आवश्यकता नहीं है। तो क्या एक नियम है कि "कुल्हाड़ी फिर से लिखी जाती है फ़ील्ड के लिए (ए,: एक्स) केवल तब होती है जब एक्स एक मौजूदा संपत्ति नहीं है" चीजों को रखने में मदद करें?

@simonbyrne , मैक्रो की आवश्यकता स्वच्छ और पारदर्शी इंटरलेंजेज कॉलिंग की इच्छा को पराजित करेगा। इसके अलावा, यह मज़बूती से काम करना मुश्किल होगा। उदाहरण के लिए, मान लें कि आपके पास type Foo; p::PyObject; end , और किसी वस्तु f::Foo आप foo.p.bar करना चाहते हैं, जहाँ bar पायथन प्रॉपर्टी लुकअप है। यह एक ऐसे मैक्रो की कल्पना करना कठिन है जो मज़बूती से दो डॉट्स के अर्थों को foo.p.bar ।

ईमानदारी से, मैं शैली के साथ बड़ी बात नहीं देखता। उच्च-गुणवत्ता वाले पैकेज Base और अन्य पैकेजों की शैली की नकल करेंगे जहां संभव हो, और कुछ लोग अजीब कोड लिखेंगे चाहे हम कुछ भी करें। यदि हम मैनुअल के बाद के भाग में डॉट ओवरलोडिंग करते हैं, और केवल कुछ सावधानी से चयनित मामलों में इसके उपयोग की सलाह देते हैं (जैसे अंतर-भाषा अंतर, पढ़ने / लिखने के गुण, शायद factor.U जैसी चीजों के लिए नाम स्थान प्रदूषण से बचने के लिए) , और सामान्य रूप से foo[:bar] ) के लिए एक क्लीनर विकल्प के रूप में, तो मुझे नहीं लगता कि हम हर चीज के साथ डॉट का उपयोग करते हुए पैकेजों से आगे निकल जाएंगे। मुख्य बात यह तय करना है कि इसके लिए _we_ क्या उपयोग करेगा और इसकी सिफारिश करेगा, और शायद हमें अनुशंसित उपयोगों की सूची को बहुत कम रखना चाहिए और केवल इसका विस्तार करना चाहिए क्योंकि वास्तविक दुनिया की आवश्यकताएं उत्पन्न होती हैं।

हम type Foo; bar(...) = ....; end लिए foo.bar(...) जैसे सुपर-आसान OO- जैसे सिंटैक्स नहीं जोड़ रहे हैं, जिससे कि newbies के लिए भी प्रलोभन सीमित हो जाएगा।

मैं मूल रूप से @stevengj के साथ पूर्ण सहमति में a..b क्योंकि यह

1. a.b समान दिखता है
2. कम सुविधाजनक है, जैसा कि यह होना चाहिए
3. केवल _slightly_ कम सुविधाजनक है
4. इसका कोई मौजूदा अर्थ नहीं है और हमने एक वर्ष से अधिक समय में इसके लिए कोई सम्मोहक उपयोग नहीं किया है
5. a b` जैसे भयानक रूप से अजीब नहीं है

इस परिवर्तन के साथ और संभवतः (https://github.com/JuliaLang/julia/issues/2403) जूलिया के लगभग सभी वाक्य ओवरलोड हो जाएंगे? (टर्नरी ऑपरेटर एकमात्र अपवाद है जिसके बारे में मैं सोच सकता हूं) कि लगभग सभी सिंटैक्स को ओवरलोड करने योग्य विधि प्रेषण के लिए उतारा गया है जो मुझे एक दृढ़ता से एकीकृत करने वाली विशेषता लगती है।

मैं मानता हूं कि यह वास्तव में एक सरलीकरण है। टर्नेरी ऑपरेटर और && और || वास्तव में नियंत्रण प्रवाह है, इसलिए यह अलग है। बेशक, उस समय के बाद से a..b वास्तविक क्षेत्र तक पहुँच बनाने के खिलाफ इस तरह का तर्क है कि _that_ केवल गैर-अधिभार सिंटैक्स होगा। लेकिन मुझे अभी भी लगता है कि यह एक अच्छा विचार है। संगति अच्छी है लेकिन अपने लिए सर्वोपरि नहीं।

ओह, फंक्शन कॉल भी है जो ओवरलोड करने योग्य नहीं है। इसलिए बुनियादी मैं इसके बारे में भूल गया।

यही समस्या # 2403 पते की है।

हां। लेकिन यह होने की तुलना में बहुत करीब है।

मेरे लिए यहाँ मरहम में केवल मक्खी यह है कि मॉड्यूल के लिए वास्तविक फ़ील्ड एक्सेस ऑपरेटर का उपयोग करना वास्तव में अच्छा होगा, लेकिन शायद ऐसा नहीं होगा क्योंकि कोई भी Package..foo लिखना नहीं चाहता है।

डॉट्स के बाद टैब-पूरा करना थोड़ा बदसूरत हो जाता है; तकनीकी रूप से आपको यह जांचना होगा कि क्या विधि x. यह देखने के लिए कॉल कर सकती है कि क्या यह ऑब्जेक्ट फ़ील्ड नामों या मॉड्यूल नामों को सूचीबद्ध करने के लिए उपयुक्त है। और मुझे आशा है कि कोई भी getfield(::Module, ...) को परिभाषित करने की कोशिश नहीं करेगा।

मुझे लगता है कि टैब को पूरा करने का काम इस तरह किया जा सकता है: foo.<tab> "सार्वजनिक क्षेत्र" और foo..<tab> "निजी क्षेत्रों" को सूचीबद्ध करता है। मॉड्यूल के लिए, यह ठीक हो बस के डिफ़ॉल्ट कार्यान्वयन की अनुमति के लिए होगा Mod.foo हो Mod..foo और बस को getfield विधियां न जोड़ना लोगों को बता Module ? मेरा मतलब है, आप पहले से ही पूर्णांक जोड़ को भाषा में फिर से परिभाषित कर सकते हैं - सभी नरक ढीले हो जाते हैं और आपको एक segfault मिलता है, लेकिन हम इसे रोकने की कोशिश नहीं करते हैं। यह इससे भी बदतर नहीं हो सकता है?

यह वास्तव में उससे थोड़ा खराब है, क्योंकि एक प्रोग्रामिंग भाषा वास्तव में केवल नामकरण की परवाह करती है। पूर्णांक जोड़ने की तुलना में नामों को हल करना बहुत अधिक महत्वपूर्ण है।

हमारे पास Mod.foo डिफ़ॉल्ट Mod..foo , लेकिन हमें संभवतः कुछ स्थानों पर बूटस्ट्रैपिंग के लिए Mod..foo का उपयोग करना होगा। .. ऑपरेटर यहां अत्यंत उपयोगी है, क्योंकि इसके बिना आप कॉलबैक को परिभाषित करने के लिए Core.getfield भी कॉल नहीं कर सकते। इसके साथ, हम संभवतः Core.getfield निकाल देंगे और केवल .. ।

यह एक उचित बिंदु है - नामकरण प्रोग्रामिंग में एक बड़ी बात है :-)। जाने के लिए एक अच्छा तरीका लगता है - केवल .. और Core.getfield ।

यह दो विचार,

[...] नियमावली के बाद के भाग में डॉट ओवरलोडिंग डालते हैं, और कुछ सावधानी से चयनित मामलों में ही इसके उपयोग की सलाह देते हैं @stevengj https://github.com/JuliaLang/julia/issues/1974#issuecument -38847340

तथा

[...] वरीयता तक संभव हो, के लिए उपयोग x.property वाक्य रचना होना चाहिए @StefanKarpinski https://github.com/JuliaLang/julia/issues/1974#issuecomment -+३,८६,९४,८८५

स्पष्ट रूप से विरोध कर रहे हैं।

मुझे लगता है कि यदि पहला विचार चुना जाना है, तो बस उन "सावधानीपूर्वक चयनित मामलों" के लिए एक नया .. ऑपरेटर बनाना अधिक समझ में आता है।
लाभ, का उपयोग कर के रूप में ..name मामलों में जहां वर्तमान के लिए [:name] प्रयोग किया जाता है (DataFrames, Dict {प्रतीक, ...}) होगा और अधिक टाइपिंग / वाक्य रचना अनुकूल है, जबकि स्पष्ट रूप से क्षेत्र का उपयोग से कि कुछ अलग करते हुए कहा हो रहा था। इसके अलावा, ..name में डबल डॉट को एक घुमाया हुआ बृहदान्त्र के रूप में देखा जा सकता है, प्रतीक वाक्यविन्यास :name लिए एक संकेत है, और साथ ही टैब पूर्णता के साथ कोई समस्या नहीं होगी।
नुकसान के रूप में, PyCall एट अल में उपयोग करता है। मूल सिंटैक्स के इतना करीब नहीं होगा (और उन मामलों के लिए भी भ्रमित हो सकता है जब . वास्तव में उपयोग किया जाना चाहिए)। लेकिन चलो ईमानदार होना चाहिए, जूलिया पूरी तरह से पायथन सिंटैक्स संगत नहीं होगी, और हमेशा ऐसे मामले होंगे जहां एक को जूलिया में बहुत अधिक टाइप करना पड़ता है क्योंकि पायथन में अन्यथा सरल निर्देश देने के लिए पाइकॉल के साथ। .. . का अनुकरण करने के लिए यहाँ एक अच्छा संतुलन दे सकता है। (कृपया मुझे गलत न समझें, मैं वास्तव में PyCall को पसंद करता हूं और सोचता हूं कि यह एक महत्वपूर्ण विशेषता है जो विशेष देखभाल के योग्य है)

दूसरी विचारधारा, जिसे मैं वर्तमान में पसंद करता हूं, के बारे में बड़ा फैसला है जब property(x) या x.property का उपयोग किया जाना चाहिए, जिसके लिए एक सुरुचिपूर्ण, अच्छी तरह से और स्पष्ट परिभाषा की आवश्यकता होती है, अगर ऐसी बात मौजूद है .. ।
ऐसा लगता है कि अगर लोग एक अधिभार . चाहते हैं, क्योंकि वे x.property API शैली को पहले स्थान पर पसंद करते हैं।
वैसे भी, मैं . को एक अधिभार क्षेत्र अभिगम संचालक के रूप में नहीं, बल्कि एक अधिभार "संपत्ति" अभिगम संचालक ( getprop(a, Field{:foo}) शायद?) के रूप में देखना चाहता हूं, जो एक गैर-अधिभार योग्य संचालक .. लिए चूक करता है?
अन्य निर्णय भी लेने पड़ेंगे, जैसे, जो क्षेत्र के लिए ठोस कार्यान्वयन कोड में उपयोग किया जाएगा, .. या . ? उदाहरण के लिए, रेंज़ स्टेप उदाहरण के लिए, जो मुहावरेदार होगा? step(r::Range1) = one(r..start) या step(r::Range1) = one(r.start) ? (इस प्रश्न का उल्लेख नहीं करने के लिए कि क्या step एक विधि या संपत्ति होना चाहिए)।

इसलिए मैंने उस एंगल का समर्थन किया और इन मानदंडों को प्रस्तावित किया: https://github.com/JuliaLang/julia/issues/1974#issuecomment -38812139।

इस दिलचस्प सूत्र को पढ़ते हुए बस एक ही ख्याल आया कि मेरे सिर में खसखस ​​है। सार्वजनिक क्षेत्रों को घोषित करने के लिए निर्यात का उपयोग किया जा सकता है, जबकि सभी क्षेत्र परिभाषित मॉड्यूल के अंदर दिखाई देते हैं, उदाहरण के लिए:

module Foo
   type Person
     name
     age
   end
   export Person, Person.name
   <strong i="6">@property</strong> Person :age(person) = person..age + 1
end

इस स्थिति में निर्यात किया गया व्यक्ति अभी भी 'नाम' और 'उम्र' की तरह दिखता है, इस मामले को छोड़कर उम्र एक फ़ंक्शन के माध्यम से आसानी से होती है जो एक जोड़ता है। सभी व्यक्ति का निर्यात निर्यात व्यक्ति के रूप में किया जा सकता है। * या समान।

[पाओ: उद्धरण]

@emeseles कृपया जूलिया कोड जैसी चीज़ों को उद्धृत करने के लिए

. और .. भ्रमित हैं: सिंटैक्स को याद करने के लिए एक स्पष्ट और आसान कुछ अच्छा है

मैं वास्तव में यह करने में सक्षम होने के लिए तत्पर हूं। क्या इसे प्राप्त करने के लिए एक बड़ा पर्याप्त परिवर्तन है (या # 5848 में WIP) को 0.4-परियोजना के रूप में चिह्नित किया गया है?

हां, यह निश्चित रूप से एक परियोजना है।

मुझे लगता है कि हम में से अधिकांश इस बात से सहमत हैं कि इसके अनुशंसित उपयोग सीमित होने चाहिए, कम से कम शुरुआत के साथ। मेरी भावना यह है कि इसे शुरू में केवल दो उपयोगों के लिए अनुशंसित किया जाना चाहिए: अंतर्संचालनीयता (अन्य भाषाओं के साथ, जैसे कि PyCall में, और अधिक सामान्य रूप से बाहरी पुस्तकालयों के लिए जहां डॉट संकेतन स्वाभाविक है), और शायद उत्परिवर्ती राज्य वाली वस्तुओं के लिए ( get_foo(x) और set_foo!(x, val) बदसूरत हैं)।

यहां तक ​​कि अगर हम इसे केवल विदेशी-कॉल इंटरऑपरेबिलिटी के लिए सुझाते हैं, तो यह उद्देश्य अकेले मेरी राय में इस सुविधा को सही ठहराने के लिए पर्याप्त है। जूलिया जैसी नई भाषा के लिए, बाकी सॉफ्टवेयर ब्रह्मांड के साथ सहजता से बात करना बेहद महत्वपूर्ण है।

स्टीवन, मैं गटर / सेटर के बारे में 100% निश्चित नहीं हूं क्योंकि मुझे डर है कि यह जल्द ही विसंगतियों को जन्म देगा लेकिन मैं अन्य उपयोग के मामले से सहमत हूं। उस पर हम Gtk.jl गतिशील गुणों में है जो सिंटैक्स से भी लाभ होगा। मेरा व्यक्तिगत पसंदीदा enum कार्यान्वयन है जो स्टीफन # 5842 में उल्लिखित है।

टक्कर। इस मुद्दे पर प्रगति को क्या रोक रहा है? क्या एक निर्णय की आवश्यकता है, या यह मुद्दा अन्य आंतरिक परिवर्तनों पर निर्भर है, अभी तक नहीं किया गया है, या यह सिर्फ कोडिंग है?

इस मुद्दे पर प्रगति को क्या रोक रहा है?

कोई काम कर रहा है और कोई हिचकिचाहट है कि क्या यह सही काम है।

ध्यान दें कि @ihnorton ने पहले ही # 5848 में एक प्रारंभिक मसौदा कार्यान्वयन किया था। मुझे लगता है कि काम मुख्य रूप से ठप हो गया है क्योंकि जूलिया कोर टीम से एक स्पष्ट बयान की जरूरत है कि क्या यह एक वांछित विशेषता है।

मैं इस पर सवार हूं। @JeffBezanson बाड़ पर लगता है।

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

इस थ्रेड में हमारी यह चर्चा ऊपर थी और मैं अभी भी पूर्ण सहमति नहीं देख सकता। वर्तमान में कई लोग सोचते हैं कि एक सार्वजनिक एपीआई कार्यों / विधियों से बना होता है जबकि निजी एपीआई एक समग्र प्रकार के क्षेत्र होते हैं। मैं इस योजना से बहुत दुर्लभ अपवाद देख सकता हूं। (एलयू अपघटन में .U ?)

इसका मतलब यह नहीं है कि मैं इसके खिलाफ हूं क्योंकि पायथन एक्सेस और एनम ऐसे मामले हैं जहां यह उपयोगी है। फिर भी कोई यह सवाल कर सकता है कि यहां जरूरत कितनी जरूरी है और अगर यह एक चक्र के अंत में इसे आगे बढ़ाने के लिए बुद्धिमान होगा।

@ ufechner7 , मैं मानता हूं कि मुख्य प्रेरणा अंतर-भाषा इंटरोप है। @ टेकनोप , हम इस तरह की किसी चीज़ पर कभी भी एकमत नहीं होने जा रहे हैं। अंततः यह @JeffBezanson और @StefanKarpinski तय करते हैं।

मुझे लगता है कि जेफ के बुरे सपने आने की कल्पना से मुझे बहुत झिझक होती है:

module DotOrientedProgramming
  Base.getfield(x, ::Field{:size}) = size(x)
  Base.getfield(x, ::Field{:length}) = length(x)
  ⋮
end

मैं इसे बहुत नापसंद भी करूंगा - कोई भी पैकेज जो इसका दुरुपयोग करने का फैसला करता है, वह अपने दुरुपयोग को सिस्टम में _all_ प्रकारों पर लागू करेगा, जिसमें मेरा स्वयं भी शामिल है। यह सुविधा बहुत शक्तिशाली है और यह बदल देगी कि जूलिया को कैसे लिखा गया है। बेहतर और (शायद, लेकिन उम्मीद नहीं) बदतर के लिए।

हाँ यकीन है कि स्टीवन, कि मुझसे ठीक से बात नहीं की जा सकती है। मैं जो बात करना चाहता था वह यह है कि इस बदलाव का एक बड़ा प्रभाव हो सकता है कि भाषा कैसे विकसित होगी। और "औपचारिक इंटरफ़ेस" का विचार जो हमारे पास किसी अन्य मुद्दे में है, वह . अधिभार बनाने से भी प्रभावित होता है। तो हां @JeffBezanson और @StefanKarpinski निर्णय लेते हैं। फिर भी सवाल यह है कि क्या निर्णय अभी लागू किया जाना है ...

इसके लायक होने के लिए, मैं लगभग सभी वाक्यविन्यास को अधिभार देने के पक्ष में आया हूं और फिर संस्कृति पर भरोसा करते हुए इसके साथ बहुत अधिक जंगली होने का विरोध करने के लिए।

+1 । मुझे लगता है कि यहां call ओवरलोडिंग के अनुरूप एक मजबूत दार्शनिक (और संभवतः व्यावहारिक ...) है। मैनुअल को Don't do stupid stuff: we won't optimize that हकदार अनुभाग की आवश्यकता है। (बेशक, call ओवरलोडिंग आंशिक रूप से _for_ प्रदर्शन के कारण थे - लेकिन यह दुर्व्यवहार के साथ व्याप्त है)

• : 100: उस तक। मुझे लगता है कि संस्कृति को इसका दुरुपयोग न करने के लिए पर्याप्त प्रेरणा होनी चाहिए

कुल मिलाकर, मैं इसके पक्ष में हूं। दुरुपयोग के लिए संभावित मेरी सबसे बड़ी चिंता नहीं है। मेरे लिए बड़ी समस्याएं हैं

• "वास्तविक" फ़ील्ड एक्सेस के लिए स्वीकार्य सिंटैक्स। मुझे a..b इतना सब कुछ पसंद नहीं है।
• मॉड्यूल। योग्य नाम अत्यंत महत्वपूर्ण हैं। विधि प्रेषण के साथ उन्हें व्यक्त करना संभव है, लेकिन व्यावहारिक कठिनाइयां हैं। अर्थात्, आपको कई योग्य चरणों से गुजरना होगा (शायद इनलाइन के माध्यम से भी) बस यह जानने के लिए कि आपके पास एक योग्य नाम है। यह एएसटी की खपत करने वाले किसी भी उपकरण को लिखने के लिए जीवन कठिन बनाता है। इस तरह के टूल में इस केस को गलत तरीके से हैंडल करना भी बहुत आसान है।

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

इस सवाल पर मेरे दो सेंट: योग्य नामों के लिए : उपयोग क्यों न करें? यह पहले से ही समान कुछ के लिए उपयोग में है:

import Base: call, show, size

यह कुछ इस तरह देना होगा

module Foo
    module Bar
        f(x) = 3*x
    end
    const a = 42
end

<strong i="10">@assert</strong> Foo:a == 42

Foo:Bar:f(789)

या क्या उनका पहले से ही : प्रतीक का बहुत अधिक उपयोग है? :: प्रतीक (C ++ शैली) मेरे लिए बहुत अधिक क्रियात्मक लगता है।

: पहले से ही जूलिया में सबसे अधिक अतिभारित प्रतीक है, इसलिए यह मदद करने वाला नहीं है, मुझे डर है।

क्या हम module.name को अधिभार नहीं देकर योग्य नामकरण समस्या को सरल बना सकते हैं? चूँकि मॉड्यूल बाइंडिंग स्थिर होती है, जो हमें योग्य नाम के लुकअप के लिए सामान्य तर्क के समान ही शॉर्ट-सर्किट रखने की अनुमति देती है, जैसे ही यह ज्ञात होता है कि LHS a.b एक मॉड्यूल है। मुझे लगता है कि यह बहुत उचित है कि लोगों को एक मॉड्यूल में एक नाम को देखने के लिए ओवरराइड करने की अनुमति न दें।

मुझे वास्तविक फ़ील्ड एक्सेस के लिए a..b सिंटैक्स पसंद है। इसमें आपको क्या आपत्ति है?

एक तरफ: हम चाहते हैं कि हम कुछ कार्यात्मक भाषाओं की तरह आयात सूची के लिए ( ) साथ गए थे। अर्थात:

import Base (call, show, size)

मेरा कारण यह है कि हम अल्पविराम को वैकल्पिक बना सकते हैं और अनुगामी अल्पविराम की अनुमति दे सकते हैं। यह वास्तव में मुझे गुस्सा दिलाता है कि आयातित नामों में से सभी को पिछले एक को छोड़कर अन्य अल्पविरामों की आवश्यकता है जो एक नहीं हो सकता है।

हां, मैं a.b माध्य बनाने की संभावना का उल्लेख करने वाला था "यदि a एक मॉड्यूल है तो पहले मॉड्यूल लुकअप करें"। यह मदद कर सकता है, और हम निश्चित रूप से मॉड्यूल लुकअप के अर्थ को ओवरराइड नहीं करना चाहते हैं। हालांकि इसकी कुछ जटिलता लागत है, क्योंकि हम तब a.b कॉल getfield(a,:b) रूप में प्रतिनिधित्व नहीं कर सकते। यह एक अंतर्निहित शाखा के साथ एक विशेष एएसटी नोड होना चाहिए। बेशक हम एक _explicit_ शाखा का उपयोग कर सकते हैं, लेकिन मैं एएसटी ब्लॉट के बारे में चिंता करूंगा।

सामने के छोर और बैक एंड की जरूरतों के बीच इतने बड़े संघर्ष से बाहर निकलने का आसान तरीका नहीं है।

अगर हर कोई a..b पसंद करता है तो मुझे लगता है कि मैं इसके साथ रहना सीख सकता हूं। यह सिर्फ मुझे लगता है जैसे यह कुछ पूरी तरह से अलग मतलब है, एक अंतराल शायद।

मैं a..b को भी नापसंद करता हूं लेकिन आश्चर्य है कि आखिर इसकी आवश्यकता क्यों होगी। इस थ्रेड को पढ़ते समय किसी को यह आभास हो जाता है कि ओवरलोडिंग का उपयोग केवल भाषा के आवरण और गतिशील उपयोग के मामलों में किया जाएगा, जहां वास्तविक फ़ील्ड एक्सेस की आवश्यकता नहीं है।

क्योंकि कुछ बिंदु पर आपको इसके साथ कुछ भी करने के लिए किसी वस्तु के प्रतिनिधित्व तक पहुंचने की आवश्यकता होती है। कोई यह तर्क दे सकता है कि यह अपेक्षाकृत दुर्लभ होगा, और इसलिए यह get_actual_field(a,:x) तरह बदसूरत हो सकता है, लेकिन ऐसा लगता है कि सिंटैक्स न होने के लिए एक ऑपरेशन बहुत महत्वपूर्ण है।

मुझे लगता है कि लेकिन यह लगता है जैसे हम एक वाक्यविन्यास के लिए चाहते हैं हम सही उपयोग नहीं करना चाहते हैं?

.. प्रदान नहीं करना डायनामिक उपयोग के मामलों के लिए हां कहने का एक तरीका होगा, लेकिन डॉट-ओरिएंटेड प्रोग्रामिंग के लिए नहीं

मैं यह नहीं देखता कि डॉट-ओरिएंटेड प्रोग्रामिंग को कैसे रोका जाएगा; आप अभी भी ऊपर @mbauman का उदाहरण दे सकते हैं।

जबकि a..b सिंटैक्स एक अंतराल की तरह दिखता है (मैंने इसे इस तरह उपयोग किया है), मुझे नहीं लगता कि अंतराल अंकगणित को अपने स्वयं के इनपुट सिंटैक्स की आवश्यकता है - Interval(a,b) लिखना बस है ठीक है और किसी और के लिए उस वाक्यविन्यास का उपयोग नहीं करना चाहता है, क्योंकि यह जूलिया में एक ऑपरेटर के रूप में वर्षों से है और कोई भी किसी भी चीज़ के लिए इसका उपयोग नहीं कर रहा है। यह फील्ड एक्सेस की तरह भी दिखता है।

इसका एक सिल्वर लाइनिंग यह है कि हम घृणित module_name को m..name । मॉड्यूल वस्तुओं के क्षेत्रों तक पहुंचने में सक्षम नहीं होना एक मस्सा है।

हां, मैं a.b माध्य बनाने की संभावना का उल्लेख करने वाला था "यदि a एक मॉड्यूल है तो पहले मॉड्यूल लुकअप करें"। यह मदद कर सकता है, और हम निश्चित रूप से मॉड्यूल लुकअप के अर्थ को ओवरराइड नहीं करना चाहते हैं। हालांकि इसकी कुछ जटिलता लागत है, क्योंकि हम तब a.b कॉल getfield(a,:b) रूप में प्रतिनिधित्व नहीं कर सकते। यह एक अंतर्निहित शाखा के साथ एक विशेष एएसटी नोड होना चाहिए। बेशक हम एक _explicit_ शाखा का उपयोग कर सकते हैं, लेकिन मैं एएसटी ब्लॉट के बारे में चिंता करूंगा।

क्या हम a.b बिना शर्त मतलब getfield(a,:b) बना सकते हैं और फिर getfield getfield(::Module, ::Field) पद्धति को प्रतिच्छेद करने के लिए तरीकों को जोड़ने में त्रुटि कर रहे हैं? यह उस व्यवहार को लागू करने के लिए एक अजीब तरीके की तरह है, लेकिन यह अंततः एक ही प्रभाव होगा। तब कम करना केवल इस तथ्य का उपयोग कर सकता है कि हम जानते हैं कि आप योग्य नाम देखने के लिए module.name को धोखा देने और कम करने के लिए ऐसा नहीं कर सकते।

ठीक है, मैं इसे दूसरे तरीके से बताता हूं: क्या इस धागे में कोई भी .. का उपयोग करेगा और यदि हाँ तो एक अनुकरणीय उपयोग का मामला क्या होगा? (यानी पूरी तरह से आंतरिक क्षेत्र का उपयोग ठीक हो सकता है)

@StefanKarpinski हां, यह काम कर सकता है। एक और मामला हो सकता है जहाँ हम किसी प्रकार के "सील" तरीके चाहते हैं।

@tknopp एक्सेस module..name और module..parent :) इसके अलावा, बस स्पष्ट करने के लिए, क्या आप निम्न-स्तरीय फ़ील्ड एक्सेस के लिए get(obj,:field) जैसे फ़ंक्शन-कॉल सिंटैक्स की वकालत कर रहे हैं?

नहीं, मैं एक निश्चित वाक्य रचना की वकालत नहीं कर रहा हूँ। मुझे लगता है कि यह सुनिश्चित करना अच्छा होगा कि इस सुविधा की आवश्यकता क्यों है और उपयोग के मामले क्या हैं। गतिशील उपयोग के मामलों के लिए यह ठीक होगा

• a.b एक फ़ील्ड एक्सेस है यदि Base.getfield(a, ::Field{:b}) को परिभाषित नहीं किया गया है
• a.b गतिशील संस्करण है यदि Base.getfield(a, ::Field{:b}) परिभाषित किया गया है। इस मामले में वास्तविक क्षेत्र का उपयोग छाया हो सकता है

मेरा सवाल यह था कि क्या ऐसे मामले हैं जहां छायांकन ठीक नहीं है।

हाँ; आप pyobject.x को परिभाषित करना चाह सकते हैं ताकि x हमेशा pyobject के शब्दकोश में दिखाई दे, सभी x । तब pyobject के जूलिया खेतों तक पहुंचने के लिए एक अलग तंत्र की आवश्यकता होती है।

आह, तो इसके सभी या कुछ भी नहीं? मुझे किसी तरह आभास हुआ कि कोई भी हो सकता है

type A
  c
end

Base.getfield(a::A, ::Field{:b}) = 3

a = A(1)

a.c # This still calls the field access
a.b # This calls the function

हां, आप _can_ ऐसा करते हैं, लेकिन सभी ऑब्जेक्ट नहीं करेंगे। कुछ सभी क्षेत्रों को इंटरसेप्ट करने के लिए getfield(a::A, ::Field) को परिभाषित करना चाहेंगे।

ठीक है धन्यवाद अब मुझे मिल गया। सभी गतिशील उपयोग के मामले getfield(a::A, ::Field) चाहेंगे और इस प्रकार आंतरिक क्षेत्रों को कॉल करने के लिए किसी भी तरह की आवश्यकता होगी।

तब मेरा लेना यह है कि Core.getfield पर्याप्त है जब तक कोई व्यावहारिक उपयोग का मामला नहीं खोजता है जहां यह कष्टप्रद है।

यह शायद एक दिया गया है, लेकिन हम setfield! , सही ओवरराइड करने की भी अनुमति देने जा रहे हैं? मैं वास्तव में एक डेटाबेस में परस्पर विचारों को उजागर करने के लिए चाहूंगा जिसमें पंक्तियाँ टाइप हो जाती हैं।

हां, यह मेरी धारणा थी।

ठीक है, IMHO चाहे वास्तविक क्षेत्र पहुंच के लिए .. उपयोग करें या Core.getfield इतनी बड़ी बात नहीं है। कोई भी सामान्य सुविधा को प्रयोगात्मक के रूप में पेश कर सकता है और इस विषय को बदल सकता है।

सवाल यह है कि यह 0.4 के समय सीमा में फिट होगा या नहीं। तो यह अंतिम कार्यान्वयन के लिए # 5848 और मॉड्यूल योग्य बात है?

@johnmyleswhite : मैं इस सममिति को बनाने के लिए भी मतदान setfield! अनुमति भी दूंगा । Gtk.jl में हम दोनों का उपयोग करेंगे।

यह बहुत स्पष्ट प्रतीत नहीं होता है कि इस सुविधा का उपयोग करने के लिए नियम क्या होगा और इसका उपयोग कब नहीं किया जाएगा। मैं PyCall के लिए बिंदु देखता हूं, जहां एक विधि / क्षेत्र को गतिशील रूप से देखा जाना चाहिए, और इस तरह एक जूलिया विधि / समग्र प्रकार नहीं हो सकता है (और परिणामस्वरूप सिंटैक्स Python के करीब है)। लेकिन फिर, Gtk.jl के लिए इसका उपयोग क्यों करें? यह कर शुरू होता है foo.bar = x के बजाय setbar!(foo, x) , तो मानक जूलिया कोड invitably भी इस पद्धति का उपयोग कर शुरू कर देंगे: यह हम क्या चाहते है? हो सकता है कि यह हो, लेकिन इसके बारे में स्पष्ट होना चाहिए।

क्या संपत्ति प्राप्तकर्ताओं और अमूर्त (और ठोस भी) प्रकारों के लिए निर्धारित करने के लिए इस सुविधा का उपयोग करना स्वीकार्य / अनुशंसित होगा?
मुझे लगता है कि विभिन्न तरीकों के विभिन्न मॉड्यूल से गुण प्राप्त करने के लिए उपयोग किए जाने वाले तरीकों के नाम के टकराव से बचने की अनुमति होगी।

रेफरी .: https://github.com/JuliaLang/julia/issues/4345 , https://groups.google.com/forum/#!msg/julia -उपयोगकर्ताओं / पी 5-lVNlDC8U / 6PYcvvsg29UJ

@nalimilan : गेटर्स /

@tknopp आह, ठीक है, वास्तव में। लेकिन अधिकांश सामान्य गुणों के लिए आपके पास एक (तेज़) गेट्टर / सेटर फ़ंक्शन है, साथ ही डायनेमिक प्रॉपर्टी भी है। तो क्या आप उपलब्ध होने पर गेटटर / सेटर फ़ंक्शन का उपयोग करने की सलाह देंगे, और फ़ील्ड केवल उन गुणों के लिए सिंटैक्स को अधिभारित करेगा जिनके पास एक नहीं है? मेरे लिए ठीक लगता है - लेकिन इस IMHO के बारे में स्पष्ट नीति रखना अच्छा है।

इस बिंदु पर मेरे विचार में (और मुझे लगता है कि हमें सही नियमों का पता लगाने के लिए इसे थोड़ा प्रयोग करने की आवश्यकता है), f(x) बेहतर है जब f एक सामान्य स्टैंडअलोन अवधारणा के रूप में समझ में आता है " लंबाई "जबकि x.f का उपयोग तब किया जाना चाहिए जब f वास्तव में x स्वतंत्र न हो। मेरे पिछले उदाहरण को फिट करने की कोशिश करने के लिए, वास्तव में यह उपयोगी नहीं है कि सामान्य step कार्य हो क्योंकि अधिकांश वैक्टर और संग्रह में किसी भी प्रकार का कोई विचार नहीं है - यह आपके पास एक सीमा होने पर समझ में आता है। किसी तरह की। इस प्रकार, x.step होना एक सीमा x सीमा पाने का तरीका है। यह एक निर्णय कॉल का एक सा है, लेकिन मुझे लगता है कि जीवन उन से भरा है।

मुझे .. पसंद नहीं है क्योंकि यह मेरे लिए सीधी पहुँच नहीं देता है। कैसे foo.bar. अंत में अतिरिक्त बिंदु इसे सीधे पहुंच के लिए पिन करता है।

एक यूनिकोड का प्रतीक भी चुन सकते हैं: हमारे पास अभी भी बहुत सारे लोग बचे हैं ...

@GlenHertz , यदि आपके पास फ़ील्ड एक्सेस करने के लिए श्रृंखला है, तो यह वास्तव में काम नहीं करता है।

@simonbyrne , मैं आम तौर पर मुख्य भाषा या मानक पुस्तकालय में कुछ भी होने के खिलाफ हूं, जिसमें यूनिकोड के उपयोग की आवश्यकता होती है। इसकी अनुमति देना एक बात है, लोगों को इसका उपयोग करने के लिए मजबूर करना एक और पूरी तरह से है।

इस बिंदु पर मेरे विचार में (और मुझे लगता है कि हमें सही नियमों का पता लगाने के लिए इसे थोड़ा प्रयोग करने की आवश्यकता है), एफ (एक्स) बेहतर है जब एफ को सामान्य लंबाई की अवधारणा के रूप में समझ में आता है जैसे "लंबाई" जबकि एक्सएफ का उपयोग किया जाना चाहिए जब f वास्तव में x से स्वतंत्र नहीं है।

इस सुविधा का उपयोग करने के लिए मेरा व्यक्तिगत नियम है: केवल भाषा इंटरोप के लिए या ऐसी चीजों के लिए उपयोग करें जो "लगभग फ़ील्ड" या "संवर्धित फ़ील्ड" हैं। उदाहरण के लिए, मैं एक कैश को अद्यतन करने के लिए इसका उपयोग कर सकता हूं जो एक प्रकार के सभी क्षेत्रों के मूल्य पर निर्भर करता है।

इस सुविधा के बारे में मेरा एक बड़ा सवाल है: यह किस प्रकार के अनुमानों के साथ बातचीत करता है? ऐसा लगता है कि आप के बारे में परिभाषित करने के लिए कर रहे हैं एक समारोह getfield(x::T, s::Symbol) , जो भिन्न के विभिन्न मूल्यों के लिए उत्पादन टाइप किया उत्पादन s । क्या यह केवल इसलिए काम करता है क्योंकि getfield जादुई है? क्या आप किसी प्रोग्राम में किसी भी बिंदु पर getfield(x, s) निश्चित x और s के आउटपुट को फिर से परिभाषित कर सकते हैं? यदि हां, तो एक प्रकार को फिर से परिभाषित करने में असमर्थता के साथ वह मेष कैसे करता है?

ऐसा लगता है कि आप के बारे में परिभाषित करने के लिए कर रहे हैं एक समारोह getfield(x::T, s::Symbol) , जो भिन्न के विभिन्न मूल्यों के लिए उत्पादन टाइप किया उत्पादन s ।

इसीलिए इस योजना को getfield{s}(x::T, f::Field{s}) रूप में व्यक्त करना है जहाँ s एक प्रतीक है।

मुझे वह याद आ गया था। मुझे साफ - साफ समझाने के लिए धन्यवाद।

@nalimilan : हाँ, अतिभारित फ़ील्ड का उपयोग केवल गतिशील गुणों के लिए किया जाएगा। यह कैसे जेम्सन इससे निपटना चाहता है और मुझे लगता है कि यह अच्छा है। सभी वास्तविक गेटर्स और सेटर को ऑटोजेनरेटेड किया जाता है लेकिन फिर भी सभी प्राप्त / सेट नामकरण के बिना कार्य करते हैं। GAccessor मॉड्यूल (लघु G_ ) में लाइव

वाक्यविन्यास पर, वास्तविक फ़ील्ड एक्सेस के लिए <- उपयोग क्यों नहीं किया जाता है?
यह -> c ++ के समान है जो कि लामदास के लिए उपयोग में है लेकिन <- वर्तमान में अप्रयुक्त है।
इसे प्रकार से पढ़ा जा सकता है, सीधे मान प्राप्त करें।

यह छोड़ देगा .. अप्रयुक्त उन लोगों के लिए जो अभी भी अंतराल पर इसका उपयोग करना चाहते हैं और एक अप्रयुक्त जोड़ी का उपयोग कर रहे हैं जिसका कोई अन्य उपयोग नहीं है जो मैं अब तक सोच सकता हूं।

आइए फील्ड एक्सेस के लिए आर असाइनमेंट नोटेशन का उपयोग न करें।

हम संभवतः C> / C ++ को सीधे दर्पण में उपयोग कर सकते हैं और इसके लिए नया सिंटैक्स प्राप्त कर सकते हैं
अनाम फ़ंक्शन। अनाम समारोह की मुझे कभी परवाह नहीं है
वाक्यविन्यास क्योंकि यह थोड़ा उलट / अपठनीय है। शायद हम इसके बजाय कर सकते थे
कुछ इस तरह

func (x) x ^ 2 अंत

या लंबे समय तक, अधिक सुसंगत

फ़ंक्शन (x) x ^ 2 अंत

शायद वहाँ एक अच्छा वाक्यविन्यास है कि आवश्यकता नहीं है के साथ आने के लिए एक रास्ता होगा
एक अंत का उपयोग कर।

चर्चा को बहुत अधिक नहीं बदलना, लेकिन यह निश्चित रूप से समझ में आता है
वास्तविक फ़ील्ड एक्सेस के लिए -> का उपयोग करने के लिए।

बुध पर, 28 जनवरी, 2015 को 8:49 बजे, जॉन माइल्स व्हाइट नोटिफिकेशन @github.com
लिखा था:

आइए फील्ड एक्सेस के लिए आर असाइनमेंट नोटेशन का उपयोग न करें।

-
इस ईमेल का उत्तर सीधे दें या इसे GitHub पर देखें
https://github.com/JuliaLang/julia/issues/1974#issuecomment -71857083।

@quinnj : func (x) x^2 end पहले से ही काम करता है। लेकिन अनाम कार्यों के लिए बहुत संक्षिप्त वाक्यविन्यास करना अच्छा है: map(x->x^2, 1:10)

मुझे नहीं लगता कि फ़ील्ड एक्सेस को विशेष सिंटैक्स की जरूरत है (जैसा कि यूनिकोड वर्ण @simonbyrne ने सुझाव दिया है कि विकल्प के रूप में ठीक है)। मैं x -> x^2 खोना नहीं चाहूंगा।

ऐसा लगता है कि यह मुद्दा अभी भी खुला / लंबित चर्चा है? बिंदी ऑपरेटर के बारे में यहाँ विभिन्न टिप्पणियों को पढ़ने में दिलचस्प रहा।

क्या अन्य नए ऑपरेटर टोकन को जोड़ने के बारे में कोई सुझाव दिया गया है? :> जैसी किसी चीज़ का उपयोग करना एक अच्छा विकल्प हो सकता है। इसमें समानताएं |> और इसमें अधिक मूल जूलिया _feel_ हो सकता है:

c = foo.a + foo.b
pyobj:>obj:>process(c)

हालांकि अभी भी लिखने में बहुत आसान है:

pyobj[:obj][:procees](c)

या तुलना:

someobj :> array |> length 
# vs
length(get_array(someobj)) 

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

या वैकल्पिक रूप से, चूंकि मैं स्ट्रिंग इंटर्निंग और / या उद्धरण के बारे में भूल गया था:

someobj <: field_name |> length

@elcritch , <: का उपयोग वर्तमान में जूलिया के "उपप्रकार" ऑपरेटर के रूप में किया जाता है, और यदि :> को पेश किया जाता है तो संभावना है कि हम इसका उपयोग किसी प्रकार से संबंधित के लिए करना चाहेंगे। विरासत।

यदि instance..member का उपयोग करना एक समस्या है, तो यहां कुछ संभावनाएं हैं। अपनी आँखें ढालो! यह संभावना है कि इनमें से हर एक बदतर है:

• instance^.member (गाजर डॉट)
• instance~.member (टिल्ड डॉट)
• instance:.member (कोलन डॉट)
• instance*.member (स्टार डॉट)
• instance-.member (डैश डॉट)
• [email protected] (एट-साइन डॉट)
• instance&.member (एम्पर डॉट)
• instance$.member (डॉलर डॉट)
• instance<.>member (स्पेसशिप डॉट)

मुझे ईमानदारी से लगता है कि (ए) .. काफी अच्छा लगता है और (b) यह वास्तव में कोई फर्क नहीं पड़ता कि यह अच्छा लग रहा है क्योंकि यह हमेशा भाषा का एक अस्पष्ट कोने होगा। ज्यादातर लोग instance.member उपयोग करेंगे क्योंकि उनके पास केवल एक फ़ील्ड या getfield पद्धति होगी, लेकिन दोनों।

(उस बात के लिए, ज्यादातर लोग जो सदस्य और एक विधि दोनों का उपयोग करना चाहते हैं, वे शायद .. बारे में जानने की जहमत नहीं उठाएँगे। वे सिर्फ foo.member लिए एक विधि को परिभाषित करेंगे और "असली" का नाम लेंगे। "फ़ील्ड foo._member । शायद, यह बेहतर शैली है - इसका मतलब है कि जब आप type परिभाषा पढ़ते हैं, तो यह तुरंत स्पष्ट हो जाएगा कि _member कुछ होने वाला नहीं है। आप सीधे पहुँच सकते हैं या उपयोग करना चाहिए। यह .. कुछ बदसूरत और अस्पष्ट बनाने के लिए तर्क देगा जैसे मूल्यवान विराम चिह्न अचल संपत्ति लेने के बजाय :. ।)

मैं एक infix अंतराल ऑपरेटर के रूप में .. का उपयोग करने की क्षमता को याद करूंगा, लेकिन अधिभार क्षेत्र की पहुंच एक सार्थक व्यापार बंद है। जबकि मैं बृहदान्त्र में किसी भी अधिक अर्थ को जोड़ने के लिए हल्के से डरता हूं, :. वह बुरा नहीं लगता है।

ध्यान दें कि :. अभी symbol(".") लिए वास्तव में मान्य सिंटैक्स है, इसलिए इसका उपयोग करना अच्छा नहीं हो सकता है। बिंदु जो .. संभावित रूप से उपयोगी है वह अच्छी तरह से लिया गया है; हम इसे एक वाक्यविन्यास पर बर्बाद नहीं करना चाहिए शायद ही कोई भी उपयोग करेगा। मैं @. तरह भी कुछ के साथ जाने के लिए पूरी तरह से खुश हूँ (क्योंकि . एक वैध मैक्रो नाम नहीं है और न ही यह एक पहचानकर्ता शुरू कर सकता है, यह किसी भी चीज़ के साथ संघर्ष की तरह नहीं लगता है )। फिर से, यह जूलिया का ऐसा अस्पष्ट कोना है कि इसे सुंदर बनाने की कोशिश करना सार्थक नहीं है।

केवल .. का उपयोग करके और किसी भी संभावित कुरूपता को अनदेखा करने के लिए +1 किया गया

हाँ, चलो .. वैसे भी यदि .. लिए उपयोग किया जा सकता है, तो मुझे लगता है कि यह एक _range_ कंस्ट्रक्टर होगा, लेकिन इसके पहले से ही कोलन जैसे उदाहरण हैं। start:stop ।

एक आखिरी पंट: .: बारे में क्या? क्या ab, a, (b), a? (: B) _and_ a.:b होना बहुत सूक्ष्म है?

@hayd , जो दुर्घटना से भी सूक्ष्म और आसान लगता है।

@ जिऑनर्टन , क्या # 5848 के संस्करण को पुनर्जीवित करने का कोई मौका है? हम वाक्यविन्यास प्रश्न पर पंट कर सकते हैं और "वास्तविक" फ़ील्ड तक पहुंचने के लिए Core.getfield(x, Field{y}) का उपयोग कर सकते हैं।

लगभग Core.getfield सिंटैक्स को अलग कर दिया, क्या कोई ठोस प्रश्न शेष हैं?

# 5848 में, @tknopp केवल "असली" क्षेत्र का उपयोग overloadable, कि सब कुछ overloadable होना चाहिए @JeffBezanson के सुझाव के विपरीत बनाने सुझाव दिया। व्यक्तिगत रूप से, मैं वास्तविक क्षेत्रों को अधिभार देना असंभव बनाकर खुश रहूंगा, सिवाय इसके कि भाषा की गतिशील प्रकृति शायद इसे लागू करने के लिए और अधिक जटिल बना देगी। जैसे "सब कुछ-अधिभार" दृष्टिकोण के साथ, अगर आपके पास x::Vector{Any} , तो x[i].y getfield(x[i], Field{:y}) व्याख्या की जा सकती है और प्रेषण प्रणाली y की परवाह किए बिना सही काम करेगी। getfield "आभासी" क्षेत्रों तो codegen के क्रम जांच के लिए प्रेषण प्रणाली का एक लघु सबसेट को लागू करना होगा के लिए x[i] प्रकार।

एक और सवाल यह था कि क्या Module.foo अधिभार होना चाहिए। एक तरफ, हर चीज के लिए getfield का उपयोग करने की एक निश्चित स्थिरता है, और उपरोक्त Vector{Any} उदाहरण में Module सरणी सदस्य हो सकते हैं इसलिए हमें उस मामले को संभालना होगा वैसे भी। दूसरी ओर @JeffBezanson ने बताया कि यह संकलन को कठिन बना सकता है, और function Base.sum(...) कड़ी मेहनत के रूप में घोषणाओं के व्यवहार को कठिन बना सकता है। मेरी प्राथमिकता Module.foo नॉन-ओवरलोडेबल बनाने की होगी, कम से कम अब के लिए, किसी भी मामले में जहां कंपाइलर जानता है कि यह Module (यानी Vector{Any} ) के साथ काम कर रहा है ; थोड़ा असंगतता के लायक लगता है कि क्या बदल जाता है के बारे में रूढ़िवादी होने के लिए।

+1 Module.foo ओवरलोडिंग की अनुमति नहीं देने के लिए।

यहां झंकार करने के लिए, वैज्ञानिक कंप्यूटिंग का एक क्षेत्र जहां ओओ प्रोग्रामिंग और सिंटैक्स वास्तव में एफपी से बेहतर है, एजेंट आधारित मॉडलिंग है। हालांकि मुझे एजेंट पदानुक्रमों को स्थापित करने के लिए ठोस और एकाधिक विरासत याद आती है, जूलिया के हल्के और तेज अमूर्त और त्वरित प्रोटोटाइप अद्भुत हैं- पहले से ही एबीएम फ्रेमवर्क के एक जोड़े ने पॉप अप किया है।

ABM में, डॉट संकेतन एजेंट इंटरैक्शन को व्यक्त करने के लिए बेहतर है: Agent1.dosomething (Agent2) बनाम dosomething (Agent1, Agent2)।

यह स्पष्ट नहीं है कि सबसे बड़ा उपयोग मामला है, लेकिन एबीएम के बारे में सोचने और कोडिंग के लिए इस वाक्यविन्यास चीनी को रखना अच्छा होगा।

मैं जूलिया में इस सिंटेक्स को उपलब्ध कराना भी बहुत पसंद करूंगा। जैसा
जितना मैं एक डिजाइन से फ़ंक्शन उन्मुख दृष्टिकोण की सराहना करता हूं
परिप्रेक्ष्य, विधि कॉल सिंटैक्स बहुत उपयोगी और कई में पठनीय है
डोमेन। यह बहुत अच्छा होगा यदि Ab (C) b (A, C) के बराबर है।
अप्रैल 22, 2015 8:50 पूर्वाह्न पर, "datnamer" सूचनाएं @github.com ने लिखा:

यहां पर झंकार करने के लिए, वैज्ञानिक कंप्यूटिंग का एक क्षेत्र जहां ओओ प्रोग्रामिंग है
और वाक्यविन्यास वास्तव में FP आधारित एजेंट आधारित मॉडलिंग से बेहतर है। हालाँकि मैं
एजेंट पदानुक्रम को स्थापित करने के लिए ठोस और कई विरासत को याद करें, और
जूलिया के हल्के और तेज अमूर्त और त्वरित प्रोटोटाइप है
आश्चर्यजनक- पहले से ही एबीएम फ्रेमवर्क के एक जोड़े ने पॉप अप किया है।

ABM में, डॉट संकेतन एजेंट इंटरैक्शन को व्यक्त करने के लिए बेहतर है:
Agent1.dosomething (Agent2) बनाम dosomething (Agent1, Agent2)।

यह स्पष्ट सबसे बड़ा उपयोग मामला नहीं है, लेकिन इसे रखना अच्छा होगा
एबीएम के बारे में सोचने और कोडिंग के लिए सिंटैक्टिक शुगर।

-
इस ईमेल का उत्तर सीधे दें या इसे GitHub पर देखें
https://github.com/JuliaLang/julia/issues/1974#issuecomment -95218555

ABM में, डॉट संकेतन एजेंट इंटरैक्शन को व्यक्त करने के लिए बेहतर है: Agent1.dosomething (Agent2) बनाम dosomething (Agent1, Agent2)।

क्यों बेहतर है? संपादित करें: मेरा मतलब इस एबीएम-संदर्भ में है।

कृपया, आइए वर्तनी पर धार्मिक युद्धों में चूसा न जाए। @ dbeach24 , कोई भी यह प्रस्ताव नहीं कर रहा है कि a.b(c) जूलिया में b(a,c) बराबर हो; यह नहीं होने वाला है।

अन्य भाषाओं के साथ प्राकृतिक इंटरोप के लिए ओवरलोडेबल डॉट्स महत्वपूर्ण है। यही कारण पर्याप्त है।

Subject.Verb (DirectObject)

कई संदर्भों में काफी स्वाभाविक है। बहुत सारे OO प्रोग्रामर का उपयोग किया जाता है
यह, और जबकि यह फ़ंक्शन (ए, बी) का एक मात्र पुनरावर्ती है, जो कि पुन: व्यवस्थित करता है
पठनीयता के लिए बहुत कुछ करता है, IMO।
अप्रैल 22, 2015 10:32 पूर्वाह्न पर, "एंडी हेडन" सूचनाएं @github.com ने लिखा:

ABM में, डॉट संकेतन एजेंट इंटरैक्शन को व्यक्त करने के लिए बेहतर है:
Agent1.dosomething (Agent2) बनाम dosomething (Agent1, Agent2)।

क्यों बेहतर है?

-
इस ईमेल का उत्तर सीधे दें या इसे GitHub पर देखें
https://github.com/JuliaLang/julia/issues/1974#issuecomment -95256390।

मैं उसे प्रपोज कर रहा था। (क्षमा करें, मेरा मतलब युद्ध शुरू करने का नहीं था, न ही मुझे पता था
सुझाव अलोकप्रिय होगा।) मैंने सोचा कि मैं इसे पहले आया देखूंगा
मंचों में, लेकिन यह महसूस नहीं किया कि इसे पहले ही खारिज कर दिया गया था
बुरा विचार। मैं पूछ सकता हूँ क्यों? (क्या आप मुझे एक सूत्र में इंगित कर सकते हैं?)

धन्यवाद।
22 अप्रैल, 2015 11:09 बजे, "स्टीवन जी। जॉनसन" सूचनाएं @github.com
लिखा था:

कृपया, आइए वर्तनी पर धार्मिक युद्धों में चूसा न जाए। @ dbeach24
https://github.com/dbeach24 , कोई भी प्रस्ताव नहीं कर रहा है कि ab (c) होना चाहिए
जूलिया में b (a, c) के बराबर; यह नहीं होने वाला है।

अन्य भाषाओं के साथ सुचारू इंटरोप के लिए ओवरलोडेबल डॉट्स महत्वपूर्ण है।
यही कारण पर्याप्त है।

-
इस ईमेल का उत्तर सीधे दें या इसे GitHub पर देखें
https://github.com/JuliaLang/julia/issues/1974#issuecomment -95266671।

ऐसा नहीं करने का एक कारण यह है कि a.b b a के दायरे में दिखता है, जबकि b अकेले b दिखता है घेरा गुंजाइश। यह बहुत भ्रामक होगा यदि बिंदीदार पहुंच कभी-कभी बाईं ओर की वस्तु में दिखाई नहीं देगी।

Btw, यह एक विशेषता माना जाता है कि जूलिया में कार्यों को वस्तुओं के अंदर नहीं बल्कि वर्तमान दायरे में देखा जाता है। मेरा मानना ​​है कि लोगों को वस्तुओं के अंदर देखे जाने वाले कार्यों का उपयोग करना शुरू करना एक कारण है जो डॉट ओवरलोडिंग को रोक रहा है।

@toivoh , डॉट ओवरलोडिंग के किसी भी कार्यान्वयन में मौजूदा पद्धति प्रेषण का उपयोग किया जाएगा, इसलिए यह @ dbeach24 , अंधाधुंध a.b(c) उपयोग को प्रोत्साहित न करने का मूल कारण यह है कि यदि आपके पास एक ही काम करने के लिए बहुत सारे वाक्यविन्यास हैं, तो भाषा और लाइब्रेरी गड़बड़ हो जाती हैं। यह इसके साथ एक वर्तनी और छड़ी लेने के लिए बेहतर है, और जूलिया के एकाधिक प्रेषण के पक्ष में b(a,c) क्योंकि यह स्पष्ट है कि b "स्वामित्व" नहीं है द्वारा a - b(a,c) पद्धति _both_ a और c द्वारा समान रूप से निर्धारित की जाती है।

बेशक, सबसे बड़ा अपवाद पायथन या सी ++ जैसी भाषाओं में बाहरी पुस्तकालयों को कॉल करने के लिए है, जहां आप जिस लाइब्रेरी को बुला रहे हैं, उसके डॉट सिंटैक्स को दर्पण करने में सक्षम होना अच्छा है। (ताकि उदाहरण के लिए लोग जूलिया में दस्तावेज़ों और उदाहरणों का सीधे अनुवाद कर सकें, बिना ज्यादा बदले।)

क्या मैं सब गीला हूँ, लेकिन अब (arg) का अर्थ यह नहीं होगा कि अनाम फ़ील्ड के बी में संग्रहीत एक अनाम फ़ंक्शन लिया जाए, और फिर दिए गए तर्क के साथ इसका मूल्यांकन करें?

मेरे आईफोन से भेजा गया

22 अप्रैल, 2015 को शाम 5:06 बजे, स्टीवन जी। जॉनसन नोटिफिकेशन @github.com ने लिखा:

बाहरी

@ScottPJones जो वर्तमान में ठीक काम करता है, लेकिन आमतौर पर इसे अच्छी शैली नहीं माना जाता है।

मुझे शैली के बारे में चिंता नहीं थी या नहीं, मैंने सिर्फ यह सोचा था कि चूंकि यह पहले से ही एक अर्थ था, जो जूलिया के काम करने के तरीके के अनुरूप था (अर्थात, खेतों में अनाम कार्यों को संग्रहीत करने में सक्षम था), यह एक अच्छा तर्क था _not_ to ab (arg) के उपचार की कोशिश करें जैसे कि यह b (a, arg) था।
I _might_ के पास अनाम कार्यों को संग्रहीत करने वाले सदस्यों के साथ एक संरचना (प्रकार) होने के लिए एक उपयोग है, हालांकि, मैं एक डेटाबेस से जूलिया में लिखे गए कार्यों को लोड कर रहा हूं, और फिर उन पर पार्स कर रहा हूं, और फ़ंक्शन को ऑब्जेक्ट में संग्रहीत कर रहा हूं ...
ऐसा कुछ करने के लिए एक बेहतर "जूलियन" शैली क्या होगी?

धन्यवाद!

@ScottPJones मुझे लगता है कि समझौता है ये बराबर नहीं होना चाहिए *।

"शैली" नियम के अपवाद हो सकते हैं, लेकिन क्षेत्र में एक फ़ंक्शन का उपयोग करने के लिए एक सम्मोहक मामला होना चाहिए, डॉट ओवरलोडिंग के लिए भी। मुझे लगता है कि मुद्दा यह है कि लोगों को इन विली-निली / के लिए ऐसा नहीं करना चाहिए / क्योंकि वे कर सकते हैं।

यह एक उदाहरण हो सकता है, लेकिन एक बेहतर तरीका भी हो सकता है (निश्चित रूप से यह एकमात्र तरीका नहीं है) ...

99% + उस समय टाइपऑफ़ (ए) पर भेजना बेहतर है; कोई फ़ंक्शन-फ़ील्ड नहीं, कोई डॉट ओवरलोडिंग नहीं।

* _जब भी, मुझे लगता है कि हर कोई जानता है कि यह दूसरी भूमि है जो एक पैकेज होगा जो बस ...

डी में, उनके पास a.b(arg) लिए एक नाम "समान फ़ंक्शन कॉल सिंटैक्स" है और यह काफी लोकप्रिय है, लेकिन मुझे लगता है कि यह जेनेरिक फ़ंक्शन, एकाधिक प्रेषण तरीका जूलिया के काम के साथ बहुत गहराई से है। यदि विचाराधीन फ़ंक्शन अनाम हैं या पूरी तरह से बतख-टाइप किए गए हैं, तो मुझे लगता है कि चीजें काम करेंगी, लेकिन यह बहुत ही प्रतिबंधात्मक आईएमओ है। मुझे नहीं लगता कि क्लास-बेस्ड ट्रेडिशनल OO लैंग्वेजेज की आदत को छोड़कर कंपोजिट टाइप के अंदर फंक्शन फील्ड्स को स्टोर करने का बहुत कारण है। जेनेरिक कार्यों को संग्रहीत करने के लिए एक बेहतर स्थान यदि आप उन्हें कहीं से लोड कर रहे हैं तो मॉड्यूल में होगा।

लेकिन अब हम "ठोस सवालों" से बहुत दूर हो गए हैं। मैं रूढ़िवादी होने के पक्ष में भी हूं कि कैसे हम ओवरफील्डिंग की अनुमति देते हैं, गेटफील्ड को मॉड्यूल पर ओवरलोडिंग की अनुमति नहीं देते हैं, और "असली गेटफील्ड" के लिए विशेष सिंटैक्स के बारे में बहुत अधिक चिंता नहीं करते हैं।

@stevengj : हाँ, और जैसा कि मैं कहना चाह रहा था, यह एक मौलिक कारण है कि यह कभी नहीं होने वाला है कि a.b(c) b(a, c) बराबर हो जाता है, भले ही हम डॉट ओवरलोड के साथ क्या करें अन्यथा ।

इस पर मेलिंग सूची को छूने पर कुछ चर्चा हुई। मेरे दृष्टिकोण से इस थ्रेड के लिए सबसे प्रासंगिक पोस्ट (@nalimilan द्वारा) है: https://groups.google.com/d/msg/julia-users/yC-sw9ykZwM/-607E_FPtl0J

इस सुविधा का उपयोग करने पर व्यक्तिगत नीति के बारे में @johnmyleswhite की टिप्पणी को जोड़ने - यह मुझे हमला करता है कि कुछ HTTP विचार यहां उपयोगी हो सकते हैं, और यह कि getfield() का दुष्प्रभाव नहीं होना चाहिए और setfield!() एक समान होना चाहिए (अर्थात, एक ही मूल्य के साथ इसे कई बार कॉल करने पर इसे एक बार कॉल करने के समान प्रभाव होना चाहिए)। जरूरी नहीं कि कठिन और तेज नियम जो संकलक द्वारा लागू किए जाते हैं, लेकिन चीजों को बहुत अधिक पागल होने से बचाने के लिए दिशानिर्देश का उपयोग करें।

मैंने सूचक मापदंडों के साथ पैरामीट्रिक प्रकारों का उपयोग करके एक वर्कअराउंड पोस्ट किया है और फ़ील्ड सेट करते समय कस्टम सेटर को कॉल करने के लिए परिवर्तित किया है:
पोस्ट: https://groups.google.com/forum/# .topic/julia -users / _I0VosEGa8o
कोड: https://github.com/barche/CppWrapper/blob/master/test/property.jl

मैं सोच रहा था कि क्या मुझे अपने पैकेज में सेटफील्ड तक वर्कअराउंड के रूप में इस दृष्टिकोण का उपयोग करना चाहिए! ओवरलोडिंग उपलब्ध है, या यह पैरामीट्रिक प्रकार प्रणाली पर बहुत अधिक तनाव है?

मैं getfield / setfield! ओवरलोडिंग का एक अतिरिक्त लाभ का उल्लेख करना चाहता हूं, मुझे आशा है कि यह इसके लिए सही जगह है, मुझे खेद है अन्यथा। (संबंधित विषय https://groups.google.com/forum/# ​​.topic/julia-users/ThQyCUgWb_Q पर आया था)

जूलिया getfield / setfield के साथ! ओवरलोडिंग एक _external पैकेज_ में ऑटोरैलोएड कार्यक्षमता के आश्चर्यजनक रूप से सुरुचिपूर्ण कार्यान्वयन के लिए अनुमति देगा। (इस कार्यक्षमता को प्राप्त करने के लिए सभी कड़ी मेहनत देखें जो IPython autoreload एक्सटेंशन https://ipython.org/ipython-doc/3/config/extensions/autoreload.html में डालनी थी। ऑटोरैलोएड का विचार यह है कि आप आरईपीएल के साथ काम करते समय बाहरी मॉड्यूल में कार्यों और प्रकारों को संशोधित कर सकते हैं।

TLDR: getfield / setfield! ओवरलोडिंग, शब्दकोशों और https://github.com/malmaud/Autoreload.jl के समान पैकेज के लिए ट्रिक करना चाहिए।

अधिक विशिष्ट होने के लिए, ऑटोरैलोएड.ज्ल के समान पैकेज की कल्पना करें जो निम्न कार्य करता है।

आप पहली बार एक मॉड्यूल बनाते हैं।

module M
type Foo
  field1::Int64
end
bar(x::Foo) = x.field1 + 1.0
end

REPL में, आप टाइप करते हैं

julia> using Autoreload2
julia> arequire("M")
julia> foo = Foo(42)

फिर आप एम.एलएल को बदल दें

module M
type Foo
  field1::Int64
  field2::Float64
end
bar(x::Foo) = x.field1+x.field2

यह स्वतःपूर्ण हो जाएगा और में परिवर्तित हो जाएगा

# type redefinition removed as already done by Autoreload.jl
const field2_dict = Dict{UInt64,Float64}()
setfield!(x::Foo, ::Field{:field2}, value) = field2_dict[object_id(x)] = value
getfield(x::Foo, ::Field{:field2}) = field2_dict[object_id(x)]
<strong i="25">@do_not_inline</strong> bar(x::Foo) = x.field1 + x.field2

और फिर REPL में आप कर सकते थे

julia> foo.field2 = 3.14
julia> println(bar(foo)) # prints 45.14

प्रदर्शन पाइथन से भी बदतर नहीं होगा, इसलिए जो लोग IPython autoreload से अपने वर्कफ़्लो को स्थानांतरित करते हैं, वे प्रदर्शन के मामले में कुछ भी नहीं खोएंगे। और एक बार जब आप REPL को पुनः आरंभ करते हैं, तो आप पूर्ण प्रदर्शन पर वापस आ जाते हैं।

मैं a[:field][:field2][:morestuff](b[:random_stuff]) लिखने से थक गया क्योंकि यह वास्तव में पठनीय नहीं है। इसलिए मैंने इस छोटे मैक्रो को लिखा जो 0.4 और 0.5 में मेरे उपयोग के मामलों के लिए काम करता है
https://github.com/sneusse/DotOverload.jl

टी एल; डॉ
एक मैक्रो जो एक अभिव्यक्ति का एएसटी a.b -> getMember(a, :b) बदलता है

0.6 से हटाना, क्योंकि कोई आम सहमति नहीं है कि यह एक अच्छा विचार है और डॉट सिंटैक्स के साथ क्या करना है, इसके लिए एक परस्पर विरोधी प्रस्ताव है।

@ केनो : क्या आपके पास परस्पर विरोधी प्रस्ताव का लिंक है?

नहीं लगता कि @StefanKarpinski ने इसे अभी तक लिखा है, लेकिन मुझे उम्मीद है कि जल्द ही इसके बारे में एक जूलप होगा।

मुझे fieldname(object) या get_fieldname(object) जैसे getter फ़ंक्शन की तुलना में object.fieldname अच्छे मिले। शायद object.fieldname (या object$fieldname ) getpublicfield (शायद बेहतर नाम के साथ) और object..fieldname वास्तविक getfield होने की कॉल हो रही है। (प्राइवेट) एक अच्छा विकल्प हो सकता है। इस प्रकार, प्रकारों को गेटर्स के बजाय getpublicfield परिभाषित करना चाहिए, और object.fieldname करने की कोशिश करनी चाहिए कि एक त्रुटि आईडी फ़ील्ड निजी है (यह निजी होगा यदि इसके लिए कोई परिभाषा नहीं है getpublicfield )।

मैंने निर्णय लेबल जोड़ा। इस मुद्दे पर चर्चा की गई है और या तो यह किया जाना है या नहीं। # 5848 को पढ़ते समय ऐसा लगा कि @JeffBezanson @StefanKarpinski और @stevengj यही चाहते हैं। यदि हाँ तो इस मुद्दे को एक मील का पत्थर मिलना चाहिए ताकि इसे भुलाया न जा सके। नहीं तो पास। किसी भी मामले में मुझे लगता है कि यह एक बदलाव है जिसे प्री 1.0 किया जाना चाहिए।

@JeffBezanson और मैं कल ही इस पर चर्चा कर रहे थे। तम्बू के निष्कर्ष: (i) हां, हमारे पास यह होना चाहिए; (ii) Module (जो विशेष रूप से नियंत्रित किया जाएगा) के लिए डॉट ओवरलोडिंग की अनुमति नहीं देता है; (iii) Core.getfield लिए किसी विशेष सिंटैक्स की आपूर्ति नहीं करते हैं (क्योंकि एक "वास्तविक" फ़ील्ड के समान नाम के लिए एक अधिभार getfield की कोई दबाव की आवश्यकता नहीं है; उत्तरार्द्ध बस के साथ शुरू हो सकता है) एक अंडरस्कोर)।

@stevengj : एक उचित योजना की तरह लगता है। क्या आप इंगित कर सकते हैं कि क्या यह एकल तर्क तक सीमित रहेगा या यदि बहु तर्क संस्करण a.fieldname(b) का भी समर्थन किया जाना चाहिए? यह उपरोक्त चर्चा का निष्कर्ष निकालेगा। इसके अलावा इस (1.0?) के लिए एक उपयुक्त मील का पत्थर लेबल लगाना बहुत अच्छा होगा। धन्यवाद!

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

मैं एक कनवर्टर का उपयोग मूल्यों को डालने और डेटा को मान्य करने के लिए करता हूं।
इस तरह:

abstract AbstractAge{T}
abstract AbstractPerson
type PersonAge <: AbstractAge{AbstractPerson} 
    value::Int64
end

Base.convert(t::Type{AbstractAge{AbstractPerson}}, value::Int64) =  begin
  if value < 140 && value > 0
    PersonAge(value) 
  else
     throw(ErrorException("ValueError"))
  end
end

type Person <: AbstractPerson
  age::AbstractAge{AbstractPerson}
end 

a = Person(32)
a.age = 67

यहाँ इस का एक मजेदार 3-लाइन कार्यान्वयन है:

diff --git a/base/boot.jl b/base/boot.jl
index cd3ae8b..a58bb7e 100644
--- a/base/boot.jl
+++ b/base/boot.jl
@@ -266,6 +266,9 @@ Void() = nothing

 (::Type{Tuple{}})() = ()

+struct Field{name} end
+(::Field{f})(x) where {f} = getfield(x, f)
+
 struct VecElement{T}
     value::T
     VecElement{T}(value::T) where {T} = new(value) # disable converting constructor in Core
diff --git a/src/julia-syntax.scm b/src/julia-syntax.scm
index b4cb4b5..59c9762 100644
--- a/src/julia-syntax.scm
+++ b/src/julia-syntax.scm
@@ -1685,7 +1685,7 @@
     (if (and (pair? e) (eq? (car e) '|.|))
         (let ((f (cadr e)) (x (caddr e)))
           (if (or (eq? (car x) 'quote) (eq? (car x) 'inert) (eq? (car x) '$))
-              `(call (core getfield) ,f ,x)
+              `(call (new (call (core apply_type) (core Field) ,x)) ,f)
               (make-fuse f (cdr x))))
         (if (and (pair? e) (eq? (car e) 'call) (dotop? (cadr e)))
             (make-fuse (undotop (cadr e)) (cddr e))

मेरी सोच है कि है a.b वास्तव में एक प्रक्षेपण समारोह बुलाना चाहिए Field{:b}() के बजाय getfield , ताकि आप जैसे कार्यों मिल x->x.a मुक्त करने के लिए पहले से ही। यह भी getfield को हमेशा निम्न-स्तरीय फ़ील्ड एक्सेस का मतलब देता है।

उपरोक्त कार्यान्वयन पूरी तरह से काम करता है लेकिन कंपाइलर (sysimg + 5%, जो वास्तव में एक सुखद आश्चर्य की तरह है) पर बहुत कठिन है। तो इसके लिए कुछ विशेषज्ञता वाले आंकड़ों की आवश्यकता होगी और कुछ शुरुआती अनुकूलन को अद्यतन करने की आवश्यकता होगी, लेकिन फिर उम्मीद है कि यह व्यवहार्य होगा।

मुझे आश्चर्य है कि परीक्षण उस कार्यान्वयन से गुजर सकते हैं। क्या यह शब्दार्थक मॉड्यूल संदर्भों को अनुकूलित करने के लिए कोडेन के लिए असंभव नहीं बनाता है? यह भी लगता है कि यह वैश्विक चर को बहुत अधिक महंगा बना देगा (गति और स्मृति)। यह sysimg में दिखाने के लिए इसके लिए बहुत अधिक संभावना नहीं लगती है। हालाँकि इनफेक्शन का ख़तरा ऐसा लगता है कि यहाँ sysimg को छोटा कर देना चाहिए था, इसलिए 5% बदतर एक अच्छी शुरुआत की तरह नहीं लगती है]

हां, GlobalRefs में कनवर्ट करने के लिए jl_resolve_globals में कोड है जिसे अपडेट करने की आवश्यकता होगी। इसके अलावा, इन को इनबिल्ड करना चाहिए ताकि कोडगेन के लिए इन्हें संभालना संभव हो। अनुमान के अनुसार, हमें संभवतः getindex tuple के समान एक विशेष मामले की आवश्यकता है।

हम शायद केवल एक विशेष मामले की जरूरत है कि tuple getindex के समान है

यह विशेष मामला आशा करता है और मानता है कि कोई भी तरीका परिभाषित नहीं किया जाएगा जो बिलिन getindex विधि हस्ताक्षर के साथ प्रतिच्छेदन करता है। मैं यह नहीं देखता कि यह मामला विशेष रूप से यहाँ कैसे लागू होता है।

मैं ::Module लिए एक विधि

@JeffBezanson क्या आपके पास उन तीन लाइनों के साथ एक शाखा है? मैंने उन्हें खुद को एक स्थानीय निर्माण में जोड़ने की कोशिश की, लेकिन लगता है कि जूलिया अब तक साथ चली गई है और मैं इसे काम नहीं कर पाया।

मुझे यह कहना चाहिए कि अगर मेरे पास जूलिया 1.0 में एक फीचर के लिए केवल एक इच्छा थी, तो यह यही होगा। यह मीमी और क्वेरी दोनों में दो लंबे समय से चली आ रही समस्याओं को हल करेगा।

मुझे लगता है कि क्वेरी के लिए मामला बहुत सामान्य है। मेरा मानना ​​है कि कोई भी इसके साथ NamedTuple फ़ील्ड के सेट के साथ लौटाते हैं। उत्पन्न समारोह में गणना की। मुझे लगता है कि यह मुझे Blackrock / NamedTuples.jl # 4 का एक प्रकार-स्थिर संस्करण लिखने में सक्षम करेगा, जो कि अभी Query.jl में मेरा सबसे बड़ा ठोकर है।

लंबी कहानी छोटी, यह जूलिया में संपूर्ण डेटा हैंडलिंग कहानी के लिए सुपर, सुपर मूल्यवान होगी।

सिंटैक्स नीचे उपलब्ध है?

function (obj::MyType).plus(n::Int)
       return obj.val + n
end

दुनिया में आप उस वाक्य रचना को क्यों चाहेंगे?

लिखने के लिए चाहते हैं obj.plus(n) के बजाय obj + n कुछ गंभीर ऊ स्टॉकहोम सिंड्रोम है।

ठीक है, दिया गया उदाहरण एक तुच्छ (और एक बुरा) था।
यह getfield से अधिक लोड करने के बजाय इस सिंटैक्स का उपयोग करने के लिए एक विचार था और तर्कों का उपयोग करने में सक्षम था।

मैं ज्यादातर कार्यक्षमता से चिंतित हूं। getfield को ओवरलोड करने के लिए एक संक्षिप्त सिंटैक्स होने के कारण यह बहुत कम महत्वपूर्ण लगता है और इसके बारे में बहस करने से पीछे नहीं हटने योग्य है। इसके अलावा, getfield और setfield! सीधे दर्पण getindex और setindex! और इसलिए जूलिया में कुछ हद तक स्वाभाविक हैं। अंत में, एक OO शैली का व्यापक उपयोग वास्तव में जूलिया के मुहावरे के लिए एक अच्छा फिट नहीं है, और मुझे नहीं लगता कि हम इसे OO जैसी विधि-परिभाषा सिंटैक्स द्वारा प्रोत्साहित करना चाहते हैं (लेकिन मेरी टिप्पणी ऊपर दिए गए तर्कों के बारे में

मेरे साथ हुई एक बात यह थी कि $ ऑपरेटर को पदावनत कर दिया गया था। अब, यह स्पष्ट रूप से $(x, sym::Symbol) = ... पहले से उपलब्ध कुछ कर रहा है, लेकिन हम भी एक कट्टरपंथी फिर से लिखना पसंद कर सकते हैं:

x$y          => $(x, ::Type{Val{:y}})
x$z(args...) => $(x, ::Type{Val{:z}}, args...)

मुझे लगता है कि इस मामले में बताए गए अधिकांश मामलों को कवर किए बिना पहले से ही पूर्ण रूप से विकसित हो रहे हैं। सच कहूँ तो, जूलिया में . ऑपरेटर बहुत शब्दार्थ से संतृप्त है, इसलिए ऐसा कुछ पचाना आसान लगता है और अभी भी उपयोगी होने के लिए पर्याप्त सुविधाजनक है।

@quinnj , पहले से ही # 18696 में प्रस्तावित है।

चूँकि हमारे पास फील्ड एक्सेस के लिए पहले से . , हालाँकि, यह दो फील्ड-एक्सेस-जैसे ऑपरेटर्स के लिए असंगत लगता है, एक ओवरलोडेबल और एक नहीं। और यह पायथन और अन्य OO भाषाओं के लिए अंतर-भाषा कॉल के लिए थोड़ा अप्राकृतिक होगा, जो लगभग सार्वभौमिक रूप से . ।

मैं अन्य भाषाओं के साथ अंतरप्रांतीयता को इस तरह से पेश करने के लिए एक वैध तर्क के रूप में नहीं देखता हूं। यह कहने की तरह है, "पायथन कोड इस तरह दिखता है, इसलिए पायथन होने का नाटक करने में सक्षम होने के लिए हमें यह भी करना चाहिए।" मैंने अभी तक इसके लिए एक तर्क देखा है जो जूलिया को बेहतर और / या अधिक सुसंगत बना देगा। यह पहले से ही अच्छी तरह से स्थापित है कि जूलिया ओओपी-शैली x.f() सिंटैक्स प्रदान नहीं करता है; उस तरह की चीजों की अनुमति देना विसंगति के लिए पूछ रहा है।

@stevengj , जहां से मैं आ रहा हूं, का हिस्सा यह तथ्य है कि x.f _is't_ फ़ील्ड एक्सेस। कोई वास्तविक क्षेत्र सदस्य f । यह पूरा मामला गेटफील्ड को ओवरलोड करने के बारे में है और मुझे लगता है कि मुख्य चिंताएं संभावित भ्रम हैं कि क्या x.f वास्तव में एक क्षेत्र को संदर्भित करता है या हुड के तहत कुछ और कर रहा है।

मेरे द्वारा प्रस्तावित सिंटैक्टिक रीराइट का लाभ यह है कि यह गेटफील्ड के साथ अतिरिक्त भ्रम की शुरुआत किए बिना भाषा इंटरोप कहानी को पूरा करता है; जब मैं . उल्लेख करता था, तो मैं इस बात का जिक्र करता था कि वह अधिक संतृप्त होगा। क्या x$f वास्तव में इतना अधिक बोझिल होगा? मैं अभी नहीं देखता कि यह _has_ डॉट ऑपरेटर का उपयोग क्यों करता है।

यह पूरा मुद्दा गेटफील्ड को ओवरलोड करने के बारे में है और मुझे लगता है कि मुख्य चिंताएं संभावित भ्रम हैं कि क्या x.f वास्तव में एक क्षेत्र को संदर्भित करता है या हुड के तहत कुछ और कर रहा है।

मुझे नहीं लगता कि @JeffBezanson के तीन लाइन प्रस्ताव में भ्रम की कोई संभावना है: a.b को हमेशा एक प्रोजेक्शन फंक्शन कॉल में उतारा जाता है, और कभी भी getfield कॉल नहीं किया जाता। और फिर प्रोजेक्शन फ़ंक्शन के लिए आधार में एक डिफ़ॉल्ट / फ़ॉलबैक विधि है जो getfield कॉल करती है। उपयोगकर्ता अपने स्वयं के प्रकारों के लिए उस प्रोजेक्शन फ़ंक्शन को जोड़ सकते हैं यदि वे चाहें। getfield हमेशा उस प्रस्ताव में निम्न स्तर के क्षेत्र की पहुंच का मतलब है, और उपयोगकर्ता getfield तरीकों को नहीं जोड़ेंगे (मुझे लगता है कि आप "ओवरलोडिंग गेटफील्ड" से क्या मतलब है)। जो मुझे बहुत साफ लगता है। ऐसा कहने के बाद, यह मेरे लिए स्पष्ट नहीं है कि यह प्रस्ताव अभी भी मेज पर है या नहीं, कुछ संकलक चिंताएं हैं जो मुझे समझ में नहीं आती हैं :)

मैं वास्तव में इस सुविधा के लिए प्यार करता हूँ (मैं इसे स्काला में हमेशा प्यार करता हूँ)। जूलिया में आईएमएचओ सीधे खेतों तक पहुंचना बहुत स्वाभाविक है (तुलना में, उदाहरण के लिए, रक्षात्मक रूप से परिभाषित गेटर्स और सब कुछ के लिए बसने का जावा तरीका)। लेकिन "वर्चुअल" फ़ील्ड्स को जोड़ने की क्षमता के बिना, बहुत सारे कोड को तोड़ने के बिना / रिफ्लेक्टर संरचनाओं को विकसित करना बहुत मुश्किल हो जाता है।

मुझे पता है कि इसे v2.0 टैग किया गया है, लेकिन मैं v1.0 के लिए इस पर पुनर्विचार करने की उम्मीद में इसे फिर से लाना चाहूंगा। यह सुविधा पैकेज / लाइब्रेरी डेवलपर्स के लिए बहुत मूल्यवान होगी।

उपयोगकर्ताओं के लिए एक पैकेज का निर्माण करते समय, विशेषता एक्सेसर को अधिभारित करने से पैकेज अनुरक्षकों को अधिक क्लीनर उपयोगकर्ता इंटरफ़ेस पेश करने की अनुमति मिलेगी। मैने तर्क किया था की,

complex_data_structure.attribute

से टाइप करना आसान है

get(complex_data_structure, :attribute)

जहां get डेटा प्राप्त करने के लिए आवश्यक एक फ़ंक्शन है जिसे :attribute द्वारा वर्णित किया गया है।

यह संभवतः REPL में खोज क्षमता में सुधार कर सकता है, और भाषा कोड और डेटा अन्वेषण को लाभान्वित करेगा।

इसके अतिरिक्त, एक सेटर विशेषता इंटरसेप्टर भी अविश्वसनीय रूप से मूल्यवान होगा। निम्नलिखित उदाहरण पर विचार करें (वर्तमान में मेरी कई लिपियों में पाया गया :),),

set(complex_data_structure, :attribute, modify_attribute(get(complex_data_structure, :attribute), additional_arguments))

यदि जूलिया के हिस्से के रूप में एक विशेषता गेट्टर और सेटर को शामिल किया गया था, तो उपरोक्त निम्नलिखित बन जाएगा।

complex_data_structure.attribute = modify_attribute(complex_data_structure.attribute, additional_arguments)

मेरी विनम्र राय में यह अधिक पठनीय है। (सिडेनोट: मैं इसे और अधिक पठनीय बनाने के लिए एक पाइप रचना का उपयोग कर सकता था, लेकिन additional_arguments फिर से इसे फिर से जटिल कर सकता था। और यहाँ तर्क अभी भी खड़ा होगा।)

इसके अलावा, उपयोगकर्ता द्वारा प्रदान किए गए मानों में बाधा डालना वास्तव में सामान्य उपयोग का मामला है, और यह v1.0 में वास्तव में बहुत अच्छा होगा। यह कई पैकेजों के लिए उपयोगकर्ता इंटरफ़ेस में बहुत सुधार करेगा। वर्तमान में, मेरे सर्वोत्तम ज्ञान के लिए, निम्न करने का कोई तरीका नहीं दिखता है (क्या कोई मुझे गलत कर सकता है यदि मैं गलत हूं)?

module point

mutable struct Point
    x::Int
    y::Int
    function Point(x, y)
        if x < 0 || y < 0
            throw(error("Only non-negative values allowed"))
        end
        this = new(x, y)
    end
end

end
# point

p1 = point.Point(-1, 0)
# Only non-negative values allowed

# Stacktrace:
# [1] point.Point(::Int64, ::Int64) at ./In[30]:8
# [2] include_string(::String, ::String) at ./loading.jl:515

p1 = point.Point(0, 0);
p1.x = -1;
p1
# point.Point(-1, 0)

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

यह उपयोगकर्ताओं के लिए यकीनन बेहतर और अधिक सहज इंटरफेस बनाने के लिए PyCall.jl और DataFrames.jl जैसे अन्य पैकेजों को भी बहुत लाभ देगा। इन पैकेजों के लेखकों ने भी इस सुविधा के होने में रुचि व्यक्त की है।

विचार? धागे के माध्यम से पढ़ना, ऐसा प्रतीत होता है कि यह पहले से ही अंतिम के बहुत करीब है। मैं उत्सुक हूं कि लेखक के विचार इस पर क्या हैं?

यहां एक प्रकार के स्थिर वैकल्पिक मैक्रो में लागू किया गया है: https://github.com/bramtayl/DotOverloading.jl। मुझे लगता है कि इसमें आधार की क्षमता है।

@bramtayl , मुझे लगता है कि @overload_dots से पहले a.b भाव रखना यहाँ बिंदु को हरा देता है।

मैं सुझाव नहीं दे रहा था कि मैक्रो को आधार से जोड़ा जाए; मैं सुझाव दे रहा था कि मैक्रो द्वारा उपयोग की जाने वाली रणनीति को पार्सर में बेक किया जाए। हालाँकि, यह एक मैक्रो है जिसे पूरी फाइलों पर चलाया जा सकता है या यहाँ तक कि एक IDE में हैक किया जा सकता है।

यही कारण है कि करना पड़ेगा a.b करने के लिए पार्स किया जाता Expr(:., :a, :(Val{:b}()) और करने के लिए कम कर दिया get_field_overloadable(a, Val{:b}())

@bramtayl , ऊपर जेफ के

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

दूसरा बिंदु यह है कि जब मैं गेटफ़ील्ड और सेटफ़ील्ड का उपयोग कर रहा हूं, तो मुझे एक उचित उम्मीद है कि मैं कुछ विशाल फ़ंक्शन तंत्र के बजाय सीधे डेटा संरचना तक पहुंच रहा हूं। इसके अलावा, कीवर्ड struct का उपयोग एक प्रकार को परिभाषित करने के लिए किया जाता है, जो आपको C की याद दिलाता है, और मुझे ऐसा लगता है कि यह आपको उम्मीद देता है कि गेटफ़ील्ड का उपयोग प्रत्यक्ष होना चाहिए।

इसलिए, मुझे लगता है कि इसके बजाय $ ऑपरेटर का उपयोग करना एक उचित समझौता है क्योंकि इस बात की कोई अपेक्षा नहीं है कि गेटफ़ील्ड में पहुंच प्रत्यक्ष है, यह पहले से ही अन्य संदर्भों में एक विशेष चरित्र है और इसलिए यह बहुत आश्चर्य की बात नहीं होगी। जब यह इस तरीके से उपयोग किया जाता है, तो इसे हटाना आसान होगा क्योंकि बहुत कम लोग इसका उपयोग करते हैं और क्योंकि यह अब एक फ़ंक्शन नहीं होगा, और इसका उपयोग आर में इसी तरह किया जाता है।

ओवरफ़ील्ड गेटफील्ड के साथ एक समस्या यह है कि कुछ पुस्तकालयों में डेटा संरचना के आंतरिक के लिए एक उचित इंटरफ़ेस नहीं है।

ऊपर से @JeffBezanson का कार्यान्वयन getfield (या setfield ) से अधिक नहीं है।

मैं इसे 1.0 में बनाने के लिए भी निवेदन करना चाहता हूं। मैं अक्सर अपने कोड को कुछ हद तक लचीला रखने के लिए गेटर्स / सेटिंग्स लिखने के बीच अपने आप को फटा हुआ पाता हूं (और फिर सोच रहा था कि उन्हें नाम कैसे दिया जाए), या डायरेक्ट फ़ील्ड एक्सेस का उपयोग करने के लिए मेरे कोड के उपयोगकर्ता को "अनुमति देना / प्रोत्साहित करना"।

बहुत से गेटर्स की रक्षात्मक रूप से लिखना और सामने बसना मुझे बहुत जूलियन नहीं लगता - आखिरकार, जूलिया के पास कोई निजी / संरक्षित क्षेत्र नहीं है और इसलिए उपयोगकर्ता को सीधे खेतों तक पहुंचने के लिए प्रोत्साहित करता है। फिर अन्य पैकेजों के साथ बहुत सारे संघर्षों को जोखिम में डाले बिना बहुत सारे गेट्टर / सेटर-फ़ंक्शंस के नाम पर सवाल है। और विकल्प, getfield और setfield! (या समान) के लिए विधियाँ जोड़ने पर, Val{:fieldname} पर भेजा गया, या तो बहुत उपयोगकर्ता के अनुकूल नहीं लगता है।

दूसरी ओर, यदि प्रत्यक्ष क्षेत्र पहुंच मूल रूप से सभी संरचनाओं को हमेशा के लिए बंद कर देती है, तो यह स्पष्ट रूप से प्रोत्साहित नहीं किया जाना चाहिए - विशेष रूप से लंबे समय तक रहने वाले कोड के लिए। @JeffBezanson का क्रियान्वयन इस दुविधा से बाहर निकलने का एक अच्छा तरीका है।

राइट, @davidanthoff मुझे getfield ओवरलोडिंग और . फ़ील्ड एक्सेस सिंटैक्स की ओवरलोडिंग का सामना करना पड़ रहा होगा। मेरा मतलब फील्ड एक्सेस सिंटैक्स की ओवरलोडिंग है।

इस सुविधा को जोड़ने के लिए पीछे की ओर संगत तरीके हैं, इसलिए इसे 1.x रिलीज़ में जोड़ा जा सकता है, लेकिन यह 1.0 में नहीं हो रहा है। हमारे पास एक भी डिज़ाइन या समय नहीं है, भले ही वह एक हो।

पॉइंटर्स टू (C-) स्ट्रक्चर्स पर डॉट-सिंटैक्स का उपयोग करना अत्यंत सुविधाजनक होगा।

मेरा पसंदीदा वाक्य विन्यास केवल बिंदुओं को स्थानांतरित करने और परिवर्तित करने के लिए डॉट्स का उपयोग करना होगा, और डीईआरएफ के लिए [] का उपयोग करना होगा।

अतः, स्ट्रक्चर लोअरपेयर a: इंट बी :: इन्ट एंड, और पी :: पंर {somepair}, तो पा एक फील्ड का पॉइंटर है, और मैं इसे पा [] = 3 के साथ लिखता हूं, या x = के साथ पढ़ता हूं पा []।

आगे हमें बस प्रकारों की घोषणाओं की आवश्यकता है, और संभवतः सी हेडर आयात करने का एक तरीका है, और फिर सी लपेटने से एक हवा बन जाती है।

Ps, स्पष्ट करने के लिए, कुछ इस तरह:

function getfield(p::Ptr{T}, fn::Symbol) # dispatch on values of T and fieldname
ftype = fieldtype(T, fn)
offset = fieldoffset(T,fn)
return convert(Ptr{ftype}, p+offset)
end

getindex(p::Ptr{T}) where T = unsafe_load(p)
setindex!(p::Ptr{T}, v) where T = unsafe_store!(p, convert(T,v))

बोनस अंक के लिए, जूलिया के रनटाइम लीब से प्रकारों को निर्यात किया जा सकता है, और पॉइंटर_फ्रॉम_बॉजफ्रे वास्तव में हमें अधिक सुविधाजनक आत्मनिरीक्षण के लिए एक अच्छी तरह से टाइप किए गए पॉइंटर दे सकता है।

मुझे लगता है कि यूनियनों को थोड़े से काम करने चाहिए, बस एक ही ऑफसेट के साथ दो क्षेत्र होने चाहिए?

@ चेतहेगा मुझे लगता है कि आप https://github.com/JuliaLang/julia/pull/21912 की तलाश कर रहे हैं, जो लगभग उसी तरह की सुविधा प्रदान करता है, जिसमें C के मेमोरी मॉडल (टाइप-पाइंटिंग वॉयलेंस, आउट-ऑफ) के आसपास के मुद्दे शामिल नहीं हैं -बाउंड एक्सेस, इंटीरियर पॉइंटर्स के अलियासिंग, आदि, जो उस भाषा में संभव प्रदर्शन अनुकूलन को सीमित करते हैं)।

क्या लगातार प्रचार करना इसे अधिक संभव बनाता है?

Pls 1.0 मील का पत्थर बदलें! :)

@ लिसो77 आपका क्या मतलब है? यह पहले से ही गिट मास्टर पर लागू किया जाता है, जैसा कि बंद होने की स्थिति में नोट किया गया है।

अगर गलत समझे तो @nalimilan को माफ़ करना! लेकिन मुझे लगा कि 1.x को पोस्टपोन की गई चीजों के रूप में लेबल किया जाता है जो 1.0 के बाद हल अब हल

खुला स्रोत एक विकेंद्रीकृत समुदाय है। मील का पत्थर सेट करता है जो 1.0 से पूरा होना चाहिए, लेकिन योगदानकर्ताओं और जो भी वे चाहते हैं उस पर काम करें। इस मामले में कोई 1.0 में ऐसा चाहता था, इसलिए उन्होंने इसे प्राप्त करने के लिए कोड का योगदान दिया।

@ लिस्नो77 जैसा कि मैं इसे समझता हूं, यह v1.0 में नहीं होगा। जूलिया v1.0 सुविधा फ्रीज की तारीख 15 दिसंबर को निर्धारित की गई थी, लेकिन यह मुद्दा 17 दिसंबर को बंद हो गया था, इसलिए मुझे लगता है कि हम इसे 1.x रिलीज में उम्मीद कर सकते हैं। यदि मेरी व्याख्या गलत है तो कोर देवता मुझे सही कर सकते हैं।

नहीं, यह मास्टर में विलय हो गया है और अगली रिलीज में होगा।

:) कुंआ! मैंने अभी सोचा था कि 1.0 में जो कुछ भी हो रहा है, उसे लेबल करना अच्छा है। यदि यह नहीं चाहता है तो परेशान करने के लिए खेद है! :)

मुझे लगता है कि 1.0 में क्या हो रहा है यह देखने के लिए NEWS फाइल एक बेहतर तरीका है।

इस मील के पत्थर को "1.x रिलीज़ सीरीज़ में अनुकूलता को तोड़े बिना" लागू किया जा सकता है, लेकिन तब कोड तैयार होने के बाद इसे 1.0 फीचर फ्रीज से पहले वैसे भी मर्ज कर दिया गया था। मैंने स्पष्टता के लिए मील का पत्थर हटा दिया है, लेकिन इस बिंदु पर जो कुछ भी मास्टर में विलय किया गया है वह 1.0 में होगा।

स्पष्टीकरण के लिए धन्यवाद! यह रोमाँचक है! NEWS फाइल भी विशेष रूप से ज्ञानवर्धक थी।

हटाने के लिए धन्यवाद! मुझे भी बहुत खुशी है कि यह 1.0 में आएगा! :)

मुझे आश्चर्य है कि अगर ऑटो-पूर्ण में इन नए "गतिशील रूप से परिभाषित क्षेत्रों" का समर्थन करने का एक तरीका है, उदाहरण के लिए fieldnames अधिभार की अनुमति देकर। यह बहुत शक्तिशाली हो सकता है, इंटरैक्टिव उपयोग के लिए, उदाहरण के लिए जब कई कॉलम और / या लंबे कॉलम नामों के साथ DataFrame s (यह मानते हुए कि वे भविष्य में df.column_name का समर्थन करेंगे)।

मुझे लगता है कि इस समय REPL (टैब-विस्तार), IJulia, इत्यादि प्रकार परिभाषा को देखते हैं, उदाहरण नहीं? लेकिन हो सकता है कि इंटरेक्टिव उपयोग के लिए इसे बदला जा सके। शायद जूनो जैसी आईडीई में समर्थन करना असंभव है, हालांकि, कोडिंग के दौरान उदाहरण उपलब्ध नहीं हैं।

@oschulz , आप पहले से ही fieldnames अधिभार ले सकते हैं:

julia> struct Foo; foo; end

julia> fieldnames(Foo)
1-element Array{Symbol,1}:
 :foo

julia> Base.fieldnames(::Type{Foo}) = [:bar, :baz]

julia> fieldnames(Foo)
2-element Array{Symbol,1}:
 :bar
 :baz

और ऐसा लगता है कि fieldnames है जो REPL को देखता है:

julia> x = Foo(3)
Foo(3)

julia> x.ba<tab>
bar baz

@yurivish सही - लेकिन क्या वर्तमान में ऐसा करना "सुरक्षित" है? मुझे यकीन नहीं है कि fieldnames पर और क्या निर्भर करता है।

यदि सुरक्षित नहीं है, तो complete_fieldnames(x) = fieldnames(x) को परिभाषित करना संभव है, REPL पूर्णता के लिए complete_fieldnames उपयोग करें, और कस्टम पूर्णता के लिए अधिभार दें।

हां, यही कारण है कि मैं इसे ऊपर ला रहा था - यदि आधार में कुछ को बदलने / जोड़ने की आवश्यकता है, ताकि आरईपीएल और मित्र बाद में इसका लाभ ले सकें। 0.7 फ़ीचर फ्रीज़ को देखते हुए ...

यही कारण है कि मुझे खुशी है कि हमने फंक्शन को getproperty ; यह स्पष्ट करने में मदद करता है कि यह fieldnames जैसी एक ही चीज़ को संदर्भित नहीं करता है। fieldnames साथ हस्तक्षेप निश्चित रूप से गंभीर समस्याएं पैदा कर सकता है।

वैध संपत्ति मान देने के लिए हमें एक समान propertynames की आवश्यकता हो सकती है। बेशक, यह एक अच्छी तरह से परिभाषित अवधारणा नहीं हो सकती है, इसलिए शायद हम पूरा होने के लिए कुछ और विशिष्ट चाहते हैं।

मुझे लग रहा था कि इसके लिए विशेषज्ञों से गहन विश्लेषण और इनपुट की आवश्यकता हो सकती है (धन्यवाद!) - क्या हमें इसके लिए एक नया मुद्दा खोलना चाहिए?