Je me demandais s'il y a une pratique standard concernant l'utilisation d'étiquettes dans Lisp. Je suis en train de jouer avec une implémentation de LISP de l'algorithme décrit dans la première réponse ici ici Génération de permutations Perzily Ma version actuelle utilise des étiquettes pour casser des portions de fonctionnalité.
(defun next-permutation (pmute)
(declare (vector pmute))
(let ((len (length pmute)))
(if (> len 2)
(labels ((get-pivot ()
(do ((pivot (1- len) (1- pivot)))
((or (= pivot 0)
(< (aref pmute (1- pivot))
(aref pmute pivot)))
pivot)))
(get-swap (pivot)
(let ((swp (1- len)))
(loop for i from (1- len) downto pivot do
(if (or (and (> (aref pmute i)
(aref pmute (1- pivot)))
(< (aref pmute i) (aref pmute swp)))
(< (aref pmute swp) (aref pmute (1- pivot))))
(setf swp i)))
swp))
(next (swp pivot)
(rotatef (aref pmute (1- pivot)) (aref pmute swp))
(reverse-vector pmute pivot (1- len))))
(let ((piv (get-pivot)))
(if (> piv 0)
(next (get-swap piv) piv)
nil))))))
3 Réponses :
Ne pas être autre chose qu'un nouveau-shelbie LISP, je dirais que vous faites la bonne chose: rendre votre code plus lisible en nommant des morceaux.
Non, ça va bien. Écrire des fonctions nommées rend le code un peu plus auto-documentant et plus modulaire.
Parfois, je voudrais également répertorier toutes les variables utilisées dans les fonctions Arglist et n'utilisez pas les variables de la fonction enfermante. Cela rend l'interface un peu plus claire et aide à déplacer la fonction autour du code (si nécessaire).
Les fonctions locales offrent également la possibilité d'ajouter des chaînes de documentation locales et des descriptions d'interface.
Si les fonctions locales deviennent trop grandes et qu'elles peuvent également être utilisées à l'extérieur, je les extraire et les rendre globaux.
Je ne vois rien de mal avec ça. Vous faites les deux sous-processus très clairs et faciles à décharger, ce qui facilite la prise de manière rapide à ce que la fonction effectue vraiment en regardant juste au corps. Il est également facile de promouvoir les fonctions internes aux fonctions mondiales si vous en avez besoin.
Vous pouvez utiliser
flect au lieu deétiquettes si vos fonctions n'ont pas besoin de se référer (ou elles-mêmes).Y a-t-il un avantage à ce que cela puisse communiquer ce peu d'informations supplémentaires à quiconque lisant le code?
Probablement pas. Cependant, rappelez-vous que vous devriez écrire du code pour la personne suivante qui lit le code, le compilateur / interprète n'est pas votre principal public.