मैं एक अनाम सलाह कैसे निकाल सकता हूं?

Question

मुझे एक समारोह में कुछ सलाह देने में मज़ा आ रहा था:

(advice-add 'executable-find :around
            (lambda (f &rest args)
              (apply g args)))
               ;;;   ^

आउच, एक टाइपो। इसे ठीक किया और फिर से कोड के ऊपर मूल्यांकन किया। लेकिन अब मेरे पास दोनों, "सही" और उस फ़ंक्शन के आसपास "टूटी हुई" सलाह है।

मैं इनसे कैसे छुटकारा पाऊं? यह देखते हुए कि advice-removeफ़ंक्शन ऑब्जेक्ट या आसपास की सलाह की आवश्यकता है (जो यहां खाली है)?

(स्पष्ट रूप से मैं बस छोड़ सकता हूं और पुनः आरंभ कर सकता हूं, लेकिन इसका एक और तरीका है, क्या यह है?)

Answer 1

आप advice-removeउसी लैंबडा एक्सप्रेशन के साथ कॉल कर सकते हैं , यानी , उसके advice-addसाथ बदल सकते हैं advice-removeऔर हटा सकते हैं :around, फिर C-x C-e।

Comments

यह काम! मैंने सोचा था कि मैं यह नहीं मानूंगा कि (1) हर बार जब आप एक लंबो फॉर्म का मूल्यांकन करते हैं तो आपको एक नया फ़ंक्शन मिलता है eqजो पिछले वाले को नहीं मिलता है, (2) सलाह-निष्कासन आपको उस फ़ंक्शन की तुलना करेगा जब तक कि वह इसे नहीं मिल जाता। एक यह है कि eqइसे हटा दें और (3), भले ही सलाह-हटाएं एक अलग परीक्षण का उपयोग करें, जैसे equal, यह अभी भी काम नहीं करेगा, क्योंकि एक लैम्ब्डा फॉर्म के विभिन्न मूल्यांकन equalएक दूसरे को नहीं करेंगे । निकला (1) सही है, लेकिन (2) और (3) गलत हैं: सलाह-उपयोग का उपयोग करता है equal, और उसी परिणाम का lambdaदो बार मूल्यांकन करता है equal!

— उमर

जब मैंने प्रश्न पूछा तो मैंने एक उत्तर को स्वीकार नहीं किया। मैं तुम्हारा चयन करता हूं क्योंकि यह IMO स्थिति में सबसे अधिक मददगार है।

— डैनियल जर्स

Answer 2

वहाँ है advice-mapc, जो कुछ फ़ंक्शन के सभी सलाह पर एक पुनरावृति करते हैं, प्रत्येक को दिए गए फ़ंक्शन को लागू करते हैं। इसके साथ, सभी सलाह निकालना आसान है:

(advice-mapc
  (lambda (adv prop)
    (advice-remove 'executable-find adv))
  'executable-find)

यह केवल उन सलाहों को हटाने के लिए बढ़ाया जा सकता है जिनके पास nameदूसरे ( props) तर्क (जो कि एक मुट्ठी है) को देखकर उन लोगों के लिए संपत्ति नहीं है जिनके पास कुंजी से जुड़ी कोई चीज नहीं है name।

Comments

हाँ। और एक nameआसान हटाने का उपयोग करता है।

— ड्रयू

Answer 3

यहाँ कुछ कोड है कि मदद करने के लिए, अंतःक्रियात्मक रूप से।

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

(defun yf/advice-list (symbol)
  (let (result)
    (advice-mapc
     (lambda (ad props)
       (push ad result))
     symbol)
    (nreverse result)))

(defun yf/kill-advice (symbol advice)
  "Kill ADVICE from SYMBOL."
  (interactive (let* ((sym (intern (completing-read "Function: " obarray #'yf/advice-list t)))
                      (advice (let ((advices-and-their-name
                                     (mapcar (lambda (ad) (cons (prin1-to-string ad)
                                                                ad))
                                             (yf/advice-list sym))))
                                (cdr (assoc (completing-read "Remove advice: " advices-and-their-name nil t)
                                            advices-and-their-name)))))
                 (list sym advice)))
  (advice-remove symbol advice))