कोष्ठक में खोए बिना क्विक को कैसे संपादित करें

13

मैं linum.el से कुछ विशिष्ट कोड को संशोधित कर रहा हूं:

(custom-set-variables '(linum-format 'dynamic))
(defadvice linum-update-window (around linum-dynamic activate)
   (let* ((w (length (number-to-string
      (+ (count-lines (point-min) (point-max)) 1))))
         (linum-format (concat " %" (number-to-string w) "d ")))
            ad-do-it))

मैं एक बग जहां खरोज संशोधित करके बंद-एक करके था ठीक करने में सक्षम था (count-lines (point-min) (point-max))करने के लिए (+ (count-lines (point-min) (point-max)) 1)। वह तो आसान था।

लेकिन अब मैं इसे संशोधित करना चाहता हूं, ताकि (concat " %" (number-to-string w) "2d ")यदि कोई लाइन-काउंट काउंट <10 है तो एक न्यूनतम-शर्त जोड़कर न्यूनतम चौड़ाई 2 हो जाए।

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

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

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

जाहिर है मैं यह सब गलत कर रहा हूं। मैं बिना किसी डर के इस तरह से कैसे छू सकता हूं?

कृपया ध्यान दें कि मेरा सवाल यह है कि कैसे नेविगेट करें और संपादित करें शैली में एक प्रश्न के रूप में नहीं। मैं पहले से ही एक स्टाइल गाइड के रूप में निम्नलिखित का उपयोग कर रहा हूं: https://github.com/bbatsov/emacs-lisp-style-guide

अपडेट:

Emacs.stackexchange पर खुद को शर्मिंदा करने से पहले कैसे ठीक से प्रारूपित करें:

अपने योग्य को चिह्नित करें और प्रदर्शन करें M-x indent-region।

समस्या समाधान:

उन लोगों के लिए, जो दो की न्यूनतम चौड़ाई के साथ लाइनम के लिए एक सही-सही प्रदर्शन करने का तरीका जानना चाहते हैं, यहां समाधान है:

(defadvice linum-update-window (around linum-dynamic activate)
  (let* ((w (length (number-to-string
                     (+ (count-lines (point-min) (point-max)) 1))))
         (linum-format (if (> w 1)
                           (concat " %" (number-to-string w) "d ")
                         " %2d ")))
    ad-do-it))
elisp  editing  programming 
— Zhro
स्रोत
1
सी। से आने वाले लिस्प को पढ़ने में हर किसी को परेशानी होती है। इसमें अभी समय लगता है, लेकिन आखिरकार यह बहुत स्वाभाविक हो जाता है। इसके अलावा आप शायद "% 2d" जैसे प्रारूप स्ट्रिंग के लिए लाइनम-प्रारूप को बदलकर अपनी समस्या को हल कर सकते हैं।
— जॉर्डन बियोन्डो
मैं सिर्फ %2dइसलिए उपयोग नहीं कर सकता क्योंकि एक बार जब चौड़ाई 3 या अधिक वर्णों तक लुढ़क जाती है तो यह दाईं-ओर से बाईं ओर से न्यायोचित हो जाती है।
— झिरो
कुछ पुस्तकालय हैं जो मेल खाते हुए कोष्ठकों को उजागर करते हैं जो अमूल्य हैं (मेरी राय में), उदाहरण के लिए highlight-parentheses; rainbow-delimiters; आदि यहाँ मेरा अपना सरलीकृत संस्करण है, highlight-parenthesesजो पिछले रंग वाले कोष्ठक को हटाए बिना स्क्रॉल करने की अनुमति देता है: stackoverflow.com/a/23998965/2112489 भविष्य में, यह प्रति ग्राहक एक सवाल है।
— कानून
1
ऐसा लगता है कि आपकी समस्या वास्तव में पढ़ रही है , न कि एलिस कोड को संपादित करना। आपको लगता है कि आपको लिस्प की संरचना को समझने में समस्याएं हैं, और यह आपके संपादन को बाधित करता है।
— PythonNut
1
अपने बचाव में, यह कोड का एक बहुत बुरी तरह से प्रेरित टुकड़ा है। मैंने इसे गलत इसलिए पढ़ा क्योंकि यह पहली बार था। इसके अलावा, पैराडिट ।
— मालाबार 16

जवाबों:

12

ऐसे कई ऐड-ऑन पैकेज हैं, जो मदद कर सकते हैं, जैसे कि पैराडिट, स्मार्टपरेंस और लिस्पी। इन पैकेजों से लिस्प कोड को नेविगेट करना और हेरफेर करना आसान हो जाता है ताकि आप एस-एक्सप्रेशन में सोच सकें और एडिटर को बैलेंसिंग पार्न्स के बारे में चिंता करने दें।

Emacs में सेक्सप्स और सूचियों से निपटने के लिए बहुत सारे अंतर्निहित कमांड हैं जो सीखने लायक हैं और आपको लिस्प कोड की संरचना में अधिक उपयोग करने में मदद कर सकते हैं। ये आम तौर पर एक C-M-उपसर्ग के साथ बंधे होते हैं , जैसे:

  • C-M-f/ C-M-bसेक्सप द्वारा आगे / पीछे जाने के लिए
  • C-M-n/ C-M-pसूची द्वारा आगे / पिछड़े जाने के लिए
  • C-M-u/ C-M-dएक स्तर ऊपर / नीचे जाने के लिए
  • C-M-t बिंदु के चारों ओर दो लिंगों को स्वैप करने के लिए
  • C-M-k सेक्सप को मारने के लिए
  • C-M-SPC एक लिंग को चिह्नित करने के लिए
  • C-M-q एक लिंग को फिर से इंडेंट करने के लिए

यदि आप इंडेंटेशन ठीक करते हैं तो आपके द्वारा प्रदान किया गया उदाहरण कोड स्पष्ट हो सकता है: शुरुआत की शुरुआत में बिंदु डालें (defadvice...और C-M-qसंपूर्ण अभिव्यक्ति को फिर से इंडेंट करने के लिए हिट करें। प्रतिस्थापित करने के लिए (concat...मैं उस सेक्सप की शुरुआत में बिंदु डालकर शुरू करूंगा और C-M-oइंडेंटेशन को संरक्षित करते हुए लाइन को विभाजित करने के लिए मारूंगा । फिर अपना जोड़ें (if..., और ऊपर दिए गए आदेशों का उपयोग करके किसी अन्य समापन पारे को जोड़ने के लिए सूची के अंत में फिर से शुरू करने के लिए वापस जाएं, आदि।

तुम भी चालू करना चाहते हो सकता है show-paren-mode, जो एक सूची के शुरू या अंत में जब बिंदु के अनुरूप है पर प्रकाश डाला जाएगा। आप मिलान परन के बजाय पूरी अभिव्यक्ति को उजागर करना पसंद कर सकते हैं, इसलिए कस्टमाइज़ करने का प्रयास करें show-paren-style।

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

— glucas
स्रोत
ध्यान दें कि बिंदु पर अभिव्यक्ति को सुंदर रूप से प्रिंट करने के लिए C-M-qएक उपसर्ग तर्क ( C-u C-M-q) के साथ बुलाया जा सकता है । यह अलग लाइनों और इंडेंट पर सब कुछ तोड़ देगा ताकि घोंसला बहुत स्पष्ट हो। आप आम तौर पर अपने लिस्प कोड को ऐसा नहीं चाहते हैं, लेकिन मैन्युअल रूप से उस पर पूर्ण के एंड आर के बिना कोड को समझने में मदद मिल सकती है। (और आप हमेशा C-x uपूर्ववत कर सकते हैं )।
— ग्लूकोज 17
6

व्यक्तिगत पात्रों या लाइनों के बजाय एएसटी में हेरफेर करके एलआईएसपी को संपादित करने का एक अच्छा तरीका है। मैं अपने पैकेज के साथ ऐसा कर रहा हूं, जिसे मैंने 2 साल पहले शुरू किया था। मुझे लगता है कि यह वास्तव में यह जानने के लिए काफी अभ्यास कर सकता है कि यह कैसे करना है, लेकिन यहां तक ​​कि सिर्फ मूल बातों का उपयोग करके आपको पहले से ही मदद करनी चाहिए।

मैं समझा सकता हूं कि मैं इस बदलाव को कैसे करूंगा:

चरण 1

प्रारंभिक स्थिति आमतौर पर शीर्ष-स्तरीय सेक्सप से पहले बिंदु होती है। यहाँ, |बिंदु है।

|(defadvice linum-update-window (around linum-dynamic activate)
   (let* ((w (length (number-to-string
      (+ (count-lines (point-min) (point-max)) 1))))
         (linum-format (concat " %" (number-to-string w) "d ")))
            ad-do-it))

आप कोड ठीक से इंडेंट करना चाहते हैं, इसलिए iएक बार दबाएं । यह अच्छी तरह से फिर से इंडेंट करेगा।

चरण 2

आप "d "एक क्षेत्र के साथ चिह्नित करना चाहते हैं , क्योंकि एक हेरफेर-सक्षम ऑब्जेक्ट lispyया तो एक सूची है, जिसे चिह्नित करने की आवश्यकता नहीं है, या प्रतीकों या / और सूचियों का एक अनुक्रम जिसे एक क्षेत्र के साथ चिह्नित करने की आवश्यकता है।

atऐसा करने के लिए दबाएँ । aआदेश माता पिता सूची के भीतर किसी एकल प्रतीक चिह्नित करने के लिए अनुमति देता है, और tइस विशेष प्रतीक के सूचकांक है।

चरण 3

  1. वर्तमान क्षेत्र को लपेटने के लिए (), दबाएँ (।
  2. C-fआगे बढ़ने के लिए एक चार दबाएँ और डालें if।
  3. (डालने के लिए फिर से दबाएं ()।
  4. सम्मिलित करें > w 10।
  5. C-f C-m स्ट्रिंग को एक नई लाइन पर ले जाने के लिए।

चरण 4

स्ट्रिंग को क्लोन करने के लिए:

  1. चिह्न-या-स्ट्रिंग-पर-बिंदु के साथ चिह्नित करें M-m।
  2. प्रेस करें c।

यदि आप इस क्षेत्र को एक फैंसी तरीके से निष्क्रिय करना चाहते हैं और स्ट्रिंग के बहुत शुरुआत में बिंदु डाल सकते हैं, तो आप दबा सकते हैं idm:

  1. i स्ट्रिंग की आंतरिक सामग्री का चयन करेगा।
  2. d बिंदु और चिह्न स्वैप करेंगे।
  3. m इस क्षेत्र को निष्क्रिय कर देगा

या आप m C-b C-b C-bइस मामले में कर सकते हैं , या C-g C-b C-b C-b। मुझे लगता idmहै कि यह बेहतर है, क्योंकि यह स्ट्रिंग की लंबाई की परवाह किए बिना समान है। मुझे लगता C-x C-x C-f C-g है कि स्ट्रिंग की लंबाई की परवाह किए बिना भी काम होगा।

अंत में, 2अंतिम कोड प्राप्त करने के लिए डालें :

(defadvice linum-update-window (around linum-dynamic activate)
  (let* ((w (length (number-to-string
                     (+ (count-lines (point-min) (point-max)) 1))))
         (linum-format (concat " %" (number-to-string w) (if (> w 10)
                                                             "2|d "
                                                           "d "))))
    ad-do-it))

सारांश

पूर्ण दृश्य था: at( C-f, if, (, > w 10, C-f C-m M-m cidm, 2।

ध्यान दें कि यदि आप कोड सम्मिलन की गणना करते हैं, तो एएसटी हेरफेर से संबंधित एकमात्र कुंजी दो C-fऔर एक नहीं थी C-m।

— abo-abo
स्रोत
3
दिलचस्प लगता है! ओपी के लिए: आप समान वर्कफ़्लोज़ को पेरेडिट के साथ विकसित कर सकते हैं: emacsrocks.com/e14.html और क्षेत्र का विस्तार करें: github.com/magnars/expand-region.el , या केवल अंतर्निहित कोष्ठक मिलान आदेशों के साथ खेल रहे हैं: ग्नू। org / सॉफ्टवेयर / emacs / मैनुअल / html_node / emacs / Parentheses.html
— टायलर
मुझे यकीन है कि जब आप मेरे लिए समस्या को हल करने के लिए बंधे थे, तो आप अनुमान लगा रहे थे; प्रयास के लिए धन्यवाद। मैं एक उदाहरण के रूप में आपके कोड का उपयोग करके इसके माध्यम से अपना रास्ता बनाने में कामयाब रहा। सही समाधान के लिए मेरा अपडेट देखें।
— झेरो
6

आपको समय के साथ इसकी आदत हो जाएगी, लेकिन निश्चित रूप से बहुत कुछ है जो आप इसे गति देने में मदद कर सकते हैं:

खरोज

इस पागलपन के लिए एक विधि है। लिस्प में आप ऐसा कर सकते हैं:

(a-fun (another-fun (magic-macro 1)))

मान लीजिए कि 1यह वास्तव में एक बड़ी अभिव्यक्ति है, और आप इसे अपनी लाइन पर इंडेंट करना चाहते हैं।

(a-fun (another-fun (magic-macro 
  1)))

यह भ्रामक है। 1केवल एक स्लॉट का इंडेंट किया जाता है, भले ही यह उच्च स्तर के घोंसले के पूरे तीन स्तर हो! बेहतर यह अपने माता पिता द्वारा डाल दिया।

(a-fun (another-fun (magic-macro 
                      1)))

यदि हम अपने कोड पर इस योजना का उपयोग करते हैं, तो हमें यह मिलता है:

(custom-set-variables '(linum-format 'dynamic))
(defadvice linum-update-window (around linum-dynamic activate)
  (let* ((w (length (number-to-string
                      (+ (count-lines (point-min) (point-max)) 1))))       
          (linum-format 
            (concat " %" (number-to-string w) "d ")))
     ad-do-it))

इंडेंटेशन और नेस्टिंग के स्तर के बीच मजबूत सहसंबंध पर ध्यान दें। घोंसले के अधिक से अधिक स्तर वाली लाइनें हमेशा कम के साथ लाइनों से अधिक इंडेंट की जाती हैं।

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

एक अभ्यास के रूप में, मैंने गैर-प्रासंगिक कोष्ठक को कोड से हटा दिया है। आपको एलिस्प के मूल ज्ञान (अर्थात्, क्या कार्य और मूल्य हैं, और की संरचना let*) को देखते हुए, आपको कोड को पढ़ने और लापता कोष्ठकों की आपूर्ति करने में सक्षम होना चाहिए ।

custom-set-variables '(linum-format 'dynamic)
defadvice linum-update-window (around linum-dynamic activate)
  let* w length number-to-string
                  + 
                    count-lines (point-min) (point-max) 
                    1       
         linum-format 
           concat " %" (number-to-string w) "d "
     ad-do-it
— PythonNut
स्रोत
1
ध्यान दें कि Emacs में, हिटिंग टैब लगभग हमेशा इंडेंटेशन को सही ढंग से सेट करेगा जैसा कि यहाँ वर्णित है - आपको कभी भी हाथ से रिक्त स्थान जोड़कर ऐसा नहीं करना चाहिए!
— टायलर
newline-and-indentEmacs- लिस्प-मोड और लिस्प-इंटरैक्शन-मोड के लिए "Cm" को अपने पहले उदाहरण, PythonNut से हल करता है। और TAB बाकी समय काम करेगा।
— क्यूब्रेनिक
5

मैं इसे एक अलग उत्तर के रूप में शामिल कर रहा हूं।

कभी-कभी, इंडेंटेशन आपको विफल कर देगा। आपका सहारा फिर, कुछ इस तरह का उपयोग करना है rainbow-delimiters:

यहाँ छवि विवरण दर्ज करें

यह किसी भी पेरेन के घोंसले के स्तर को स्पष्ट और आसानी से स्कैन करता है।

एक बहुत बड़ी समस्या है, हालांकि: परायी लडकियाँ ध्यान भटका रही हैं। यहां जोर का संतुलन है। rainbow-delimitersआम तौर पर अपने कोड के बाकी की कीमत पर Parens पर बहुत जोर दिया जाएगा ! लेकिन अगर आप इंद्रधनुष का सामना करते हैं, तो वे स्कैन करने के लिए उत्तरोत्तर कठिन हो जाते हैं।

यदि आप ऐसे चेहरे का एक सेट पा सकते हैं जो इसे अच्छी तरह से संतुलित करता है, तो हर तरह से इसका उपयोग करें।

उस ने कहा, एक समाधान (एक जो मुझे उल्लास से भर देता है), चेहरे के दो सेट हैं, और मक्खी के बीच उन पर स्विच करें। जब आप अन्य सामान कर रहे होते हैं, तो चेहरे को पतला और पृष्ठभूमि में फीका कर दिया जाता है:

यहाँ छवि विवरण दर्ज करें

लेकिन जब आप बिंदु को एक परन पर रखते हैं, तो यह पार्न्स को छिद्रित करता है ताकि आप घोंसले के स्तर को देख सकें:

यहाँ छवि विवरण दर्ज करें

और यहाँ यह करने के लिए कोड है:

(defvar rainbow-delimiters-switch nil
  "t if rainbow-delimiters are currently punched")
(defvar rainbow-delimiters-face-cookies nil
  "a list of face-remap-add-relative cookies to reset")

(make-variable-buffer-local 'rainbow-delimiters-switch)
(make-variable-buffer-local 'rainbow-delimiters-face-cookies)

(add-hook 'prog-mode-hook #'rainbow-delimiters-mode)
(add-hook 'text-mode-hook #'rainbow-delimiters-mode)

(with-eval-after-load 'rainbow-delimiters
  (set-face-foreground 'rainbow-delimiters-depth-1-face "#889899")
  (set-face-foreground 'rainbow-delimiters-depth-2-face "#9b7b6b")
  (set-face-foreground 'rainbow-delimiters-depth-3-face "#7b88a5")
  (set-face-foreground 'rainbow-delimiters-depth-4-face "#889899")
  (set-face-foreground 'rainbow-delimiters-depth-5-face "#839564")
  (set-face-foreground 'rainbow-delimiters-depth-6-face "#6391aa")
  (set-face-foreground 'rainbow-delimiters-depth-7-face "#9d748f")
  (set-face-foreground 'rainbow-delimiters-depth-8-face "#7b88a5")
  (set-face-foreground 'rainbow-delimiters-depth-9-face "#659896")

  (defun rainbow-delimiters-focus-on ()
    "Punch the rainbow-delimiters"
    (setq rainbow-delimiters-face-cookies
      (list
        (face-remap-add-relative 'rainbow-delimiters-depth-1-face
          '((:foreground "#3B9399") rainbow-delimiters-depth-1-face))
        (face-remap-add-relative 'rainbow-delimiters-depth-2-face
          '((:foreground "#9B471D") rainbow-delimiters-depth-2-face))
        (face-remap-add-relative 'rainbow-delimiters-depth-3-face
          '((:foreground "#284FA5") rainbow-delimiters-depth-3-face))
        (face-remap-add-relative 'rainbow-delimiters-depth-4-face
          '((:foreground "#3B9399") rainbow-delimiters-depth-4-face))
            (face-remap-add-relative 'rainbow-delimiters-depth-5-face
          '((:foreground "#679519") rainbow-delimiters-depth-5-face))
        (face-remap-add-relative 'rainbow-delimiters-depth-6-face
          '((:foreground "#0E73AA") rainbow-delimiters-depth-6-face))
        (face-remap-add-relative 'rainbow-delimiters-depth-7-face
          '((:foreground "#9D2574") rainbow-delimiters-depth-7-face))
        (face-remap-add-relative 'rainbow-delimiters-depth-8-face
          '((:foreground "#284FA5") rainbow-delimiters-depth-8-face))
        (face-remap-add-relative 'rainbow-delimiters-depth-9-face
          '((:foreground "#199893") rainbow-delimiters-depth-9-face)))
      rainbow-delimiters-switch t))

  (defun rainbow-delimiters-focus-off ()
    "Reset the rainbow-delimiters faces"
    (mapc #'face-remap-remove-relative rainbow-delimiters-face-cookies)
    (setq rainbow-delimiters-switch nil))

  (defun rainbow-delimiters-focus-on-maybe ()
    "Punch the rainbow-delimiters if the point is on a paren"
    (when (looking-at "[][(){}]")
      (unless (or rainbow-delimiters-switch (minibufferp))
        (rainbow-delimiters-focus-on))))

  (defun rainbow-delimiters-focus-off-maybe ()
    "Reset the rainbow-delimiters if the point is not on a paren"
    (unless (looking-at "[][(){}]")
      (when rainbow-delimiters-switch
        (rainbow-delimiters-focus-off))))

  (run-with-idle-timer 0.6 t 'rainbow-delimiters-focus-on-maybe)
  (run-with-idle-timer 0.1 t 'rainbow-delimiters-focus-off-maybe))
— PythonNut
स्रोत
यह अच्छा है! किसी भी कारण से आपने शुरू करने के लिए हाइलाइट-कोष्ठकों पर इंद्रधनुष-सीमांकक चुना?
— टायलर
@ टायलर कोई विशेष कारण नहीं है, हालांकि मैं अभी भी इंद्रधनुषी के साथ छड़ी करूंगा (लेकिन यह सिर्फ इसलिए हो सकता है क्योंकि मैं इसका उपयोग कर रहा हूं)। मैंने बहुत हाल तक हाइलाइट-कोष्ठक के बारे में नहीं सुना था।
— पायथनटन
4

यदि आप अपने कोड को इंडेंट करते हैं, तो आपको वास्तव में इसे ठीक से इंडेंट करने की आवश्यकता है। लिस्प डेवलपर्स को उम्मीद है कि ठीक से इंडेंट की तरह दिखना चाहिए। इसका मतलब यह नहीं है कि कोड सभी समान दिखता है। कोड को प्रारूपित करने के लिए अभी भी अलग-अलग तरीके हैं।

  • एक पंक्ति कितनी लंबी होनी चाहिए?
  • कैसे एक समारोह / मैक्रो कॉल लाइनों पर वितरित करने के लिए?
  • इंडेंटेशन के कितने स्थान होने चाहिए?
(defadvice linum-update-window (around linum-dynamic activate)
   (let* ((w (length (number-to-string
      (+ (count-lines (point-min) (point-max)) 1))))
         (linum-format (concat " %" (number-to-string w) "d ")))
            ad-do-it))

मुझे उम्मीद है कि इंडेंटेशन किसी तरह से कंटेंट को दर्शाता है। लेकिन आपके कोड में नहीं।

डिफ़ॉल्ट रूप से आपका कोड इस तरह इंडेंट किया जा सकता है। अन्य उत्तर बताए गए हैं कि आप Emacs की मदद से कैसे कर सकते हैं:

(defadvice linum-update-window (around linum-dynamic activate)
  (let* ((w (length (number-to-string
                     (+ (count-lines (point-min) (point-max)) 1))))
         (linum-format (concat " %" (number-to-string w) "d ")))
    ad-do-it))

मैं उम्मीद करूंगा कि letबाध्य चर उसी ऊर्ध्वाधर स्तंभ पर शुरू होते हैं। मैं भी उम्मीद होती है कि शरीर के letकम इंडेंट है। हम सीखते हैं कि कैसे letइंडेंट होना चाहिए। एक बार जब आप इसे थोड़ा सा प्रशिक्षित करते हैं, तो यह एक दृश्य पैटर्न है जिसे पहचानना आसान है।

कोड में मुख्य दृश्य बिल्डिंग ब्लॉक हैं defadvice, let*और फ़ंक्शन कॉल का एक गुच्छा है। defनाम में मुझसे कहता है कि यह एक परिभाषा एक नाम, एक तर्क सूची और एक शरीर के द्वारा पीछा किया है।

इस प्रकार मैं देखना पसंद करता हूं

defadvice name arglist
  body

यह let*होगा: let*बाइंडिंग और एक निकाय की सूची।

इस प्रकार मैं देखना पसंद करता हूं:

let*  list of bindings
  body

अधिक विवरण:

let*   binding1
       binding2
       binding3
  body

एक फ़ंक्शन कॉल के लिए मुझे देखना पसंद है:

FUNCTIONNAME ARG1 ARG2 ARG3

या

FUNCTIONNAME ARG1
             ARG2
             ARG3

या

FUNCTIONNAME
  ARG1
  ARG2
  ARG3

कौन सा उपयोग किया जाता है यह इस बात पर निर्भर करता है कि तर्क कितने लंबे हैं। हम लाइनों को बहुत लंबा नहीं करना चाहते हैं और इसकी अपनी लाइन पर प्रत्येक arg हमें अधिक संरचना की अनुमति देता है।

तो आपको उन पैटर्नों का उपयोग करके अपना कोड लिखना होगा और आपको यह सुनिश्चित करने की आवश्यकता है कि पाठक आपके कोड में उन पैटर्नों को आसानी से पहचान सके।

कोष्ठकों को सीधे अपने निर्माणों को संलग्न करना चाहिए।

(sin 10)

(sin
  10)

व्हॉट्सएप उदाहरणों से बचें:

(  sin 10  )

या

(
   sin
)

या

(sin 10
)

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

अभिव्यक्ति सीमाओं को खोजने में सहायता करने के लिए कोष्ठक का उपयोग करें। उन्हें सूची से सूची में जाने, सूचियों को संपादित करने, सूचियों को काटने और कॉपी करने, सूचियों को बदलने, सूचियों / प्रारूप सूचियों का चयन करने, सूचियों का चयन करने, ...

— रेनर जोसविग
स्रोत
2

इंडेंटेशन के साथ बुनियादी मदद के लिए, TAB और "CMq" ( indent-pp-sexp) का उपयोग करें; "Cm" को बांधने से newline-and-indentआप एक नई सीमा के बाद TAB को दबाएंगे।

आप "सीएम-बाएं / दाएं / ऊपर / नीचे / घर / अंत" के साथ सेक्सप द्वारा नेविगेट कर सकते हैं, जो बहुत उपयोगी है।

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

अंत में, हाइपरेंस को हाइलाइट करने के लिए, विकल्प को चालू करके शुरू करें (विकल्प मेनू-> मेल खाने वाले कोष्ठक हाइलाइट करें, या show-paren-mode।) आप अपनी टिप्पणी में लॉलिस्ट द्वारा उल्लेखित पैकेजों में से एक का उपयोग कर सकते हैं, जैसे "हाइलाइट-कोष्ठक" या "इंद्रधनुष-सीमांकक"। "।

— क्यूबेरिक का स्वाद लें
स्रोत
1

दूसरों ने जवाब के रूप में जो दिया है, उसके अलावा, यहाँ मेरे 2 सेंट हैं:

  • द्वारा प्रदान किया गया स्वचालित इंडेंटेशन emacs-lisp-modeआवश्यक है।
  • blink-matching-parennilडिफ़ॉल्ट रूप से (गैर- ) पर है। इसे छोड़ दो।
  • मैं उपयोग करता हूं show-paren-mode, कर्सर से पहले दाएं पैर के लिए बाएं पैरेन को उजागर करने के लिए।
  • मैं अस्थायी रूप से कर्सर से पहले दाएं पैरेन को हटा देता हूं और फिर से रखता हूं, अगर मैं बेहतर देखना चाहता हूं कि मैचिंग बाएं पेरेन कहां है।

मैं इलेक्ट्रिक पेयरिंग या इंद्रधनुष का उपयोग नहीं करता हूं और न ही ऐसी कोई अन्य "मदद" करता हूं । मेरे लिए वे एक परेशान हैं, सहायता नहीं।

विशेष रूप से, electric-pair-modeमेरे लिए, एक असुविधाजनक परेशान है। लेकिन कुछ लोग इसे पसंद करते हैं। और मुझे लगता है कि यह लिस्प कोष्ठक के अलावा कुछ अन्य बाँधने के संदर्भों में सहायक हो सकता है (मैं कल्पना करता हूं, लेकिन मैं ऐसे उपयोग मामलों के लिए आश्वस्त नहीं हूं)।

आप पाएंगे कि आपके लिए सबसे अच्छा काम क्या है। मुख्य बातें जो मैं कहना चाहता हूं: (1) स्वत: इंडेंटेशन आपका मित्र है, जैसा कि बाएं पेरेन को स्पॉट करने का कुछ तरीका है जो बिंदु से पहले दाएं पेरेन से मेल खाता है।

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

स्वत: इंडेंटेशन के अलावा आप के साथ मिलता है RETऔर TAB, का उपयोग कर आराम मिलता है C-M-q। (प्रयोग C-h kमें emacs-lisp-modeपता लगाने के लिए क्या इन कुंजियों से करते हैं।)

— ड्रयू
स्रोत
1

मैंने देखा कि कुछ लोगों ने पहले से ही इंद्रधनुष-सीमांकक का उल्लेख किया है, लिस्प कोड को संपादित करते समय यह मेरी पसंदीदा विधा भी है।

वास्तव में मैं कोष्ठकों से प्यार करता हूँ, लिस्प के बारे में सबसे अच्छी बात यह है कि वे कोष्ठक हैं, यदि आप जानते हैं कि उनके साथ काम करना मजेदार है:

  • बुराई-मोड और इसके प्लगइन को बुराई से घिरा हुआ स्थापित करें, ताकि आप कोष्ठक को आसानी से संपादित कर सकें, उदाहरण के लिए, प्रेस ci(सब कुछ अंदर हटा देगा (), va("()" और "()" खुद से लिपटे हुए चीज का चयन करेगा। और आप %मिलान किए गए कोष्ठकों के बीच कूदने के लिए दबा सकते हैं

  • फ्लाईचेक या फ्लाईमाके का उपयोग करें, बेजोड़ कोष्ठक वास्तविक समय में रेखांकित किया जाएगा

— चने बिन
स्रोत
0

यहां कठिनाई यह है कि आप एक निश्चित से पहले और बाद में कुछ कोड जोड़ना चाहते हैं sexp। इस स्थिति में सेक्सप है (concat " %" (number-to-string w) "d ")। आप इससे पहले इफ-स्टेटमेंट (if (> w 1) डालना चाहते हैं और उसके बाद और स्टेटमेंट " %2d ") ।

कठिनाई का एक प्रमुख हिस्सा है अलग इस sexp, व्यक्तिगत रूप से मैं आदेश के नीचे एक अलग करने के लिए उपयोग करेंsexp

(defun isolate-sexp () (interactive)
       (save-excursion (forward-sexp) (if (not (eolp-almost))
               (split-line) nil)))
(defun eolp-almost () (interactive)
(save-excursion (while (equal (char-after) ? ) (forward-char 1))
        (if (eolp) t nil )      ))

बस (concat " %" (number-to-string w) "d "), यानी की शुरुआत में कर्सर रखें (, फिर ऊपर लागू करें isolate-sexp। आप प्राप्त करें

(defadvice linum-update-window (around linum-dynamic activate)
   (let* ((w (length (number-to-string
      (+ (count-lines (point-min) (point-max)) 1))))
         (linum-format (concat " %" (number-to-string w) "d ")
                                  ))
            ad-do-it))

इसके बाद और इसके बाद उपयुक्त कोड जोड़ें sexp, अर्थात

(defadvice linum-update-window (around linum-dynamic activate)
   (let* ((w (length (number-to-string
      (+ (count-lines (point-min) (point-max)) 1))))
         (linum-format (if (> w 1) (concat " %" (number-to-string w) "d ") " %2d ")
                                  ))
            ad-do-it))

और वोइला। इस तरह से प्राप्त कोड शायद सुंदर नहीं है लेकिन खो जाने की संभावना कम है।

— नाम
स्रोत
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.