Например, рассмотрим простую функцию:

(defun add (x y) (+ x y))
Как я упоминал в главе 10, если вы сравните производительность этой LISP-функции с вроде бы эквивалентной функцией на языке C,

int add (int x, int y) { return x + y; }
вы возможно обнаружите, что LISP-функция заметно медленнее, даже если ваша реализация Common Lisp обладает высококачественным компилятором в машинный код.

Это происходит потому, что версия функции на Common Lisp выполняет гораздо больше всего – компилятор Common LISP даже не знает, что значения x и y являются числами, и таким образом вынужден сгенерирвать код для проверки типов во время выполнения. И как только он определил, что это - числа, он должен также определить, какого типа эти числа - целые, рациональные, с плавающей точкой или комплексные, и перенаправить вызов соответствующей вспомогательной процедуре, обрабатывающей соответствующие типы. И даже если x и y являются целыми числами, то процедура сложения должна позаботиться о том, что результат сложения может быть слишком большим для представления в FIXNUM-числе, числе, которое может быть представлено в одном машинном слове, и, таким образом, должна выделить число типа BIGNUM.

В языке C, с другой стороны, поскольку типы всех переменных объявлены, компилятор знает точно, какой тип значений будет храниться в x и y. И, поскольку арифметика языка C просто вызывает переполнение, когда результат сложения слишком большой, чтобы быть представленным в возвращаемом типе, в функции нет ни проверки на переполнение, ни выделения длинного целого значения, если результат не вмещается в машинное слово

Таким образом, поскольку поведение кода на Common Lisp гораздо более близко к математической корректности, версия на языке C, возможно, может быть скомпилирована в одну или две машинных инструкции. Но если вы пожелаете дать компилятору Common Lisp ту же информацию, которую имеет компилятор языка C о типах аргументов и возвращаемом значении, и принять некоторые компромисы, подобные используемым в языке C, относительно общности кода и проверки ошибок, функция на Common Lisp также может компилироваться в пару машинных инструкций.

Именно для этого и служат объявления. Главная польза объявлений в том, чтобы сказать компилятору о типах переменных и других выражений. Например, вы можете указать компилятору, что складываемые аргументы являются FIXNUM-значениями, написав функцию следующим образом:

(defun add (x y)
(declare (fixnum x y))
(+ x y))
Выражение DECLARE не является формой языка Common LISP, это – часть синтаксиса макроса DEFUN, где оно должно быть указано до тела функции, если оно используется5). Данное объявление объявляет, что аргументы функции x и y будут всегда FIXNUM-значениями. Другими словами, это обещание компилятору, и компилятору разрешено генерировать код в предположении, что все, что вы пообещали ему, будет истинным.

Чтобы объявить тип возвращаемого значения, вы можете обернуть основное выражение функции (+ x y) в специальный оператор THE. Этот оператор принимает спецификатор типа, такой как FIXNUM, и какую-то форму, и говорит компилятору, что эта форма будет возвращать значение указанного типа. Таким образом, чтобы дать компилятору Common Lisp всю ту же информацию, которую имеет компилятор языка C, вы можете написать следующее:

(defun add (x y)
(declare (fixnum x y))
(the fixnum (+ x y)))
Однако даже эта версия нуждается в еще одном объявлении, чтоб дать компилятору Common Lisp те же разрешения, что есть и у компилятора языка C, генерировать быстрый, но опасный код. Объявление OPTIMIZE используется для того, чтобы указать компилятору как распределить свое внимание между пятью целями:

скоростью генерируемого кода
количеством проверок времени выполнения
использованием памяти, как в терминах размера кода, так и в терминах размера памяти данных
количеством отладочной информации, хранимой вместе с кодом
скоростью процесса компиляции.
Объявление OPTIMIZE содержит один или более списков, каждый из которых содержит один из символов: SPEED, SAFETY, SPACE, DEBUG или COMPILATION-SPEED и число от нуля до трех включительно. Число указывает относительный вес, который компилятор должен дать соответствующему параметру, причем 3 означает наиболее важное направление, а 0 - что это не имеет значения вообще. Таким образом, чтобы заставить компилятор Common Lisp компилировать функцию add более-менее так же, как это бы делал компилятор языка C, вы можете переписать ее так:

(defun add (x y)
(declare (optimize (speed 3) (safety 0)))
(declare (fixnum x y))
(the fixnum (+ x y)))
Конечно, теперь LISP-версия функции страдает многими из слабостей C-версии: если переданные аргументы не FIXNUM-значения или если сложение вызывает переполнение, результаты будут математически некорректны или даже хуже. Также если кто-то вызовет функцию add с неправильным количеством параметров, будет мало хорошего. Таким образом, вам следует использовать объявления этого вида только после того, как ваша программа стала работать правильно, и вы должны добавлять их только в местах, где профилирование показывает необходимость этого. Если вы имеете достаточную производительность без этих объявлений, пропускайте их. Но если профайлер показывает вам какое-то проблемное место в вашем коде и вам нужно оптимизировать его - вперёд. Поскольку вы можете использовать объявления таким образом, редко когда нужно переписывать код на языке C только из соображений производительности. Для доступа к существующему коду на C используется FFI, но когда нужна производительность, подобная языку C, используют объявления. И конечно, то, как близко вы захотите приблизить производительность данной части кода на языке Common Lisp к коду на C или C++, зависит главным образом от вашего желания.

Другое средство оптимизации, встроенное в язык Lisp, – это функция DISASSEMBLE. Точное поведение этой функции зависит от реализации, потому что оно зависит от того, как реализация компилирует код: в машинный код, байт-код или какую-то другую форму. Но основная идея в том, что она показывает вам код, сгенерированный компилятором, когда он компилировал данную функцию.

Таким образом, вы можете использовать DISASSEMBLE, чтобы увидеть, возымели ли ваши объявления какой-то эффект на генерируемый код. Если ваша реализация языка LISP использует компиляцию в машинный код, и если вы знаете язык ассемблера вашей платформы, вы сможете достаточно хорошо представить себе, что реально происходит, когда вы вызываете одну из ваших функций. Например, вы можете использовать DISASSEMBLE, чтобы понять, в чем различия между нашей первой версией add и окончательной версией. Сначала определите и скомпилируйте исходную версию

(defun add (x y) (+ x y))
Затем, в сессии REPL вызовите DISASSEMBLE с именем этой функции. В Allegro это выведет следующий ассемблероподобный листинг сгенерированного компилятором кода:

CL-USER> (disassemble 'add)
;; disassembly of #<Function ADD>
;; formals: X Y

;; code start: #x737496f4:
0: 55 pushl ebp
1: 8b ec movl ebp,esp
3: 56 pushl esi
4: 83 ec 24 subl esp,$36
7: 83 f9 02 cmpl ecx,$2
10: 74 02 jz 14
12: cd 61 int $97 ; SYS::TRAP-ARGERR
14: 80 7f cb 00 cmpb [edi-53],$0 ; SYS::C_INTERRUPT-PENDING
18: 74 02 jz 22
20: cd 64 int $100 ; SYS::TRAP-SIGNAL-HIT
22: 8b d8 movl ebx,eax
24: 0b da orl ebx,edx
26: f6 c3 03 testb bl,$3
29: 75 0e jnz 45
31: 8b d8 movl ebx,eax
33: 03 da addl ebx,edx
35: 70 08 jo 45
37: 8b c3 movl eax,ebx
39: f8 clc
40: c9 leave
41: 8b 75 fc movl esi,[ebp-4]
44: c3 ret
45: 8b 5f 8f movl ebx,[edi-113] ; EXCL::+_2OP
48: ff 57 27 call *[edi+39] ; SYS::TRAMP-TWO
51: eb f3 jmp 40
53: 90 nop
; No value
Очевидно, что здесь полно всякой всячины. Если вы знакомы с ассемблером процессоров архитектуры x86, вы может быть это поймете. Теперь скомпилируйте версию функции add со всеми объявлениями:

(defun add (x y)
(declare (optimize (speed 3) (safety 0)))
(declare (fixnum x y))
(the fixnum (+ x y)))
Теперь дизассемблируйте функцию add снова, и посмотрите, был ли какой-то толк от этих объявлений.

CL-USER> (disassemble 'add)
;; disassembly of #<Function ADD>
;; formals: X Y

;; code start: #x7374dc34:
0: 03 c2 addl eax,edx
2: f8 clc
3: 8b 75 fc movl esi,[ebp-4]
6: c3 ret
7: 90 nop
; No value
Похоже, что был.