CommunityProgramación y desarrollogithub.com

lisper

Revisión y generación estricta de Common Lisp y Emacs Lisp para compilación sin advertencias, condiciones estructuradas, macros higiénicas, núcleos funcionales puros, disciplina de ámbito léxico, predicados semánticos, símbolos documentados y semántica de listas no destructiva. Úsalo cuando el trabajo con Common Lisp o Elisp requiera completitud del modelo, higiene de macros, diseño de condiciones/reinicios, aislamiento de límites de búfer/proceso, cumplimiento con checkdoc/package-lint/sblint y tamaño de código acotado.

¿Qué es lisper?

Este skill define un conjunto riguroso de aserciones para escribir y revisar código en Common Lisp y Emacs Lisp. Su propósito es garantizar que el código sea libre de advertencias de compilación, use condiciones estructuradas (no cadenas de error), implemente macros higiénicas que no capturen símbolos ni evalúen múltiples veces argumentos, y mantenga un núcleo funcional puro separado de los efectos secundarios (mutación de búferes, E/S, estado global). El skill aplica disciplina de ámbito léxico, predicados semánticos con nombres en `-p`, y documentación completa (docstrings y comentarios de cabecera). Está diseñado para plataformas como SBCL, CCL, Emacs y ASDF, y exige que las invariantes se expresen primero en tipos, luego en constructores, luego en aserciones en tiempo de ejecución, luego en pruebas y por último en comentarios. El resultado es código Lisp predecible, mantenible y profesional, adecuado para sistemas de producción donde la corrección y la legibilidad son críticas.

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

Installed? Explore more Programación y desarrollo skills: steipete/bluebubbles, steipete/eightctl, steipete/blucli · View all 6 →

Preguntar en tu IA favorita

Abre un nuevo chat con esta habilidad de agente ya precargada.

Documentación

¿Qué hace lisper?

Regla de operación

Usa este skill como un conjunto de aserciones. Trata cada aserción como cumplida, violada o diferida explícitamente por una restricción del usuario. Prefiere hechos de código exactos sobre afirmaciones de gusto. Nombra el paquete, símbolo, estructura, condición, expansión de macro, invariante, prueba o límite de efecto secundario que haga verdadera la aserción.

Indica el hecho. Nombra el testigo. No discutas sobre gusto.

Al informar sobre código Common Lisp o Emacs Lisp, escribe en enunciados declarativos cortos:

  • La invariante está en el constructor.
  • La extensión dinámica está delimitada por unwind-protect.
  • La macro filtra el orden de evaluación.
  • La condición es estructurada.
  • La operación destructiva de lista muta la estructura del llamante.
  • El predicado está desnudo.
  • La advertencia del compilador permanece.
  • El efecto de búfer se filtra al núcleo puro.

Aserciones

  1. El código modela el problema. Las S-expresiones son árboles de sintaxis antes de ser texto. Preserva cada estado real del problema. Usa símbolos, estructuras etiquetadas (defstruct / cl-defstruct), clases CLOS o alistas/plistas algebraicas con constructores explícitos. Elimina solo las distinciones que no se usan semánticamente.

  2. Las funciones de orden superior componen antes de que las macros reescriban. Lisp es cálculo lambda primero: las funciones son valores de primera clase, los cierres llevan entornos léxicos y el currificado (apply-partially o retornar (lambda (x) ...)) reemplaza la plomería multiparámetro. Cuando la misma estructura aparece dos veces, inspecciónala; cuando aparece tres veces, abstraela con un combinador de orden superior, un cierre currificado o una función genérica, nunca con un ayudante procedimental de 10 argumentos. Introduce una macro solo para controlar la evaluación, enlazar símbolos léxicos o eliminar código repetitivo en tiempo de compilación. Cada macro debe evaluar los argumentos de valor como máximo una vez en orden de izquierda a derecha y enlazar temporales con gensym / make-symbol (with-gensyms).

  3. Las transformaciones de datos puras permanecen fuera del mundo mutable de la imagen. Prefiere catamorfismos (cl-reduce / seq-reduce), mapeos homomórficos (mapcar / seq-keep) y tuberías de predicados (seq-filter) sobre bucles imperativos con let + setq + push + nreverse. Separa las transformaciones puras de símbolos/listas/estructuras de la mutación de búferes, E/S de procesos, estado del sistema de archivos, flujos de red, temporizadores y especiales globales (*earmuffs*). Las funciones del núcleo toman valores y devuelven valores. Los efectos de host permanecen en funciones de límite nombradas.

  4. El ámbito léxico es la ley por defecto. Cada archivo de Emacs Lisp debe comenzar con ;; -*- lexical-binding: t; -*- en la línea 1. Cada variable especial dinámica en Common Lisp o Emacs Lisp debe llevar *earmuffs* (o +signos+más+ para constantes en CL) y ser reenlazada dinámicamente con let en lugar de mutada globalmente con setq / setf, a menos que cambiar la configuración global sea el contrato explícito.

  5. Las invariantes son proposiciones. Expresa las invariantes primero con tipos (deftype con satisfies, proclamaciones ftype, slots :type de defstruct), luego con constructores inteligentes (:constructor), luego con aserciones en tiempo de ejecución (check-type / cl-check-type), luego con pruebas y por último con comentarios. Un constructor es una prueba de que una estructura cumple con las invariantes de sus slots.

  6. Las condiciones son hechos algebraicos, no cadenas en bruto. Define jerarquías de condiciones explícitas (define-condition en Common Lisp; define-error en Emacs Lisp). Señala condiciones estructuradas con error / cerror / signal para que los llamantes puedan manejarlas con handler-case, handler-bind o condition-case sin tener que coincidir con subcadenas del mensaje de error. Usa reinicios de Common Lisp (restart-case) cuando la política de recuperación pertenece al llamante y el mecanismo pertenece a la función de bajo nivel.

  7. La propiedad de las celdas cons es una afirmación semántica. Trata las listas de entrada, árboles y secuencias como inmutables a menos que el nombre y la cadena de documentación de la función declaren explícitamente comportamiento destructivo (nreverse, nconc, delete, sort, cl-delete, setf en celdas cons compartidas). Nunca apliques operaciones destructivas a literales citados ('(a b c)) o listas prestadas del llamante. Duplica la estructura (copy-list, copy-tree, copy-sequence) solo en el límite donde comienza la mutación.

  8. La calidad se demuestra, no se afirma. Cero advertencias del compilador de bytes, cero errores de checkdoc / package-lint y cero diagnósticos STYLE-WARNING de SBCL son solo el piso. Agrega pruebas ERT (ert-deftest) o FiveAM/Rove/Parachute para transformaciones puras, leyes de expansión de macros, entradas en los límites, limpieza dinámica bajo salida no local y regresiones corregidas. El nombre de una prueba enuncia la proposición que demuestra.

  9. La documentación y los prefijos de espacio de nombres son parte del contrato público.

    • En Common Lisp: define paquetes explícitos (defpackage / uiop:define-package) sin contaminación masiva con :use más allá de :cl; documenta cada función, macro, clase, variable y condición exportada.
    • En Emacs Lisp: prefija cada símbolo público con <paquete>- y cada símbolo interno con <paquete>--; escribe cadenas de documentación conformes a checkdoc cuya primera línea sea una oración completa y cuyas referencias a parámetros estén en MAYÚSCULAS; declara Package-Requires y los encabezados ;;; Commentary: con precisión.
  10. La vida útil de los recursos está delimitada por la extensión dinámica. Nunca emparejes asignación y limpieza manuales a través de expresiones falibles. Envuelve cada cambio temporal de búfer, movimiento de punto, manejador de archivo, proceso, socket o instalación de hook en unwind-protect (o with-open-file, with-temp-buffer, save-excursion, save-restriction, save-match-data). Las salidas no locales (throw, return-from, signal, error) deben dejar el estado global y los búferes limpios.

  11. El tamaño y la disposición de los paréntesis son señales estructurales. Mantén cada archivo fuente por debajo de 1000 líneas y el cuerpo ejecutable de cada defun / defmacro (excluyendo su cadena de documentación y formas declare) por debajo de 80 líneas. Nunca trunques cadenas de documentación, elimines comentarios explicativos ni empaques múltiples formas secuenciales con efectos secundarios en una sola línea para eludir los límites de conteo de líneas. Nunca coloques paréntesis de cierre ))) solos en líneas finales. Indenta de acuerdo con la semántica estándar de las formas Lisp (declarando (declare (indent ...)) en cada macro Elisp). Divide archivos y funciones por proposición de dominio, no por cortes arbitrarios de conteo de líneas o cubos vagos de utils.

  12. La lógica merece un nombre. No expongas cadenas en bruto de car/cdr/nth (cadddr), plomería anidada de assoc/plist-get o expresiones de múltiples cláusulas and/or/not en el sitio de llamada cuando expresen una proposición de dominio. Define accesores nombrados y predicados semánticos que terminen en -p o p (ej., order-matchable-p, same-principal-p, session-active-p).

Completitud del modelo

Antes de elegir paquetes, estructuras y funciones, nombra el modelo formal que hace que el código sea coherente.

Para macros y transformaciones sintácticas:

  • Una macro es un paso del compilador de sintaxis a sintaxis: $\text{AST}{\text{superficie}} \to \text{AST}{\text{núcleo}}$.
  • Especifica la gramática superficial (lista lambda desestructuradora), la disciplina de enlace, la multiplicidad de evaluación de cada subforma y la expansión objetivo.
  • Verifica la higiene con macroexpand-1 / macrostep: sin captura de símbolos libres, sin evaluación múltiple de argumentos con efectos y sin eval en tiempo de ejecución.
  • Si una macro se expande en definiciones, preserva las ubicaciones de origen y las declaraciones (declare, colocación de la cadena de documentación) para el compilador anfitrión y el inspector.

Para estado interactivo, búferes y procesos concurrentes:

  • Un sistema interactivo es una relación de transición de estado antes de ser un búfer o un hilo.
  • Separa el valor del estado del dominio del búfer de renderizado (UI de Emacs) o del hilo/trabajador/socket de proceso (CL/Emacs).
  • Modela la salida asíncrona del proceso (filtros/sentinels de proceso en Emacs, hilos/canales en CL) como eventos discretos que alimentan una transición de estado total: $\text{Estado} \times \text{Evento} \to (\text{Estado} \times \text{Lista}[\text{Efecto}])$.
  • Los filtros de proceso en Emacs Lisp pueden recibir límites de fragmentos arbitrarios; almacena en búfer y analiza explícitamente los marcos incompletos antes de despachar eventos del dominio.
  • Protege el estado local del búfer (defvar-local) contra búferes eliminados (buffer-live-p) cuando los temporizadores, centinelas o devoluciones de llamada se activen de forma asíncrona.

Para condiciones, reinicios y control no local:

  • Separa qué salió mal (el dato de la condición) de cómo recuperarse (reinicios en CL; manejadores estructurados en Elisp) y qué recuperación elegir (el manejador de política externo).
  • Nunca tragues condiciones con un (ignore-errors ...) o (condition-case nil ... (error nil)) a menos que el tipo exacto de condición ignorada esté acotado y el valor de respaldo sea un estado de dominio válido.

Comentarios de lógica formal

Usa comentarios formales solo cuando aclaren una obligación de prueba que ftype, deftype o cl-defstruct no expresen completamente. Usa ;; dentro de funciones/formas y ;;; a nivel superior, siguiendo la jerarquía estándar de comentarios Lisp (;;;; sección, ;;; nivel superior, ;; alineado en el cuerpo, ; margen).

;;; Pre: (and (<= 0 inicio fin (longitud secuencia)) (listp secuencia))
;;; Post: (and (equal resultado (subseq secuencia inicio fin))
;;;            (not (eq resultado secuencia)))
(defun slice-copia-verificada (secuencia inicio fin)
  "Devuelve una subsecuencia nueva de SECUENCIA desde INICIO hasta FIN."
  (check-type secuencia list)
  (assert (<= 0 inicio fin (length secuencia)))
  (copy-list (subseq secuencia inicio fin)))

;;; Invariante: (null (intersection (work-set-pendiente ws) (work-set-completado ws) :test #'equal))
;;; Preservación: `work-set-completar' elimina ID de `pendiente' antes de conrear en `completado'.
(defstruct (conjunto-trabajo (:copier nil))
  (pendiente nil :type list)
  (completado nil :type list))

;;; Ley: (equal (decode-paquetes (encode-paquetes x)) x) para toda estructura de paquete válida X.

Prefiere estas formas:

  • Pre: la condición que un llamante debe satisfacer.
  • Post: la condición que la función garantiza, incluyendo frescura/compartición (eq vs equal).
  • Invariante: la proposición preservada a través de operaciones de estructura/búfer/sesión.
  • Ley: una relación algebraica o de expansión de macros que las pruebas deben demostrar.
  • Preservación: por qué una transición o forma unwind-protect mantiene la invariante verdadera.

Predicados semánticos

Usa predicados nombrados siguiendo las convenciones de Lisp -p / p para expresar la lógica del dominio de forma declarativa:

  • Raíz de una sola palabra (convención de Common Lisp): evenp, Orderp -> orderp, validp (o en Elisp, -p consistentemente para símbolos con prefijo de paquete).
  • Raíz con guión (tanto CL como Elisp): order-matchable-p, same-principal-p, lispm-session-live-p.

Prefiere:

(cuando (order-matchable-p orden orden-en-reposo)
  (match-order libro orden orden-en-reposo))

(cuando (same-principal-p actor propietario)
  (grant-access actor recurso))

Evita:

(cuando (and (not (eq (order-side orden) (order-side orden-en-reposo)))
           (>= (order-price orden) (order-price orden-en-reposo))
           (plusp (order-quantity orden)))
  (match-order libro orden orden-en-reposo))

(cuando (and (equal (principal-id actor) (principal-id propietario))
           (eq (principal-realm actor) (principal-realm propietario)))
  (grant-access actor recurso))

También evita el acceso posicional profundo a listas ((cadddr registro), (nth 4 elemento)) en la lógica del dominio; define un defstruct / cl-defstruct o funciones de acceso nombradas para que el sitio de llamada lea el concepto del dominio en lugar de la topología de cons.

Disciplina de implementación

Comienza desde el dominio y respeta la semántica funcional del dialecto.

  • Currificación, aplicación parcial y combinadores:
    • Nunca descompongas una función larga extrayendo un ayudante procedimental con 6+ parámetros posicionales que reflejen los enlaces let* del llamante, o dividiendo un let* en subrutinas de un solo uso foo--parte-1 / foo--parte-2.
    • Nunca introduzcas "currificación falsa" (ej., (lambda (fn-getter) (lambda () ...))) para simular un ámbito léxico que un let* local ya proporciona.
    • En su lugar, currifica invariantes genuinas del dominio en cierres léxicos ((defun dominio--coincidencia (consulta rol) (lambda (evento) ...)) o (apply-partially #'fn arg-fijo)) y compone pequeñas transformaciones unarias/binarias: $f \circ g = \lambda x., f(g(x))$.
    • Reemplaza sondeos imperativos repetitivos, recorridos de grafos seguros para ciclos o patrones de horquilla de recursos con combinadores de orden superior que acepten una función de paso (funcall paso elemento) y devuelvan valores.
  • Precisión de igualdad: Nunca uses eq donde se requiera eql (números/caracteres), equal (cadenas/listas estructurales) o equalp / igualdad de dominio. Elige el predicado de igualdad más ajustado que coincida con la relación de equivalencia del tipo, y pasa :test #'equal explícitamente a assoc, member, gethash, remove y cl-find cuando las claves sean cadenas o valores compuestos.
  • Específicos de Emacs Lisp:
    • La línea 1 debe declarar ;; -*- lexical-binding: t; -*-.
    • Usa cl-lib (cl-defstruct, cl-loop, cl-destructuring-bind, cl-check-type), nunca el paquete cl obsoleto en tiempo de ejecución.
    • Protege todos los efectos secundarios de punto, marca, restricción y datos de coincidencia con save-excursion, save-restriction y save-match-data.
    • Prefiere pasar el búfer o usar explícitamente (with-current-buffer buf ...) en lugar de asumir current-buffer a través de límites asíncronos.
    • Anota las macros con (declare (indent ...) (debug ...)) para que la indentación y la instrumentación de Edebug funcionen automáticamente.
  • Específicos de Common Lisp:
    • Proclama (declaim (ftype (function (...) ...) nombre)) para funciones públicas de dominio, de modo que SBCL realice inferencia de tipos en tiempo de compilación y comprobaciones de exhaustividad.
    • Usa etypecase / ecase / ctypecase en lugar de case / typecase abiertos, para que las variantes no manejadas señalen inmediatamente un error de tipo estructurado.
    • Evita la contaminación de la tabla de lectura y las fugas de símbolos no exportados (paquete::sym-interno).
    • Prefiere ASDF con paquetes inferidos o :components serial explícitos con DAGs de dependencia limpios.
  • Constructos prohibidos en rutas de producción:
    • Sin eval en tiempo de ejecución para despachar funciones o construir código (usa funcall, apply o macros en tiempo de compilación).
    • Sin setq dinámico en variables libres no declaradas.
    • Sin mutación in situ (nconc, nreverse, delete, sort) de literales citados o listas no poseídas del llamante.

Skills relacionados