Que fait lisper ?
Règle de fonctionnement
Utilisez cette compétence comme un ensemble d'assertions. Traitez chaque assertion comme satisfaite, violée ou explicitement reportée par une contrainte utilisateur. Préférez des faits de code exacts aux affirmations de goût. Nommez le package, le symbole, la struct, la condition, l'expansion de macro, l'invariant, le test ou la limite d'effet secondaire qui rend l'assertion vraie.
Énoncez le fait. Nommez le témoin. Ne discutez pas de goût.
Lorsque vous rapportez du code Common Lisp ou Emacs Lisp, écrivez en courtes déclaratives :
- L'invariant est dans le constructeur.
- La portée dynamique est bornée par
unwind-protect. - La macro fuit l'ordre d'évaluation.
- La condition est structurée.
- L'opérateur de liste destructif mute la structure de l'appelant.
- Le prédicat est nu.
- L'avertissement du compilateur persiste.
- L'effet de tampon fuit dans le cœur pur.
Assertions
-
Le code représente un modèle. Les S-expressions sont des arbres syntaxiques avant d'être du texte. Préservez chaque état réel du problème. Utilisez des symboles, des structures étiquetées (
defstruct/cl-defstruct), des classes CLOS, ou des alists/plists algébriques avec des constructeurs explicites. Effacez uniquement les distinctions qui ne sont pas utilisées sémantiquement. -
Les fonctions d'ordre supérieur composent avant que les macros ne réécrivent. Lisp est d'abord le lambda-calcul : les fonctions sont des valeurs de première classe, les fermetures transportent des environnements lexicaux, et le currying (
apply-partiallyou retourner(lambda (x) ...)) remplace le câblage multi-paramètres. Lorsque la même structure apparaît deux fois, inspectez-la ; lorsqu'elle apparaît trois fois, abstraisez-la avec un combinator d'ordre supérieur, une fermeture curryfiée, ou une fonction générique—jamais un assistant procédural à 10 arguments. Introduisez une macro uniquement pour contrôler l'évaluation, lier des symboles lexicaux, ou éliminer le code standard à la compilation. Chaque macro doit évaluer les arguments de valeur au plus une fois dans l'ordre gauche-droite et lier les temporaires avecgensym/make-symbol(with-gensyms). -
Les transformations de données pures restent en dehors du monde mutable de l'image. Préférez les catamorphismes (
cl-reduce/seq-reduce), les mappages homomorphes (mapcar/seq-keep), et les pipelines de prédicats (seq-filter) aux boucles impérativeslet+setq+push+nreverse. Séparez les transformations pures symboliques/liste/struct de la mutation de tampon, des E/S de processus, de l'état du système de fichiers, des flux réseau, des minuteries, et des variables spéciales globales (*earmuffs*). Les fonctions principales prennent des valeurs et retournent des valeurs. Les effets d'hôte restent dans des fonctions de limite nommées. -
La portée lexicale est la loi par défaut. Chaque fichier Emacs Lisp doit commencer par
;; -*- lexical-binding: t; -*-à la ligne 1. Chaque variable spéciale dynamique en Common Lisp ou Emacs Lisp doit porter*earmuffs*(ou+plus-signs+pour les constantes en CL) et être rebondie dynamiquement avecletplutôt que mutée globalement avecsetq/setf, à moins que la modification de la configuration globale ne soit le contrat explicite. -
Les invariants sont des propositions. Exprimez les invariants dans les types (
deftypeavecsatisfies, proclamationsftype, slotsdefstruct:type) d'abord, les constructeurs intelligents (:constructor) en second, les assertions runtime (check-type/cl-check-type) en troisième, les tests en quatrième, et les commentaires en dernier. Un constructeur est une preuve qu'une structure satisfait ses invariants de slot. -
Les conditions sont des faits algébriques, pas des chaînes brutes. Définissez des hiérarchies de conditions explicites (
define-conditionen Common Lisp ;define-erroren Emacs Lisp). Signalez les conditions structurées avecerror/cerror/signalafin que les appelants puissent les gérer avechandler-case,handler-bind, oucondition-casesans correspondance de sous-chaînes de message d'erreur. Utilisez les redémarrages Common Lisp (restart-case) lorsque la politique de récupération appartient à l'appelant et le mécanisme appartient à la fonction de bas niveau. -
La propriété des cons-cells est une affirmation sémantique. Traitez les listes, arbres et séquences d'entrée comme immuables, sauf si le nom et la docstring de la fonction déclarent explicitement un comportement destructif (
nreverse,nconc,delete,sort,cl-delete,setfsur des cons cells partagés). N'appliquez jamais d'opérations destructives à des littéraux entre guillemets ('(a b c)) ou à des listes d'appelants empruntées. Dupliquez la structure (copy-list,copy-tree,copy-sequence) uniquement à la limite où la mutation commence. -
La qualité est témoignée, pas affirmée. Zéro avertissement du compilateur de bytecode, zéro erreur
checkdoc/package-lint, et zéro diagnostic SBCLSTYLE-WARNINGne sont que le minimum. Ajoutez des tests ERT (ert-deftest) ou FiveAM/Rove/Parachute pour les transformations pures, les lois d'expansion de macros, les entrées limites, le nettoyage dynamique sous sortie non locale, et les régressions corrigées. Un nom de test énonce la proposition qu'il témoigne. -
La documentation et les préfixes d'espace de noms font partie du contrat public.
- En Common Lisp : définissez des packages explicites (
defpackage/uiop:define-package) sans pollution:useen gros au-delà de:cl; documentez chaque fonction, macro, classe, variable et condition exportée. - En Emacs Lisp : préfixez chaque symbole public avec
<package>-et chaque symbole interne avec<package>--; écrivez des docstrings conformes àcheckdocdont la première ligne est une phrase complète et dont les références de paramètres sont enUPPERCASE; déclarez les en-têtesPackage-Requireset;;; Commentary:avec précision.
- En Common Lisp : définissez des packages explicites (
-
La durée de vie des ressources est bornée par la portée dynamique. N'associez jamais l'allocation manuelle et le nettoyage à travers des expressions faillibles. Enveloppez chaque modification temporaire de tampon, déplacement de point, gestionnaire de fichier, processus, socket ou installation de hook dans
unwind-protect(ouwith-open-file,with-temp-buffer,save-excursion,save-restriction,save-match-data). Les sorties non locales (throw,return-from,signal,error) doivent laisser l'état global et les tampons propres. -
La taille et la disposition des parenthèses sont des signaux structurels. Gardez chaque fichier source sous 1000 lignes et chaque corps exécutable
defun/defmacro(excluant sa docstring et les formesdeclare) sous 80 lignes. Ne tronquez jamais les docstrings, ne supprimez jamais les commentaires explicatifs, et ne regroupez jamais plusieurs formes à effets secondaires séquentiels sur une seule ligne pour contourner les limites de nombre de lignes. Ne placez jamais les parenthèses fermantes)))seules sur des lignes de fin. Indentez selon la sémantique de forme Lisp standard (déclarez(declare (indent ...))sur chaque macro Elisp). Divisez les fichiers et fonctions par proposition de domaine, pas par tranches arbitraires de nombre de lignes ou par buckets vaguesutils. -
La logique mérite un nom. N'exposez pas de chaînes
car/cdr/nthbrutes (cadddr), de câblageassoc/plist-getimbriqué, ou d'expressions multi-clauseand/or/notau point d'appel lorsqu'elles expriment une proposition de domaine. Définissez des accesseurs nommés et des prédicats sémantiques se terminant par-poup(par exemple,order-matchable-p,same-principal-p,session-active-p).
Complétude du modèle
Avant de choisir des packages, structs et fonctions, nommez le modèle formel qui rend le code cohérent.
Pour les macros et transformations syntaxiques :
- Une macro est un passage compilateur de syntaxe à syntaxe : $\text{AST}{\text{surface}} \to \text{AST}{\text{noyau}}$.
- Spécifiez la grammaire de surface (liste de destructuring lambda), la discipline de liaison, la multiplicité d'évaluation de chaque sous-forme, et l'expansion cible.
- Vérifiez l'hygiène avec
macroexpand-1/macrostep: pas de capture de symbole libre, pas d'évaluation multiple d'arguments avec effets, et pas d'evalruntime. - Si une macro s'expand en définitions, préservez les emplacements source et les déclarations (
declare, placement de docstring) pour le compilateur et l'inspecteur hôtes.
Pour l'état interactif, les tampons et les processus concurrents :
- Un système interactif est une relation de transition d'état avant d'être un tampon ou un thread.
- Séparez la valeur d'état du domaine du tampon de rendu (UI Emacs) ou du thread/socket de travail (processus CL/Emacs).
- Modélisez la sortie asynchrone du processus (filtres/sentinelles de processus Emacs, threads/canaux CL) comme des événements discrets alimentant une transition d'état totale : $\text{État} \times \text{Événement} \to (\text{État} \times \text{Liste}[\text{Effet}])$.
- Les filtres de processus en Emacs Lisp peuvent recevoir des limites de chunks arbitraires ; tamponnez et parsez les trames incomplètes explicitement avant de distribuer les événements du domaine.
- Protégez l'état local du tampon (
defvar-local) contre les tampons tués (buffer-live-p) lorsque les minuteries, sentinelles ou callbacks se déclenchent de manière asynchrone.
Pour les conditions, les redémarrages et le contrôle non local :
- Séparez ce qui a mal tourné (la donnée de condition) de comment récupérer (les redémarrages en CL ; les gestionnaires structurés en Elisp) et quelle récupération choisir (le gestionnaire de politique externe).
- N'avalez jamais les conditions avec un
(ignore-errors ...)nu ou(condition-case nil ... (error nil))à moins que le type de condition ignoré exacte ne soit restreint et que la valeur de repli ne soit un état de domaine valide.
Commentaires de logique formelle
Utilisez des commentaires formels uniquement lorsqu'ils clarifient une obligation de preuve que ftype, deftype, ou cl-defstruct n'exprime pas entièrement. Utilisez ;; à l'intérieur des fonctions/formes et ;;; au niveau supérieur, en suivant la hiérarchie standard des commentaires Lisp (;;;; section, ;;; niveau supérieur, ;; aligné dans le corps, ; marge).
;;; Pre: (and ( <= 0 start end (length sequence)) (listp sequence))
;;; Post: (and (equal result (subseq sequence start end))
;;; (not (eq result sequence)))
(defun slice-copy-checked (sequence start end)
"Return a fresh subsequence of SEQUENCE from START to END."
(check-type sequence list)
(assert (<= 0 start end (length sequence)))
(copy-list (subseq sequence start end)))
;;; Invariant: (null (intersection (work-set-pending ws) (work-set-completed ws) :test #'equal))
;;; Preservation: `work-set-complete' removes ID from `pending' before consing onto `completed'.
(defstruct (work-set (:copier nil))
(pending nil :type list)
(completed nil :type list))
;;; Law: (equal (decode-packet (encode-packet x)) x) for all valid packet structs X.
Préférez ces formes :
Pre: la condition qu'un appelant doit satisfaire.Post: la condition que la fonction garantit, y compris la fraîcheur/partage (eqvsequal).Invariant: la proposition préservée à travers les opérations de struct/tampon/session.Law: une relation algébrique ou d'expansion de macro que les tests doivent attester.Preservation: pourquoi une transition ou une formeunwind-protectmaintient l'invariant vrai.
Prédicats sémantiques
Utilisez des prédicats nommés suivant les conventions -p / p de Lisp pour exprimer la logique du domaine de manière déclarative :
- Racine d'un seul mot (convention Common Lisp) :
evenp,Orderp->orderp,validp(ou en Elisp,-pde manière cohérente pour les symboles préfixés par le package). - Racine avec trait d'union (CL et Elisp) :
order-matchable-p,same-principal-p,lispm-session-live-p.
Préférez :
(when (order-matchable-p order resting-order)
(match-order book order resting-order))
(when (same-principal-p actor owner)
(grant-access actor resource))
Évitez :
(when (and (not (eq (order-side order) (order-side resting-order)))
(>= (order-price order) (order-price resting-order))
(plusp (order-quantity order)))
(match-order book order resting-order))
(when (and (equal (principal-id actor) (principal-id owner))
(eq (principal-realm actor) (principal-realm owner)))
(grant-access actor resource))
Évitez également l'accès profond à une liste positionnelle ((cadddr record), (nth 4 item)) dans la logique du domaine ; définissez un defstruct / cl-defstruct ou des fonctions d'accès nommées afin que le site d'appel lise le concept du domaine plutôt que la topologie des cons.
Discipline d'implémentation
Partez du domaine et respectez la sémantique fonctionnelle du dialecte.
- Currying, Application Partielle et Combinators :
- Ne décomposez jamais une longue fonction en extrayant un assistant procédural avec 6+ paramètres positionnels qui reflètent les liaisons
let*de l'appelant, ou en découpant unlet*en sous-routinesfoo--part-1/foo--part-2à usage unique. - N'introduisez jamais de "faux currying" (par exemple,
(lambda (getter-fn) (lambda () ...))) pour simuler une portée lexicale qu'unlet*local fournit déjà. - Au lieu de cela, curryfiez les invariants de domaine authentiques dans des fermetures lexicales (
(defun domain--matcher (query role) (lambda (event) ...))ou(apply-partially #'fn fixed-arg)) et composez de petites transformations unaires/binaires : $f \circ g = \lambda x., f(g(x))$. - Remplacez le sondage impératif répétitif, le parcours de graphe sûr pour les cycles, ou les motifs de ressource-bracket par des combinators d'ordre supérieur qui acceptent une fonction d'étape
(funcall step item)et retournent des valeurs.
- Ne décomposez jamais une longue fonction en extrayant un assistant procédural avec 6+ paramètres positionnels qui reflètent les liaisons
- Précision de l'égalité : N'utilisez jamais
eqlà oùeql(nombres/caractères),equal(chaînes/listes structurelles), ouequalp/ égalité de domaine est requis. Choisissez le prédicat d'égalité le plus serré qui correspond à la relation d'équivalence du type, et passez:test #'equalexplicitement àassoc,member,gethash,remove, etcl-findlorsque les clés sont des chaînes ou des valeurs composites. - Spécificités d'Emacs Lisp :
- La ligne 1 doit déclarer
;; -*- lexical-binding: t; -*-. - Utilisez
cl-lib(cl-defstruct,cl-loop,cl-destructuring-bind,cl-check-type), jamais le packageclruntime déprécié. - Protégez tous les effets secondaires de point, marque, restriction et match-data avec
save-excursion,save-restriction, etsave-match-data. - Préférez le passage de tampon ou
(with-current-buffer buf ...)explicite plutôt que de supposercurrent-bufferà travers les limites asynchrones. - Annotez les macros avec
(declare (indent ...) (debug ...))pour que l'indentation et l'instrumentation Edebug fonctionnent automatiquement.
- La ligne 1 doit déclarer
- Spécificités de Common Lisp :
- Proclamez
(declaim (ftype (function (...) ...) name))pour les fonctions de domaine public afin que SBCL effectue une inférence de type et des vérifications d'exhaustivité à la compilation. - Utilisez
etypecase/ecase/ctypecaseau lieu decase/typecaseouverts afin que les variantes non traitées signalent immédiatement une erreur de type structurée. - Évitez la pollution de la table de lecture et les fuites de symboles non exportés (
pkg::internal-sym). - Préférez ASDF package-inferred ou des
:componentsséries explicites avec des DAG de dépendances propres.
- Proclamez
- Constructions interdites dans les chemins de production :
- Pas d'
evalruntime pour distribuer des fonctions ou construire du code (utilisezfuncall,apply, ou des macros à la compilation). - Pas de
setqdynamique sur des variables libres non déclarées. - Pas de mutation sur place (
nconc,nreverse,delete,sort) de littéraux entre guillemets ou de listes d'appelants non possédées.
- Pas d'