lisper

Revisão e geração estrita de Common Lisp e Emacs Lisp para compilação sem avisos, condições estruturadas, macros higiênicas, núcleos puramente funcionais, disciplina de escopo léxico, predicados semânticos, símbolos documentados e semântica de lista não destrutiva.

O que é lisper?

O Lisper é uma habilidade especializada para agentes de IA que trabalham com Common Lisp e Emacs Lisp. Ele impõe um conjunto rigoroso de 12 asserções de qualidade, garantindo que o código gerado ou revisado seja correto, seguro e mantenha a elegância funcional da linguagem. Isso inclui desde a transformação de dados puros em funções de ordem superior e separação de efeitos colaterais, até a definição de condições como fatos algébricos, a garantia de macros higiênicas com uso de `gensym` e a documentação completa de símbolos públicos. A habilidade suporta ambos os dialetos (CL e Elisp), com regras específicas para cada um, como a exigência `lexical-binding: t` no Emacs Lisp e o uso de `declaim` para inferência de tipos no SBCL. Seu objetivo é produzir código que seja semanticamente rico e expressivo, com zero avisos de compilador e que respeite os contratos públicos de pacotes e namespaces.

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

Installed? Explore more Programação e Desenvolvimento skills: steipete/bluebubbles, steipete/eightctl, steipete/blucli · View all 6 →

Perguntar na sua IA favorita

Abre um novo chat com esta habilidade de agente já pré-carregada.

Documentação

O que lisper faz?

Regra de Operação

Use esta habilidade como um conjunto de asserções. Trate cada asserção como satisfeita, violada ou explicitamente adiada por uma restrição do usuário. Prefira fatos exatos de código a alegações de gosto. Nomeie o pacote, símbolo, struct, condição, expansão de macro, invariante, teste ou limite de efeito colateral que torna a asserção verdadeira.

Declare o fato. Nomeie a testemunha. Não argumente sobre gosto.

Ao relatar sobre código Common Lisp ou Emacs Lisp, escreva em declarações curtas e afirmativas:

  • O invariante está no construtor.
  • A extensão dinâmica é delimitada por unwind-protect.
  • A macro vaza a ordem de avaliação.
  • A condição é estruturada.
  • A operação de lista destrutiva altera a estrutura do chamador.
  • O predicado está exposto.
  • O aviso do compilador permanece.
  • O efeito no buffer vaza para o núcleo puro.

Asserções

  1. O código representa um modelo. S-expressões são árvores sintáticas antes de serem texto. Preserve todo estado real do problema. Use símbolos, estruturas etiquetadas (defstruct / cl-defstruct), classes CLOS, ou alists/plists algébricas com construtores explícitos. Apague apenas distinções que não são semanticamente usadas.

  2. Funções de ordem superior compõem antes de macros reescreverem. Lisp é cálculo lambda primeiro: funções são valores de primeira classe, closures carregam ambientes léxicos, e currying (apply-partially ou retornar (lambda (x) ...)) substitui encanamento multi-parâmetro. Quando a mesma estrutura aparece duas vezes, inspecione-a; quando aparece três vezes, abstraia-a com um combinador de ordem superior, closure curried, ou função genérica—nunca um auxiliar procedimental de 10 argumentos. Introduza uma macro apenas para controlar avaliação, vincular símbolos léxicos, ou eliminar boilerplate em tempo de compilação. Toda macro deve avaliar argumentos de valor no máximo uma vez, em ordem da esquerda para a direita, e vincular temporários com gensym / make-symbol (with-gensyms).

  3. Transformações de dados puros permanecem fora do mundo mutável da imagem. Prefira catamorfismos (cl-reduce / seq-reduce), mapeamentos homomórficos (mapcar / seq-keep), e pipelines de predicados (seq-filter) a loops imperativos com let + setq + push + nreverse. Separe transformações puras de símbolos/listas/estruturas de mutação de buffer, IO de processo, estado de sistema de arquivos, fluxos de rede, timers e especiais globais (*earmuffs*). Funções centrais recebem valores e retornam valores. Efeitos hospedeiros permanecem em funções de fronteira nomeadas.

  4. Escopo léxico é a lei padrão. Todo arquivo Emacs Lisp deve começar com ;; -*- lexical-binding: t; -*- na linha 1. Toda variável especial dinâmica em Common Lisp ou Emacs Lisp deve usar *earmuffs* (ou +plus-signs+ para constantes em CL) e ser religada dinamicamente com let em vez de mutada globalmente com setq / setf, a menos que alterar a configuração global seja o contrato explícito.

  5. Invariantes são proposições. Expresse invariantes em tipos (deftype com satisfies, proclamações ftype, slots :type de defstruct) primeiro, construtores inteligentes (:constructor) segundo, asserções em tempo de execução (check-type / cl-check-type) terceiro, testes quarto e comentários por último. Um construtor é uma prova de que uma estrutura satisfaz seus invariantes de slot.

  6. Condições são fatos algébricos, não strings brutas. Defina hierarquias de condições explícitas (define-condition em Common Lisp; define-error em Emacs Lisp). Sinalize condições estruturadas com error / cerror / signal para que chamadores possam tratá-las com handler-case, handler-bind, ou condition-case sem corresponder substrings de mensagens de erro. Use restarts Common Lisp (restart-case) quando a política de recuperação pertence ao chamador e o mecanismo pertence à função de baixo nível.

  7. Propriedade de cons-cell é uma alegação semântica. Trate listas, árvores e sequências de entrada como imutáveis a menos que o nome da função e sua docstring declarem explicitamente comportamento destrutivo (nreverse, nconc, delete, sort, cl-delete, setf em cons cells compartilhadas). Nunca aplique operações destrutivas a literais citados ('(a b c)) ou listas emprestadas do chamador. Duplique estrutura (copy-list, copy-tree, copy-sequence) apenas na fronteira onde a mutação começa.

  8. Qualidade é testemunhada, não afirmada. Zero avisos de byte-compiler, zero erros checkdoc / package-lint, e zero diagnósticos STYLE-WARNING do SBCL são apenas o piso. Adicione testes ERT (ert-deftest) ou FiveAM/Rove/Parachute para transformações puras, leis de expansão de macro, entradas de fronteira, limpeza dinâmica sob saída não local e regressões corrigidas. Um nome de teste declara a proposição que testemunha.

  9. Documentação e prefixos de namespace são parte do contrato público.

    • Em Common Lisp: defina pacotes explícitos (defpackage / uiop:define-package) sem poluição :use em massa além de :cl; documente toda função, macro, classe, variável e condição exportada.
    • Em Emacs Lisp: prefixe todo símbolo público com <pacote>- e todo símbolo interno com <pacote>--; escreva docstrings compatíveis com checkdoc cuja primeira linha seja uma frase completa e cujas referências a parâmetros estejam em UPPERCASE; declare cabeçalhos Package-Requires e ;;; Commentary: com precisão.
  10. O tempo de vida de recursos é delimitado pela extensão dinâmica. Nunca emparelhe alocação manual e limpeza entre expressões sujeitas a falhas. Envolva toda alteração temporária de buffer, movimento de ponto, manipulador de arquivo, processo, soquete ou instalação de hook em unwind-protect (ou with-open-file, with-temp-buffer, save-excursion, save-restriction, save-match-data). Saídas não locais (throw, return-from, signal, error) devem deixar o estado global e buffers limpos.

  11. Tamanho e layout de parênteses são sinais estruturais. Mantenha cada arquivo de código-fonte abaixo de 1000 linhas e cada corpo executável de defun / defmacro (excluindo sua docstring e formas declare) abaixo de 80 linhas. Nunca trunque docstrings, exclua comentários explicativos ou empacote múltiplas formas sequenciais com efeitos colaterais em uma única linha para burlar limites de contagem de linhas. Nunca coloque parênteses de fechamento ))) sozinhos em linhas finais. Indente de acordo com a semântica padrão de formulários Lisp (declarando (declare (indent ...)) em toda macro Elisp). Divida arquivos e funções por proposição de domínio, não por fatias arbitrárias de contagem de linhas ou buckets vagos de utils.

  12. Lógica merece um nome. Não exponha cadeias brutas de car/cdr/nth (cadddr), encanamentos aninhados de assoc/plist-get, ou expressões multi-cláusula and/or/not no local da chamada quando elas expressam uma proposição de domínio. Defina acessadores nomeados e predicados semânticos terminando em -p ou p (por exemplo, order-matchable-p, same-principal-p, session-active-p).

Completude do Modelo

Antes de escolher pacotes, structs e funções, nomeie o modelo formal que torna o código coerente.

Para macros e transformações sintáticas:

  • Uma macro é uma passagem de compilador de sintaxe para sintaxe: $ ext{AST}{\text{superfície}} \to \text{AST}{\text{núcleo}}$.
  • Especifique a gramática de superfície (lista de parâmetros de desestruturação), a disciplina de vinculação, a multiplicidade de avaliação de cada subformulário e a expansão alvo.
  • Verifique higiene com macroexpand-1 / macrostep: nenhuma captura de símbolo livre, nenhuma avaliação múltipla de argumentos com efeitos colaterais e nenhum eval em tempo de execução.
  • Se uma macro se expande em definições, preserve localizações de fonte e declarações (declare, colocação de docstring) para o compilador hospedeiro e inspetor.

Para estado interativo, buffers e processos concorrentes:

  • Um sistema interativo é uma relação de transição de estado antes de ser um buffer ou thread.
  • Separe o valor do estado de domínio do buffer de renderização (IU Emacs) ou thread/soquete de trabalho (processo CL/Emacs).
  • Modele saída de processo assíncrona (filtros/sentinels de processo Emacs, threads/canais CL) como eventos discretos alimentando uma transição total de estado: $\text{Estado} \times \text{Evento} \to (\text{Estado} \times \text{Lista}[ \text{Efeito}])$.
  • Filtros de processo em Emacs Lisp podem receber limites de bloco arbitrários; faça buffer e analise quadros incompletos explicitamente antes de despachar eventos de domínio.
  • Proteja estado local de buffer (defvar-local) contra buffers mortos (buffer-live-p) quando timers, sentinels ou callbacks disparam assincronamente.

Para condições, restarts e controle não local:

  • Separe o que deu errado (o dado da condição) de como recuperar (restarts em CL; manipuladores estruturados em Elisp) e qual recuperação escolher (o manipulador de política externo).
  • Nunca engula condições com um (ignore-errors ...) ou (condition-case nil ... (error nil)) a menos que o tipo exato da condição ignorada seja restrito e o valor de fallback seja um estado de domínio válido.

Comentários de Lógica Formal

Use comentários formais apenas quando eles esclarecem uma obrigação de prova que ftype, deftype ou cl-defstruct não expressam completamente. Use ;; dentro de funções/formulários e ;;; no nível superior, seguindo a hierarquia de comentários Lisp padrão (;;;; seção, ;;; nível superior, ;; alinhado no corpo, ; margem).

;;; 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)
  "Retorna uma nova subsequência de SEQUENCE de START a 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' remove ID de `pending' antes de cons em `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.

Prefira estas formas:

  • Pre: a condição que um chamador deve satisfazer.
  • Post: a condição que a função garante, incluindo frescor/compartilhamento (eq vs equal).
  • Invariant: a proposição preservada entre operações de struct/buffer/sessão.
  • Law: uma relação algébrica ou de expansão de macro que testes devem testemunhar.
  • Preservation: por que uma transição ou forma unwind-protect mantém o invariante verdadeiro.

Predicados Semânticos

Use predicados nomeados seguindo as convenções -p / p do Lisp para expressar lógica de domínio declarativamente:

  • Raiz de palavra única (convenção Common Lisp): evenp, Orderp -> orderp, validp (ou em Elisp, -p consistentemente para símbolos prefixados por pacote).
  • Raiz hifenizada (ambos CL e Elisp): order-matchable-p, same-principal-p, lispm-session-live-p.

Prefira:

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

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

Evite:

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

Evite também acesso posicional profundo a listas ((cadddr record), (nth 4 item)) em lógica de domínio; defina um defstruct / cl-defstruct ou funções acessadoras nomeadas para que o local da chamada leia o conceito de domínio em vez da topologia de cons.

Disciplina de Implementação

Comece pelo domínio e respeite a semântica funcional do dialeto.

  • Currying, Aplicação Parcial e Combinadores:
    • Nunca decomponha uma função longa extraindo um auxiliar procedimental com 6+ parâmetros posicionais que espelham as vinculações let* do chamador, ou fatiando um let* em sub-rotinas de uso único foo--part-1 / foo--part-2.
    • Nunca introduza "currying falso" (por exemplo, (lambda (getter-fn) (lambda () ...))) para simular um escopo léxico que um let* local já fornece.
    • Em vez disso, curry invariantes genuínos de domínio em closures léxicas ((defun domain--matcher (query role) (lambda (event) ...)) ou (apply-partially #'fn fixed-arg)) e componha pequenas transformações unárias/binárias: $f \circ g = \lambda x., f(g(x))$.
    • Substitua polling imperativo repetitivo, travessia de grafo segura para ciclos ou padrões de colchete de recurso com combinadores de ordem superior que aceitam uma função de passo (funcall step item) e retornam valores.
  • Precisão de igualdade: Nunca use eq onde eql (números/caracteres), equal (strings/listas estruturais) ou equalp / igualdade de domínio é necessário. Escolha o predicado de igualdade mais restrito que corresponda à relação de equivalência do tipo, e passe :test #'equal explicitamente para assoc, member, gethash, remove e cl-find quando chaves são strings ou valores compostos.
  • Especificidades do Emacs Lisp:
    • A linha 1 deve declarar ;; -*- lexical-binding: t; -*-.
    • Use cl-lib (cl-defstruct, cl-loop, cl-destructuring-bind, cl-check-type), nunca o pacote cl obsoleto em tempo de execução.
    • Proteja todos os efeitos colaterais de ponto, marca, estreitamento e match-data com save-excursion, save-restriction e save-match-data.
    • Prefira passagem de buffer ou (with-current-buffer buf ...) explícito a assumir current-buffer através de limites assíncronos.
    • Anote macros com (declare (indent ...) (debug ...)) para que indentação e instrumentação Edebug funcionem automaticamente.
  • Especificidades do Common Lisp:
    • Proclame (declaim (ftype (function (...) ...) name)) para funções públicas de domínio, para que o SBCL realize inferência de tipos em tempo de compilação e verificações de exaustividade.
    • Use etypecase / ecase / ctypecase em vez de case / typecase abertos, para que variantes não tratadas sinalizem um erro de tipo estruturado imediatamente.
    • Evite poluição da tabela de leitura e vazamento de símbolos não exportados (pkg::internal-sym).
    • Prefira ASDF package-inferred ou :components serial explícito com DAGs de dependência limpos.
  • Construções proibidas em caminhos de produção:
    • Nenhum eval em tempo de execução para despachar funções ou construir código (use funcall, apply ou macros em tempo de compilação).
    • Nenhum setq dinâmico em variáveis livres não declaradas.
    • Nenhuma mutação in-place (nconc, nreverse, delete, sort) de literais citados ou listas não próprias do chamador.

Habilidades Relacionadas