lisper

Révision et génération strictes de code Common Lisp et Emacs Lisp pour une compilation sans avertissements, conditions structurées, macros hygiéniques, cœurs fonctionnels purs, discipline lexicale, prédicats sémantiques, symboles documentés et sémantique de liste non destructive. À utiliser lorsque du code Common Lisp ou Elisp nécessite complétude du modèle, hygiène des macros, conception condition/redémarrage, isolation des limites tampon/processus, conformité checkdoc/package-lint/sblint et taille de code bornée.

Qu'est-ce que lisper ?

Lisper est une compétence pour agents IA, comme Claude Code, Cursor ou Codex, spécialisée dans la révision et la génération de code Common Lisp et Emacs Lisp. Elle impose une discipline stricte de programmation fonctionnelle et de compilation sans avertissement. Sa force principale réside dans un ensemble de 12 assertions et règles (par exemple, les S-expressions comme arbres syntaxiques, l'ordre supérieur avant les macros, les invariants exprimés dans les types, les conditions comme faits algébriques). Elle utilise le marquage `*earmuffs*` pour les variables globales, les prédicats `-p` pour la logique métier, et assure une hygiène des macros via `gensym`. Lisper est disponible pour améliorer la qualité du code Lisp en environnement professionnel, en se concentrant sur la correction, la clarté et la sécurité des transformations de données.

Compatible avec~Claude Code~Codex CLI~Cursor
npx skills add https://github.com/RyanKung/Lisper/tree/master

Installed? Explore more Développement et programmation skills: steipete/bluebubbles, steipete/eightctl, steipete/blucli · View all 6 →

Demander à votre IA préférée

Ouvre une nouvelle conversation avec cette compétence d'agent déjà préchargée.

Documentation

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

  1. 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.

  2. 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-partially ou 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 avec gensym / make-symbol (with-gensyms).

  3. 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ératives let + 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.

  4. 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 avec let plutôt que mutée globalement avec setq / setf, à moins que la modification de la configuration globale ne soit le contrat explicite.

  5. Les invariants sont des propositions. Exprimez les invariants dans les types (deftype avec satisfies, proclamations ftype, slots defstruct :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.

  6. Les conditions sont des faits algébriques, pas des chaînes brutes. Définissez des hiérarchies de conditions explicites (define-condition en Common Lisp ; define-error en Emacs Lisp). Signalez les conditions structurées avec error / cerror / signal afin que les appelants puissent les gérer avec handler-case, handler-bind, ou condition-case sans 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.

  7. 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, setf sur 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.

  8. 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 SBCL STYLE-WARNING ne 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.

  9. 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 :use en 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 à checkdoc dont la première ligne est une phrase complète et dont les références de paramètres sont en UPPERCASE ; déclarez les en-têtes Package-Requires et ;;; Commentary: avec précision.
  10. 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 (ou with-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.

  11. 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 formes declare) 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 vagues utils.

  12. La logique mérite un nom. N'exposez pas de chaînes car/cdr/nth brutes (cadddr), de câblage assoc/plist-get imbriqué, ou d'expressions multi-clause and/or/not au 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 -p ou p (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'eval runtime.
  • 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 (eq vs equal).
  • 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 forme unwind-protect maintient 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, -p de 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 un let* en sous-routines foo--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'un let* 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.
  • Précision de l'égalité : N'utilisez jamais eq là où eql (nombres/caractères), equal (chaînes/listes structurelles), ou equalp / é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 #'equal explicitement à assoc, member, gethash, remove, et cl-find lorsque 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 package cl runtime déprécié.
    • Protégez tous les effets secondaires de point, marque, restriction et match-data avec save-excursion, save-restriction, et save-match-data.
    • Préférez le passage de tampon ou (with-current-buffer buf ...) explicite plutôt que de supposer current-buffer à travers les limites asynchrones.
    • Annotez les macros avec (declare (indent ...) (debug ...)) pour que l'indentation et l'instrumentation Edebug fonctionnent automatiquement.
  • 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 / ctypecase au lieu de case / typecase ouverts 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 :components séries explicites avec des DAG de dépendances propres.
  • Constructions interdites dans les chemins de production :
    • Pas d'eval runtime pour distribuer des fonctions ou construire du code (utilisez funcall, apply, ou des macros à la compilation).
    • Pas de setq dynamique 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.

Skills associés