जूलिया में "प्रतीक" क्या है?

Question

विशेष रूप से: मैं जूलिया के डेटाफ्रेम पैकेज का उपयोग करने की कोशिश कर रहा हूं, विशेष रूप से नाम विकल्प के साथ पठनीय() फ़ंक्शन, लेकिन इसके लिए प्रतीकों के वेक्टर की आवश्यकता होती है।

• प्रतीक क्या है?
• वे स्ट्रिंग के वेक्टर पर क्यों चुनेंगे?

अब तक मुझे जूलिया भाषा में शब्द प्रतीक के केवल कुछ हद तक संदर्भ मिले हैं। ऐसा लगता है कि प्रतीक ": var" द्वारा दर्शाए जाते हैं, लेकिन यह मेरे लिए स्पष्ट है कि वे क्या हैं।

एक तरफ: मैं

df = readtable("table.txt", names = [symbol("var1"), symbol("var2")]) 

मेरे दो बुलेटेड सवाल अभी भी खड़ा चला सकते हैं।

Answer 1

जूलिया में प्रतीक लिस्प, योजना या रूबी के समान हैं। हालांकि, the answers उन संबंधित प्रश्नों के लिए are not really satisfactory, मेरी राय में। यदि आप उन उत्तरों को पढ़ते हैं, तो ऐसा लगता है कि प्रतीक एक स्ट्रिंग से अलग है क्योंकि तार विचलित होते हैं जबकि प्रतीकों अपरिवर्तनीय होते हैं, और प्रतीक भी "इंटर्न" होते हैं - जो भी इसका मतलब है। स्ट्रिंग्स रूबी और लिस्प में उत्परिवर्तनीय होने लगती हैं, लेकिन वे जूलिया में नहीं हैं, और यह अंतर वास्तव में एक लाल हेरिंग है। तथ्य यह है कि प्रतीकों को प्रशिक्षित किया जाता है - यानी तेजी से समानता तुलना के लिए भाषा कार्यान्वयन द्वारा धोया गया - यह भी एक अप्रासंगिक कार्यान्वयन विस्तार है। आप एक कार्यान्वयन कर सकते हैं जो आंतरिक प्रतीक नहीं है और भाषा बिल्कुल वही होगी।

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

foo == "foo" 

अब हम इस मामले के दिल के लिए हो रही है: एक प्रतीक के बीच का अंतर और एक स्ट्रिंग है उस तुलना के बाईं ओर foo और दाएं हाथ की ओर "foo" के बीच का अंतर। बाईं ओर, foo एक पहचानकर्ता है और यह वर्तमान दायरे में परिवर्तनीय foo से संबंधित मान का मूल्यांकन करता है। दाईं ओर, "foo" एक स्ट्रिंग अक्षर है और यह स्ट्रिंग मान "foo" का मूल्यांकन करता है। लिस्प और जूलिया दोनों में एक प्रतीक यह है कि आप डेटा के रूप में एक चर का प्रतिनिधित्व कैसे करते हैं। एक स्ट्रिंग सिर्फ खुद का प्रतिनिधित्व करता है। आप उन्हें eval लगाने से अंतर देख सकते हैं:

julia> eval(:foo) 
ERROR: foo not defined 

julia> foo = "hello" 
"hello" 

julia> eval(:foo) 
"hello" 

julia> eval("foo") 
"foo" 

क्या प्रतीक :foo का मूल्यांकन क्या पर निर्भर करता है - अगर कुछ - चर foo, करने के लिए बाध्य किया जाता है जबकि "foo" हमेशा बस "foo" करने के लिए मूल्यांकन करता है। यदि आप जूलिया में अभिव्यक्तियां बनाना चाहते हैं जो चर का उपयोग करते हैं, तो आप प्रतीकों का उपयोग कर रहे हैं (चाहे आप इसे जानते हों या नहीं)।उदाहरण के लिए:

julia> ex = :(foo = "bar") 
:(foo = "bar") 

julia> dump(ex) 
Expr 
    head: Symbol = 
    args: Array{Any}((2,)) 
    1: Symbol foo 
    2: String "bar" 
    typ: Any 

क्या है कि सामान से पता चलता है बाहर फेंक दिया, अन्य बातों के अलावा, वहाँ अभिव्यक्ति वस्तु आप कोड foo = "bar" को उद्धृत करके मिल के अंदर एक :foo प्रतीक वस्तु है कि है। यहाँ एक और उदाहरण है, प्रतीक :foo चर sym में संग्रहीत के साथ एक अभिव्यक्ति का निर्माण:

julia> sym = :foo 
:foo 

julia> eval(sym) 
"hello" 

julia> ex = :($sym = "bar"; 1 + 2) 
:(begin 
     foo = "bar" 
     1 + 2 
    end) 

julia> eval(ex) 
3 

julia> foo 
"bar" 

आप जब sym स्ट्रिंग "foo" के लिए बाध्य है यह करने के लिए प्रयास करते हैं तो यह काम नहीं करेगा:

julia> sym = "foo" 
"foo" 

julia> ex = :($sym = "bar"; 1 + 2) 
:(begin 
     "foo" = "bar" 
     1 + 2 
    end) 

julia> eval(ex) 
ERROR: syntax: invalid assignment location ""foo"" 

यह देखना बहुत स्पष्ट है कि यह क्यों काम नहीं करेगा - अगर आपने हाथ से "foo" = "bar" असाइन करने का प्रयास किया है, तो यह भी काम नहीं करेगा।

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

ध्यान दें कि मैंने रूबी के बारे में कुछ समय पहले बात करना बंद कर दिया था। ऐसा इसलिए है क्योंकि रूबी homoiconic नहीं है: रूबी रूबी वस्तुओं के रूप में अपने अभिव्यक्ति का प्रतिनिधित्व नहीं करता है। तो रूबी का प्रतीक प्रकार एक वेस्टिगियल अंग है - एक बचे हुए अनुकूलन, जिसे लिस्प से विरासत में मिला है, लेकिन अब इसका मूल उद्देश्य नहीं है। रूबी प्रतीकों को अन्य उद्देश्यों के लिए सह-चुना गया है - हैश कुंजी के रूप में, विधि तालिकाओं से विधियों को खींचने के लिए - लेकिन रुबी में प्रतीकों का उपयोग चर का प्रतिनिधित्व करने के लिए नहीं किया जाता है।

स्ट्रिंग के बजाए डेटाफ्रेम में प्रतीकों का उपयोग क्यों किया जाता है, ऐसा इसलिए है क्योंकि यह डेटाफ्रेम में उपयोगकर्ता द्वारा प्रदत्त अभिव्यक्तियों के अंदर चर के लिए कॉलम मानों को बाध्य करने के लिए एक सामान्य पैटर्न है। तो कॉलम नामों के प्रतीक होने के लिए यह स्वाभाविक है, क्योंकि प्रतीक वही हैं जो आप डेटा के रूप में चर का प्रतिनिधित्व करने के लिए उपयोग करते हैं। वर्तमान में, आपको foo कॉलम तक पहुंचने के लिए df[:foo] लिखना है, लेकिन भविष्य में, आप इसे df.foo के रूप में एक्सेस करने में सक्षम हो सकते हैं। जब यह संभव हो जाता है, केवल कॉलम जिनके नाम मान्य पहचानकर्ता हैं, इस सुविधाजनक वाक्यविन्यास के साथ पहुंच योग्य होंगे।

यह भी देखें:

• https://docs.julialang.org/en/latest/manual/metaprogramming/
• In what sense are languages like Elixir and Julia homoiconic?