Existe-t-il un meilleur moyen de gérer les docstrings multilignes dans elisp?

Je déteste la façon dont elisp (pas sûr si LISP en général) gère les docstrings multilignes.

(defun foo ()
  "This is
a multi
liner
docstring"
  (do-stuff))

Je souhaite vraiment pouvoir faire quelque chose comme

(defun foo ()
  (eval-when-compile 
    (concat
      "This is\n"
       "a multi\n"
       "line\n"
       "docstring"))
  (do-stuff))

de sorte que l'indentation était cohérente.

Malheureusement, eval-when-compile ne fait pas le travail.

Quelqu'un a-t-il une idée?

Bien sûr, une my-defunmacro est la solution de facilité. Mais une solution plus simple serait

(advice-add 'eval-when-compile :filter-return
            (lambda (exp)
              (if (and (eq 'quote (car-safe exp))
                       (stringp (cadr exp)))
                  (cadr exp)
                exp)))

Ce qui devrait faire fonctionner votre astuce, au moins dans tous les cas où la fonction est agrandie avant d'être réellement définie, ce qui devrait inclure les principaux cas d'utilisation (par exemple, si elle est chargée à partir d'un fichier, si elle est compilée en octets ou si elle est définie via M-C-x).

Pourtant, cela ne résoudra pas tout le code existant, alors peut-être qu'une meilleure réponse est quelque chose comme:

;; -*- lexical-binding:t -*-

(defun my-shift-docstrings (orig ppss)
  (let ((face (funcall orig ppss)))
    (when (eq face 'font-lock-doc-face)
      (save-excursion
        (let ((start (point)))
          (parse-partial-sexp (point) (point-max) nil nil ppss 'syntax-table)
          (while (search-backward "\n" start t)
            (put-text-property (point) (1+ (point)) 'display
                               (propertize "\n  " 'cursor 0))))))
    face))

(add-hook 'emacs-lisp-mode-hook
          (lambda ()
            (font-lock-mode 1)
            (push 'display font-lock-extra-managed-props)
            (add-function :around (local 'font-lock-syntactic-face-function)
                          #'my-shift-docstrings)))

ce qui devrait simplement déplacer les docstrings de 2 espaces, mais uniquement du côté de l'affichage, sans affecter le contenu réel du tampon.

Vous pouvez utiliser une macro comme celle-ci:

(defmacro my-defun (name arglist &rest forms)
  "Like `defun', but concatenates strings."
  (declare (indent defun))
  (let (doc-lines)
    (while (and (stringp (car-safe forms))
                (> (length forms) 1))
      (setq doc-lines
            (append doc-lines (list (pop forms)))))
    `(defun ,name ,arglist
       ,(mapconcat #'identity doc-lines "\n")
       ,@forms)))

Ensuite, vous pouvez définir vos fonctions comme ceci:

(my-defun test (a)
  "Description"
  "asodksad"
  "ok"
  (interactive)
  (+ 1 a))

Néanmoins, je recommande fortement de ne pas aller à l'encontre des normes pour un avantage aussi marginal. L '«indentation irrégulière» qui vous dérange n'est que de 2 colonnes, sans oublier qu'elle permet de mettre en évidence la première ligne de documentation qui est plus importante.

J'ai vu des packages qui définissent des docstrings comme ceci:

(defun my-function (x y) "
this is my docstring
that lines always lines up
across multiple lines."
  (+ x y))

Placer la première citation sur la première ligne puis commencer le texte sur la suivante pour qu'ils s'alignent tous. Ce n'est certainement pas la norme, mais vous ne seriez pas le seul à le faire.