Понимание того, как работает функция компиляции в Common Lisp SBCL

Компиляция уже скомпилированной функции в SBCL

Проблема очень тонкая:

(compile 'square (lambda (x) (* x x)))

COMPILE — это функция. Теперь посмотрите на (lambda (x) (* x x)). Что оценивается?

> (compiled-function-p (lambda (x) (* x x)))
T

Это скомпилированная функция!

В SBCL все функции по умолчанию компилируются.

Теперь мы вызываем COMPILE для уже скомпилированной функции.

Что происходит?

• мы вызываем COMPILE с именем и скомпилированной функцией
• SBCL не компилирует функцию, она уже скомпилирована
• SBCL не устанавливает имя, поскольку не скомпилировал уже скомпилированную функцию.

Можно возразить, что функцию все же следует задать. Лучше обсудить это с сопровождающими

Компиляция исходного кода

Это работает:

CL-USER> (compile 'square '(lambda (x) (* x x)))
SQUARE
NIL
NIL

CL-USER> #'square
#<FUNCTION SQUARE>

Это работает, потому что '(lambda (x) (* x x)) возвращает список, который является допустимой LAMBDA макроформой. Компилятор успешно скомпилирует этот исходный код, а затем присвоит полученной скомпилированной функции символьную функцию SQUARE.

Сравните с другой реализацией CL, здесь LispWorks.

Сравните с LispWorks, который по умолчанию не компилирует функции.

CL-USER 134 > (let ((f (compile nil '(lambda (x) (* x x)))))
                (compile 'square f))
;;;*** Warning in SQUARE: The definition supplied for SQUARE is already compiled.
SQUARE
((SQUARE #<CONDITIONS::SIMPLE-STYLE-WARNING 80101F2C9B>))
NIL

CL-USER 135 > (symbol-function 'square)
#<Function 14 8020000CB9>

LispWorks предупреждает, что функция уже скомпилирована, и все равно устанавливает символьную функцию SQUARE.

Я думаю, что это ошибка в SBCL. В частности, кажется, что если вы передадите compile скомпилированную функцию в качестве второго аргумента, все будет работать неправильно.

Это работает так, как и следовало ожидать (каждый пример выполняется в холодном SBCL после версии 2.4.5):

> (fboundp 'square)
nil
> (compile 'square '(lambda (x) (* x x)))
square
nil
nil
> (fboundp 'square)
#<function square>
> (square 10)
100

Но

> (fboundp 'square)
nil
> (compile 'square (lambda (x) (* x x)))
square
nil
nil
> (fboundp 'square)
nil
> (type-of (lambda (x) (* x x)))
compiled-function

Эквивалентные вещи применяются в вашем случае переопределения.

SBCL обычно не имеет интерпретируемых функций, но стандарт подготовлен для этого случая:

compile создает скомпилированную функцию из определения. Если определение является лямбда-выражением, оно приводится к функции. Если определение уже является скомпилированной функцией, компиляция либо создает саму эту функцию (т. е. является идентификационной операцией), либо эквивалентную функцию.

Если имя равно nil, результирующая скомпилированная функция возвращается непосредственно как основное значение. Если задано ненулевое имя, то результирующая скомпилированная функция заменяет существующее определение функции name, и имя возвращается в качестве основного значения; если имя является символом, который называет макрос, его функция макроса обновляется, и имя возвращается в качестве основного значения.

Из КОМПИЛЯ, мой акцент.

Таким образом, SBCL неправильно рассматривает случай, когда определение (a) еще не является определением, связанным с name, а (b) уже является скомпилированной функцией. Я бы сообщил об этом как об ошибке.

Это работает правильно, если определение является интерпретируемой функцией. Вы можете заставить это произойти, установив для *evaluator-mode* значение :interpret:

> (setf *evaluator-mode* :interpret)
:interpret
> (compile 'square (lambda (x) (* x x)))
square
nil
nil
> (fboundp 'square)
#<function (lambda (x) nil) {7007117D6B}>
> (square 100)
10000
> (type-of #'square)
compiled-function
> (type-of (lambda (x) (* x x)))
sb-kernel:interpreted-function

Похоже, ошибка связана только с скомпилированной функцией.

На практике, если вы хотите установить фрагмент исходного кода в форме лямбда-выражения, то в этом случае все будет в порядке, поскольку SBCL правильно обрабатывает этот случай, как вы можете видеть выше. или вы можете написать что-то вроде этого:

(defun compile-and-install (name definition)
  ;; Does not handle the macro case that COMPILE does
  (setf (fdefinition name)
        (typecase definition
          (compiled-function definition)
          (t (compile nil definition))))
  name)