मैं एक सरल `पूर्ण-बिंदु-कार्य-कार्य` कैसे लिखूं?

Question

मैं जादू संपादन के लिए एक प्रमुख विधा लिखने पर विचार कर रहा हूं: सभा डेक।

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

जाहिर है मुझे नए कार्ड आदि के साथ सिंक करने का एक तरीका खोजने की जरूरत होगी और भविष्य में शायद कार्ड के नाम की तुलना में अन्य विशेषताओं द्वारा कार्ड की खोज करने में सक्षम हो सकता है लेकिन यह इंतजार कर सकता है।

Answer 1

प्रलेखन

बिंदु समारोह में पूरा होने वाले एपीआई के प्रलेखन में पाया जा सकता है completion-at-point-functions

इस हुक पर प्रत्येक फ़ंक्शन को बिना किसी तर्क के बदल दिया जाता है और इसका मतलब यह है कि यह बिंदु पर लागू नहीं होता है, या पूर्ण (हतोत्साहित), या फ़ॉर्म की सूची को पूरा करने के लिए कोई तर्क नहीं है (START END COLLECTION) ।

start, endऔर propsस्पष्ट हैं, लेकिन मुझे लगता है कि का प्रारूप collectionठीक से परिभाषित नहीं है। उसके लिए आप try-completionया के दस्तावेज देख सकते हैंall-completions

यदि संकलन एक एलिस्ट है, तो कुंजी (तत्वों की कार) संभव पूर्णताएं हैं। यदि कोई तत्व एक कोन्स सेल नहीं है, तो वह तत्व ही संभव पूर्णता है। यदि COLLECTION एक हैश-टेबल है, तो सभी कुंजी जो तार या प्रतीक हैं, वे संभावित पूर्णताएं हैं। यदि संकलन एक बाधा है, तो मोटे तौर पर सभी प्रतीकों के नाम संभव पूर्णता हैं।

संकलन भी पूरा करने के लिए एक समारोह हो सकता है। यह तीन तर्क प्राप्त करता है: मान STRING, PREDICATE और nil। जो भी लौटाता है वह `कोशिश-पूर्ण 'का मूल्य बन जाता है।

उदाहरण

नीचे बिंदु फ़ंक्शन पर पूरा होने का एक सरल उदाहरण है जो /etc/dictionaries-common/wordsबफर में शब्दों को पूरा करने के लिए परिभाषित शब्दों का उपयोग करता है

(defvar words (split-string (with-temp-buffer
                              (insert-file-contents-literally "/etc/dictionaries-common/words")
                              (buffer-string))
                            "\n"))

(defun words-completion-at-point ()
  (let ((bounds (bounds-of-thing-at-point 'word)))
    (when bounds
      (list (car bounds)
            (cdr bounds)
            words
            :exclusive 'no
            :company-docsig #'identity
            :company-doc-buffer (lambda (cand)
                                  (company-doc-buffer (format "'%s' is defined in '/etc/dictionaries-common/words'" cand)))
            :company-location (lambda (cand)
                                (with-current-buffer (find-file-noselect "/etc/dictionaries-common/words")
                                  (goto-char (point-min))
                                  (cons (current-buffer) (search-forward cand nil t))))))))

पूरा होने वाला कार्य बिंदु पर शब्द के लिए दिखता है (लाइब्रेरी thingatptका उपयोग शब्द की सीमा को खोजने के लिए किया जाता है) और इसे /etc/dictionaries-common/wordsफाइल में शब्दों के खिलाफ पूरा करता है , संपत्ति :exclusiveसेट की जाती है noताकि एमएसीएस अन्य कैपफ कार्यों का उपयोग कर सके यदि हमारी विफलता होती है। अंत में कंपनी-मोड एकीकरण को बढ़ाने के लिए कुछ अतिरिक्त गुण निर्धारित किए गए हैं।

प्रदर्शन

मेरे सिस्टम पर शब्द फ़ाइल में 99171 प्रविष्टियाँ थीं और एमएसीएस उन्हें बिना किसी समस्या के पूरा करने में सक्षम था, इसलिए मुझे लगता है कि 15000 प्रविष्टियों को कोई समस्या नहीं होनी चाहिए।

कंपनी-मोड के साथ एकीकरण

कंपनी मोड बैकएंड completion-at-point-functionsका उपयोग करने के साथ बहुत अच्छी तरह से एकीकृत करता है company-capf, इसलिए इसे आपके लिए बॉक्स से बाहर काम करना चाहिए, लेकिन आप कंपनी द्वारा प्रस्तुत किए गए propsपूर्णताओं को कैपफ फ़ंक्शन के परिणाम में अतिरिक्त वापस करके बढ़ा सकते हैं । वर्तमान में समर्थित सहारा हैं

:company-doc-buffer - कंपनी द्वारा वर्तमान उम्मीदवार के लिए मेटाडेटा प्रदर्शित करने के लिए उपयोग किया जाता है

:company-docsig - कंपनी द्वारा मिनीबफर में उम्मीदवार के बारे में मेटाडेटा गूंजने के लिए उपयोग किया जाता है

:company-location - वर्तमान उम्मीदवार के स्थान पर कूदने के लिए कंपनी द्वारा उपयोग किया जाता है

Comments

अरे बाप रे! पूरी तरह से उत्तर के लिए धन्यवाद! मैं इसे थोड़ा आज़माऊंगा और उसके बाद स्वीकार करूंगा। कंपनी संकेत के लिए अतिरिक्त धन्यवाद (जो मैं वास्तव में उपयोग कर रहा हूं)।

— मटियास बेंग्टसन

धन्यवाद, यह वास्तव में उपयोगी है अब मैं आसानी से कस्टम पूर्णता को कॉन्फ़िगर कर सकता हूं :)

— क्लीमेरा

खुशी है कि मैं मदद कर सकता हूं :)

— इकबाल अंसारी

Answer 2

@ इकबाल अंसारी ने दिया शानदार जवाब। यहाँ एक पूरक उत्तर है, आशा है कि यह मदद करेगा।

यहाँ emacs क्लासिक पूर्ण तंत्र का उपयोग करते हुए एक कार्यान्वयन है, 2009।

;; this is your lang's keywords
(setq xyz-kwdList
      '("touch"
       "touch_start"
       "touch_end"
       "for"
       "foreach"
       "forall"
       ))

निम्नलिखित कोड है जो पूरा करता है।

(defun xyz-complete-symbol ()
  "Perform keyword completion on word before cursor."
  (interactive)
  (let ((posEnd (point))
        (meat (thing-at-point 'symbol))
        maxMatchResult)

    ;; when nil, set it to empty string, so user can see all lang's keywords.
    ;; if not done, try-completion on nil result lisp error.
    (when (not meat) (setq meat ""))
    (setq maxMatchResult (try-completion meat xyz-kwdList))

    (cond ((eq maxMatchResult t))
          ((null maxMatchResult)
           (message "Can't find completion for “%s”" meat)
           (ding))
          ((not (string= meat maxMatchResult))
           (delete-region (- posEnd (length meat)) posEnd)
           (insert maxMatchResult))
          (t (message "Making completion list…")
             (with-output-to-temp-buffer "*Completions*"
               (display-completion-list 
                (all-completions meat xyz-kwdList)
                meat))
             (message "Making completion list…%s" "done")))))

इडो-मोड के इंटरफेस का उपयोग करके एक कार्यान्वयन के बाद। बहुत सरल।

(defun abc-complete-symbol ()
  "Perform keyword completion on current symbol.
This uses `ido-mode' user interface for completion."
  (interactive)
  (let* (
         (bds (bounds-of-thing-at-point 'symbol))
         (p1 (car bds))
         (p2 (cdr bds))
         (current-sym
          (if  (or (null p1) (null p2) (equal p1 p2))
              ""
            (buffer-substring-no-properties p1 p2)))
         result-sym)
    (when (not current-sym) (setq current-sym ""))
    (setq result-sym
          (ido-completing-read "" xyz-kwdList nil nil current-sym ))
    (delete-region p1 p2)
    (insert result-sym)))

आपको अपने शब्दों की सूची के रूप में xyz-kwdList को परिभाषित करना होगा।

Comments

-1 को पूरा करने के लिए एक बुरे तरीके से इंटरफ़ेस को रोकने के लिए, nullअधिक से अधिक जाने के लिए notऔर ऊंट पहचानकर्ता और ग्रीक प्रतीकों का उपयोग करना जो केवल अपने स्वयं के मोड में समझ में आता है।

— वामासा

-1 के बारे में उस प्रश्न का उत्तर न देने के लिए completion-at-point-functions(मैं nullबनाम notचीज़ को लेकर @wasamasa से असहमत था )।

— npostavs 14

@XahLee फ़ंक्शंस completion-at-point-functionsपूरा होने वाले डेटा को वापस करने के लिए हैं, स्वयं को पूरा करने के लिए नहीं। तो आपके उत्तर में कार्य प्रविष्टियों के रूप में उपयोग करने योग्य नहीं हैं completion-at-point-functions।

— npostavs

@npostavs आह मैं देख रहा हूँ। तुम सही हो। धन्यवाद!

— Xah ली

@npostavs इस तरह का फ़ंक्शन अभी भी काम करेगा, लेकिन वास्तव में इस तरह से पूरा होने वाला फ़ंक्शन लिखना दस्तावेज़ इंटरफ़ेस के विरुद्ध है, और यह दृढ़ता से हतोत्साहित करता है।

— दिमित्री