Oluşturulan doc dizesini lambda'ya eklemek mümkün müdür?

Emacs dokümanları, doc dizesi içine konduğunda lambdaveya defun“doğrudan fonksiyon nesnesinde saklandığında” olduğunu söyler . Ancak, aşağıdaki gibi adlandırılmış işlevlerin belgelerini değiştirebiliriz:

(put 'my-function-name 'function-documentation "Blah.")

Ancak aynı hile lambdalarla çalışmaz. Lambda'ya doküman eklemenin bir yolu var mı? Veya bir şekilde dinamik olarak doc-string değişmezini mi üretiyorsunuz?

Açıklığa kavuşturmak için aşağıdaki durumu hayal edin:

(let ((foo 1)
      (bar 2))
  (lambda ()
    (+ foo bar)))

Ben değerlerini bahseder doc dize olması lambda istiyorum foove bar.

Peki lambdaların diğer işlev tanımları gibi düzenli öğretileri olabilir:

(lambda ()
   "I'm a docstring!"
   (+ foo bar))

Böylece şunları kullanabilirsiniz:

(let ((foo 1)
      (bar 2))
  `(lambda ()
     ,(format "Function which sums foo=%s and bar=%s" foo bar)
     (+ foo bar)))

Anonim bir işlev hakkında neden bir doktora almak istediğinizi, aldığınız yaklaşımı etkileyebilecek başka bir soru.

Örneğin, bir anahtara bağlamayı planlıyorsanız ve C-h kbu yardımı görüntülemek istiyorsanız , bu yaklaşımı kullanabilirsiniz, ancak elbette yardım yine de işlev nesnesinin kendisini (doktora dahil) gösterecektir; harika; yine de bunu yapsam, sen olur (aynı zamanda) güzel biçimli halini görmek:

(global-set-key
 (kbd "C-c a")
 (let ((foo 1)
       (bar 2))
   `(lambda ()
      ,(format "Function which sums foo=%s and bar=%s" foo bar)
      (interactive)
      (+ foo bar))))

Bununla birlikte, bir sembol kullanmayı tercih edebilirsiniz. Anonim bir işlevi sınırsız bir sembolle eşleştirebilir ve aynı addaki diğer sembollerle çakışması konusunda endişelenmenize gerek yoktur. Bu, işlevi işlev nesnesi yerine sembol adını görüntüleyeceği için yardımı daha temiz hale getirir. Bu durumda, öğretiyi defaliaslambda formuna gömmek yerine geçme seçeneğimiz var .

(global-set-key
 (kbd "C-c a")
 (let ((foo 1)
       (bar 2))
   (defalias (make-symbol "a-foo-bar-function")
     (lambda ()
       (interactive)
       (+ foo bar))
     (format "Function which sums foo=%s and bar=%s" foo bar))))

veya (ve bu hemen hemen aynı şeydir) belirsiz bir sembolü yakalayabilir ve orijinal kodunuza göre symbol özelliğini doğrudan ayarlayabilirsiniz:

(global-set-key
 (kbd "C-c a")
 (let ((foo 1)
       (bar 2)
       (sym (make-symbol "a-foo-bar-function")))
   (put sym 'function-documentation
        (format "Function which sums foo=%s and bar=%s" foo bar))
   (defalias sym
     (lambda ()
       (interactive)
       (+ foo bar)))))

Bir yan not olarak, bu fonksiyon olduğunu unutmayın sadece için let bağlı değerleri toplamak olacak foove barkullandığınız takdirde lexical-binding: tkütüphanenin. Foo ve bar dinamik olarak bağlıysa, oluşturduğum docstrings büyük olasılıkla çalışma zamanında doğru olmaz. Aslında bu duruma dinamik öğretilerle hitap edebiliriz . Bilgi düğümü (elisp) Accessing Documentationşunları söylüyor documentation-property:

Özellik değeri 'nil' değilse, bir dize değilse ve bir dosyadaki metne başvurmuyorsa, dize elde etmek için Lisp ifadesi olarak değerlendirilir.

Bu nedenle, sembol tabanlı yaklaşımlardan herhangi birinde, çağrı sırasında değerlendirilmesini sağlamak için dokümantasyon formunu alıntılayabiliriz:

(defalias (make-symbol "a-foo-bar-function")
   (lambda ()
     (interactive)
     (+ foo bar))
   '(format "Function which sums foo=%s and bar=%s" foo bar))

Emacs-25'te tam olarak bu amaç için yeni bir özellik var:

(let ((foo 1)
      (bar 2))
  (lambda ()
    (:documentation (format "Return the sum of %d and %d." foo bar))
    (+ foo bar)))