Common Lisp - Википедия - Common Lisp

Common Lisp (CL) является диалектом Язык программирования Лисп, опубликовано в ANSI стандартный документ ANSI INCITS 226-1994 [S2008] (ранее X3.226-1994 (R1999)).^[1] В Common Lisp HyperSpec HTML-версия с гиперссылками была получена из стандарта ANSI Common Lisp.^[2]

Язык Common Lisp был разработан как стандартизированный и улучшенный преемник Маклисп. К началу 1980-х несколько групп уже работали над разнообразными преемниками MacLisp: Лисп-машина Лисп (он же ZetaLisp), Spice Lisp, Ноль и S-1 Лисп. Common Lisp стремился унифицировать, стандартизировать и расширить возможности этих диалектов MacLisp. Common Lisp - это не реализация, а язык Технические характеристики.^[3] Несколько реализации стандарта Common Lisp, включая бесплатное программное обеспечение с открытым исходным кодом и фирменные продукты.^[4]Common Lisp - это универсальный, язык программирования с несколькими парадигмами. Он поддерживает комбинацию процедурный, функциональный, и объектно-ориентированного программирования парадигмы. Как язык динамического программирования, это способствует эволюции и инкрементальная разработка программного обеспечения, с итеративным сборник в эффективные программы времени выполнения. Эта инкрементальная разработка часто выполняется в интерактивном режиме без прерывания работы приложения.

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

Common Lisp включает ЗАКРЫТЬ, объектная система что поддерживает мультиметоды и комбинации методов. Часто это реализуется с помощью Метаобъект Протокол.

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

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

История

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

Документация на первом языке была опубликована в 1984 году как Common Lisp язык (известное как 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 - это диалект Lisp. Оно использует S-выражения для обозначения кода и структуры данных. Вызовы функций, макроформы и специальные формы записываются в виде списков с именем оператора первым, как в этих примерах:

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

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

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

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

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

Типы данных

Common Lisp имеет много типы данных.

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

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

Общий Лисп персонаж тип не ограничен ASCII символы. Большинство современных реализаций позволяют Unicode символы.^[11]

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

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

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

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

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

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

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

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

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

Классы похожи на структуры, но предлагают более динамичные функции и множественное наследование. (Видеть ЗАКРЫТЬ ). Классы были добавлены в Common Lisp поздно, и есть некоторое концептуальное совпадение со структурами. Объекты, созданные из классов, называются Экземпляры. Особый случай - универсальные функции. Общие функции - это как функции, так и экземпляры.

Функции

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

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

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

 ;; Сортирует список по первому элементу каждого подсписка. (Сортировать (список '(9 А) '(3 B) '(4 C)) #'< :ключ #'первый)   ; Возврат ((3 B) (4 C) (9 A))

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

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

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

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

В макрос defun определяет функции, в которых определение функции дает имя функции, имена любых аргументов и тело функции:

 (defun квадрат (Икс)   (* Икс Икс))

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

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

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

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

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

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

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

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

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

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

 (defgeneric Добавить (а б))

 (defmethod Добавить ((а номер) (б номер))   (+ а б))

 (defmethod Добавить ((а вектор) (б номер))   (карта 'вектор (лямбда (п) (+ п б)) а))

 (defmethod Добавить ((а вектор) (б вектор))   (карта 'вектор #'+ а б))

(defmethod Добавить ((а нить) (б нить))  (соединять 'нить а б))

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

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

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

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

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

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

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

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

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

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

(позволять ((Икс 1266778)      (у 458))  (привязка нескольких значений (частное остаток)      (обрезать Икс у)    (формат ноль "~ A, деленное на ~ A, составляет ~ остаток ~ A" Икс у частное остаток)));;;; => "1266778 делить на 458 дает 2765 остаток 408"

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

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

Множественные значения поддерживаются несколькими стандартными формами, наиболее распространенными из которых являются МНОЖЕСТВЕННАЯ СВЯЗЬ специальная форма для доступа к вторичным ценностям и ЗНАЧЕНИЯ для возврата нескольких значений:

(defun волшебный шар-восьмерка ()  "Вернуть прогноз прогноза с вероятностью в качестве второстепенного значения"  (значения "Прогноз хороший" (случайный 1.0)));;;; => "Хороший прогноз";;;; => 0.3187

Другие типы

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

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

Объем

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

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

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

Определители объема

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

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

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

Виды среды

Глобальный

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

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

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

Common Lisp поддерживает переменные с динамической областью видимости, которые также называются специальными переменными. Некоторые другие виды привязок также обязательно имеют динамическую область видимости, например, перезапуск и теги перехвата. Привязки функций не могут быть динамически ограничены с помощью флет (который предоставляет только привязки функций с лексической областью видимости), но объекты функций (объект первого уровня в Common Lisp) могут быть назначены переменным с динамической областью видимости, привязанным с использованием позволять в динамической области, затем вызывается с использованием веселье или же ПОДАТЬ ЗАЯВЛЕНИЕ.

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

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

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

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

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

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

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

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

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

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

Лексический

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

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

  (defvar * спрятан *) ;; будет выполнять функцию  (tagbody    (setf * спрятан * (лямбда () (идти какой-то ярлык)))    (идти концевая этикетка) ;; пропустить (напечатать "Hello")   какой-то ярлык    (Распечатать "Привет")   концевая этикетка)  -> Ноль

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

  (веселье * спрятан *) ;; Ошибка!

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

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

Лексическая привязка - это режим привязки по умолчанию для переменных Common Lisp. Для отдельного символа его можно переключить в динамическую область видимости либо локальным объявлением, либо глобальным объявлением. Последнее может происходить неявно посредством использования таких конструкций, как DEFVAR или DEFPARAMETER. Это важное соглашение в программировании на Common Lisp, что специальные (т.е. динамически ограниченные) переменные имеют имена, которые начинаются и заканчиваются звездочкой. сигил * в том, что называется "наушник соглашение".^[16] При соблюдении этого соглашения создается отдельное пространство имен для специальных переменных, так что переменные, которые должны быть лексическими, не могут быть случайно сделаны специальными.

Лексический объем полезен по нескольким причинам.

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

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

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

Макросы

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

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

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

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

• стандарт setf абстракция, позволяющая настраивать расширения операторов присваивания / доступа во время компиляции
• с аксессуарами, с прорезями, с открытым файлом и другие подобные С макросы
• В зависимости от реализации, если или же cond макрос, построенный на другом, специальном операторе; когда и пока не состоят из макросов
• Мощный петля предметно-ориентированный язык

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

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

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

Макросы позволяют программистам на Лиспе создавать новые синтаксические формы на языке. Типичное использование - создание новых структур управления. Пример макроса предоставляет до того как циклическая конструкция. Синтаксис:

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

Определение макроса для до того как:

(дефмакро до того как (тест &тело тело)  (позволять ((начальный тег (генсим "НАЧНИТЕ"))        (конечный тег   (генсим "КОНЕЦ")))    `(tagbody ,начальный тег              (когда ,тест (идти ,конечный тег))              (прогноз ,@тело)              (идти ,начальный тег)              ,конечный тег)))

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

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

(до того как (= (случайный 10) 0)  (линия записи "Привет"))

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

(TAGBODY #: START1136 (КОГДА (ZEROP (СЛУЧАЙНЫЙ 10))   (ИДТИ #: END1137)) (PROGN (НАПИСАТЬ ЛИНИЮ "Привет")) (ИДТИ #: START1136) #: END1137)

При раскрытии макроса значение переменной тест является (= (случайное 10) 0) and the value of the variable тело является ((write-line "Hello")). The body is a list of forms.

Symbols are usually automatically upcased. The expansion uses the TAGBODY with two labels. The symbols for these labels are computed by GENSYM and are not interned in any package. Два идти forms use these tags to jump to. С tagbody is a primitive operator in Common Lisp (and not a macro), it will not be expanded into something else. The expanded form uses the когда macro, which also will be expanded. Fully expanding a source form is called code walking.

In the fully expanded (ходил) form, the когда form is replaced by the primitive если:

(TAGBODY #:START1136 (ЕСЛИ (ZEROP (СЛУЧАЙНЫЙ 10))     (PROGN (ИДТИ #:END1137))   Ноль) (PROGN (WRITE-LINE "hello")) (ИДТИ #:START1136)) #:END1137)

All macros must be expanded before the source code containing them can be evaluated or compiled normally. Macros can be considered functions that accept and return S-expressions - похожий на абстрактные синтаксические деревья, but not limited to those. These functions are invoked before the evaluator or compiler to produce the final source code.Macros are written in normal Common Lisp, and may use any Common Lisp (or third-party) operator available.

Variable capture and shadowing

Common Lisp macros are capable of what is commonly called variable capture, where symbols in the macro-expansion body coincide with those in the calling context, allowing the programmer to create macros wherein various symbols have special meaning. Период, термин variable capture is somewhat misleading, because all namespaces are vulnerable to unwanted capture, including the operator and function namespace, the tagbody label namespace, catch tag, condition handler and restart namespaces.

Variable capture can introduce software defects. This happens in one of the following two ways:

• In the first way, a macro expansion can inadvertently make a symbolic reference which the macro writer assumed will resolve in a global namespace, but the code where the macro is expanded happens to provide a local, shadowing definition which steals that reference. Let this be referred to as type 1 capture.
• The second way, type 2 capture, is just the opposite: some of the arguments of the macro are pieces of code supplied by the macro caller, and those pieces of code are written such that they make references to surrounding bindings. However, the macro inserts these pieces of code into an expansion which defines its own bindings that accidentally captures some of these references.

The Scheme dialect of Lisp provides a macro-writing system which provides the referential transparency that eliminates both types of capture problem. This type of macro system is sometimes called "hygienic", in particular by its proponents (who regard macro systems which do not automatically solve this problem as unhygienic).^{[нужна цитата ]}

In Common Lisp, macro hygiene is ensured one of two different ways.

One approach is to use генсимы: guaranteed-unique symbols which can be used in a macro-expansion without threat of capture. The use of gensyms in a macro definition is a manual chore, but macros can be written which simplify the instantiation and use of gensyms. Gensyms solve type 2 capture easily, but they are not applicable to type 1 capture in the same way, because the macro expansion cannot rename the interfering symbols in the surrounding code which capture its references. Gensyms could be used to provide stable aliases for the global symbols which the macro expansion needs. The macro expansion would use these secret aliases rather than the well-known names, so redefinition of the well-known names would have no ill effect on the macro.

Another approach is to use packages. A macro defined in its own package can simply use internal symbols in that package in its expansion. The use of packages deals with type 1 and type 2 capture.

However, packages don't solve the type 1 capture of references to standard Common Lisp functions and operators. The reason is that the use of packages to solve capture problems revolves around the use of private symbols (symbols in one package, which are not imported into, or otherwise made visible in other packages). Whereas the Common Lisp library symbols are external, and frequently imported into or made visible in user-defined packages.

The following is an example of unwanted capture in the operator namespace, occurring in the expansion of a macro:

 ;; expansion of UNTIL makes liberal use of DO (defmacro до того как (выражение &body тело)   `(делать () (,выражение) ,@тело)) ;; macrolet establishes lexical operator binding for DO (macrolet ((делать (...) ... что нибудь еще ...))   (до того как (= (случайный 10) 0) (write-line "Привет")))

В до того как macro will expand into a form which calls делать which is intended to refer to the standard Common Lisp macro делать. However, in this context, делать may have a completely different meaning, so до того как may not work properly.

Common Lisp solves the problem of the shadowing of standard operators and functions by forbidding their redefinition. Because it redefines the standard operator делать, the preceding is actually a fragment of non-conforming Common Lisp, which allows implementations to diagnose and reject it.

Condition system

В condition system Ответственный за Обработка исключений in Common Lisp.^[17] Это обеспечивает условия, обработчикпесок перезапускс. Условиеs are objects describing an exceptional situation (for example an error). Если condition is signaled, the Common Lisp system searches for a обработчик for this condition type and calls the handler. В обработчик can now search for restarts and use one of these restarts to automatically repair the current problem, using information such as the condition type and any relevant information provided as part of the condition object, and call the appropriate restart function.

These restarts, if unhandled by code, can be presented to users (as part of a user interface, that of a debugger for example), so that the user can select and invoke one of the available restarts. Since the condition handler is called in the context of the error (without unwinding the stack), full error recovery is possible in many cases, where other exception handling systems would have already terminated the current routine. The debugger itself can also be customized or replaced using the *debugger-hook* dynamic variable. Code found within unwind-protect forms such as finalizers will also be executed as appropriate despite the exception.

In the following example (using Symbolics Genera ) the user tries to open a file in a Lisp function тест called from the Read-Eval-Print-LOOP (REPL ), when the file does not exist. The Lisp system presents four restarts. The user selects the Retry OPEN using a different pathname restart and enters a different pathname (lispm-init.lisp instead of lispm-int.lisp). The user code does not contain any error handling code. The whole error handling and restart code is provided by the Lisp system, which can handle and repair the error without terminating the user code.

Command: (test ">zippy>lispm-int.lisp")Error: The file was not found.       For lispm:>zippy>lispm-int.lisp.newestLMFS:OPEN-LOCAL-LMFS-1   Arg 0: #P"lispm:>zippy>lispm-int.lisp.newest"s-A, : Retry OPEN of lispm:>zippy>lispm-int.lisp.newests-B:           Retry OPEN using a different pathnames-C, :  Return to Lisp Top Level in a TELNET servers-D:           Restart process TELNET terminal-> Retry OPEN using a different pathnameUse what pathname instead [default lispm:>zippy>lispm-int.lisp.newest]:   lispm:>zippy>lispm-init.lisp.newest...the program continues

Common Lisp Object System (CLOS)

Common Lisp includes a toolkit for объектно-ориентированного программирования, the Common Lisp Object System or ЗАКРЫТЬ, which is one of the most powerful object systems available in any language. Например, Питер Норвиг explains how many Шаблоны проектирования are simpler to implement in a dynamic language with the features of CLOS (Multiple Inheritance, Mixins, Multimethods, Metaclasses, Method combinations, etc.).^[18]Several extensions to Common Lisp for object-oriented programming have been proposed to be included into the ANSI Common Lisp standard, but eventually CLOS was adopted as the standard object-system for Common Lisp. CLOS is a динамичный object system with множественная отправка и multiple inheritance, and differs radically from the OOP facilities found in static languages such as C ++ или же Ява. As a dynamic object system, CLOS allows changes at runtime to generic functions and classes. Methods can be added and removed, classes can be added and redefined, objects can be updated for class changes and the class of objects can be changed.

CLOS has been integrated into ANSI Common Lisp. Generic functions can be used like normal functions and are a first-class data type. Every CLOS class is integrated into the Common Lisp type system. Many Common Lisp types have a corresponding class. There is more potential use of CLOS for Common Lisp. The specification does not say whether conditions are implemented with CLOS. Pathnames and streams could be implemented with CLOS. These further usage possibilities of CLOS for ANSI Common Lisp are not part of the standard. Actual Common Lisp implementations use CLOS for pathnames, streams, input–output, conditions, the implementation of CLOS itself and more.

Compiler and interpreter

A Lisp interpreter directly executes Lisp source code provided as Lisp objects (lists, symbols, numbers, ...) read from s-expressions. A Lisp compiler generates байт-код или же Машинный код from Lisp source code. Common Lisp allows both individual Lisp functions to be compiled in memory and the compilation of whole files to externally stored compiled code (fasl файлы).

Several implementations of earlier Lisp dialects provided both an interpreter and a compiler. Unfortunately often the semantics were different. These earlier Lisps implemented lexical scoping in the compiler and dynamic scoping in the interpreter. Common Lisp requires that both the interpreter and compiler use lexical scoping by default. The Common Lisp standard describes both the semantics of the interpreter and a compiler. The compiler can be called using the function компилировать for individual functions and using the function compile-file for files. Common Lisp allows type declarations and provides ways to influence the compiler code generation policy. For the latter various optimization qualities can be given values between 0 (not important) and 3 (most important): скорость, Космос, безопасность, отлаживать и compilation-speed.

There is also a function to evaluate Lisp code: eval. eval takes code as pre-parsed s-expressions and not, like in some other languages, as text strings. This way code can be constructed with the usual Lisp functions for constructing lists and symbols and then this code can be evaluated with the function eval. Several Common Lisp implementations (like Clozure CL and SBCL) are implementing eval using their compiler. This way code is compiled, even though it is evaluated using the function eval.

The file compiler is invoked using the function compile-file. The generated file with compiled code is called a fasl (из fast load) file. Эти fasl files and also source code files can be loaded with the function нагрузка into a running Common Lisp system. Depending on the implementation, the file compiler generates byte-code (for example for the Виртуальная машина Java ), Язык C code (which then is compiled with a C compiler) or, directly, native code.

Common Lisp implementations can be used interactively, even though the code gets fully compiled. Идея Интерпретируемый язык thus does not apply for interactive Common Lisp.

The language makes a distinction between read-time, compile-time, load-time, and run-time, and allows user code to also make this distinction to perform the wanted type of processing at the wanted step.

Some special operators are provided to especially suit interactive development; например, defvar will only assign a value to its provided variable if it wasn't already bound, while defparameter will always perform the assignment. This distinction is useful when interactively evaluating, compiling and loading code in a live image.

Some features are also provided to help writing compilers and interpreters. Symbols consist of first-level objects and are directly manipulable by user code. В progv special operator allows to create lexical bindings programmatically, while packages are also manipulable. The Lisp compiler is available at runtime to compile files or individual functions. These make it easy to use Lisp as an intermediate compiler or interpreter for another language.

Примеры кода

Birthday paradox

The following program calculates the smallest number of people in a room for whom the probability of unique birthdays is less than 50% (the парадокс дня рождения, where for 1 person the probability is obviously 100%, for 2 it is 364/365, etc.). The answer is 23.

By convention, constants in Common Lisp are enclosed with + characters.

(defconstant +year-size+ 365)(defun birthday-paradox (вероятность number-of-people)  (позволять ((new-probability (* (/ (- +year-size+ number-of-people)                               +year-size+)                            вероятность)))    (если (< new-probability 0.5)        (1+ number-of-people)        (birthday-paradox new-probability (1+ number-of-people)))))

Calling the example function using the REPL (Read Eval Print Loop):

CL-USER > (birthday-paradox 1.0 1)23

Sorting a list of person objects

We define a class человек and a method for displaying the name and age of a person.Next we define a group of persons as a list of человек objects.Then we iterate over the sorted list.

(defclass человек ()  ((имя :initarg :name :accessor person-name)   (возраст  :initarg :age  :accessor person-age))  (:documentation "The class PERSON with slots NAME and AGE."))(defmethod отображать ((объект человек) транслировать)  "Displaying a PERSON object to an output stream."  (with-slots (имя возраст) объект    (формат транслировать "~a (~a)" имя возраст)))(defparameter *group*  (список (make-instance 'person :name "Боб"   :age 33)        (make-instance 'person :name "Chris" :age 16)        (make-instance 'person :name "Ash"   :age 23))  "A list of PERSON objects.")(долист (человек (Сортировать (copy-list *group*)                      #'>                      :key #'person-age))  (отображать человек *standard-output*)  (terpri))

It prints the three names with descending age.

Bob (33)Ash (23)Chris (16)

Exponentiating by squaring

Use of the LOOP macro is demonstrated:

(defun мощность (Икс п)  (петля с результат = 1        пока (plusp п)        когда (oddp п) делать (setf результат (* результат Икс))        делать (setf Икс (* Икс Икс)                 п (обрезать п 2))        наконец-то (возвращаться результат)))

Example use:

CL-USER > (power 2 200)1606938044258990275541962092341162602522202993782792835301376

Compare with the built in exponentiation:

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

Find the list of available shells

WITH-OPEN-FILE is a macro that opens a file and provides a stream. When the form is returning, the file is automatically closed. FUNCALL calls a function object. The LOOP collects all lines that match the predicate.

(defun list-matching-lines (файл предикат)  "Returns a list of lines in file, for which the predicate applied to the line returns T."  (with-open-file (транслировать файл)    (петля за линия = (read-line транслировать ноль ноль)          пока линия          когда (funcall предикат линия)          собирать Это)))

The function AVAILABLE-SHELLS calls above function LIST-MATCHING-LINES with a pathname and an anonymous function as the predicate. The predicate returns the pathname of a shell or NIL (if the string is not the filename of a shell).

(defun available-shells (&optional (файл #p"/etc/shells"))  (list-matching-lines   файл   (лямбда (линия)     (и (plusp (длина линия))          (char= (char линия 0) #\/)          (pathname           (string-right-trim '(#space #	ab) линия))))))

Example results (on Mac OS X 10.6):

CL-USER > (available-shells)(#P"/bin/bash" #P"/bin/csh" #P"/bin/ksh" #P"/bin/sh" #P"/bin/tcsh" #P"/bin/zsh")

Comparison with other Lisps

Common Lisp is most frequently compared with, and contrasted to, Схема —if only because they are the two most popular Lisp dialects. Scheme predates CL, and comes not only from the same Lisp tradition but from some of the same engineers—Guy L. Steele, с кем Джеральд Джей Сассман designed Scheme, chaired the standards committee for Common Lisp.

Common Lisp is a general-purpose programming language, in contrast to Lisp variants such as Emacs Lisp и AutoLISP которые extension languages embedded in particular products (GNU Emacs and AutoCAD, respectively). Unlike many earlier Lisps, Common Lisp (like Схема ) uses lexical variable объем by default for both interpreted and compiled code.

Most of the Lisp systems whose designs contributed to Common Lisp—such as ZetaLisp and Franz Lisp—used dynamically ограниченный variables in their interpreters and lexically scoped variables in their compilers. Scheme introduced the sole use of lexically scoped variables to Lisp; an inspiration from ALGOL 68. CL supports dynamically scoped variables as well, but they must be explicitly declared as "special". There are no differences in scoping between ANSI CL interpreters and compilers.

Common Lisp is sometimes termed a Lisp-2 and Scheme a Lisp-1, referring to CL's use of separate namespaces for functions and variables. (In fact, CL has много namespaces, such as those for go tags, block names, and петля keywords). There is a long-standing controversy between CL and Scheme advocates over the tradeoffs involved in multiple namespaces. In Scheme, it is (broadly) necessary to avoid giving variables names which clash with functions; Scheme functions frequently have arguments named Лис, lst, или же lyst so as not to conflict with the system function список. However, in CL it is necessary to explicitly refer to the function namespace when passing a function as an argument—which is also a common occurrence, as in the Сортировать пример выше.

CL also differs from Scheme in its handling of boolean values. Scheme uses the special values #t and #f to represent truth and falsity. CL follows the older Lisp convention of using the symbols T and NIL, with NIL standing also for the empty list. In CL, любой non-NIL value is treated as true by conditionals, such as если, whereas in Scheme all non-#f values are treated as true. These conventions allow some operators in both languages to serve both as predicates (answering a boolean-valued question) and as returning a useful value for further computation, but in Scheme the value '() which is equivalent to NIL in Common Lisp evaluates to true in a boolean expression.

Lastly, the Scheme standards documents require tail-call optimization, which the CL standard does not. Most CL implementations do offer tail-call optimization, although often only when the programmer uses an optimization directive. Nonetheless, common CL coding style does not favor the ubiquitous use of recursion that Scheme style prefers—what a Scheme programmer would express with tail recursion, a CL user would usually express with an iterative expression in делать, долист, петля, or (more recently) with the повторять упаковка.

Реализации

See the Category Common Lisp implementations.

Common Lisp is defined by a specification (like Ада и C ) rather than by one implementation (like Perl ). There are many implementations, and the standard details areas in which they may validly differ.

In addition, implementations tend to come with extensions, which provide functionality not covered in the standard:

• Interactive Top-Level (REPL)
• Вывоз мусора
• Debugger, Stepper and Inspector
• Weak data structures (hash tables)
• Extensible sequences
• Extensible LOOP
• Environment access
• CLOS Meta-object Protocol
• CLOS based extensible streams
• CLOS based Condition System
• Network streams
• Persistent CLOS
• Поддержка Unicode
• Foreign-Language Interface (often to C)
• Operating System interface
• Интерфейс Java
• Threads and Multiprocessing
• Application delivery (applications, dynamic libraries)
• Saving of images

Бесплатное программное обеспечение с открытым исходным кодом libraries have been created to support extensions to Common Lisp in a portable way, and are most notably found in the repositories of the Common-Lisp.net^[19] and CLOCC (Common Lisp Open Code Collection)^[20] проекты.

Common Lisp implementations may use any mix of native code compilation, byte code compilation or interpretation. Common Lisp has been designed to support incremental compilers, file compilers and block compilers. Standard declarations to optimize compilation (such as function inlining or type specialization) are proposed in the language specification. Most Common Lisp implementations compile source code to native Машинный код. Some implementations can create (optimized) stand-alone applications. Others compile to interpreted байт-код, which is less efficient than native code, but eases binary-code portability. Some compilers compile Common Lisp code to C code. The misconception that Lisp is a purely interpreted language is most likely because Lisp environments provide an interactive prompt and that code is compiled one-by-one, in an incremental way. With Common Lisp incremental compilation is widely used.

Немного Unix -based implementations (CLISP, SBCL ) can be used as a язык сценариев; that is, invoked by the system transparently in the way that a Perl или же Оболочка Unix interpreter is.^[21]

List of implementations

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

Аллегро Common Lisp

for Microsoft Windows, FreeBSD, Linux, Apple macOS and various UNIX variants. Allegro CL provides an Integrated Development Environment (IDE) (for Windows and Linux) and extensive capabilities for application delivery.

Liquid Common Lisp

ранее назывался Lucid Common Lisp. Only maintenance, no new releases.

LispWorks

for Microsoft Windows, FreeBSD, Linux, Apple macOS, iOS, Android and various UNIX variants. LispWorks provides an Integrated Development Environment (IDE) (available for all platforms, but not for iOS and Android) and extensive capabilities for application delivery.

mocl

for iOS, Android and macOS.

Open Genera

for DEC Alpha.

Scieneer Common Lisp

which is designed for high-performance scientific computing.

Freely redistributable implementations

Armed Bear Common Lisp (ABCL)

A CL implementation that runs on the Виртуальная машина Java.^[22] It includes a compiler to Java byte code, and allows access to Java libraries from CL. It was formerly just a component of the Armed Bear J Editor.

CLISP

A bytecode-compiling implementation, portable and runs on several Unix and Unix-like systems (including macOS ), as well as Microsoft Windows and several other systems.

Clozure CL (CCL)

Первоначально бесплатно и с открытым исходным кодом fork of Macintosh Common Lisp. As that history implies, CCL was written for the Macintosh, but Clozure CL now runs on macOS, FreeBSD, Linux, Солярис и Windows. 32 and 64 bit x86 ports are supported on each platform. Additionally there are Power PC ports for Mac OS and Linux. CCL was previously known as OpenMCL, but that name is no longer used, to avoid confusion with the open source version of Macintosh Common Lisp.

CMUCL

Первоначально из Университет Карнеги Меллон, now maintained as бесплатное программное обеспечение с открытым исходным кодом by a group of volunteers. CMUCL uses a fast native-code compiler. Он доступен на Linux и BSD for Intel x86; Linux for Alpha; macOS for Intel x86 and PowerPC; and Solaris, IRIX, and HP-UX on their native platforms.

Corman Common Lisp

for Microsoft Windows. In January 2015 Corman Lisp has been published under MIT license.^[23]

Embeddable Common Lisp (ECL)

ECL includes a bytecode interpreter and compiler. It can also compile Lisp code to machine code via a C compiler. ECL then compiles Lisp code to C, compiles the C code with a C compiler and can then load the resulting machine code. It is also possible to embed ECL in C programs, and C code into Common Lisp programs.

GNU Common Lisp (GCL)

В GNU Project's Lisp compiler. Not yet fully ANSI-compliant, GCL is however the implementation of choice for several large projects including the mathematical tools Максима, АКСИОМА and (historically) ACL2. GCL runs on Linux under eleven different architectures, and also under Windows, Solaris, and FreeBSD.

Macintosh Common Lisp (MCL)

Version 5.2 for Apple Macintosh computers with a PowerPC processor running Mac OS X is open source. RMCL (based on MCL 5.2) runs on Intel-based Apple Macintosh computers using the Rosetta binary translator from Apple.

ManKai Common Lisp (MKCL)

Филиал ECL. MKCL emphasises reliability, stability and overall code quality through a heavily reworked, natively multi-threaded, runtime system. On Linux, MKCL features a fully POSIX compliant runtime system.

Movitz

Implements a Lisp environment for x86 computers without relying on any underlying OS.

Поплог

Poplog implements a version of CL, with ПОП-11, и необязательно Пролог, и Standard ML (SML), allowing mixed language programming. For all, the implementation language is POP-11, which is compiled incrementally. It also has an integrated Emacs -like editor that communicates with the compiler.

Steel Bank Common Lisp (SBCL)

Филиал от CMUCL. "Broadly speaking, SBCL is distinguished from CMU CL by a greater emphasis on maintainability."^[24] SBCL runs on the platforms CMUCL does, except HP/UX; in addition, it runs on Linux for AMD64, PowerPC, SPARC, MIPS, Windows x86^[25] and has experimental support for running on Windows AMD64. SBCL does not use an interpreter by default; all expressions are compiled to native code unless the user switches the interpreter on. The SBCL compiler generates fast native code according to a previous version of Игра "Тесты компьютерного языка".^[26]

Ufasoft Common Lisp

port of CLISP for windows platform with core written in C++.

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

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

Austin Kyoto Common Lisp

an evolution of Киотский Common Lisp к Bill Schelter

Butterfly Common Lisp

an implementation written in Scheme for the BBN Бабочка multi-processor computer^[27][28]

CLICC

a Common Lisp to C compiler^[29]

CLOE

Common Lisp for PCs by Symbolics

Codemist Common Lisp

used for the commercial version of the computer algebra system Axiom^[30][31]

ExperCommon Lisp

an early implementation for the Apple Macintosh by ExperTelligence

Golden Common Lisp

an implementation for the PC by GoldHill Inc.^[32][33]

Ibuki Common Lisp

a commercialized version of Kyoto Common Lisp

Киотский Common Lisp

the first Common Lisp compiler that used C as a target language. GCL, ECL and MKCL originate from this Common Lisp implementation.

L

a small version of Common Lisp for embedded systems developed by IS Robotics, now iRobot^[34]

Лисп-машины (из Symbolics, TI^[35][36] and Xerox^[37])

provided implementations of Common Lisp in addition to their native Lisp dialect (Lisp Machine Lisp or Interlisp). CLOS was also available. Symbolics provides an enhanced version Common Lisp.^[38][39][40]

Procyon Common Lisp

an implementation for Windows and Mac OS, used by Franz for their Windows port of Allegro CL

Star Sapphire Common LISP

an implementation for the PC

SubL

a variant of Common Lisp used for the implementation of the Цикл knowledge-based system^[41]

Top Level Common Lisp

an early implementation for concurrent execution^[42]

WCL

a shared library implementation^[43][44]

Vax Common Lisp

Корпорация цифрового оборудования 's implementation that ran on VAX системы работают VMS или же ULTRIX

XLISP

an implementation written by David Betz^[45]

Приложения

Common Lisp is used to develop research applications (often in Artificial Intelligence), for rapid development of prototypes or for deployed applications.

Common Lisp is used in many commercial applications, including the Yahoo! Store web-commerce site, which originally involved Пол Грэм and was later rewritten in C++ and Perl.^[46] Other notable examples include:

• ACT-R, a cognitive architecture used in a large number of research projects.
• Authorizer's Assistant,^[47][48] a large rule-based system used by American Express, analyzing credit requests.
• Цикл, a long running project a to create a knowledge-based system that provides a huge amount of common sense knowledge
• Gensym G2, a real-time expert system and business rules engine^[49]
• Genworks GDL, based on the open-source Gendl kernel.
• The development environment for the Джек и Дакстер video game series, developed by Игривый щенок.
• Программное обеспечение ITA 's low fare search engine, used by travel websites such as Orbitz и Kayak.com and airlines such as американские авиалинии, Continental Airlines и US Airways.
• Mirai, a 3d graphics suite. It was used to animate the face of Gollum in the movie Lord of the Rings: The Two Towers.
• Система проверки прототипа (PVS), a mechanized environment for formal specification and verification.
• PWGL is a sophisticated visual programming environment based on Common Lisp, used in Computer assisted composition and sound synthesis.^[50]
• Piano, a complete aircraft analysis suite, written in Common Lisp,^[51] used by companies like Боинг, Airbus, Northrop Grumman.^[52]
• Грамматика, an English-language writing-enhancement platform, has its core grammar engine written in Common Lisp^[53]
• В Dynamic Analysis and Replanning Tool (DART), which is said to alone have paid back during the years from 1991 to 1995 for all thirty years of DARPA investments in AI research.
• NASA's (Jet Propulsion Lab's) "Remote Agent ", an award-winning^[54] Common Lisp^[55] program for autopiloting the Deep Space One spaceship.
• SigLab, a Common Lisp platform for signal processing used in missile defense, built by Raytheon^[51]
• NASA's Mars Pathfinder Mission Planning System^[56]
• SPIKE, a scheduling system for earth or space based observatories and satellites, notably the Хаббл Space Telescope.,^[57] written in Common Lisp^[58]
• Common Lisp has been used for prototyping the garbage collector of Microsoft's .NET общеязыковая среда выполнения^[59]
• Оригинальная версия Reddit, though the developers later switched to Python due to the lack of libraries for Common Lisp, according to an official blog post by Reddit co-founder Стив Хаффман.^[60]

There also exist open-source applications written in Common Lisp, such as:

• ACL2, a full-featured автоматическое доказательство теорем для аппликативный variant of Common Lisp.
• Аксиома, сложный система компьютерной алгебры.
• Максима, сложный система компьютерной алгебры, based on Macsyma.
• OpenMusic is an object-oriented visual programming environment based on Common Lisp, used in Computer assisted composition.
• Pgloader, a data loader for PostgreSQL, which was re-written from Python to Common Lisp.^[61]
• Stumpwm, a tiling, keyboard driven X11 Window Manager written entirely in Common Lisp.

Смотрите также

• Common Lisp the Language
• On Lisp
• Practical Common Lisp

Рекомендации

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

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

внешняя ссылка

• Quicklisp - Очень популярный и качественный менеджер библиотек для Common Lisp.
• В Потрясающий CL list, тщательно подобранный список фреймворков и библиотек Common Lisp.
• В Поваренная книга Common Lisp, совместный проект.
• В CLiki, Wiki для бесплатно и с открытым исходным кодом Системы Common Lisp, работающие в Unix-подобных системах.
• Одним из основных репозиториев бесплатного Common Lisp для программного обеспечения является Common-Lisp.net.
• lisp-lang.org есть документация и демонстрация историй успеха.
• Обзор истории Common Lisp: "История". Common Lisp HyperSpec.
• Краткий справочник Common Lisp - компактный обзор стандартного языка Common Lisp.
• Планета Лисп Статьи о Common Lisp.
• Quickdocs обобщает документацию и информацию о зависимостях для многих проектов Quicklisp.