lua - लुआ ऑपरेटर्स, क्यों नहीं==,-= और इतने पर परिभाषित?




language-design assignment-operator (2)

यह एक प्रश्न है कि मैं थोड़ी देर के बारे में हल्के से चिढ़ गया हूं और जवाब खोजने के लिए लगभग कभी नहीं मिला।

हालांकि मैंने सोचा कि मैं शायद कम से कम सवाल पूछ सकता हूं और शायद कोई व्यक्ति समझा सकता है।

मूल रूप से कई भाषाओं में मैंने वाकए वाक्यविन्यास चीनी का इस्तेमाल करने के लिए काम किया है (सी ++ से वाक्यविन्यास के उपयोग से):

int main() {
    int a = 2;
    a += 3; // a=a+3
}

जबकि लुआ में += परिभाषित नहीं है, इसलिए मुझे a=a+3 लिखना होगा, जो फिर से सभी सिंटेक्टिकल चीनी के बारे में है जब एक अधिक "सार्थक" चर नाम का उपयोग करते समय जैसे: bleed_damage_over_time या कुछ ऐसा लिखना कठिन हो जाता है:

bleed_damage_over_time = bleed_damage_over_time + added_bleed_damage_over_time 

के बजाय:

bleed_damage_over_time += added_bleed_damage_over_time

तो मैं यह नहीं जानना चाहता कि यह कैसे हल करना है अगर आपके पास कोई अच्छा समाधान नहीं है, तो उस मामले में मुझे निश्चित रूप से इसे सुनने में दिलचस्पी होगी; बल्कि इस बात की वजह से लुआ इस वाक्यविन्यास चीनी को लागू नहीं करता है


मुझे लगता है कि आप इस प्रश्न को फिर से लिख सकते हैं

<featureY> <languageZ> से क्यों नहीं है?

आम तौर पर यह एक ट्रेड-ऑफ है, जो कि भाषा डिजाइनर उनके दृष्टिकोण के आधार पर बनाते हैं, जिनके लिए भाषा का उद्देश्य है, और उनके लक्ष्य।

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

यदि आप प्रत्येक और हर छोटी सुविधा को लागू करते हैं, तो आप 'रसोई सिंक' भाषा के साथ समाप्त कर सकते हैं: एडीए , कोई भी?

और जैसा कि आप कहते हैं, यह सिर्फ वाक्यात्मक चीनी है


यह मेरे भाग पर सिर्फ अनुमान है, लेकिन:

1. यह एक एकल-पास संकलक में लागू करना कठिन है

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

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

foo.bar.baz = "value"

जब आप foo.bar.baz पार्स कर रहे हैं, तो आप यह नहीं समझते कि आप वास्तव में एक असाइनमेंट को पार्स कर रहे हैं जब तक कि आप पहले ही पार्स करने के बाद = लूआ के कंपाइलर की इस वजह से असाइनमेंट को संभालने के लिए बहुत जटिलता है

स्व-असाइनमेंट का समर्थन करना इससे भी मुश्किल होगा कुछ इस तरह:

foo.bar.baz += "value"

में अनुवाद करने की आवश्यकता है:

foo.bar.baz = foo.bar.baz + "value"

लेकिन इस बिंदु पर कि संकलक = हिट करता है, यह पहले से ही foo.bar.baz बारे में भूल गया है। यह संभव है, लेकिन आसान नहीं है

2. यह व्याकरण के साथ अच्छा नहीं खेल सकता है

लुआ में वास्तव में व्याकरण में कोई कथन या रेखा विभाजक नहीं होते हैं। व्हाइटस्पेस को नजरअंदाज किया गया है और कोई अनिवार्य अर्धविराम नहीं है। तुम कर सकते हो:

io.write("one")
io.write("two")

या:

io.write("one") io.write("two")

और लुआ दोनों के साथ समान रूप से खुश हैं। उस व्याकरण की तरह एक व्याकरण रखना मुश्किल है मुझे यकीन नहीं है, लेकिन स्वयं-असाइनमेंट ऑपरेटर उस कठिन बना सकते हैं

3. यह एकाधिक असाइनमेंट के साथ अच्छा नहीं खेलता है

Lua एकाधिक असाइनमेंट का समर्थन करता है, जैसे:

a, b, c = someFnThatReturnsThreeValues()

यह मेरे लिए यह भी स्पष्ट नहीं है कि यदि आप करने की कोशिश की तो इसका क्या मतलब होगा:

a, b, c += someFnThatReturnsThreeValues()

आप स्वयं-असाइनमेंट ऑपरेटरों को एकल असाइनमेंट में सीमित कर सकते हैं, लेकिन फिर आप एक अजीब कोने के मामले में लोगों को इसके बारे में जानना चाहते हैं।

इस सबके साथ, यह बिल्कुल स्पष्ट नहीं है कि स्वयं-असाइनमेंट ऑपरेटरों के लिए उपयोगी हैं जो उपरोक्त मुद्दों से निपटने के लिए उपयुक्त हैं।





compound-assignment