myname's questions

Tenho uma classe na qual quero que alguns slots sejam nulos quando o objeto for criado, mas eles devem ser configuráveis ​​apenas com objetos de um determinado tipo. Algo como:

(defclass Something ()
  ((foo :initarg :foo
        :type (or character 'nil)
        :initform nil
        :accessor something-foo)))

Se eu disser apenas :type character, ou :type (or character nil), então o SBCL reclama por NILnão ser do tipo de caractere declarado. Se eu disser :type (or character 'nil), então parece que ele aceita caracteres e o tipo de símbolo, já que qualquer símbolo parece ser:

CL-USER> (defvar *foo* (make-instance 'Something))
*FOO*
CL-USER> (setf (something-foo *foo*) 'test)
TEST
CL-USER> (something-foo *foo*)
TEST

Existe uma maneira de afirmar que um slot é nulo ou possui o tipo fornecido? Ou devo simplesmente omitir o especificador de tipo e afirmar o tipo no método acessador ou escritor?

Editar:

Depois de pensar um pouco, talvez a expressão seja: :type characterdeixe-o desvinculado e verifique se o slot está vinculado ou não, em vez de verificar se é nulo ou não nulo?

Considere isto:

(defclass my-string ()
  ((data :initarg :data :type simple-string)
   (properties :initarg :properties :type interval-tree))
  (:documentation
   "Represents a string with properties."))

Gostaria de usar my-string como um tipo em uma expressão typecase:

(defun upcase (obj)
  (typecase obj
    (my-string (string-upcase (slot-value obj 'data)))
    (string (string-upcase obj))
    (integer (char-upcase (code-char obj)))
    (character (char-upcase obj))
    (otherwise (error "Wrong type argument ~S" obj))))

Eu pensei que classes são tipos, mas obviamente não, já que o acima é um erro do compilador. Então eu declarei um tipo:

(deftype my-string (s) (typep s 'my-string))

que parece que tenho que usar assim (caso contrário, recebo um erro de compilação de que o typedef espera um argumento):

(defun upcase (obj)
  (typecase obj
    ((my-string obj) (string-upcase (slot-value obj 'data)))
    (string (string-upcase obj))
    (integer (char-upcase (code-char obj)))
    (character (char-upcase obj))
    (otherwise (error "Wrong type argument ~S" obj))))

No entanto, o SBCL exclui meu código como inacessível! :-)

Como faço isso? Como declarar corretamente um tipo para uma classe para que eu possa usá-lo em expressões onde declarações de tipo são utilizáveis?

Entendo que posso usar struct em vez de class, nesse caso o compilador gera código para o tipo, e o typecase inicial "simplesmente funciona":

(defstruct my-string
  data properties)

Macroexpandir e olhar o código gerado não me deixou realmente mais esclarecido. Vejo isso:

(SB-C:XDEFUN MY-STRING-P
     :PREDICATE
     NIL
     (SB-KERNEL::OBJECT)
   (TYPEP SB-KERNEL::OBJECT 'MY-STRING))

que faz exatamente o que eu fiz, mas não acho que essa função esteja na peça, ou estou errado? Ou eles de alguma forma associam structs com tipos internamente, ou eu perdi alguma parte relevante do código gerado? Não estou muito familiarizado com tudo isso, então é bem provável também.

Uma pergunta relacionada: qual é a maneira correta de modelar uma classe personalizada que estende um tipo interno como string no CommonLisp? É uma maneira melhor de fazer a composição, como feito em my-string, ou talvez seja melhor herdar de alguma classe de string CL interna? Com ​​base nesta pergunta e respostas do SX , parece-me que a herança não é a melhor maneira de modelar tipos, o que provavelmente é para melhor, já que não gostamos de taxonomias como as conhecidas do Java ou do antigo C++.

Por fim, eu nem precisaria de typecase neste caso se eu fizesse upcase um método genérico que se especializasse nesses tipos, todo o problema desaparece, do que estou totalmente ciente. No entanto, eu gostaria de aprender mais sobre tipos e classes, e como modelar algo como o acima em CL.

Desculpe se for um pouco longo e muitas perguntas reunidas em uma, estou apenas aprendendo isso. Parece que cada pergunta que tenho e experimento para uma resposta abre mais 10 perguntas :).

Como o título diz, como posso verificar (programaticamente) de forma portátil (se possível) se um símbolo representa uma macro de símbolos?

CL-USER> (define-symbol-macro some-macro some)
SOME-MACRO
CL-USER> (macro-function 'some-macro)
NIL
CL-USER> (fboundp 'some-macro)
NIL

SBCL tem sb-impl::info:

CL-USER> (describe 'sb-impl::info)
SB-INT:INFO
  [symbol]

INFO names a compiled function:
  Lambda-list: (CATEGORY KIND NAME)
  Declared type: (FUNCTION (T T T) (VALUES T T &OPTIONAL))
  Source file: SYS:SRC;COMPILER;GLOBALDB.LISP

INFO has a compiler-macro:
  Source file: SYS:SRC;COMPILER;EARLY-GLOBALDB.LISP

(SETF INFO) names a compiled function:
  Lambda-list: (NEW-VALUE CATEGORY KIND NAME)
  Declared type: (FUNCTION (T T T T) (VALUES T &OPTIONAL))
  Source file: SYS:SRC;COMPILER;GLOBALDB.LISP

(SETF INFO) has a compiler-macro:
  Source file: SYS:SRC;COMPILER;EARLY-GLOBALDB.LISP

Parece funcionar:

CL-USER> (sb-impl::info :variable :kind 'some-macro)
:MACRO
T

É isso que eles usam no código-fonte para a função 'describe' (eu descobri olhando lá).

Antes disso, eu estava olhando para clhs, mas não encontrei nada. Eu perdi ou não há uma maneira padrão? Existe alguma biblioteca portátil/"trivial" que faça isso?

Editar:

Após uma resposta útil, encontrei um wrapper "trivial" para cltl2 . Parece estar no quicklisp também, então podemos ter além do 'special-operator-p' embutido :

(defun special-variable-p (symbol)
    (multiple-value-bind (info ignore1 ignore2)
        (variable-information symbol)
      (declare (ignore ignore1 ignore2))
      (eq :special info)))

(defun symbol-macro-p (symbol)
    (multiple-value-bind (info ignore1 ignore2)
        (variable-information symbol)
      (declare (ignore ignore1 ignore2))
      (eq :symbol-macro info)))

Na verdade, prefiro um booleano generalizado, parece mais útil, então estou usando isto:

(defun symbol-macro-p (symbol)
  "Return if SYMBOL stands for a symbol macro."
    (multiple-value-bind (info ignore1 ignore2)
        (variable-information symbol)
      (declare (ignore ignore1 ignore2))
      (when (eq :symbol-macro info)
        (multiple-value-bind (expansion ignored)
            (macroexpand symbol)
          (declare (ignore ignored))
          expansion))))

CL-USER> (symbol-macro-p 'some-macro)
SOME

Este é um pouco embaraçoso, mas estou preso nisso há mais tempo do que gostaria de admitir.

Gostaria de gerar uma macro que sombreie automaticamente um símbolo se ele for encontrado em algum pacote existente. Estou usando apenas o pacote :common-lisp e ocultarei várias funções do padrão.

Anteriormente, mantive uma lista de símbolos sombreados e exportados, mas gostaria de não manter essas listas. Em vez disso, eu preferiria sombrear o símbolo de uma macro, para poder ter a declaração de sombra e de exportação junto com a definição. Parece muito simples, entretanto, seja qual for a maneira que eu o implementei, ou estou violando os bloqueios de pacote, ou meu símbolo é indefinido, ou algo mais. Para começar, aqui está um pacote def:

(in-package :cl-user)

(uiop:define-package :foo-package
  (:nicknames :foo)
  (:use :common-lisp)
  (:shadow #:defun))

(in-package :foo)

A função de teste não faz nada, apenas um pequeno wrapper para o teste:

(defun make-string (length init)
  (cl:make-string length :initial-element init))

Minha primeira tentativa ficou assim:

(cl:defmacro defun (name arglist &optional docstring &rest body)
  `(progn
     (when (symbol-package ',name)
       (shadow ',name))
     (cl:defun ,name ,arglist ,docstring ,@body)
     (export '(,name))))

No entanto, isso resulta em uma violação de bloqueio de pacote com SBCL, portanto, a função shadow obviamente não entra em vigor antes de eu tentar redefinir a função com cl:defun.

Envolvê-lo (eval-when (:compile-toplevel :load-toplevel :execute)para disponibilizá-lo em tempo de compilação não ajudou.

Outra tentativa foi usar um gerador:

(eval-when (:compile-toplevel :load-toplevel :execute)
  (cl:defmacro defun (name args &optional docstring &rest body)
    (macrolet ((export-it (name args &optional docstring &rest body)
                 `(progn
                    (when (symbol-package ',name)
                      (shadow ',name))
                    (cl:defun ,name ,args ,docstring ,@body)
                    (export '(,name) *package*))))
      `(export-it ,name ,args ,docstring ,@body))))

Isso me dá common-lisp:make-string desvinculado:

depurador invocado em um UNBOUND-VARIABLE @10039FFD22 no thread #<THREAD "main thread" RUNNING {10044982F3}>: a variável MAKE-STRING não está associada.

Tentei gerar um lambda e funcall, mas também sem muito sucesso.

Se eu sombrear make-string manualmente de repl: (shadow 'make-string), posso posteriormente redefinir e exportar make-string sem problemas.

Parece que não entendi algo mais fundamental aí.

A propósito, eu estava lendo o artigo de M. Cracauer Compile Time Programming e achei uma boa ideia manter tudo no mesmo lugar, mas acho que minha familiaridade com macros e avaliação de tempo de compilação versus tempo de execução não é onde deveria estar .

Entendo que posso usar coisas específicas do SBCL para remover temporariamente bloqueios de pacotes, mas 'shadow' e 'symbol-package' ou 'find-package' e 'find-symbol' que usei inicialmente para verificar se um símbolo está internado em :common -lisp pacote, deve ser mais portátil.