Подробное руководство по распространенным типам lisp

Вам нужно указать компилятору оптимизировать для безопасности, если вы хотите, чтобы он фактически применял типы:

CL-USER> (declaim (optimize (safety 3)))
NIL
CL-USER> (defclass foobar () ())
#<STANDARD-CLASS COMMON-LISP-USER::FOOBAR>
CL-USER> (defun foo (a)
           (make-array 1 :element-type 'foobar
                         :initial-contents (list a)))
FOO
CL-USER> (foo (make-instance 'foobar))
#(#<FOOBAR {1005696CE3}>)
CL-USER> (foo 12)
;=> ERROR
CL-USER> (declaim (ftype (function (integer integer) integer) quux))
(QUUX)
CL-USER> (defun quux (a b)
           (+ a b))
QUUX
CL-USER> (quux 12 12)
24 (5 bits, #x18, #o30, #b11000)
CL-USER> (quux 12 "asd")
;=> ERROR

Проверка типов во время выполнения добавляет некоторые накладные расходы (особенно если это происходит в цикле) и может выполняться несколько раз для одного значения, поэтому по умолчанию это не делается.

(declaim (optimize (safety 3)))

(defun some-predicate-p (a)
  (format t "~&Checking type...")
  (integerp a))

(deftype foo () `(satisfies some-predicate-p))

(defclass bar ()
  ((foo :type foo :initarg :foo)))

(declaim (ftype (function (foo) list) qwerty))
(defun qwerty (foo)
  (loop repeat 10 collecting (make-instance 'bar :foo foo)))

(qwerty 12)
; Checking type...
; Checking type...
; Checking type...
; Checking type...
; Checking type...
; Checking type...
; Checking type...
; Checking type...
; Checking type...
; Checking type...
; Checking type...
;=> (#<BAR {1003BCA213}> #<BAR {1003BCA263}> #<BAR {1003BCA2B3}>
;    #<BAR {1003BCA303}> #<BAR {1003BCA353}> #<BAR {1003BCA3A3}>
;    #<BAR {1003BCA3F3}> #<BAR {1003BCA443}> #<BAR {1003BCA493}>
;    #<BAR {1003BCA4E3}>)

Если вы хотите, чтобы функция всегда проверяла тип места, независимо от настроек оптимизации, вам следует использовать CHECK-TYPE вручную.

Почему непримитивные типы, объявленные в :element-type make-array, повышаются до t? Есть ли возможность проверки реального объявленного типа во время компиляции или во время выполнения?

Параметр :element-type предназначен для того, чтобы реализация могла выбрать оптимизированную структуру памяти для массива — в основном для экономии места в памяти. Это обычно полезно с примитивными типами. Для других типов большинство исполняющих сред Common Lisp не будут иметь оптимизированной реализации хранилища, и поэтому объявление не будет иметь никакого полезного эффекта.

Почему типы, определенные слотом CLOS, не работают как ограничения, позволяющие помещать в слот значение любого типа? Опять же, что с чеками?

Реализация может сделать это.

Закрытие CL:

? (defclass foo () ((bar :type integer :initform 0 :initarg :bar)))
#<STANDARD-CLASS FOO>
? (make-instance 'foo :bar "baz")
> Error: The value "baz", derived from the initarg :BAR,
  can not be used to set the value of the slot BAR in
  #<FOO #x302000D3EC3D>, because it is not of type INTEGER. 

То же самое для объявлений типов функций с помощью declare.. Являются ли они просто подсказками по оптимизации для компилятора?

Объявления типов с помощью declare можно игнорировать - например, в Symbolics Genera большинство объявлений будут игнорироваться. Реализации не требуются для их обработки. Большинство реализаций, по крайней мере, интерпретируют их как гарантию того, что какой-то объект будет иметь этот тип, и создадут для этого оптимизированный код — возможно, без проверок во время выполнения и/или специализированного кода для этого типа. Но обычно необходимо установить соответствующие уровни оптимизации (скорость, безопасность, отладка,...)

Кроме того, компиляторы, производные от компилятора CMUCL (SBCL, ...), могут использовать их для некоторых проверок времени компиляции.

Но ни один из эффектов не указан в стандарте ANSI CL. Стандарт предоставляет объявления и оставляет интерпретацию реализации.

То, как типы обрабатываются во время компиляции, определяется реализациями. В случае SBCL типы обычно рассматриваются как утверждения, но фактическое поведение зависит от уровней оптимизации.

Типы как утверждения означают, что если функция принимает число n и возвращает строку s, вы обычно не предполагаете, что n является числом. Вместо этого у вас есть гарантия того, что если функция возвращает значение, то n фактически было числом, а s теперь является строкой. Но если вы повторно используете s, у вашего компилятора есть возможность пропустить проверку того, что s является строкой. Как правило, это то, что вам нужно, потому что ваши функции доступны глобально и, следовательно, могут быть вызваны из любого места. Поскольку функции отвечают за проверку своих входных данных, нормально, что вы всегда сначала проверяете, является ли n числом.

Тем не менее, объявления типов для функций могут помочь вам в случае, если вы вызываете функцию в контексте, где можно доказать, что во время выполнения типы точно не совпадут (пересечение типов пусто). Чтобы слепо доверять утверждениям типа, вы должны снизить уровни безопасности.

Примечание. Первоначально я разместил его в комментарии, но, чтобы его не удалили, вот ссылка на красивую графику, представляющую отношения между типами в CL:

http://sellout.github.io/2012/03/03/common-lisp-type-hierarchy