Общий Лисп

Общий Лисп

Парадигма	Мультипарадигма : процедурная , функциональная , объектно-ориентированная , мета , рефлексивная , универсальная.
Семья	Лисп
Разработано	Скотт Фалман , Ричард П. Гэбриэл , Дэвид А. Мун , Кент Питман , Гай Стил , Дэн Вайнреб
Разработчик	ANSI X3J13 Комитет
Впервые появился	1984 ( 1984 ) , 1994 ( 1994 ) для ANSI Common Lisp
Дисциплина набора текста	Динамичный , сильный
Объем	Лексический, опционально динамический
ТЫ	Кросс-платформенный
Расширения имен файлов	.lisp, .lsp, .l, .cl, .fasl
Веб-сайт	Common-Lisp .сеть
Основные реализации
Allegro CL , ABCL , Clasp , CLISP , Clozure CL , CMUCL , ECL , GCL , LispWorks , Scieneer CL , SBCL , Символика Common Lisp
Диалекты
CLtL1, CLtL2, ANSI Common Lisp
Под влиянием
Лисп , Лисп-машинный Лисп , Maclisp , Схема , Интерлисп
Под влиянием
Clojure , Dylan , Emacs Lisp , EuLisp , ISLISP , *Lisp , AutoLisp , Julia , Moose , R , SKILL , SubL

Common Lisp ( CL ) — диалект языка программирования Lisp , опубликованный в Американского национального института стандартов стандартном документе (ANSI) ANSI INCITS 226-1994 (S2018). (ранее X3.226-1994 (R1999) ). Common Lisp HyperSpec , с гиперссылками версия HTML , была получена из стандарта ANSI Common Lisp.

Язык Common Lisp был разработан как стандартизированный и улучшенный преемник Maclisp . К началу 1980-х годов несколько групп уже работали над различными преемниками MacLisp: Lisp Machine Lisp (он же ZetaLisp), Spice Lisp , NIL и S-1 Lisp . Common Lisp стремился унифицировать, стандартизировать и расширить возможности этих диалектов MacLisp. Common Lisp — это не реализация, а скорее спецификация языка . Доступно несколько реализаций стандарта Common Lisp, включая бесплатное программное обеспечение и программное обеспечение с открытым исходным кодом , а также проприетарные продукты. общего назначения Common Lisp — это многопарадигмальный язык программирования . Он поддерживает комбинацию процедурных , функциональных и объектно-ориентированных парадигм программирования. Являясь динамическим языком программирования , он облегчает эволюционную и поэтапную разработку программного обеспечения с итеративной компиляцией в эффективные программы времени выполнения. Эта поэтапная разработка часто выполняется в интерактивном режиме, не прерывая работающее приложение.

Он также поддерживает необязательную аннотацию типов и приведение типов, которые при необходимости можно добавить на более поздних этапах профилирования и оптимизации, чтобы позволить компилятору генерировать более эффективный код. Например, fixnumможет содержать неупакованное целое число в диапазоне, поддерживаемом аппаратным обеспечением и реализацией, что обеспечивает более эффективную арифметику, чем для больших целых чисел или типов произвольной точности. можно указать компилятору для каждого модуля или для каждой функции, какой тип уровня безопасности требуется оптимизации Аналогично, с помощью объявлений .

Common Lisp включает CLOS — объектную систему , поддерживающую мультиметоды и комбинации методов. Это часто реализуется с помощью метаобъектного протокола.

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

Common Lisp обеспечивает частичную обратную совместимость с Maclisp Джона Маккарти и оригинальным Lisp . Это позволяет портировать старое программное обеспечение Lisp на Common Lisp.

История

Работа над Common Lisp началась в 1981 году после инициативы менеджера ARPA Боба Энгельмора по разработке единого стандартного диалекта Lisp. Большая часть первоначального языкового дизайна была выполнена через электронную почту. В 1982 году Гай Л. Стил-младший сделал первый обзор Common Lisp на симпозиуме ACM 1982 года по LISP и функциональному программированию.

Документация по первому языку была опубликована в 1984 году под названием Common Lisp the Language (известная как CLtL1), первое издание. Второе издание (известное как CLtL2), опубликованное в 1990 году, включало в язык множество изменений, внесенных в процессе стандартизации ANSI Common Lisp: расширенный синтаксис LOOP, объектную систему Common Lisp, систему условий для обработки ошибок, интерфейс для красивый принтер и многое другое. Но CLtL2 не описывает окончательную версию стандарта ANSI Common Lisp и, следовательно, не является документацией ANSI Common Lisp. Окончательный стандарт ANSI Common Lisp был опубликован в 1994 году. С тех пор никаких обновлений стандарта не публиковалось. Различные расширения и улучшения Common Lisp (примеры — Unicode, Concurrency, ввод-вывод на основе CLOS) были предоставлены реализациями и библиотеками .

Синтаксис

Common Lisp — это диалект Лиспа. Он использует S-выражения для обозначения как кода, так и структуры данных. Вызовы функций, макроформы и специальные формы записываются в виде списков, начиная с имени оператора, как в этих примерах:

 (  +   2   2  )             ;   складывает 2 и 2, получая 4. Имя функции — «+».   В Лиспе нет операторов как таковых. 

 (  defvar   *x*  )        ;   Гарантирует существование переменной *x*, 
                    ;   не придавая ему значения.   Звездочки являются частью 
                    ;   имя, по соглашению обозначающее специальную (глобальную) переменную. 
                     ;   Символ *x* также наделен свойством 
                    ;   последующие его привязки являются скорее динамическими, чем лексическими. 
   (  setf   *x*   42.1  )     ;   Устанавливает переменную *x* в значение с плавающей запятой 42,1. 

 ;;   Определите функцию, которая возводит число в квадрат: 
  (  defun   Square   (  x  ) 
    (  *   x   x  )) 

 ;;   Выполните функцию: 
  (  квадрат   3  )          ;   Возвращает 9 

 ;;   Конструкция let создает область для локальных переменных.   Здесь 
  ;;   переменная «a» привязана к 6, а переменная «b» привязана 
  ;;   до 4. Внутри «let» находится «тело», куда возвращается последнее вычисленное значение. 
   ;;   Здесь результат сложения a и b возвращается из выражения let. 
   ;;   Переменные a и b имеют лексическую область видимости, если только символы не были 
  ;;   помечены как специальные переменные (например, предшествующим DEFVAR). 
   (  пусть   ((  а   6  ) 
        (  б   4  )) 
    (  +   а   б  ))          ;   возвращает 10 

Типы данных

Common Lisp имеет множество типов данных .

Скалярные типы

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

Common Lisp Тип символов не ограничивается символами ASCII . Большинство современных реализаций допускают Юникода . символы

Тип символа . является общим для языков Лисп, но практически неизвестен за его пределами Символ — это уникальный именованный объект данных, состоящий из нескольких частей: имени, значения, функции, списка свойств и пакета. Из них ячейка значения и ячейка функции наиболее важными являются . Символы в Лиспе часто используются аналогично идентификаторам в других языках: для хранения значения переменной; однако есть много других применений. Обычно при оценке символа возвращается его значение. Некоторые символы оцениваются сами по себе, например, все символы в пакете ключевых слов являются самооценочными. Логические значения в Common Lisp представлены символами самовычисления T и NIL. В Common Lisp есть пространства имен для символов, называемые «пакетами».

Доступен ряд функций для округления скалярных числовых значений различными способами. Функция roundокругляет аргумент до ближайшего целого числа, а в промежуточных случаях округляет до четного целого числа. Функции truncate, floor, и ceilingокругление в сторону нуля, вниз или вверх соответственно. Все эти функции возвращают отброшенную дробную часть как вторичное значение. Например, (floor -2.5) дает -3, 0,5; (ceiling -2.5) дает -2, -0,5; (round 2.5)дает 2, 0,5; и (round 3.5) дает 4, -0,5.

Структуры данных

Типы последовательностей в Common Lisp включают списки, векторы, битовые векторы и строки. Существует множество операций, которые могут работать с любым типом последовательности.

Как и почти во всех других диалектах Lisp, списки в Common Lisp состоят из conses , иногда называемых cons-ячейками или парами . Cons — это структура данных с двумя слотами, называемая car и cdr . Список — это связанная цепочка аргументов или пустой список. Автомобиль каждого преступника относится к члену списка (возможно, другого списка). Cdr каждого минуса относится к следующему минусу, за исключением последнего минуса в списке, чей cdr относится к nilценить. Conses также можно легко использовать для реализации деревьев и других сложных структур данных; хотя обычно вместо этого рекомендуется использовать экземпляры структур или классов. Также возможно создавать циклические структуры данных с минусами.

Common Lisp поддерживает многомерные массивы и может динамически изменять размер регулируемых при необходимости массивов. Многомерные массивы можно использовать для матричной математики. Вектор — это одномерный массив. Массивы могут содержать элементы любого типа (даже смешанные типы в одном массиве) или могут быть специализированы для содержания элементов определенного типа, как в векторе битов. Обычно поддерживаются только несколько типов. Многие реализации могут оптимизировать функции массива, если используемый массив специализирован по типам. Стандартными являются два типа массивов, специализирующихся на типах: строка представляет собой вектор символов, а битовый вектор — это вектор битов .

Хэш-таблицы хранят связи между объектами данных. Любой объект может использоваться в качестве ключа или значения. Размер хеш-таблиц автоматически изменяется по мере необходимости.

Пакеты — это наборы символов, используемые в основном для разделения частей программы на пространства имен . Пакет может экспортировать некоторые символы, отмечая их как часть общедоступного интерфейса. Пакеты могут использовать другие пакеты.

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

Классы похожи на структуры, но предлагают больше динамических функций и множественное наследование. (См. КЛОС ). Классы были добавлены в Common Lisp поздно, и существует некоторое концептуальное совпадение со структурами. Объекты, созданные из классов, называются экземплярами . Особый случай — универсальные функции. Универсальные функции — это одновременно функции и экземпляры.

Функции

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

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

 ;;   Сортирует список, используя функции > и < в качестве оператора отношения. 
   (  сортировка   (  список   5   2   6   3   1   4  )   #'  >  )     ;   Возвращает (6 5 4 3 2 1) 
  (  sort   (  список   5   2   6   3   1   4  )   #'  <  )     ;   Возврат (1 2 3 4 5 6) 

 ;;   Сортирует список по первому элементу каждого подсписка. 
   (  sort   (  list   '  (  9A   3B  )   '  (  4C   )  )   '  (  first   )  ;   #'  :   #   '  )  <     key   Возвращает ((3 Б) (4 С) (9 А)) 

Модель оценки функций очень проста. Когда оценщик сталкивается с формой (f a1 a2...) тогда предполагается, что символ с именем f является одним из следующих:

1. Специальный оператор (легко проверяется по фиксированному списку)
2. Макрооператор (должен быть определен ранее)
3. Имя функции (по умолчанию), которое может быть либо символом, либо подформой, начинающейся с символа. lambda.

Если f — имя функции, то аргументы a1, a2, ..., an оцениваются в порядке слева направо, а функция находится и вызывается с этими значениями, предоставленными в качестве параметров.

Определение функций

Макрос ​ defun определяет функции, где определение функции дает имя функции, имена всех аргументов и тело функции:

 (  defun   квадрат   (  x  ) 
    (  *   x   x  )) 

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

 (  defun   Square   (  x  ) 
    "Вычисляет квадрат одинарного числа с плавающей запятой x." 
    (  объявление   (  одинарное число с плавающей запятой   x  )   (  оптимизация   (  скорость   3  )   (  отладка   0  )   (  безопасность   1  ))) 
    (  одинарное   число с плавающей запятой   (  *   x   Икс  ))) 

Анонимные функции ( функциональные литералы ) определяются с помощью lambda выражения, например (lambda (x) (* x x))для функции, которая возводит в квадрат свой аргумент. В стиле программирования на Лиспе часто используются функции высшего порядка, для которых полезно предоставлять анонимные функции в качестве аргументов.

Локальные функции могут быть определены с помощью flet и labels.

 (  флет   ((  квадрат   (  x  ) 
           (  *   x   x  ))) 
    (  квадрат   3  )) 

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

Определение общих функций и методов

Макрос defgenericопределяет общие функции . Универсальные функции представляют собой набор методов . Макрос defmethod определяет методы.

Методы могут специализировать свои параметры по стандартным классам CLOS , системным классам , классам структур или отдельным объектам. Для многих типов существуют соответствующие системные классы .

Когда вызывается универсальная функция, множественная диспетчеризация определяет эффективный метод, который следует использовать.

 (  defgeneric   add   (  a   b  )) 

 (  defmethod   add   ((  число   )  (   число  )   b  ) 
    (  +   a   b  )) 

 (  defmethod   add   ((  вектор   )  (   число  )   b  ) 
    (  карты   вектор   (  лямбда   (  n  )   (  +   n   b  ))   a  )) 

 (  defmethod   add   ((  a   вектор  )   (  b   вектор  )) 
    (  карта   'вектор   #'  +   a   b  )) 

(  defmethod   add   ((  a   строка  )   (  b   строка  )) 
   (  объединить   ' строку   a   b  )) 

 (  добавить   2   3  )                     ;   возвращает 5 
  (  добавить   #(  1   2   3   4  )   7  )            ;   возвращает #(8 9 10 11) 
  (  добавьте   #(  1   2   3   4  )   #(  4   3   2   1  ) )   ;   возвращает #(5 5 5 5) 
  (  добавить   "COMMON"   "LISP"  )        ;   возвращает «ОБЩИЙ ЛИСП» 

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

Пространство имен функции

Пространство имен для имен функций отделено от пространства имен для переменных данных. Это ключевое различие между Common Lisp и Scheme . В Common Lisp операторы, определяющие имена в пространстве имен функций, включают: defun, flet, labels, defmethod и defgeneric.

Чтобы передать функцию по имени в качестве аргумента другой функции, необходимо использовать оператор function специальный оператор, обычно сокращенно называемый #'. Первый sort пример выше относится к функции, названной символом > в пространстве имен функции с кодом #'>. И наоборот, чтобы вызвать функцию, переданную таким образом, можно было бы использовать funcall оператор аргумента.

Модель оценки Scheme проще: существует только одно пространство имен, и оцениваются все позиции в форме (в любом порядке), а не только аргументы. Поэтому код, написанный на одном диалекте, иногда сбивает с толку программистов, более опытных в другом. Например, многие программисты Common Lisp любят использовать описательные имена переменных, такие как список или строка , что может вызвать проблемы в Scheme, поскольку они локально затеняют имена функций.

Является ли отдельное пространство имен для функций преимуществом, является источником разногласий в сообществе Lisp. Обычно это называют дебатами о Lisp-1 и Lisp-2 . Lisp-1 относится к модели Scheme, а Lisp-2 относится к модели Common Lisp. Эти названия были придуманы в статье 1988 года Ричарда П. Габриэля и Кента Питмана , в которой два подхода подробно сравниваются.

Несколько возвращаемых значений

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

• The TRUNCATE функция округляет заданное число до целого числа в сторону нуля. Однако он также возвращает остаток в качестве вторичного значения, что позволяет легко определить, какое значение было усечено. Он также поддерживает необязательный параметр делителя, который можно использовать для выполнения евклидова деления : тривиального

(  let   ((  x   1266778  ) 
       (  y   458  )) 
   (  привязка нескольких значений   (  частного   остаток от  ) 
       (  усечение   x   y  ) 
     (  формат   nil   "~A разделенный на ~A равен ~A остатку ~A"   x   y   остаток   от  частного )) ) 

 ;;;;   => "1266778 разделить на 458 равно 2765, остаток 408" 

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

(  defun   get-ответ   (  библиотека  ) 
   (  gethash   '   библиотека   ответов 42  )) 

 (  defun   the-ответ-1   (  библиотека  ) 
   (  формат   nil   "Ответ ~A"   (  get-ответ   библиотека  ))) 
 ;;;;   Возвращает "Ответ 42", если ОТВЕТ отсутствует в БИБЛИОТЕКЕ 

 (  defun   the-ответ-2   (  библиотека  ) 
   (  привязка нескольких значений   (  ответ   уверен-р  ) 
       (  получения ответа   библиотека  ) 
     (  если   (  не   уверен-р  ) 
         " Я не знаю" 
      (  формат   nil   "Ответ ~A"   ответ  )))) 
 ;;;;   Возвращает «Я не знаю», если ОТВЕТ отсутствует в БИБЛИОТЕКЕ. 

Множественные значения поддерживаются несколькими стандартными формами, наиболее распространенными из которых являются MULTIPLE-VALUE-BIND специальная форма для доступа к второстепенным значениям и VALUES для возврата нескольких значений:

(  defun   Magic-eight-ball   () 
   "Вернуть прогноз прогноза с вероятностью в качестве вторичного значения" 
   (  значения   "Перспектив хороший"   (  random   1.0  ))) 

 ;;;;   => "Перспективы хорошие" 
 ;;;;   => 0,3187 

Другие типы

Другие типы данных в Common Lisp включают:

• Пути представляют файлы и каталоги в файловой системе . Средство именования путей Common Lisp является более общим, чем соглашения об именовании файлов в большинстве операционных систем, что делает доступ программ Lisp к файлам широко переносимым в различных системах.
• ввода и вывода Потоки представляют собой источники и приемники двоичных или текстовых данных, таких как терминал или открытые файлы.
• Common Lisp имеет встроенный генератор псевдослучайных чисел (PRNG). Объекты случайного состояния представляют собой повторно используемые источники псевдослучайных чисел, позволяющие пользователю заполнять ГПСЧ или заставлять его воспроизводить последовательность.
• Условия — это тип, используемый для представления ошибок, исключений и других «интересных» событий, на которые может реагировать программа.
• Классы являются объектами первого класса и сами являются экземплярами классов, называемых классами метаобъектов ( метаклассами ). сокращенно
• Таблицы чтения — это тип объекта, который управляет тем, как программа чтения Common Lisp анализирует текст исходного кода. Контролируя, какая таблица чтения используется при чтении кода, программист может изменить или расширить синтаксис языка.

Область применения

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

Связь между именем и объектом, на который это имя ссылается, называется привязкой.

Область действия относится к набору обстоятельств, при которых имя определяется как имеющее определенную привязку.

Определители области действия

Обстоятельства, определяющие область действия в Common Lisp, включают в себя:

• расположение ссылки внутри выражения. Если это крайняя левая позиция составного слова, оно относится к специальному оператору, макросу или привязке функции, в противном случае — к привязке переменной или чему-то еще.
• вид выражения, в котором имеет место ссылка. Например, (go x) означает передачу управления метке x, тогда как (print x) относится к переменной x. Обе сферы xмогут быть активны в той же области текста программы, поскольку метки тегов находятся в отдельном пространстве имен от имен переменных. Специальная форма или макроформа имеет полный контроль над значениями всех символов в своем синтаксисе. Например, в (defclass x (a b) ()), определение класса, (a b) представляет собой список базовых классов, поэтому эти имена ищутся в пространстве имен классов, и x это не ссылка на существующую привязку, а имя нового класса, полученного из a и b. Эти факты вытекают исключительно из семантики defclass. Единственный общий факт об этом выражении заключается в том, что defclassотносится к привязке макроса; все остальное зависит defclass.
• расположение ссылки в тексте программы. Например, если ссылка на переменную x заключен в конструкцию привязки, такую ​​как let который определяет привязку для x, то ссылка находится в области, созданной этой привязкой.
• для ссылки на переменную независимо от того, объявлен ли символ переменной локально или глобально специальным. Это определяет, разрешается ли ссылка в лексической среде или в динамической среде.
• конкретный экземпляр среды, в которой разрешается ссылка. Среда — это словарь времени выполнения, который сопоставляет символы с привязками. Каждый вид ссылки использует свою собственную среду. Ссылки на лексические переменные разрешаются в лексической среде и так далее. С одной и той же ссылкой может быть связано более одной среды. Например, благодаря рекурсии или использованию нескольких потоков одновременно может существовать несколько активаций одной и той же функции. Эти активации используют один и тот же текст программы, но каждая из них имеет свой собственный экземпляр лексической среды.

Чтобы понять, на что ссылается символ, программист Common Lisp должен знать, какой тип ссылки выражается, какую область видимости он использует, если это ссылка на переменную (динамическая или лексическая область действия), а также ситуацию во время выполнения: в какой среде разрешена ссылка, где в среду была введена привязка и т. д.

Виды окружающей среды

Глобальный

Некоторые среды Lisp являются глобальными. Например, если определен новый тип, он впоследствии будет известен повсюду. Ссылки на этот тип позволяют найти его в этой глобальной среде.

Динамический

Одним из типов среды в Common Lisp является динамическая среда. Привязки, установленные в этой среде, имеют динамический размер. Это означает, что привязка устанавливается в начале выполнения некоторой конструкции, например letблок и исчезает, когда эта конструкция завершает выполнение: его время жизни связано с динамической активацией и деактивацией блока. Однако динамическая привязка не просто видна внутри этого блока; он также виден всем функциям, вызываемым из этого блока. Этот тип видимости известен как неопределенная область действия. Привязки, которые имеют динамическую протяженность (срок действия, связанный с активацией и деактивацией блока) и неопределенную область действия (видимую для всех функций, вызываемых из этого блока), называются динамическими.

Common Lisp поддерживает переменные с динамической областью действия, которые также называются специальными переменными. Некоторые другие виды привязок также обязательно имеют динамическую область действия, например перезапуски и теги catch. Привязки функций не могут быть динамически ограничены с помощью flet (который обеспечивает только привязки функций с лексической областью), но объекты функций (объект первого уровня в Common Lisp) могут быть назначены переменным с динамической областью видимости, привязанным с помощью let в динамической области, затем вызывается с использованием funcall или APPLY.

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

В Common Lisp специальная переменная, имеющая привязку только верхнего уровня, ведет себя точно так же, как глобальная переменная в других языках программирования. В него можно сохранить новое значение, и это значение просто заменяет то, что находится в привязке верхнего уровня. Неосторожная замена значения глобальной переменной лежит в основе ошибок, вызванных использованием глобальных переменных. Однако другой способ работы со специальной переменной — присвоить ей новую локальную привязку внутри выражения. Иногда это называют «перепривязкой» переменной. Привязка переменной с динамической областью временно создает новое место в памяти для этой переменной и связывает имя с этим местом. Пока эта привязка действует, все ссылки на эту переменную относятся к новой привязке; предыдущая привязка скрыта. Когда выполнение выражения привязки завершается, область временной памяти исчезает и открывается старая привязка с неповрежденным исходным значением. Конечно, несколько динамических привязок для одной и той же переменной могут быть вложенными.

В реализациях Common Lisp, поддерживающих многопоточность, динамические области действия специфичны для каждого потока выполнения. Таким образом, специальные переменные служат абстракцией для локального хранилища потоков. Если один поток перепривязывает специальную переменную, эта перепривязка не влияет на эту переменную в других потоках. Значение, хранящееся в привязке, может быть получено только потоком, создавшим эту привязку. Если каждый поток связывает некоторую специальную переменную *x*, затем *x*ведет себя как локальное хранилище потока. Среди потоков, которые не перепривязываются *x*, он ведет себя как обычный глобальный: все эти потоки ссылаются на одну и ту же привязку верхнего уровня *x*.

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

В библиотеке Common Lisp имеется множество стандартных специальных переменных. Например, все стандартные потоки ввода-вывода хранятся в привязках верхнего уровня известных специальных переменных. Стандартный поток вывода хранится в *standard-output*.

Предположим, функция foo записывает в стандартный вывод:

  (  defun   foo   () 
     (  формат   t   "Привет, мир"  )) 

Чтобы записать вывод в виде символьной строки, *standard-output* можно привязать к строковому потоку и вызвать:

  (  с выводом в строку   (  *стандартный вывод*  ) 
     (  foo  )) 

-> «Привет, мир» ;  собранный вывод возвращается в виде строки
 

Лексический

Common Lisp поддерживает лексические среды. Формально привязки в лексической среде имеют лексическую область действия и могут иметь либо неопределенный, либо динамический размер, в зависимости от типа пространства имен. Лексическая область видимости означает, что видимость физически ограничена блоком, в котором установлена ​​привязка. Ссылки, которые не текстуально (т.е. лексически) не встроены в этот блок, просто не видят этой привязки.

Теги в TAGBODY имеют лексическую область видимости. Выражение (GO X) является ошибочным, если оно не встроено в TAGBODY, который содержит метку X. Однако привязки меток исчезают, когда TAGBODY завершает свое выполнение, поскольку они имеют динамический размер. Если этот блок кода вводится повторно при вызове лексического замыкания , тело этого замыкания не может попытаться передать управление тегу через GO:

  (  defvar   *спрятано*  )   ;;   будет содержать функцию 

   (  tagbody 
     (  setf   *stashed*   (  лямбда   ()   (  go   some-label  ))) 
     (  go   end-label  )   ;; пропустить (print "Hello") 
    some-label 
     (  print   "Hello"  ) 
    end- метка  ) 
   ->   НОЛЬ 

Когда TAGBODY выполняется, он сначала оценивает форму setf, которая сохраняет функцию в специальной переменной *stashed*. Затем (go end-label) передает управление конечной метке, пропуская код (выводит «Hello»). Поскольку конечная метка находится в конце тела тега, тело тега завершается, что дает NIL. Предположим, что ранее запомненная функция теперь вызывается:

  (  funcall   *спрятано*  )   ;;   Ошибка! 

Эта ситуация ошибочна. Ответом одной реализации является состояние ошибки, содержащее сообщение «GO: тело тега для тега SOME-LABEL уже оставлено». Функция попыталась вычислить (go some-label), которая лексически встроена в тело тега, и разрешилась в метку. Однако тело тега не выполняется (его экстент закончился), поэтому передача управления не может произойти.

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

Лексическое связывание — это режим связывания по умолчанию для переменных Common Lisp. Для отдельного символа его можно переключить в динамическую область действия либо с помощью локального объявления, либо с помощью глобального объявления. Последнее может произойти неявно за счет использования такой конструкции, как DEFVAR или DEFPARAMETER. В программировании на Common Lisp существует важное соглашение, согласно которому специальные переменные (т. е. с динамической областью действия) имеют имена, которые начинаются и заканчиваются знаком звездочки . * в так называемом « соглашении о наушниках ». При соблюдении этого соглашения фактически создается отдельное пространство имен для специальных переменных, так что переменные, предназначенные для лексического использования, не могут случайно стать специальными.

Лексическая область видимости полезна по нескольким причинам.

Во-первых, ссылки на переменные и функции могут быть скомпилированы в эффективный машинный код, поскольку структура среды выполнения относительно проста. Во многих случаях его можно оптимизировать для стекового хранилища, поэтому открытие и закрытие лексических областей требует минимальных затрат. Даже в тех случаях, когда необходимо создать полные замыкания, доступ к среде замыкания по-прежнему эффективен; обычно каждая переменная становится смещением в векторе привязок, и поэтому ссылка на переменную становится простой инструкцией загрузки или сохранения с режимом адресации «база плюс смещение» .

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

В-третьих, возможно, самое главное: даже если лексические замыкания не используются, использование лексической области видимости изолирует программные модули от нежелательных взаимодействий. Из-за ограниченной видимости лексические переменные являются частными. Если один модуль A связывает лексическую переменную X и вызывает другой модуль B, ссылки на X в B не будут случайно разрешаться в X, связанный в A. B просто не имеет доступа к X. Для ситуаций, в которых дисциплинированное взаимодействие через переменную недопустимо. Желательно, чтобы Common Lisp предоставлял специальные переменные. Специальные переменные позволяют модулю A установить привязку для переменной X, которая видна другому модулю B, вызываемому из A. Возможность сделать это является преимуществом, а возможность предотвратить это также является преимуществом; следовательно, Common Lisp поддерживает как лексическую, так и динамическую область видимости .

Макросы

Макрос в Лиспе внешне напоминает функцию. Однако вместо выражения, которое вычисляется, оно представляет собой преобразование исходного кода программы. Макрос получает исходный код, который он окружает, в качестве аргументов, привязывает его к своим параметрам и вычисляет новую исходную форму. Эта новая форма также может использовать макрос. Расширение макроса повторяется до тех пор, пока новая исходная форма не будет использовать макрос. Окончательная вычисленная форма — это исходный код, исполняемый во время выполнения.

Типичное использование макросов в Лиспе:

• новые структуры управления (пример: конструкции цикла, конструкции ветвления)
• конструкции области видимости и привязки
• упрощенный синтаксис для сложного и повторяющегося исходного кода
• определение форм верхнего уровня с побочными эффектами во время компиляции
• программирование, управляемое данными
• встроенные языки, специфичные для предметной области (примеры: SQL , HTML , Prolog )
• неявные формы завершения

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

• стандарт setf абстракция, позволяющая настраивать расширения операторов присваивания/доступа во время компиляции.
• with-accessors, with-slots, with-open-file и другие подобные WITH макросы
• В зависимости от реализации, if или cond это макрос, построенный на другом специальном операторе; when и unless состоят из макросов
• Мощный loop предметно-ориентированный язык

Макросы определяются макросом defmacro . Специальный макролет оператора позволяет определять локальные макросы (с лексической областью действия). Также можно определить макросы для символов, используя define-symbol-macro иsymbol -macrolet .

Пола Грэма « Книга О Лиспе» подробно описывает использование макросов в Common Lisp. Дуга Хойта Книга Let Over Lambda расширяет обсуждение макросов, утверждая, что «Макросы — это единственное величайшее преимущество lisp как языка программирования и единственное величайшее преимущество любого языка программирования». Хойт приводит несколько примеров итеративной разработки макросов.

Пример использования макроса для определения новой структуры управления

Макросы позволяют программистам Lisp создавать новые синтаксические формы на языке. Одним из типичных применений является создание новых структур управления. Макрос в качестве примера предоставляет untilцикличная конструкция. Синтаксис:

(до тестовой формы*)
 

Определение макроса до тех пор, пока :

(  defmacro   Until   (  test   &body   body  ) 
   (  let   ((  start-tag   (  gensym   "START"  )) 
         (  end-tag     (  gensym   "END"  ))) 
     `  (  tagbody   ,  start-tag 
               (  When   ,  test   (  go   ,  end- тег  )) 
               (  progn   ,@  body  ) 
               (  go   ,  начальный тег  ) 
               ,  конечный тег  ))) 

tagbody — это примитивный специальный оператор Common Lisp, который предоставляет возможность называть теги и использовать форму go для перехода к этим тегам. Обратная кавычка ` предоставляет нотацию, которая предоставляет шаблоны кода, в которых заполняются значения форм, которым предшествует запятая. Формы, которым предшествует запятая и знак at, объединяются . Форма tagbody проверяет конечное условие. Если условие истинно, оно переходит к конечному тегу. В противном случае предоставленный основной код выполняется, а затем переходит к начальному тегу.

Пример использования приведенного выше макроса до :

(  до   (  =   (  случайное   10  )   0  ) 
   (  строка записи   «Привет»  )) 

Код можно расширить с помощью функции macroexpand-1 . Расширение приведенного выше примера выглядит следующим образом:

(  TAGBODY 
  #:START1136 
  (  WHEN   (  ZEROP   (  RANDOM   10  )) 
    (  GO   #:END1137  )) 
  (  PROGN   (  WRITE-LINE   "hello"  ) )) 
  (  GO   #:START1136  ) 
  #:END1137  ) 

Во время раскрытия макроса значение переменной test равно (= (random 10) 0), а значение тела переменной равно ((write-line "Hello")) . Тело представляет собой список форм.

Символы обычно автоматически повышаются. В расширении используется TAGBODY с двумя метками. Символы для этих меток вычисляются GENSYM и не интернируются ни в один пакет. Две формы go используют эти теги для перехода. Поскольку tagbody — это примитивный оператор в Common Lisp (а не макрос), он не будет расширен во что-то еще. В развернутой форме используется макрос When , который также будет развернут. Полное раскрытие исходной формы называется обходом кода .

В полностью развернутой ( пройденной ) форме форма When заменяется примитивом if :

(  TAGBODY 
  #:START1136 
  (  IF   (  ZEROP   (  RANDOM   10  )) 
      (  PROGN   (  GO   #:END1137  )) 
    NIL  ) 
  (  PROGN   (  WRITE-LINE   "hello"  )) 
  (  GO   #:START1136  )) 
  #:END1137  ) 

Все макросы должны быть расширены, прежде чем содержащий их исходный код сможет быть нормально оценен или скомпилирован. Макросы можно считать функциями, которые принимают и возвращают S-выражения — аналогично абстрактным синтаксическим деревьям , но не ограничиваясь ими. Эти функции вызываются перед оценщиком или компилятором для создания окончательного исходного кода. Макросы написаны на обычном Common Lisp и могут использовать любой доступный оператор Common Lisp (или сторонний).

Переменный захват и затенение

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

Захват переменных может привести к дефектам программного обеспечения. Это происходит одним из следующих двух способов:

• В первом случае раскрытие макроса может непреднамеренно создать символическую ссылку, которая, по предположению автора макроса, будет разрешена в глобальном пространстве имен, но код, в котором раскрыт макрос, оказывается, предоставляет локальное теневое определение, которое крадет эту ссылку. Пусть это будет называться захватом типа 1.
• Второй способ, захват типа 2, является прямо противоположным: некоторые аргументы макроса представляют собой фрагменты кода, предоставленные вызывающим макросом, и эти фрагменты кода написаны таким образом, что они ссылаются на окружающие привязки. Однако макрос вставляет эти фрагменты кода в расширение, которое определяет свои собственные привязки, случайно перехватывающие некоторые из этих ссылок.

Диалект Scheme Lisp предоставляет систему написания макросов, которая обеспечивает ссылочную прозрачность, устраняющую оба типа проблем захвата. Этот тип макросистемы иногда называют «гигиеничным», особенно его сторонники (которые считают макросистемы, которые не решают эту проблему автоматически, негигиеничными).

В Common Lisp гигиена макросов обеспечивается одним из двух способов.

Один из подходов — использовать gensyms : гарантированно уникальные символы, которые можно использовать в макрорасширении без угрозы захвата. Использование gensyms в определении макроса — это рутинная работа, но можно написать макросы, которые упрощают создание и использование gensyms. Gensyms легко решает проблему захвата типа 2, но они не применимы к захвату типа 1 таким же образом, поскольку расширение макроса не может переименовывать мешающие символы в окружающем коде, которые захватывают его ссылки. Gensyms можно использовать для предоставления стабильных псевдонимов для глобальных символов, необходимых для макрорасширения. В расширении макроса будут использоваться эти секретные псевдонимы, а не общеизвестные имена, поэтому переопределение общеизвестных имен не окажет вредного воздействия на макрос.

Другой подход — использовать пакеты. Макрос, определенный в своем собственном пакете, может просто использовать внутренние символы этого пакета в своем расширении. Использование пакетов касается захвата типа 1 и типа 2.

Однако пакеты не решают проблему захвата ссылок типа 1 на стандартные функции и операторы Common Lisp. Причина в том, что использование пакетов для решения проблем захвата основано на использовании частных символов (символов в одном пакете, которые не импортируются или иным образом не становятся видимыми в других пакетах). Принимая во внимание, что символы библиотеки Common Lisp являются внешними и часто импортируются или становятся видимыми в определяемых пользователем пакетах.

Ниже приведен пример нежелательного захвата пространства имен оператора, происходящего при расширении макроса:

 ;;   расширение UNTIL позволяет широко использовать DO 
  (  defmacro   до тех пор, пока   (  выражение   &body   body  ) 
    `  (  do   ()   (  ,  выражение  )   ,@  body  ) 

  ;;   макролет устанавливает лексическую привязку оператора для DO 
  (  макролет   ((  do   (  ...  )   ...   что-то   еще   ...  )) 
    (  до   (  =   (  случайный   10  )   0  )   (  строка записи   "Hello"  ))) 

The until макрос развернется в форму, которая вызывает do который предназначен для ссылки на стандартный макрос Common Lisp do. Однако в этом контексте do может иметь совершенно другой смысл, поэтому until может работать неправильно.

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

Система условий

Система условий отвечает за обработку исключений в Common Lisp. Он предоставляет условия , обработчики и перезапуск . Условия — это объекты, описывающие исключительную ситуацию (например, ошибку). Если условие сигнализируется, система Common Lisp ищет обработчик для этого типа условия и вызывает обработчик. Теперь обработчик может искать перезапуски и использовать один из этих перезапусков для автоматического устранения текущей проблемы, используя такую ​​информацию , как тип условия и любую соответствующую информацию, предоставленную как часть объекта условия, и вызывать соответствующую функцию перезапуска.

Эти перезапуски, если они не обрабатываются кодом, могут быть представлены пользователям (как часть пользовательского интерфейса, например, отладчика), чтобы пользователь мог выбрать и вызвать один из доступных перезапусков. Поскольку обработчик условия вызывается в контексте ошибки (без раскручивания стека), полное восстановление ошибки возможно во многих случаях, когда другие системы обработки исключений уже завершили бы текущую подпрограмму. Сам отладчик также можно настроить или заменить с помощью *debugger-hook*динамическая переменная. Код, найденный в формах unwind-protect, таких как финализаторы, также будет выполнен соответствующим образом, несмотря на исключение.

В следующем примере (с использованием символики Genera ) пользователь пытается открыть файл в функциональном тесте Lisp , вызываемом из Read-Eval-Print-LOOP ( REPL ), когда файл не существует. Система Lisp обеспечивает четыре перезапуска. Пользователь выбирает повторную попытку OPEN, используя перезапуск с другим путем , и вводит другое имя пути (lispm-init.lisp вместо lispm-int.lisp). Код пользователя не содержит кода обработки ошибок. Весь код обработки ошибок и перезапуска обеспечивается системой Lisp, которая может обрабатывать и исправлять ошибку, не завершая работу пользовательского кода.

Команда: (тест «>zippy>lispm-int.lisp»)

 Ошибка: Файл не найден.
        Для lispm:>zippy>lispm-int.lisp.newest

 ЛМФС:ОТКРЫТЫЙ-ЛОКАЛЬНЫЙ-LMFS-1
    Аргумент 0: #P"lispm:>zippy>lispm-int.lisp.newest"

 sA, <Resume>: повторите попытку OPEN lispm:>zippy>lispm-int.lisp.newest
 SB: Повторить попытку OPEN, используя другой путь.
 sC, <Abort>: возврат на верхний уровень Lisp на сервере TELNET.
 SD: перезапустить процесс терминала TELNET.

 -> Повторить попытку OPEN, используя другой путь.
 Вместо этого используйте путь [default lispm:>zippy>lispm-int.lisp.newest]:
    lispm:>zippy>lispm-init.lisp.newest

 ...программа продолжается
 

Common Lisp Object System (CLOS)

Основная статья: Общая объектная система Lisp

Common Lisp включает в себя набор инструментов для объектно-ориентированного программирования , Common Lisp Object System или CLOS . Питер Норвиг объясняет, насколько проще реализовать многие шаблоны проектирования на динамическом языке с функциями CLOS (множественное наследование, примеси, мультиметоды, метаклассы, комбинации методов и т. д.). Было предложено включить несколько расширений Common Lisp для объектно-ориентированного программирования в стандарт ANSI Common Lisp, но в конечном итоге CLOS была принята в качестве стандартной объектной системы для Common Lisp. CLOS — это динамическая объектная система с множественной диспетчеризацией и множественным наследованием , которая радикально отличается от средств ООП, имеющихся в статических языках, таких как C++ или Java . Будучи динамической объектной системой, CLOS позволяет во время выполнения вносить изменения в общие функции и классы. Методы можно добавлять и удалять, классы можно добавлять и переопределять, объекты можно обновлять в соответствии с изменениями классов, а класс объектов можно изменять.

CLOS интегрирован в ANSI Common Lisp. Универсальные функции могут использоваться как обычные функции и представляют собой первоклассный тип данных. Каждый класс CLOS интегрирован в систему типов Common Lisp. Многие типы Common Lisp имеют соответствующий класс. Существует больше возможностей использования CLOS для Common Lisp. В спецификации не сказано, реализуются ли условия с помощью CLOS. Пути и потоки могут быть реализованы с помощью CLOS. Эти дополнительные возможности использования CLOS для ANSI Common Lisp не являются частью стандарта. Фактические реализации Common Lisp используют CLOS для имен путей, потоков, ввода-вывода, условий, реализации самого CLOS и многого другого.

Компилятор и интерпретатор

Интерпретатор Lisp напрямую выполняет исходный код Lisp, предоставленный в виде объектов Lisp (списки, символы, числа и т. д.), считанных из s-выражений. Компилятор Lisp генерирует байт-код или машинный код из исходного кода Lisp. Common Lisp позволяет компилировать как отдельные функции Lisp в памяти, так и компилировать целые файлы во внешний хранимый скомпилированный код ( fasl -файлы).

Несколько реализаций более ранних диалектов Лиспа содержали как интерпретатор, так и компилятор. К сожалению, часто семантика была разной. Эти более ранние Lisps реализовали лексическую область видимости в компиляторе и динамическую область видимости в интерпретаторе. Common Lisp требует, чтобы и интерпретатор, и компилятор по умолчанию использовали лексическую область видимости. Стандарт Common Lisp описывает как семантику интерпретатора, так и компилятора. Компилятор можно вызвать с помощью функции compile для отдельных функций и с помощью функции compile-file для файлов. Common Lisp позволяет объявлять типы и предоставляет способы влиять на политику генерации кода компилятора. Для последнего различным качествам оптимизации могут быть присвоены значения от 0 (не важно) до 3 (наиболее важно): скорость , пространство , безопасность , отладка и скорость компиляции .

Существует также функция для оценки кода Lisp: eval. evalпринимает код в виде предварительно проанализированных s-выражений, а не в виде текстовых строк, как в некоторых других языках. Таким образом, код можно создать с помощью обычных функций Лиспа для создания списков и символов, а затем этот код можно вычислить с помощью функции eval. Некоторые реализации Common Lisp (например, Clozure CL и SBCL) реализуют evalиспользуя их компилятор. Таким образом код компилируется, даже если он оценивается с помощью функции eval.

Компилятор файлов вызывается с помощью функции compile-file . Сгенерированный файл с скомпилированным кодом называется файлом fasl (от fast load ). Эти fasl -файлы, а также файлы исходного кода можно загрузить с помощью функции load в работающую систему Common Lisp. В зависимости от реализации компилятор файла генерирует байт-код (например, для виртуальной машины Java ), код языка C (который затем компилируется компилятором C) или, напрямую, собственный код.

Реализации Common Lisp можно использовать в интерактивном режиме, даже если код полностью скомпилирован. Таким образом , идея интерпретируемого языка неприменима к интерактивному Common Lisp.

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

Некоторые специальные операторы предназначены специально для интерактивной разработки; например, defvar присвоит значение предоставленной переменной только в том случае, если она еще не была привязана, в то время как defparameterвсегда выполнит задание. Это различие полезно при интерактивной оценке, компиляции и загрузке кода в живом образе.

Также предусмотрены некоторые функции, помогающие писать компиляторы и интерпретаторы. Символы состоят из объектов первого уровня и могут напрямую управляться пользовательским кодом. progvспециальный оператор позволяет программно создавать лексические привязки, при этом пакетами также можно манипулировать. Компилятор Lisp доступен во время выполнения для компиляции файлов или отдельных функций. Это упрощает использование Lisp в качестве промежуточного компилятора или интерпретатора другого языка.

Примеры кода

Парадокс

Следующая программа вычисляет наименьшее количество людей в комнате, для которых вероятность уникальных дней рождения меньше 50% ( парадокс дней рождения , где для 1 человека вероятность очевидно 100%, для 2 — 364/365 и т. д. ). Ответ: 23.

В Common Lisp константы по соглашению заключаются в символы +.

(  defconstant   +год-размер+   365  ) 

 (  defun   день рождения-парадокс   (  вероятность   количество людей  ) 
   (  let   ((  новая вероятность   (  *   (  /   (  -   +год-размер+   количество людей  ) 
                                +год-размер+  ) 
                             вероятность  ))) 
     (  if   (  <   новая вероятность   0,5  ) 
         (  1+   количество людей  ) 
         (  парадокс дня рождения   новая вероятность   (  1+   количество людей  ))))) 

Вызов функции примера с использованием REPL (цикл чтения Eval Print):

CL-USER > (парадокс дня рождения 1.0 1)
 23
 

Сортировка списка объектов-людей

Мы определяем класс personи способ отображения имени и возраста человека. Далее мы определяем группу людей как список personобъекты. Затем мы перебираем отсортированный список.

(  defclass   person   () 
   ((  name   :initarg   :name   :accessor   person-name  ) 
    (  age    :initarg   :age    :accessor   person-age  )) 
   (  :documentation   "Класс PERSON со слотами NAME и AGE."  )) 

 (  defmethod   display   ((  объект   person  )   поток  ) 
   "Отображение объекта PERSON в выходном потоке." 
   (  with-slots   (  name   age  )   object 
     (  formatstream   "   ~a (~a)"   name   age  ))) 

 (  defparameter   *group* 
   (  list   (  make-instance   'person   :name   "Bob"     :возраст   33  ) 
         (  make-instance   'person   :name   "Chris"   :возраст   16  ) 
         (  make-instance   'person   :name   "Ash"     :возраст   23  )) 
   "Список Объекты PERSON."  ) 

 (  dolist   (  person   (  sort   (  copy-list   *group*  ) 
                       #'  > 
                       :key   #'  person-age  )) 
   (  display   person   *standard-output*  ) 
   (  terpri  )) 

Он печатает три имени по убыванию возраста.

Боб (33)
 Ясень (23)
 Крис (16)
 

Возведение в степень возведением в квадрат

Демонстрируется использование макроса LOOP:

(  defun   power   (  x   n  ) 
   (  цикл   с   результатом   =   1 
         while   (  plusp   n  ) 
         if   (  нечетный   n  )   do   (  setf   result   (  *   result   x  )) 
         do   (  setf   x   (  *   x   x  ) 
                  n   (  truncate   n   2  )) 
         наконец   (  возврат   результата  ))) 

Пример использования:

CL-USER   >   (  мощность   2   200  ) 
 1606938044258990275541962092341162602522202993782792835301376 

Сравните со встроенным возведением в степень:

CL-USER   >   (  =   (  expt   2   200  )   (  power   2   200  )) 
 T 

Найдите список доступных оболочек

With-OPEN-FILE — это макрос, который открывает файл и предоставляет поток. Когда форма возвращается, файл автоматически закрывается. FUNCALL вызывает объект функции. LOOP собирает все строки, соответствующие предикату.

(  defun   list-matching-lines   (  файла   предикат  ) 
   "Возвращает список строк в файле, для которых предикат, примененный к 
 строке, возвращает T." 
   (  with-open-file   (  stream   file  ) 
     (  цикл   для   строки   =   (  read- строковый   поток   nil   nil  ) 
           while   line 
           When   (  funcall   предиката   строка  ) 
           собирает   ее  ))) 

Функция AVAILABLE-SHELLS вызывает указанную выше функцию LIST-MATCHING-LINES с именем пути и анонимной функцией в качестве предиката. Предикат возвращает путь к оболочке или NIL (если строка не является именем файла оболочки).

(  defun   доступные оболочки   (  &optional   (  file   #p"/etc/shells"  )) 
   (  списка совпадающих строк 
    файл 
    (  лямбда   (  строка  ) 
      (  и   (  plusp   (  длина   строки  )) 
           (  char=   (  char   line   0  )   #\ /  ) 
           (  путь 
            (  string-right-trim   '  (  #\space   #\tab  )   строка  )))))) 

Пример результатов (в Mac OS X 10.6):

CL-USER   >   (  доступные оболочки  ) 
 (  #P"/bin/bash"   #P"/bin/csh"   #P"/bin/ksh"   #P"/bin/sh"   #P"/bin/tcsh"   #P"/bin/zsh"  ) 

Сравнение с другими Лиспами

Common Lisp чаще всего сравнивают и противопоставляют Scheme — хотя бы потому, что это два самых популярных диалекта Lisp. Scheme предшествует CL и исходит не только из той же традиции Lisp, но и от одних и тех же инженеров — Гай Стил , вместе с которым Джеральд Джей Сассман разработал Scheme, возглавлял комитет по стандартизации Common Lisp.

Common Lisp — это язык программирования общего назначения, в отличие от вариантов Lisp, таких как Emacs Lisp и AutoLISP , которые представляют собой языки расширения , встроенные в определенные продукты (GNU Emacs и AutoCAD соответственно). В отличие от многих более ранних Lisp, Common Lisp (как и Scheme лексических переменных использует область ) по умолчанию как для интерпретируемого, так и для скомпилированного кода.

Большинство систем Lisp, чьи разработки способствовали созданию Common Lisp, например ZetaLisp и Franz Lisp, использовали переменные с динамической областью действия в своих интерпретаторах и переменные с лексической областью действия в своих компиляторах. Scheme ввел в Lisp единоличное использование переменных с лексической областью; вдохновение от АЛГОЛА 68 . CL также поддерживает переменные с динамической областью действия, но они должны быть явно объявлены как «специальные». Между интерпретаторами и компиляторами ANSI CL нет различий в области видимости.

Common Lisp иногда называют Lisp-2 , а Scheme — Lisp-1 , имея в виду использование CL отдельных пространств имен для функций и переменных. (На самом деле в CL имеется множество пространств имен, например, для тегов go, имен блоков и т. д.). loopключевые слова). Между сторонниками CL и Scheme существует давний спор по поводу компромиссов, связанных с использованием нескольких пространств имен. В Scheme (в широком смысле) необходимо избегать присвоения имен переменных, которые конфликтуют с функциями; Функции схемы часто имеют аргументы с именами lis, lst, или lyst чтобы не конфликтовать с функцией системы list. Однако в CL необходимо явно ссылаться на пространство имен функции при передаче функции в качестве аргумента, что также является распространенным явлением, как в sort пример выше.

CL также отличается от Scheme обработкой логических значений. Схема использует специальные значения #t и #f для представления истины и ложности. CL следует старому соглашению Lisp об использовании символов T и NIL, причем NIL также обозначает пустой список. В CL любое значение, отличное от NIL, рассматривается как истинное с помощью условных операторов, таких как if, тогда как в Scheme все значения, отличные от #f, считаются истинными. Эти соглашения позволяют некоторым операторам в обоих языках служить как предикатами (отвечая на логический вопрос), так и возвращая полезное значение для дальнейших вычислений, но в Scheme значение '(), которое эквивалентно NIL в Common Lisp, оценивается как true в логическом выражении.

Наконец, документы стандартов Scheme требуют оптимизации хвостового вызова , чего нет в стандарте CL. Большинство реализаций CL предлагают оптимизацию хвостового вызова, хотя часто только тогда, когда программист использует директиву оптимизации. Тем не менее, общий стиль кодирования CL не благоприятствует повсеместному использованию рекурсии, которое предпочитает стиль Scheme: то, что программист Scheme выразил бы с помощью хвостовой рекурсии, пользователь CL обычно выразил бы с помощью итеративного выражения в do, dolist, loopили (в последнее время) с помощью iterate упаковка.

Реализации

См. раздел Реализации категории Common Lisp .

Common Lisp определяется спецификацией (например, Ada и C ), а не одной реализацией (например, Perl ). Существует множество реализаций и областей стандартных деталей, в которых они могут существенно отличаться.

Кроме того, реализации, как правило, поставляются с расширениями, которые обеспечивают функциональность, не описанную в стандарте:

• Интерактивный верхний уровень (REPL)
• Вывоз мусора
• Отладчик, Степпер и Инспектор
• Слабые структуры данных (хеш-таблицы)
• Расширяемые последовательности
• Расширяемый цикл
• Доступ к среде
• CLOS Мета-объектный протокол
• Расширяемые потоки на основе CLOS
• Система условий на основе CLOS
• Сетевые потоки
• Постоянное замыкание
• Поддержка Юникод
• Интерфейс на иностранном языке (часто на C)
• Интерфейс операционной системы
• Java-интерфейс
• Потоки и многопроцессорность
• Доставка приложений (приложения, динамические библиотеки)
• Сохранение изображений

Библиотеки бесплатного программного обеспечения с открытым исходным кодом были созданы для переносимой поддержки расширений Common Lisp и, в первую очередь, находятся в репозиториях Common-Lisp.net. и CLOCC (коллекция открытого кода Common Lisp) проекты.

Реализации Common Lisp могут использовать любое сочетание компиляции собственного кода, компиляции или интерпретации байт-кода. Common Lisp был разработан для поддержки инкрементальных , файловых и блочных компиляторов. Стандартные объявления для оптимизации компиляции (например, встраивание функций или специализация типов) предлагаются в спецификации языка. Большинство реализаций Common Lisp компилируют исходный код в машинный код . Некоторые реализации могут создавать (оптимизированные) автономные приложения. Другие компилируются в интерпретируемый байт-код , что менее эффективно, чем собственный код, но облегчает переносимость двоичного кода. Некоторые компиляторы компилируют код Common Lisp в код C. Заблуждение о том, что Lisp — это чисто интерпретируемый язык, скорее всего, связано с тем, что среды Lisp предоставляют интерактивную подсказку и этот код компилируется один за другим, поэтапно. В Common Lisp широко используется инкрементная компиляция.

Некоторые Unix реализации на основе ( CLISP , SBCL ) могут использоваться в качестве языка сценариев ; то есть вызывается системой прозрачно, как интерпретатор оболочки Perl или Unix .

Список реализаций

Коммерческие реализации

Аллегро Общий Лисп

для Microsoft Windows, FreeBSD, Linux, Apple macOS и различных вариантов UNIX. Allegro CL предоставляет интегрированную среду разработки (IDE) (для Windows и Linux) и обширные возможности для доставки приложений.

Жидкий Common Lisp

ранее называвшийся Lucid Common Lisp. Только техническое обслуживание, никаких новых выпусков.

Лиспворкс

для Microsoft Windows, FreeBSD, Linux, Apple macOS, iOS, Android и различных вариантов UNIX. LispWorks предоставляет интегрированную среду разработки (IDE) (доступную для большинства платформ, но не для iOS и Android) и обширные возможности для доставки приложений.

мокл

для iOS, Android и macOS.

Открытая генера

для ДЭК Альфа.

Ученый Common Lisp

который предназначен для высокопроизводительных научных вычислений.

Свободно распространяемые реализации

Вооруженный медведь Common Lisp (ABCL)

Реализация CL, работающая на виртуальной машине Java . Он включает в себя компилятор байт-кода Java и обеспечивает доступ к библиотекам Java из CL. Раньше это был просто компонент редактора Armed Bear J.

Застежка

Реализация на основе LLVM, которая легко взаимодействует с библиотеками C++. Работает на нескольких Unix и Unix-подобных системах (включая macOS ).

КЛИСП

Реализация компиляции байт-кода, переносимая и работающая на нескольких Unix и Unix-подобных системах (включая macOS ), а также Microsoft Windows и некоторых других системах.

Закрытие CL (CCL)

Первоначально с открытым исходным кодом бесплатная версия Macintosh Common Lisp . Как следует из этой истории, CCL был написан для Macintosh, но Clozure CL теперь работает на macOS , FreeBSD , Linux , Solaris и Windows . 32- и 64-битные порты x86 На каждой платформе поддерживаются . Кроме того, имеются порты Power PC для Mac OS и Linux. CCL ранее был известен как OpenMCL, но это имя больше не используется, чтобы избежать путаницы с версией Macintosh Common Lisp с открытым исходным кодом.

КМУКЛ

Первоначально из Университета Карнеги-Меллона , сейчас поддерживается как бесплатное программное обеспечение с открытым исходным кодом группой добровольцев. CMUCL использует быстрый компилятор собственного кода. Он доступен в Linux и BSD для Intel x86; Linux для Альфа; macOS для Intel x86 и PowerPC; и Solaris, IRIX и HP-UX на их родных платформах.

Корман Common Lisp

для Microsoft Windows. В январе 2015 года Corman Lisp был опубликован под лицензией MIT.

Встраиваемый Common Lisp (ECL)

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

GNU Common Lisp (GCL)

. GNU Компилятор Lisp проекта GCL еще не полностью совместим с ANSI, но является предпочтительной реализацией для нескольких крупных проектов, включая математические инструменты Maxima , AXIOM и (исторически) ACL2 . GCL работает в Linux под одиннадцатью различными архитектурами, а также под Windows, Solaris и FreeBSD .

Macintosh Common Lisp (MCL)

Версия 5.2 для компьютеров Apple Macintosh с процессором PowerPC под управлением Mac OS X имеет открытый исходный код. RMCL (на основе MCL 5.2) работает на компьютерах Apple Macintosh на базе процессора Intel с использованием двоичного транслятора Rosetta от Apple.

МанКай Common Lisp (MKCL)

Филиал ЭКЛ . MKCL подчеркивает надежность, стабильность и общее качество кода благодаря сильно переработанной многопоточной системе времени выполнения. В Linux MKCL имеет полностью совместимую с POSIX систему выполнения.

Мовитц

Реализует среду Lisp для компьютеров x86 , не полагаясь на какую-либо базовую ОС.

Напольное покрытие

Poplog реализует версию CL с POP-11 и, при необходимости, Prolog и Standard ML (SML), что позволяет программировать на смешанных языках. В общем, языком реализации является POP-11, который компилируется поэтапно. Он также имеет встроенный редактор, подобный Emacs , который взаимодействует с компилятором.

Общий Lisp Steel Bank (SBCL)

Филиал от CMUCL . «Вообще говоря, SBCL отличается от CMU CL большим упором на удобство обслуживания». SBCL работает на платформах CMUCL, за исключением HP/UX; кроме того, он работает на Linux для AMD64, PowerPC, SPARC, MIPS, Windows x86 и AMD64. . SBCL по умолчанию не использует интерпретатор; все выражения компилируются в собственный код, если пользователь не включит интерпретатор. Компилятор SBCL генерирует быстрый собственный код в соответствии с предыдущей версией игры The Computer Language Benchmarks Game .

Уфасофт Common Lisp

порт CLISP для платформы Windows с ядром, написанным на C++.

Другие реализации

Остин Киото Common Lisp

эволюция Kyoto Common Lisp Билла Шелтера

Бабочка Common Lisp

реализация, написанная на Scheme для BBN Butterfly многопроцессорного компьютера

КЛИКК

компилятор Common Lisp в C

КЛОЭ

Common Lisp для ПК от Symbolics

Кодемист Common Lisp

используется для коммерческой версии системы компьютерной алгебры Axiom

ExperCommon Lisp

ранняя реализация для Apple Macintosh от ExperTelligence

Золотой Общий Лисп

реализация для ПК от GoldHill Inc.

Ибуки Common Lisp

коммерческая версия Kyoto Common Lisp

Киотский общий Лисп

первый компилятор Common Lisp, использовавший C в качестве целевого языка. GCL, ECL и MKCL происходят из этой реализации Common Lisp.

л

небольшая версия Common Lisp для встраиваемых систем, разработанная IS Robotics, теперь iRobot

Lisp-машины (от компании Symbolics , TI и ксерокс )

предоставили реализации Common Lisp в дополнение к своему родному диалекту Lisp (Lisp Machine Lisp или Interlisp). CLOS также был доступен. Символика предоставляет расширенную версию Common Lisp.

Процион Общий Лисп

реализация для Windows и Mac OS, используемая Францем для их порта Allegro CL для Windows.

Звездный сапфир Общий LISP

реализация для ПК

курсив

вариант Common Lisp, используемый для реализации Cyc системы знаний

Common Lisp верхнего уровня

ранняя реализация для одновременного выполнения

ВКЛ

реализация общей библиотеки

VAX Общий Лисп

Digital Equipment Corporation Реализация VAX , работающая на системах под управлением VMS или ULTRIX.

XLISP

реализация, написанная Дэвидом Бетцем

Приложения

См. Также: Категория: Программное обеспечение Common Lisp (язык программирования).

Common Lisp используется для разработки исследовательских приложений (часто в области искусственного интеллекта ), для быстрой разработки прототипов или для развернутых приложений.

Common Lisp используется во многих коммерческих приложениях, включая Yahoo! Сайт интернет-торговли Store, над созданием которого первоначально работал Пол Грэм , а затем был переписан на C++ и Perl . Другие известные примеры включают в себя:

• ACT-R — когнитивная архитектура, используемая в большом количестве исследовательских проектов.
• Помощник авторизатора, большая основанная на правилах система, используемая American Express для анализа кредитных запросов.
• Cyc — давний проект по созданию системы, основанной на знаниях, которая предоставляет огромное количество знаний, основанных на здравом смысле.
• Gensym G2 — экспертная система реального времени и движок бизнес-правил.
• Генворкс ГДЛ, на основе ядра Gendl с открытым исходным кодом.
• Среда разработки серии видеоигр Jak and Daxter , разработанная Naughty Dog .
• Поисковая система низких цен от ITA Software , используемая туристическими веб-сайтами, такими как Orbitz и Kayak.com , и такими авиакомпаниями, как American Airlines , Continental Airlines и US Airways .
• Mirai — пакет 3D-графики. Его использовали для анимации лица Голлума в фильме « Властелин колец: Две башни» .
• Opusmodus — это система музыкальной композиции, основанная на Common Lisp, используемая в компьютерной композиции .
• Система проверки прототипов (PVS), механизированная среда для формальной спецификации и проверки.
• PWGL — это сложная среда визуального программирования, основанная на Common Lisp, используемая в компьютерной композиции и синтезе звука.
• Piano — полный пакет анализа самолетов, написанный на Common Lisp. используется такими компаниями, как Boeing , Airbus и Northrop Grumman .
• Grammarly , платформа для улучшения письма на английском языке, имеет основной грамматический движок, написанный на Common Lisp.
• Инструмент динамического анализа и перепланирования (DART), который, как говорят, один только окупил в период с 1991 по 1995 годы все тридцать лет инвестиций DARPA в исследования ИИ.
• НАСА » Лаборатории реактивного движения « Глубокий космос-1 , отмеченный наградами Общий Лисп Программа автопилота космического корабля Deep Space One .
• SigLab — платформа Common Lisp для обработки сигналов, используемая в противоракетной обороне, созданная компанией Raytheon .
• НАСА Mars Pathfinder . Система планирования миссии
• SPIKE, система планирования для наземных или космических обсерваторий и спутников, в частности космического телескопа Хаббл . написан на Common Lisp.
• Common Lisp использовался для создания прототипа сборщика мусора Microsoft .NET Common Language Runtime .
• Исходная версия Reddit , хотя позже разработчики перешли на Python из-за отсутствия библиотек для Common Lisp, согласно официальному сообщению в блоге сооснователя Reddit Стива Хаффмана .

Также существуют приложения с открытым исходным кодом, написанные на Common Lisp, такие как:

• ACL2 — полнофункциональная автоматизированная программа доказательства теорем для аппликативного варианта Common Lisp.
• Аксиома , сложная система компьютерной алгебры .
• Maxima — сложная система компьютерной алгебры , основанная на Macsyma.
• OpenMusic — объектно-ориентированная среда визуального программирования, основанная на Common Lisp, используемая в компьютерной композиции .
• Pgloader, загрузчик данных для PostgreSQL , который был переписан с Python на Common Lisp.
• Stumpwm — мозаичный оконный менеджер X11, управляемый с клавиатуры, полностью написанный на Common Lisp.

См. также

• Общий язык Lisp
• На Лиспе
• Практический Common Lisp

Библиография

Хронологический список опубликованных (или готовых к публикации) книг о Common Lisp (языке) или о программировании с использованием Common Lisp (особенно о программировании искусственного интеллекта).

• Гай Л. Стил : Язык Common Lisp, 1-е издание , Digital Press, 1984, ISBN   0-932376-41-X
• Родни Аллен Брукс : Программирование на Common Lisp , John Wiley and Sons Inc, 1985, ISBN   0-471-81888-7
• Ричард П. Габриэль : Производительность и оценка систем Lisp , MIT Press, 1985, ISBN   0-262-57193-5 , PDF
• Роберт Виленски : Common LISPcraft , WW Norton & Co., 1986, ISBN   0-393-95544-3
• Юджин Чарняк , Кристофер К. Рисбек , Дрю В. Макдермотт , Джеймс Р. Михан : Программирование искусственного интеллекта, 2-е издание , Лоуренс Эрлбаум, 1987, ISBN   0-89859-609-2
• Венди Л. Милнер : Common Lisp: Учебное пособие , Prentice Hall, 1987, ISBN   0-13-152844-0
• Дебора Г. Татар : Руководство программиста по Common Lisp , Высшее образование Лонгмана, 1987, ISBN   0-13-728940-5
• Тайити Юаса , Масами Хагия : Введение в Common Lisp , Elsevier Ltd, 1987, ISBN   0-12-774860-1
• Кристиан Кейннек , Жером Шайу : Эволюция и стандартизация Лиспа , Ios Pr Inc., 1988, ISBN   90-5199-008-1
• Тайичи Юаса , Ричард Вейраух , Ясуко Китадзима : Common Lisp Drill , Academic Press Inc, 1988, ISBN   0-12-774861-X
• Уэйд Л. Хеннесси : Common Lisp , McGraw-Hill Inc., 1989, ISBN   0-07-028177-7
• Тони Хасемер , Джон Доминк : Программирование на Common Lisp для искусственного интеллекта , Addison-Wesley Educational Publishers Inc, 1989, ISBN   0-201-17579-7
• Соня Э. Кин : Объектно-ориентированное программирование в Common Lisp: Руководство программиста по CLOS , Аддисон-Уэсли, 1989, ISBN   0-201-17589-4
• Дэвид Джей Стил : Golden Common Lisp: практический подход , Эддисон Уэсли, 1989, ISBN   0-201-41653-0
• Дэвид С. Турецкий : Common Lisp: нежное введение в символические вычисления , Бенджамин-Каммингс, 1989, ISBN   0-8053-0492-4 . в Интернете / PDF в Дувре (2013 г.) Переиздание ISBN   978-0486498201
• Christopher K. Riesbeck, Roger C. Schank: Inside Case-Based Reasoning, Lawrence Erlbaum, 1989, ISBN 0-89859-767-6
• Patrick Winston, Berthold Horn: Lisp, 3rd Edition, Addison-Wesley, 1989, ISBN 0-201-08319-1, Web
• Gerard Gazdar, Chris Mellish: Natural Language Processing in LISP: An Introduction to Computational Linguistics, Addison-Wesley Longman Publishing Co., 1990, ISBN 0-201-17825-7
• Patrick R. Harrison: Common Lisp and Artificial Intelligence, Prentice Hall PTR, 1990, ISBN 0-13-155243-0
• Timothy Koschmann: The Common Lisp Companion, John Wiley & Sons, 1990, ISBN 0-471-50308-8
• W. Richard Stark: LISP, Lore, and Logic, Springer Verlag New York Inc., 1990, ISBN 978-0-387-97072-1, PDF
• Molly M. Miller, Eric Benson: Lisp Style & Design, Digital Press, 1990, ISBN 1-55558-044-0
• Guy L. Steele: Common Lisp the Language, 2nd Edition, Digital Press, 1990, ISBN 1-55558-041-6, Web
• Robin Jones, Clive Maynard, Ian Stewart: The Art of Lisp Programming, Springer Verlag New York Inc., 1990, ISBN 978-3-540-19568-9, PDF
• Стивен Л. Танимото : Элементы искусственного интеллекта с использованием Common Lisp , Computer Science Press, 1990, ISBN   0-7167-8230-8
• Питер Ли : Темы расширенной языковой реализации , MIT Press, 1991, ISBN   0-262-12151-4
• Джон Х. Райли : Рабочая тетрадь по Common Lisp , Prentice Hall, 1991, ISBN   0-13-155797-1
• Питер Норвиг : Парадигмы программирования искусственного интеллекта: тематические исследования в Common Lisp , Морган Кауфманн, 1991, ISBN   1-55860-191-0 , Интернет
• Грегор Кичалес , Джим де Ривьер , Дэниел Г. Боброу : Искусство протокола метаобъектов , MIT Press, 1991, ISBN   0-262-61074-4
• Джо А. Лоулесс , Молли М. Миллер : Понимание CLOS: объектная система Common Lisp , Digital Press, 1991, ISBN   0-13-717232-X
• Марк Уотсон: Модули Common Lisp: искусственный интеллект в эпоху нейронных сетей и теории хаоса , Springer Verlag New York Inc., 1991, ISBN   0-387-97614-0 , PDF
• Джеймс Л. Нойес : Искусственный интеллект с Common Lisp: основы символьной и числовой обработки , Jones & Bartlett Pub, 1992, ISBN   0-669-19473-5
• Стюарт К. Шапиро : COMMON LISP: интерактивный подход , Computer Science Press, 1992, ISBN   0-7167-8218-9 , Интернет/PDF
• Кеннет Д. Форбус , Йохан де Клир : Создание решений проблем , MIT Press, 1993, ISBN   0-262-06157-0
• Андреас Пэпке : Объектно-ориентированное программирование: перспектива CLOS , MIT Press, 1993, ISBN   0-262-16136-2
• Пол Грэм : О Лиспе , Прентис Холл, 1993, ISBN   0-13-030552-9 , Интернет/PDF
• Пол Грэм : ANSI Common Lisp , Прентис Холл, 1995, ISBN   0-13-370875-6
• Отто Майер : Программирование на Common Lisp , немецкий, Spektrum Akademischer Verlag, 1995, ISBN   3-86025-710-2
• Стивен Слэйд : Объектно-ориентированный Common Lisp , Прентис Холл, 1997, ISBN   0-13-605940-6
• Richard P. Gabriel: Patterns of Software: Tales from the Software Community, Oxford University Press, 1998, ISBN 0-19-512123-6, PDF
• Taiichi Yuasa, Hiroshi G. Okuno: Advanced Lisp Technology, CRC, 2002, ISBN 0-415-29819-9
• David B. Lamkins: Successful Lisp: How to Understand and Use Common Lisp, bookfix.com, 2004. ISBN 3-937526-00-5, Web
• Peter Seibel: Practical Common Lisp, Apress, 2005. ISBN 1-59059-239-5, Web
• Doug Hoyte: Let Over Lambda, Lulu.com, 2008, ISBN 1-4357-1275-7, Web
• George F. Luger, William A. Stubblefield: AI Algorithms, Data Structures, and Idioms in Prolog, Lisp and Java, Addison Wesley, 2008, ISBN 0-13-607047-7, PDF
• Conrad Barski: Land of Lisp: Learn to program in Lisp, one game at a time!, No Starch Press, 2010, ISBN 1-59327-200-6, Web
• Pavel Penev: Lisp Web Tales, Leanpub, 2013, Web
• Edmund Weitz: Common Lisp Recipes, Apress, 2015, ISBN 978-1-484211-77-9, Web
• Patrick M. Krusenotto: Funktionale Programmierung und Metaprogrammierung, Interaktiv in Common Lisp, Springer Fachmedien Wiesbaden 2016, ISBN 978-3-658-13743-4, Web

External links

• Quicklisp - A very popular and high quality library manager for Common Lisp
• The Awesome CL list, a curated list of Common Lisp frameworks and libraries.
• The Common Lisp Cookbook, a collaborative project.
• The CLiki, a Wiki for free and open-source Common Lisp systems running on Unix-like systems.
• One of the main repositories for free Common Lisp for software is Common-Lisp.net Archived September 27, 2009, at the Wayback Machine.
• lisp-lang.org has documentation and a showcase of success stories.
• An overview of the history of Common Lisp: "History". Common Lisp HyperSpec.
• Common Lisp Quick Reference – a compact overview of the Common Lisp standard language.
• Planet Lisp Articles about Common Lisp.
• Quickdocs summarizes documentation and dependency information for many Quicklisp projects.