रूबी में ब्लॉकों के लिए घुंघराले ब्रेसिज़ बनाम

Question

मेरे पास एक सहकर्मी है जो मुझे यह समझाने के लिए सक्रिय रूप से कोशिश कर रहा है कि मुझे do..end का उपयोग नहीं करना चाहिए और इसके बजाय रूबी में मल्टीलाइन ब्लॉक को परिभाषित करने के लिए घुंघराले ब्रेसिज़ का उपयोग करना चाहिए।

मैं केवल एक-लाइनर्स के लिए घुंघराले ब्रेसिज़ का उपयोग करने के लिए दृढ़ता से शिविर में हूं और बाकी सभी चीजों के लिए करता हूं। लेकिन मुझे लगा कि मैं कुछ संकल्प लेने के लिए अधिक से अधिक समुदाय तक पहुंचूंगा।

तो यह कौन है, और क्यों? (कुछ कंडा कोड का उदाहरण)

context do
  setup { do_some_setup() }
  should "do somthing" do
    # some more code...
  end
end

या

context {
  setup { do_some_setup() }
  should("do somthing") {
    # some more code...
  }
}

निजी तौर पर, ऊपर वाला मेरे लिए सवाल का जवाब देख रहा है, लेकिन मैं इसे बड़े समुदाय तक खोलना चाहता था।

Comments

बस सोच रहा था लेकिन ब्रेसिज़ का उपयोग करने के लिए आपके सहकर्मियों के तर्क क्या हैं? तर्क की चीज़ की तुलना में व्यक्तिगत पसंद को अधिक पसंद करता है।

— डैनियल ली

यदि आप एक चर्चा चाहते हैं, तो इसे एक सामुदायिक विकि बनाएं। आपके प्रश्न के लिए: यह सिर्फ व्यक्तिगत शैली है। मैं घुंघराले ब्रेसिज़ पसंद करती हूं क्योंकि वे अधिक नीरस दिखते हैं।

— अर्धांश

यह एक प्राथमिकता की बात नहीं है, शैलीगत कारणों के अलावा एक दूसरे पर उपयोग करने के लिए वाक्यात्मक कारण हैं। उत्तर के कई कारण बताते हैं। सही का उपयोग करने में विफल होने से बहुत सूक्ष्म कीड़े पैदा हो सकते हैं जो यह खोजने के लिए कठिन हैं कि क्या एक और "शैलीगत" विकल्प बना है ताकि तरीकों के लिए रैपिंग कोष्ठक का उपयोग न करें।

— टिन मैन

"एज की स्थिति" उन लोगों पर चुपके करने की बुरी आदत है जो उनके बारे में नहीं जानते हैं। कोडिंग रक्षात्मक तरीके से कोडिंग शैलियों का उपयोग करने का निर्णय लेने सहित कई चीजों का मतलब है, जो मामलों में कभी भी चलने की संभावना को कम करते हैं। हो सकता है कि आप जानते हों, लेकिन आपके द्वारा जनजातीय ज्ञान को भुला दिए जाने के बाद दो लोग नहीं हो सकते हैं। यह दुर्भाग्य से कॉर्पोरेट वातावरण में होता है।

— टिन मैन

@tinman इस प्रकार की बढ़त की स्थिति TDD द्वारा नियंत्रित की जाती है। यही कारण है कि रुबिस्ट इस तरह से कोड लिख सकते हैं और पूरी रात आराम कर सकते हैं, ऐसी त्रुटियों को जानते हुए भी उनके कोड में मौजूद नहीं है। टीडीडी या बीडीडी के साथ विकसित होने और पूर्ववर्ती में इस तरह की गलती को स्क्रीन पर दिखाया गया लाल बना दिया जाता है जो हमें "आदिवासी ज्ञान" की याद दिलाता है। आमतौर पर इसका समाधान कहीं न कहीं परेंस के एक जोड़े को जोड़ना है जो मानक सम्मेलनों के भीतर पूरी तरह से स्वीकार्य है। :)

— ब्लेक टेलर

Answer 1

सामान्य सम्मेलन का उपयोग करना है .. बहु-लाइन ब्लॉकों के लिए और सिंगल लाइन ब्लॉकों के लिए घुंघराले ब्रेसिज़ के लिए, लेकिन दोनों के बीच एक अंतर भी है जिसे इस उदाहरण के साथ चित्रित किया जा सकता है:

puts [1,2,3].map{ |k| k+1 }
2
3
4
=> nil
puts [1,2,3].map do |k| k+1; end
#<Enumerator:0x0000010a06d140>
=> nil

इसका मतलब यह है कि {} में do..end से अधिक पूर्वता है, इसलिए यह ध्यान रखें कि आप क्या उपयोग करना चाहते हैं यह तय करते समय।

पुनश्च: अपनी प्राथमिकताएँ विकसित करते समय एक और उदाहरण ध्यान में रखें।

निम्नलिखित कोड:

task :rake => pre_rake_task do
  something
end

वास्तव में इसका मतलब है:

task(:rake => pre_rake_task){ something }

और यह कोड:

task :rake => pre_rake_task {
  something
}

वास्तव में इसका मतलब है:

task :rake => (pre_rake_task { something })

तो घुंघराले ब्रेसिज़ के साथ आप जो वास्तविक परिभाषा चाहते हैं, उसे पाने के लिए आपको करना होगा:

task(:rake => pre_rake_task) {
  something
}

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

Comments

मैं पूरे मामले को दरकिनार करने के लिए हमेशा विधि मापदंडों के आसपास कोष्ठक का उपयोग करने के लिए वोट देता हूं।

— टिन मैन

@ टिन मैन: आप भी रेक में कोष्ठक का उपयोग करते हैं?

— एंड्रयू ग्रिम

यह मेरे लिए एक पुरानी स्कूल प्रोग्रामिंग की आदत है। यदि कोई भाषा कोष्ठक का समर्थन करती है, तो मैं उनका उपयोग करता हूं।

— टिन मैन

पूर्ववर्ती मुद्दे को इंगित करने के लिए +1। जब मैं कोशिश करता हूं और परिवर्तित करता हूं तो मुझे कभी-कभी अप्रत्याशित अपवाद मिलते हैं; अंत {}

— idrinkpabst

puts [1,2,3].map do |k| k+1; endकेवल एन्यूमरेटर यानी एक चीज ही क्यों छापता है। कहते हैं अर्थात् यहाँ दो तर्क पारित नहीं किया है [1,2,3].mapऔर do |k| k+1; end?

— बेन

Answer 2

से रूबी प्रोग्रामिंग :

ब्रेसिज़ की एक उच्च मिसाल है; कम मिसाल है। यदि विधि इनवोकेशन में पैरामीटर होते हैं जो कोष्ठकों में संलग्न नहीं होते हैं, तो ब्लॉक का ब्रेस फॉर्म अंतिम पैरामीटर के लिए बाध्य होगा, न कि समग्र आहरण के लिए। क्या प्रपत्र आह्वान के लिए बाध्य होगा।

तो कोड

f param {do_something()}

paramकोड के दौरान ब्लॉक को वेरिएबल से बांधता है

f param do do_something() end

फ़ंक्शन को ब्लॉक को बांधता है f।

हालाँकि यह एक गैर-मुद्दा है यदि आप कोष्ठक में फ़ंक्शन तर्कों को संलग्न करते हैं।

Comments

+1 "हालाँकि यह एक गैर-मुद्दा है यदि आप कोष्ठक में फ़ंक्शन तर्क संलग्न करते हैं।" मैं मौका और दुभाषिया की सनक पर भरोसा करने के बजाय आदत के रूप में ऐसा करता हूं। :-)

— टिन मैन

@TheTinMan, यदि आपका दुभाषिया अपने पार्सर में मौके का उपयोग करता है, तो आपको एक नया दुभाषिया चाहिए।

— पॉल ड्रेपर

@PaulDraper - वास्तव में, लेकिन सभी भाषाएँ इस मुद्दे पर सहमत नहीं हैं। लेकिन (मुझे लगता है) यह बहुत ही दुर्लभ है कि पैरेंस के लिए "अपना काम" नहीं करना है, इसलिए parens का उपयोग करके सार्वभौमिक रूप से आपको भाषा डिजाइनरों द्वारा किए गए "यादृच्छिक" निर्णयों को याद रखने से बचाता है - भले ही वे ईमानदारी से कंपाइलर और दुभाषियों के कार्यान्वयनकर्ताओं द्वारा निष्पादित हों ।

— DLU

Answer 3

इस पर कुछ दृष्टिकोण हैं, यह वास्तव में व्यक्तिगत प्राथमिकता का मामला है। कई रूबिस्ट आपके द्वारा किए गए दृष्टिकोण को लेते हैं। हालांकि, दो अन्य शैलियां जो सामान्य हैं, हमेशा एक या दूसरे का उपयोग करना, या उन {}ब्लॉकों के लिए उपयोग करना है जो मूल्यों को लौटाते हैं, और do ... endसाइड इफेक्ट्स के लिए निष्पादित ब्लॉक के लिए।

Comments

यह केवल व्यक्तिगत पसंद की बात नहीं है। यदि पैराम्स को कोष्ठक में संलग्न नहीं किया जाता है, तो मापदंडों को बांधने से सूक्ष्म कीड़े हो सकते हैं।

— टिन मैन

मैं वर्तमान में अंतिम विकल्प नहीं कर रहा हूं, लेकिन मैं उल्लेख करने के लिए + 1-आईएनजी हूं कि कुछ लोग उस दृष्टिकोण को लेते हैं।

— एंड्रयू ग्रिम

अवधी ग्रिम इसके लिए एक ब्लॉग पोस्ट में वकालत करते हैं: devblog.avdi.org/2011/07/26/…

— alxndr

Answer 4

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

Comments

उदाहरण के लिए RubyMine, do ... endडिफ़ॉल्ट रूप से कीवर्ड हाइलाइट करें

— ck3g

जबकि मैं ब्रेसिज़ पसंद करता हूं, मुझे कोई कारण नहीं दिखता है कि एक संपादक को एक एकल चरित्र बनाम 2/3 वर्ण स्ट्रिंग खोजने में परेशानी होगी। हालांकि यह तर्क है कि अधिकांश संपादक पहले से ही ब्रेसिज़ से मेल खाते हैं, जबकि do ... endएक विशेष मामला है जिसके लिए भाषा विशिष्ट तर्क की आवश्यकता होती है।

— चिनोटो वोक्रो

Answer 5

सबसे आम नियम जो मैंने देखा है (हाल ही में एलोकेन्ट रूबी में है ):

• यदि यह एक बहु-पंक्ति ब्लॉक है, तो do / end का उपयोग करें
• यदि यह सिंगल लाइन ब्लॉक है, तो {} का उपयोग करें

Answer 6

मैं मत / अंत के लिए मतदान कर रहा हूँ

---

अधिवेशन do .. endबहुस्तरीय और { ... }एक-लाइनरों के लिए है।

लेकिन मुझे do .. endबेहतर पसंद है, इसलिए जब मेरे पास एक लाइनर होता है, तो मैं do .. endवैसे भी उपयोग करता हूं लेकिन इसे तीन पंक्तियों में हमेशा की तरह / अंत के लिए प्रारूपित करता हूं। इससे सभी लोग खुश हैं।

  10.times do 
    puts ...
  end

इसके साथ एक समस्या { }यह है कि यह कविता-विधा-शत्रुतापूर्ण है (क्योंकि वे अंतिम पैरामीटर को कसकर बांधते हैं न कि पूरी विधि कॉल के लिए, इसलिए आपको मेथड पार्न्स को शामिल करना होगा) और वे बस, मेरे दिमाग में, अच्छे नहीं लगते। वे कथन-समूह नहीं हैं और वे पठनीयता के लिए हैश स्थिरांक से टकराते हैं।

साथ ही, मैंने { }C कार्यक्रमों में पर्याप्त देखा है । रूबी का रास्ता, हमेशा की तरह, बेहतर है। बिल्कुल एक प्रकार का ifब्लॉक है, और आपको कभी भी वापस जाने और किसी बयान को यौगिक-कथन में बदलने की आवश्यकता नहीं है।

Comments

"मैंने C प्रोग्राम्स में पर्याप्त {} देखा है ..." और पर्ल। और, वहाँ कई बयानों के लिए +1 और रूबी के ज़ेन जैसी कोडिंग शैलियों की वकालत करने के लिए। :-)

— टीन मैन

कड़ाई से बोलते हुए, एक और "अगर" सिंटैक्स - पोस्टफिक्स "अगर" ( do_stuff if x==1) है, जो नियमित सिंटैक्स में बदलने के लिए कष्टप्रद है। लेकिन यह एक और चर्चा है।

— केल्विन

उपसर्ग if, पोस्टफिक्स if, पोस्टफिक्स unless(एक तरह का if, एक-नहीं तो) और एक लाइन के ifसाथ हैं then। रूबी रास्ता वास्तव में एक ही चीज़ को व्यक्त करने के लिए बहुत सारे तरीके हैं, जो हमेशा एक ही चीज है, सी जो पेशकश कर रहा है उससे बहुत बदतर, बहुत सरल, सख्त नियमों का पालन करता है।

— मेक्सी

तो अगर हम C में {} को पसंद करते हैं, तो इसका मतलब है कि हमें उन्हें रूबी में भी इस्तेमाल करना चाहिए?

— वारेन ड्यू

Answer 7

जब आप रिटर्न वैल्यू का उपयोग करते हैं तो कुछ प्रभावशाली रूबिस्ट्स ब्रेसिज़ का उपयोग करने का सुझाव देते हैं, और जब आप नहीं करते हैं तो / अंत करते हैं।

http://talklikeaduck.denhaven2.com/2007/10/02/ruby-blocks-do-or-brace (kut.org पर)

http://onestepback.org/index.cgi/Tech/Ruby/BraceVsDoEnd.rdoc (kut.org पर)

यह सामान्य रूप में एक अच्छा अभ्यास है।

मैं इस सिद्धांत को थोड़ा संशोधित करके कहूंगा कि आपको एक पंक्ति में do / end का उपयोग करने से बचना चाहिए क्योंकि यह पढ़ना कठिन है।

आपको ब्रेसिज़ का उपयोग करने में अधिक सावधानी बरतने की ज़रूरत है क्योंकि यह पूरी विधि कॉल के बजाय एक विधि के अंतिम परम के लिए बाध्य होगी। बस इससे बचने के लिए कोष्ठक जोड़ें।

Answer 8

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

एक उदाहरण होगा, यदि आप एक JAVA पृष्ठभूमि से आ रहे हैं, तो एक बूलियन विधि के लिए जिसका आप उपयोग कर सकते हैं

def isExpired
  #some code
end 

ऊंट मामले पर ध्यान दें और सबसे अधिक बार 'यह एक उपसर्ग विधि के रूप में पहचान करने के लिए उपसर्ग है।

लेकिन माणिक दुनिया में भी यही तरीका होगा

def expired?
  #code
end

इसलिए मैं व्यक्तिगत रूप से सोचता हूं, 'रूबी मार्ग' के साथ जाना बेहतर है (लेकिन मुझे पता है कि इसे समझने में कुछ समय लगता है (मुझे लगभग 1 वर्ष लग गया: डी)।

अंत में, मैं साथ जाऊंगा

do 
  #code
end

ब्लॉक।

Answer 9

मैंने एक और उत्तर दिया, हालांकि बड़ा अंतर पहले से ही इंगित किया गया था (पूर्वता / बंधन), और इससे मुश्किलों का पता चल सकता है (टिन मैन, और अन्य लोगों ने कहा कि बाहर)। मुझे लगता है कि मेरा उदाहरण एक सामान्य कोड स्निपेट के साथ समस्या दिखाता है, यहां तक ​​कि अनुभवी प्रोग्रामर भी रविवार की तरह नहीं पढ़ते हैं:

module I18n
    extend Module.new {
        old_translate=I18n.method(:translate)
        define_method(:translate) do |*args|
            InplaceTrans.translate(old_translate, *args)
        end
        alias :t :translate
    }
end

module InplaceTrans
    extend Module.new {
        def translate(old_translate, *args)
            Translator.new.translate(old_translate, *args)
        end
    }
end

फिर मैंने कुछ कोड सुशोभित किए ...

#this code is wrong!
#just made it 'better looking'
module I18n
    extend Module.new do
        old_translate=I18n.method(:translate)
        define_method(:translate) do |*args|
            InplaceTrans.translate(old_translate, *args)
        end
        alias :t :translate
    end
end

यदि आप {}यहां पर परिवर्तन करते हैं तो आपको do/endत्रुटि मिलेगी, यह विधि translateमौजूद नहीं है ...

ऐसा क्यों होता है, यहां एक से अधिक बातों का उल्लेख किया गया है - पूर्वता। लेकिन यहां ब्रेसेस कहां लगाएं? (@ टिन मैन: मैं हमेशा आपकी तरह ब्रेसिज़ का उपयोग करता हूं, लेकिन यहां ... ओवरसीन)

इसलिए हर उत्तर की तरह

If it's a multi-line block, use do/end
If it's a single line block, use {}

बस गलत है अगर "लेकिन ब्रेस / पूर्वता पर नजर रखें!"

फिर:

extend Module.new {} evolves to extend(Module.new {})

तथा

extend Module.new do/end evolves to extend(Module.new) do/end

(क्या कभी विस्तार का परिणाम ब्लॉक के साथ होता है ...)

तो अगर आप इसका उपयोग करना चाहते हैं / अंत का उपयोग करें:

#this code is ok!
#just made it 'better looking'?
module I18n
    extend(Module.new do 
        old_translate=I18n.method(:translate)
        define_method(:translate) do |*args|
            InplaceTrans.translate(old_translate, *args)
        end
        alias :t :translate
    end)
end

Answer 10

व्यक्तिगत पूर्वाग्रह के लिए नीचे आता है, मैं कर्ली ब्रेसिज़ को एक एंड / एंड ब्लॉक पर अधिक पसंद करता हूं क्योंकि इसकी अधिक संख्या डेवलपर्स के लिए अधिक समझ में आती है क्योंकि अधिकांश बैकग्राउंड लैंग्वेजेस उन्हें डू / एंड कन्वेंशन का उपयोग करते हैं। इसके साथ ही कहा जा रहा है कि असली कुंजी आपकी दुकान के भीतर एक समझौते पर आती है, यदि 6/10 डेवलपर्स द्वारा हर चीज का उपयोग किया जाता है, तो यदि उनका उपयोग किया जा रहा है, तो उस प्रतिमान से चिपके रहें।

इसका सभी एक पैटर्न बनाने के बारे में है ताकि एक पूरे के रूप में टीम कोड संरचनाओं को जल्दी से पहचान सके।

Comments

यह वरीयता से अधिक है। दोनों के बीच का बंधन अलग है और उन समस्याओं का कारण बन सकता है जिनका निदान मुश्किल है। जवाब में से कई समस्या का विस्तार करते हैं।

— टिन मैन

अन्य भाषा पृष्ठभूमि के लोगों के संदर्भ में - मुझे लगता है कि "समझदारी" में अंतर इस मामले में इतना छोटा है जितना कि वारंट विचार नहीं। (यह मेरा नीचा btw नहीं था।)

— केल्विन

Answer 11

उन दोनों के बीच एक सूक्ष्म अंतर है, लेकिन {} ऐसा करने / समाप्त होने की तुलना में तंग बांधता है।

Answer 12

मेरी व्यक्तिगत शैली {... }बनाम do... endपसंद के कठोर नियमों पर पठनीयता पर जोर देना है , जब ऐसी पसंद संभव है। पठनीयता के बारे में मेरा विचार इस प्रकार है:

[ 1, 2, 3 ].map { |e| e + 1 }      # preferred
[ 1, 2, 3 ].map do |e| e + 1 end   # acceptable

[ 1, 2, 3 ].each_with_object [] do |e, o| o << e + 1 end # preferred, reads like a sentence
[ 1, 2, 3 ].each_with_object( [] ) { |e, o| o << e + 1 } # parens make it less readable

Foo = Module.new do     # preferred for a multiline block, other things being equal
  include Comparable
end

Foo = Module.new {      # less preferred
  include Comparable
}

Foo = Module.new { include Comparable }      # preferred for a oneliner
Foo = module.new do include Comparable end   # imo less readable for a oneliner

[ [ 1 ], [ 1, 2 ] ].map { |e| e.map do |e| e + 1 end }  # slightly better
[ [ 1 ], [ 1, 2 ] ].map { |e| e.map { |e| e + 1 } }     # slightly worse

अधिक जटिल वाक्यविन्यास में, जैसे कि बहुस्तरीय नेस्टेड ब्लॉक, मैं सबसे प्राकृतिक परिणाम के लिए {... }और do... को endपरिसीमन करने की कोशिश करता हूं , जैसे।

Foo = Module.new { 
  if true then
    Bar = Module.new {                          # I intersperse {} and keyword delimiters
      def quux
        "quux".tap do |string|                  # I choose not to intersperse here, because
          puts "(#{string.size} characters)"    # for multiline tap, do ... end in this
        end                                     # case still loks more readable to me.
      end
    }
  end
}

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

Comments

पायथन से आ रहा है, शायद मुझे रूबी को छोड़ देना चाहिए और इसके बजाय विस्प सीखना चाहिए।

— Cees Timmerman

मेरा मानना Rubyथा कि वहाँ सबसे अच्छी व्यावहारिक भाषा थी। क्या मुझे स्क्रिप्टिंग भाषा बोलनी चाहिए? आज, मुझे लगता है कि आप समान रूप से अच्छी तरह से सीखना चाहते हैं Brainfuck।

— बोरिस स्टिटनिक

Answer 13

मैंने यहां सबसे अधिक वोट किए गए उत्तर का उदाहरण लिया। कहो,

[1,2,3].map do 
  something 
end

यदि आप यह जांचते हैं कि array.rb में आंतरिक कार्यान्वयन क्या है, तो मैप विधि का हेडर कहता है :

Invokes the given block once for each element of self.

def map(*several_variants)
    (yield to_enum.next).to_enum.to_a
end

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

इसलिए जब भी आप एक do-end ब्लॉक या {} का सामना करते हैं , तो बस एक माइंड मैप करें कि कोड के ब्लॉक को एक पैरामीटर के रूप में पास किया जा रहा है, जिसे आंतरिक रूप से निष्पादित किया जाएगा।

Answer 14

एक तीसरा विकल्प है: इंडेंटेशन से अपनी लाइन पर "अंत" का अनुमान लगाने के लिए एक प्रीप्रोसेसर लिखें। संक्षिप्त कोड पसंद करने वाले गहरे विचारक सही होते हैं।

बेहतर अभी तक, माणिक हैक करें तो यह एक झंडा है।

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

मेरी रूबी कोड लाइनों का 20% से 25% अपनी खुद की लाइन पर "अंत" है, सभी तुच्छ रूप से मेरे इंडेंटेशन सम्मेलनों से प्रभावित हैं। रूबी सबसे बड़ी सफलता हासिल करने वाली लिस्प जैसी भाषा है। जब लोग इस पर विवाद करते हैं, तो पूछते हैं कि सभी भयंकर कोष्ठक कहां हैं, मैं उन्हें एक फंतासी समारोह दिखा रहा हूं जो कि "अंत" की सात पंक्तियों में समाप्त होता है।

मैंने अधिकांश कोष्ठकों का पता लगाने के लिए एक लिस्प प्रीप्रोसेसर का उपयोग करके वर्षों तक कोड किया: A bar '| एक समूह खोला जो पंक्ति के अंत में दिखाई देता है, और एक डॉलर चिह्न '$' एक खाली प्लेसहोल्डर के रूप में कार्य करता है जहां समूह बनाने में मदद करने के लिए अन्यथा कोई प्रतीक नहीं होगा। यह बेशक धार्मिक युद्ध क्षेत्र है। कोष्ठक के बिना लिस्प / योजना सभी भाषाओं में सबसे अधिक काव्यात्मक है। फिर भी, सिंटैक्स रंग का उपयोग करके केवल कोष्ठक को शांत करना आसान है।

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