CommunityCodierung & Entwicklunggithub.com

lisper

Strikte Überprüfung und Generierung von Common Lisp und Emacs Lisp Code für warnungsfreie Kompilierung, strukturierte Conditions, hygienische Makros, rein funktionale Kerne, lexical-binding Disziplin, semantische Prädikate, dokumentierte Symbole und nicht-destruktive Listen-Semantik. Verwenden Sie dies, wenn Common Lisp oder Elisp-Arbeiten Modellvollständigkeit, Makrohygiene, Condition-/Restart-Design, Buffer-/Prozess-Grenzisolierung, checkdoc/package-lint/sblint-Konformität und begrenzte Codegröße erfordern.

Was ist lisper?

Lisper ist ein KI-Agenten-Skill, der auf die strikte Überprüfung und Generierung von Common Lisp und Emacs Lisp Code spezialisiert ist. Es basiert auf einer Reihe von formalen Assertionen, die von Modellvollständigkeit und hygienischen Makros über lexikalische Bindung und strukturierte Conditions bis hin zu dokumentierten öffentlichen Schnittstellen und gebundenen Ressourcenlebenszyklen reichen. Der Skill unterstützt die Entwicklung in Common Lisp und Emacs Lisp, indem er sicherstellt, dass Code ohne Byte-Compiler-Warnungen auskommt, `checkdoc` und `package-lint` erfüllt und eine disziplinierte Trennung von reinen Datenumwandlungen und Nebeneffekten einhält. Er fördert den Einsatz von höherwertigen Funktionen, hygienischen Makros mit `gensym`, benannten Zugriffsfunktionen anstelle von rohen `car/cdr`-Ketten und formalen Logikkommentaren für Einladungen, Vor- und Nachbedingungen sowie Invarianten. Entwickler können diesen Skill verwenden, um Code zu überprüfen, funktionale Änderungen vorzuschlagen oder neue Module zu generieren, die den strengen hier dargelegten Konventionen und Semantiken entsprechen.

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

Installed? Explore more Codierung & Entwicklung skills: steipete/bluebubbles, steipete/eightctl, steipete/blucli · View all 6 →

In Ihrer bevorzugten KI fragen

Öffnet einen neuen Chat, in dem dieser Agent-Skill bereits geladen ist.

Dokumentation

Was macht lisper?

Betriebsregel

Verwenden Sie diesen Skill als eine Reihe von Behauptungen. Behandeln Sie jede Behauptung als erfüllt, verletzt oder explizit durch eine Benutzereinschränkung aufgeschoben. Bevorzugen Sie genaue Code-Fakten gegenüber Geschmacksbehauptungen. Nennen Sie das Paket, das Symbol, die Struktur, die Condition, die Makroexpansion, die Invariante, den Test oder die Seiteneffektgrenze, die die Behauptung wahr macht.

Geben Sie die Tatsache an. Nennen Sie den Zeugen. Argumentieren Sie nicht über Geschmack.

Wenn Sie über Common Lisp- oder Emacs Lisp-Code berichten, schreiben Sie in kurzen deklarativen Aussagen:

  • Die Invariante befindet sich im Konstruktor.
  • Der dynamische Umfang ist durch unwind-protect begrenzt.
  • Das Makro leckt die Auswertungsreihenfolge.
  • Die Condition ist strukturiert.
  • Die destruktive Listenoperation mutiert die Aufruferstruktur.
  • Das Prädikat ist nackt.
  • Die Compiler-Warnung bleibt bestehen.
  • Der Buffer-Effekt leckt in den reinen Kern.

Behauptungen

  1. Code bildet ein Modell ab. S-Ausdrücke sind Syntaxbäume, bevor sie Text sind. Bewahren Sie jeden realen Zustand des Problems. Verwenden Sie Symbole, getaggte Strukturen (defstruct / cl-defstruct), CLOS-Klassen oder algebraische Alists/Plists mit expliziten Konstruktoren. Löschen Sie nur Unterscheidungen, die semantisch nicht verwendet werden.

  2. Funktionen höherer Ordnung komponieren, bevor Makros umschreiben. Lisp ist zuerst Lambda-Kalkül: Funktionen sind erstklassige Werte, Closures tragen lexikalische Umgebungen, und Currying (apply-partially oder Rückgabe von (lambda (x) ...)) ersetzt Multi-Parameter-Leitungen. Wenn dieselbe Struktur zweimal erscheint, untersuchen Sie sie; wenn sie dreimal erscheint, abstrahieren Sie sie mit einem Kombinator höherer Ordnung, einer gecurryten Closure oder einer generischen Funktion – niemals mit einem 10-argumentigen prozeduralen Helfer. Führen Sie ein Makro nur ein, um die Auswertung zu kontrollieren, lexikalische Symbole zu binden oder Boilerplate zur Kompilierzeit zu eliminieren. Jedes Makro muss Wertargumente höchstens einmal in Links-nach-Rechts-Reihenfolge auswerten und Temporäre mit gensym / make-symbol binden (with-gensyms).

  3. Reine Datentransformationen bleiben außerhalb der mutierbaren Welt des Images. Bevorzugen Sie Katamorphismen (cl-reduce / seq-reduce), homomorphe Abbildungen (mapcar / seq-keep) und Prädikat-Pipelines (seq-filter) gegenüber imperativen let + setq + push + nreverse-Schleifen. Trennen Sie reine symbolische/Listen/Struktur-Transformationen von Buffer-Mutation, Prozess-E/A, Dateisystemzustand, Netzwerk-Streams, Timern und globalen Specials (*earmuffs*). Kernfunktionen nehmen Werte entgegen und geben Werte zurück. Host-Effekte bleiben in benannten Grenzfunktionen.

  4. Lexikalischer Gültigkeitsbereich ist das Standardgesetz. Jede Emacs Lisp-Datei muss mit ;; -*- lexical-binding: t; -*- in Zeile 1 beginnen. Jede dynamische Special-Variable in Common Lisp oder Emacs Lisp muss *earmuffs* tragen (oder +plus-signs+ für Konstanten in CL) und dynamisch mit let neu gebunden werden, anstatt global mit setq / setf mutiert zu werden, es sei denn, die Änderung der globalen Konfiguration ist der explizite Vertrag.

  5. Invarianten sind Aussagen. Drücken Sie Invarianten zuerst in Typen aus (deftype mit satisfies, ftype-Proklamationen, defstruct :type-Slots), dann mit intelligenten Konstruktoren (:constructor), dann mit Laufzeit-Assertions (check-type / cl-check-type), dann mit Tests und zuletzt mit Kommentaren. Ein Konstruktor ist ein Beweis dafür, dass eine Struktur ihre Slot-Invarianten erfüllt.

  6. Conditions sind algebraische Fakten, keine rohen Zeichenketten. Definieren Sie explizite Condition-Hierarchien (define-condition in Common Lisp; define-error in Emacs Lisp). Signalieren Sie strukturierte Conditions mit error / cerror / signal, damit Aufrufer sie mit handler-case, handler-bind oder condition-case behandeln können, ohne Fehlermeldungs-Teilzeichenfolgen abzugleichen. Verwenden Sie Common Lisp Restarts (restart-case), wenn die Wiederherstellungsrichtlinie dem Aufrufer gehört und der Mechanismus der Funktion auf niedriger Ebene gehört.

  7. Cons-Zellen-Besitz ist eine semantische Behauptung. Behandeln Sie Eingabelisten, Bäume und Sequenzen als unveränderlich, es sei denn, der Funktionsname und die Dokumentzeichenfolge deklarieren explizit destruktives Verhalten (nreverse, nconc, delete, sort, cl-delete, setf auf gemeinsamen Cons-Zellen). Wenden Sie niemals destruktive Operationen auf zitierte Literale ('(a b c)) oder geliehene Aufruferlisten an. Duplizieren Sie Strukturen (copy-list, copy-tree, copy-sequence) nur an der Grenze, an der die Mutation beginnt.

  8. Qualität wird bezeugt, nicht behauptet. Null Byte-Compiler-Warnungen, null checkdoc / package-lint-Fehler und null SBCL STYLE-WARNING-Diagnosen sind nur die Untergrenze. Fügen Sie ERT- (ert-deftest) oder FiveAM/Rove/Parachute-Tests für reine Transformationen, Makroexpansionsgesetze, Grenzeingaben, dynamische Bereinigung bei nicht-lokalem Exit und behobene Regressionen hinzu. Ein Testname gibt die Aussage an, die er bezeugt.

  9. Dokumentation und Namensraum-Präfixe sind Teil des öffentlichen Vertrags.

    • In Common Lisp: Definieren Sie explizite Pakete (defpackage / uiop:define-package) ohne vollständige :use-Verschmutzung über :cl hinaus; dokumentieren Sie jede exportierte Funktion, jedes Makro, jede Klasse, jede Variable und jede Condition.
    • In Emacs Lisp: Präfixieren Sie jedes öffentliche Symbol mit <package>- und jedes interne Symbol mit <package>--; schreiben Sie checkdoc-konforme Docstrings, deren erste Zeile ein vollständiger Satz ist und deren Parameterreferenzen in GROSSBUCHSTABEN sind; deklarieren Sie Package-Requires und ;;; Commentary:-Header korrekt.
  10. Die Ressourcenlebensdauer ist durch den dynamischen Umfang begrenzt. Paaren Sie niemals manuelle Allokation und Bereinigung über fehlerträchtige Ausdrücke hinweg. Wickeln Sie jede temporäre Buffer-Änderung, Punktbewegung, Dateihandle, jeden Prozess, Socket oder Hook-Installation in unwind-protect (oder with-open-file, with-temp-buffer, save-excursion, save-restriction, save-match-data). Nicht-lokale Exits (throw, return-from, signal, error) müssen den globalen Zustand und die Buffer sauber hinterlassen.

  11. Größe und Klammernlaufwerk sind strukturelle Signale. Halten Sie jede Quelldatei unter 1000 Zeilen und jeden defun / defmacro ausführbaren Rumpf (ohne Docstring und declare-Formulare) unter 80 Zeilen. Kürzen Sie niemals Docstrings, löschen Sie keine erklärenden Kommentare oder packen Sie mehrere sequenzielle nebeneffektive Formulare in eine einzelne Zeile, um Zeilenzahlgrenzen zu umgehen. Platzieren Sie niemals schließende Klammern ))) allein auf nachfolgenden Zeilen. Rückene Sie gemäß der Standard-Lisp-Form-Semantik ein (deklarieren Sie (declare (indent ...)) bei jedem Elisp-Makro). Teilen Sie Dateien und Funktionen nach Domänenaussagen auf, nicht nach willkürlichen Zeilenzahl-Scheiben oder vagen utils-Eimern.

  12. Logik verdient einen Namen. Setzen Sie keine rohen car/cdr/nth-Ketten (cadddr), verschachtelte assoc/plist-get-Leitungen oder mehrklauselige and/or/not-Ausdrücke an der Aufrufstelle frei, wenn sie eine Domänenaussage ausdrücken. Definieren Sie benannte Zugriffsfunktionen und semantische Prädikate, die auf -p oder p enden (z. B. order-matchable-p, same-principal-p, session-active-p).

Modellvollständigkeit

Bevor Sie Pakete, Strukturen und Funktionen auswählen, nennen Sie das formale Modell, das den Code kohärent macht.

Für Makros und syntaktische Transformationen:

  • Ein Makro ist ein Compiler-Durchlauf von Syntax zu Syntax: $\text{AST}{\text{Oberfläche}} \to \text{AST}{\text{Kern}}$.
  • Geben Sie die Oberflächengrammatik (destrukturierende Lambda-Liste), die Bindungsdisziplin, die Auswertungsmultiplizität jeder Unterform und die Zielexpansion an.
  • Überprüfen Sie die Hygiene mit macroexpand-1 / macrostep: keine freie Symbolerfassung, keine mehrfache Auswertung von effektiven Argumenten und kein Laufzeit-eval.
  • Wenn ein Makro zu Definitionen expandiert, bewahren Sie Quellpositionen und Deklarationen (declare, Docstring-Platzierung) für den Host-Compiler und den Inspektor.

Für interaktiven Zustand, Buffer und nebenläufige Prozesse:

  • Ein interaktives System ist eine Zustandsübergangsrelation, bevor es ein Buffer oder Thread ist.
  • Trennen Sie den Domänenzustandswert vom Rendering-Buffer (Emacs UI) oder Arbeits-Thread/Socket (CL/Emacs-Prozess).
  • Modellieren Sie asynchrone Prozessausgaben (Emacs-Prozessfilter/-Sentinels, CL-Threads/Kanäle) als diskrete Ereignisse, die einen totalen Zustandsübergang speisen: $\text{Zustand} \times \text{Ereignis} \to (\text{Zustand} \times \text{Liste}[\text{Effekt}])$.
  • Prozessfilter in Emacs Lisp können beliebige Chunk-Grenzen empfangen; puffern und parsen Sie unvollständige Frames explizit, bevor Sie Domänenereignisse dispatchen.
  • Schützen Sie Buffer-lokalen Zustand (defvar-local) vor getöteten Buffern (buffer-live-p), wenn Timer, Sentinels oder Callbacks asynchron ausgelöst werden.

Für Conditions, Restarts und nicht-lokale Kontrolle:

  • Trennen Sie was schiefgelaufen ist (das Condition-Datum) von wie man sich erholt (Restarts in CL; strukturierte Handler in Elisp) und welche Wiederherstellung zu wählen ist (der äußere Richtlinien-Handler).
  • Schlucken Sie niemals Conditions mit einem nackten (ignore-errors ...) oder (condition-case nil ... (error nil)), es sei denn, der genaue ignorierte Condition-Typ ist eingegrenzt und der Fallback-Wert ist ein gültiger Domänenzustand.

Formale Logikkommentare

Verwenden Sie formale Kommentare nur, wenn sie eine Beweispflicht klären, die ftype, deftype oder cl-defstruct nicht vollständig ausdrücken. Verwenden Sie ;; innerhalb von Funktionen/Formularen und ;;; auf oberster Ebene, gemäß der standardmäßigen Lisp-Kommentarhierarchie (;;;; Abschnitt, ;;; oberste Ebene, ;; im Rumpf ausgerichtet, ; Rand).

;;; 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)
  "Gib eine frische Teilsequenz von SEQUENCE von START bis END zurück."
  (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' entfernt ID aus `pending', bevor es zu `completed' konsiert.
(defstruct (work-set (:copier nil))
  (pending nil :type list)
  (completed nil :type list))

;;; Law: (equal (decode-packet (encode-packet x)) x) für alle gültigen Paket-Strukturen X.

Bevorzugen Sie diese Formen:

  • Pre: die Bedingung, die ein Aufrufer erfüllen muss.
  • Post: die Bedingung, die die Funktion garantiert, einschließlich Neuheit/Teilen (eq vs equal).
  • Invariant: die Aussage, die über Struct-/Buffer-/Session-Operationen hinweg erhalten bleibt.
  • Law: eine algebraische oder Makroexpansions-Beziehung, die Tests bezeugen müssen.
  • Preservation: warum ein Übergang oder eine unwind-protect-Form die Invariante wahr hält.

Semantische Prädikate

Verwenden Sie benannte Prädikate, die den Lisp -p / p-Konventionen folgen, um Domänenlogik deklarativ auszudrücken:

  • Einwortstamm (Common Lisp-Konvention): evenp, Orderp -> orderp, validp (oder in Elisp konsistent -p für paket-präfigierte Symbole).
  • Mit Bindestrich versehener Stamm (sowohl CL als auch Elisp): order-matchable-p, same-principal-p, lispm-session-live-p.

Bevorzugen Sie:

(when (order-matchable-p order resting-order)
  (match-order book order resting-order))

(when (same-principal-p actor owner)
  (grant-access actor resource))

Vermeiden Sie:

(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))

Vermeiden Sie ebenfalls tiefen positionsbezogenen Listen-Zugriff ((cadddr record), (nth 4 item)) in der Domänenlogik; definieren Sie ein defstruct / cl-defstruct oder benannte Zugriffsfunktionen, sodass die Aufrufstelle das Domänenkonzept liest, nicht die Cons-Topologie.

Implementierungsdisziplin

Beginnen Sie von der Domäne und respektieren Sie die funktionale Semantik des Dialekts.

  • Currying, Partielle Anwendung und Kombinatoren:
    • Zerlegen Sie niemals eine lange Funktion, indem Sie einen prozeduralen Helfer mit 6+ positionsbezogenen Parametern extrahieren, die die let*-Bindungen des Aufrufers widerspiegeln, oder indem Sie ein let* in einmalige foo--part-1 / foo--part-2-Subroutinen aufteilen.
    • Führen Sie niemals "falsches Currying" ein (z. B. (lambda (getter-fn) (lambda () ...))), um einen lexikalischen Gültigkeitsbereich zu simulieren, den ein lokales let* bereits bereitstellt.
    • Currien Sie stattdessen echte Domäneninvarianten in lexikalische Closures ((defun domain--matcher (query role) (lambda (event) ...)) oder (apply-partially #'fn fixed-arg)) und komponieren Sie kleine unäre/binäre Transformationen: $f \circ g = \lambda x., f(g(x))$.
    • Ersetzen Sie repetitive imperatives Polling, zyklenfreie Graph-Traversierung oder Resource-Bracket-Muster durch Kombinatoren höherer Ordnung, die eine Schrittfunktion (funcall step item) akzeptieren und Werte zurückgeben.
  • Gleichheitsgenauigkeit: Verwenden Sie niemals eq, wo eql (Zahlen/Zeichen), equal (strukturelle Zeichenketten/Listen) oder equalp / Domänengleichheit erforderlich sind. Wählen Sie das engste Gleichheitsprädikat, das der Äquivalenzrelation des Typs entspricht, und übergeben Sie :test #'equal explizit an assoc, member, gethash, remove und cl-find, wenn Schlüssel Zeichenketten oder zusammengesetzte Werte sind.
  • Emacs Lisp-Spezifika:
    • Zeile 1 muss ;; -*- lexical-binding: t; -*- deklarieren.
    • Verwenden Sie cl-lib (cl-defstruct, cl-loop, cl-destructuring-bind, cl-check-type), niemals das veraltete Laufzeit-cl-Paket.
    • Schützen Sie alle Punkt-, Markierungs-, Einschränkungs- und Match-Data-Seiteneffekte mit save-excursion, save-restriction und save-match-data.
    • Bevorzugen Sie Buffer-Übergabe oder explizites (with-current-buffer buf ...) gegenüber der Annahme von current-buffer über asynchrone Grenzen hinweg.
    • Kommentieren Sie Makros mit (declare (indent ...) (debug ...)), damit Einrückung und Edebug-Instrumentierung automatisch funktionieren.
  • Common Lisp-Spezifika:
    • Proklamieren Sie (declaim (ftype (function (...) ...) name)) für öffentliche Domänenfunktionen, damit SBCL Typinferenz und Vollständigkeitsprüfungen zur Kompilierzeit durchführt.
    • Verwenden Sie etypecase / ecase / ctypecase anstelle von offenem case / typecase, sodass nicht behandelte Varianten sofort einen strukturierten Typfehler signalisieren.
    • Vermeiden Sie Reader-Table-Verschmutzung und nicht exportierte Symbollecks (pkg::internal-sym).
    • Bevorzugen Sie ASDF-Paket-inferierte oder explizite serielle :components mit sauberen Abhängigkeits-DAGs.
  • Verbotene Konstrukte in Produktionspfaden:
    • Kein Laufzeit-eval, um Funktionen zu dispatchen oder Code zu konstruieren (verwenden Sie funcall, apply oder Compile-Zeit-Makros).
    • Kein dynamisches setq auf nicht deklarierten freien Variablen.
    • Keine In-Place-Mutation (nconc, nreverse, delete, sort) von zitierten Literalen oder nicht besessenen Aufruferlisten.

Verwandte Skills