path: root/ru-ru/common-lisp-ru.html.markdown

---

language: "Common Lisp"
filename: commonlisp.lisp
contributors:
  - ["Paul Nathan", "https://github.com/pnathan"]
  - ["Rommel Martinez", "https://ebzzry.io"]
translators:
  - ["Michael Filonenko", "https://github.com/filonenko-mikhail"]
lang: ru-ru
---

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

Идеальная отправная точка - книга
[Common Lisp на практике (перевод)](https://github.com/pcl-ru/pcl-ru/releases/download/v1.1/pcl-ru.pdf).
Ещё одна популярная книга [Land of Lisp](http://landoflisp.com/).
И одна из последних книг [Common Lisp Recipes](http://weitz.de/cl-recipes/) вобрала в себя лучшие
архитектурные решения на основе опыта коммерческой работки автора.



```common-lisp

;;;-----------------------------------------------------------------------------
;;; 0. Синтаксис
;;;-----------------------------------------------------------------------------

;;; Основные формы

;;; Существует два фундамента CL: АТОМ и S-выражение.
;;; Как правило, сгруппированные S-выражения называют `формами`.

10            ; атом; вычисляется в самого себя
:thing        ; другой атом; вычисляется в символ :thing
t             ; ещё один атом, обозначает `истину` (true)
(+ 1 2 3 4)   ; s-выражение
'(4 :foo t)   ; ещё одно s-выражение

;;; Комментарии

;;; Однострочные комментарии начинаются точкой с запятой. Четыре знака подряд
;;; используют для комментария всего файла, три для раздела, два для текущего
;;; определения; один для текущей строки. Например:

;;;; life.lisp

;;; То-сё - пятое-десятое. Оптимизировано для максимального бадабума и ччччч.
;;; Требуется для функции PoschitatBenzinIsRossiiVBelarus

(defun meaning (life)
  "Возвращает смысл Жизни"
  (let ((meh "abc"))
    ;; Вызывает бадабум
    (loop :for x :across meh
       :collect x)))                    ; сохранить значения в x, и потом вернуть

;;; А вот целый блок комментария можно использовать как угодно.
;;; Для него используются #| и |#

#| Целый блок комментария, который размазан
   на несколько строк
    #|
       которые могут быть вложенными!
    |#
|#

;;; Чем пользоваться

;;; Существует несколько реализаций: и коммерческих, и открытых.
;;; Все они максимально соответствуют стандарту языка.
;;; SBCL, например, добротен. А за дополнительными библиотеками
;;; нужно ходить в Quicklisp

;;; Обычно разработка ведется в текстовом редакторе с запущенным в цикле
;;; интерпретатором (в CL это Read Eval Print Loop). Этот цикл (REPL)
;;; позволяет интерактивно выполнять части программы вживую сразу наблюдая
;;; результат.

;;;-----------------------------------------------------------------------------
;;; 1. Базовые типы и операторы
;;;-----------------------------------------------------------------------------

;;; Символы

'foo ; => FOO Символы автоматически приводятся к верхнему регистру.

;;; INTERN создаёт символ из строки.

(intern "AAAA")        ; => AAAA
(intern "aaa")         ; => |aaa|

;;; Числа

9999999999999999999999 ; целые
#b111                  ; двоичные => 7
#o111                  ; восьмеричные => 73
#x111                  ; шестнадцатиричные => 273
3.14159s0              ; с плавающей точкой
3.14159d0              ; с плавающей точкой с двойной точностью
1/2                    ; рациональные)
#C(1 2)                ; комплексные

;;; Вызов функции пишется как s-выражение (f x y z ....), где f это функция,
;;; x, y, z, ... аругменты.

(+ 1 2)                ; => 3

;;; Если вы хотите просто представить код как данные, воспользуйтесь формой QUOTE
;;; Она не вычисляет аргументы, а возвращает их как есть.
;;; Она даёт начало метапрограммированию

(quote (+ 1 2))        ; => (+ 1 2)
(quote a)              ; => A

;;; QUOTE можно сокращенно записать знаком '

'(+ 1 2)               ; => (+ 1 2)
'a                     ; => A

;;; Арифметические операции

(+ 1 1)                ; => 2
(- 8 1)                ; => 7
(* 10 2)               ; => 20
(expt 2 3)             ; => 8
(mod 5 2)              ; => 1
(/ 35 5)               ; => 7
(/ 1 3)                ; => 1/3
(+ #C(1 2) #C(6 -4))   ; => #C(7 -2)

;;; Булевые

t                      ; истина; любое не-NIL значение `истинно`
nil                    ; ложь; а ещё пустой список () тоже `ложь`
(not nil)              ; => T
(and 0 t)              ; => T
(or 0 nil)             ; => 0

;;; Строковые символы

#\A                    ; => #\A
#\λ                    ; => #\GREEK_SMALL_LETTER_LAMDA
#\u03BB                ; => #\GREEK_SMALL_LETTER_LAMDA

;;; Строки это фиксированные массивы символов

"Hello, world!"
"Тимур \"Каштан\" Бадтрудинов"   ; экранировать двойную кавычку обратным слешом

;;; Строки можно соединять

(concatenate 'string "ПРивет, " "мир!") ; => "ПРивет, мир!"

;;; Можно пройтись по строке как по массиву символов

(elt "Apple" 0) ; => #\A

;;; Для форматированного вывода используется FORMAT. Он умеет выводить, как просто значения,
;;; так и производить циклы и учитывать условия. Первый агрумент указывает куда отправить
;;; результат. Если NIL, FORMAT вернет результат как строку, если T результат отправиться
;;; консоль вывода а форма вернет NIL.

(format nil "~A, ~A!" "Привет" "мир")   ; => "Привет, мир!"
(format t "~A, ~A!" "Привет" "мир")     ; => NIL


;;;-----------------------------------------------------------------------------
;;; 2. Переменные
;;;-----------------------------------------------------------------------------

;;; С помощью DEFVAR и DEFPARAMETER вы можете создать глобальную (динамческой видимости)
;;; переменную.
;;; Имя переменной может состоять из любых символов кроме: ()",'`;#|\

;;; Разница между DEFVAR и DEFPARAMETER в том, что повторное выполнение DEFVAR
;;; переменную не поменяет. А вот DEFPARAMETER меняет переменную при каждом вызове.

;;; Обычно глобальные (динамически видимые) переменные содержат звездочки в имени.

(defparameter *some-var* 5)
*some-var* ; => 5

;;; Можете использовать unicode.
(defparameter *КУКУ* nil)

;;; Доступ к необъявленной переменной - это непредсказуемое поведение. Не делайте так.

;;; С помощью LET можете сделать локальное связывание.
;;; В следующем куске кода, `я` связывается с "танцую с тобой" только
;;; внутри формы (let ...). LET всегда возвращает значение последней формы.

(let ((я "танцую с тобой")) я) ; => "танцую с тобой"


;;;-----------------------------------------------------------------------------;
;;; 3. Структуры и коллекции
;;;-----------------------------------------------------------------------------;


;;; Структуры

(defstruct dog name breed age)
(defparameter *rover*
    (make-dog :name "rover"
              :breed "collie"
              :age 5))
*rover*            ; => #S(DOG :NAME "rover" :BREED "collie" :AGE 5)
(dog-p *rover*)    ; => T
(dog-name *rover*) ; => "rover"

;;; DEFSTRUCT автоматически создала DOG-P, MAKE-DOG, и DOG-NAME


;;; Пары (cons-ячейки)

;;; CONS создаёт пары. CAR и CDR возвращают начало и конец CONS-пары.

(cons 'SUBJECT 'VERB)         ; => '(SUBJECT . VERB)
(car (cons 'SUBJECT 'VERB))   ; => SUBJECT
(cdr (cons 'SUBJECT 'VERB))   ; => VERB


;;; Списки

;;; Списки это связанные CONS-пары, в конце самой последней из которых стоит NIL
;;; (или '() ).

(cons 1 (cons 2 (cons 3 nil)))     ; => '(1 2 3)

;;; Списки с произвольным количеством элементов удобно создавать с помощью LIST

(list 1 2 3)                       ; => '(1 2 3)

;;; Если первый аргумент для CONS это атом и второй аргумент список, CONS
;;; возвращает новую CONS-пару, которая представляет собой список

(cons 4 '(1 2 3))                  ; => '(4 1 2 3)

;;; Чтобы объединить списки, используйте APPEND

(append '(1 2) '(3 4))             ; => '(1 2 3 4)

;;; Или CONCATENATE

(concatenate 'list '(1 2) '(3 4))  ; => '(1 2 3 4)

;;; Списки это самый используемый элемент языка. Поэтому с ними можно делать
;;; многие вещи. Вот несколько примеров:

(mapcar #'1+ '(1 2 3))             ; => '(2 3 4)
(mapcar #'+ '(1 2 3) '(10 20 30))  ; => '(11 22 33)
(remove-if-not #'evenp '(1 2 3 4)) ; => '(2 4)
(every #'evenp '(1 2 3 4))         ; => NIL
(some #'oddp '(1 2 3 4))           ; => T
(butlast '(subject verb object))   ; => (SUBJECT VERB)


;;; Вектора

;;; Вектора заданные прямо в коде - это массивы с фиксированной длинной.

#(1 2 3) ; => #(1 2 3)

;;; Для соединения векторов используйте CONCATENATE

(concatenate 'vector #(1 2 3) #(4 5 6)) ; => #(1 2 3 4 5 6)


;;; Массивы

;;; И вектора и строки это подмножества массивов.

;;; Двухмерные массивы

(make-array (list 2 2))         ; => #2A((0 0) (0 0))
(make-array '(2 2))             ; => #2A((0 0) (0 0))
(make-array (list 2 2 2))       ; => #3A(((0 0) (0 0)) ((0 0) (0 0)))

;;; Внимание: значение по-умолчанию элемента массива зависит от реализации.
;;; Лучше явно указывайте:

(make-array '(2) :initial-element 'unset)  ; => #(UNSET UNSET)

;;; Для доступа к элементу в позиции 1, 1, 1:

(aref (make-array (list 2 2 2)) 1 1 1)     ;  => 0


;;; Вектора с изменяемой длиной

;;; Вектора с изменяемой длиной при выводе на консоль выглядят также,
;;; как и вектора, с константной длиной

(defparameter *adjvec* (make-array '(3) :initial-contents '(1 2 3)
                                   :adjustable t :fill-pointer t))
*adjvec* ; => #(1 2 3)

;;; Добавление новых элементов

(vector-push-extend 4 *adjvec*)   ; => 3
*adjvec*                          ; => #(1 2 3 4)


;;; Множества, это просто списки:

(set-difference '(1 2 3 4) '(4 5 6 7))   ; => (3 2 1)
(intersection '(1 2 3 4) '(4 5 6 7))     ; => 4
(union '(1 2 3 4) '(4 5 6 7))            ; => (3 2 1 4 5 6 7)
(adjoin 4 '(1 2 3 4))                    ; => (1 2 3 4)

;;; Несмотря на все, для действительно больших объемов данных, вам нужно что-то
;;; лучше, чем просто связанные списки

;;; Словари представлены хеш таблицами.

;;; Создание хеш таблицы:

(defparameter *m* (make-hash-table))

;;; Установка пары ключ-значение

(setf (gethash 'a *m*) 1)

;;; Возврат значения по ключу

(gethash 'a *m*) ; => 1, T

;;; CL выражения умеют возвращать сразу несколько значений.

(values 1 2) ; => 1, 2

;;; которые могут быть распределены по переменным с помощью MULTIPLE-VALUE-BIND

(multiple-value-bind (x y)
    (values 1 2)
  (list y x))

; => '(2 1)

;;; GETHASH как раз та функция, которая возвращает несколько значений. Первое
;;; значение - это значение по ключу в хеш таблицу. Если ключ не был найден,
;;; возвращает NIL.

;;; Второе возвращаемое значение, указывает был ли ключ в хеш таблице. Если ключа
;;; не было, то возвращает NIL. Таким образом можно проверить, это значение
;;; NIL, или ключа просто не было.

;;; Вот возврат значений, в случае когда ключа в хеш таблице не было:

(gethash 'd *m*) ;=> NIL, NIL

;;; Можете задать значение по умолчанию.

(gethash 'd *m* :not-found) ; => :NOT-FOUND

;;; Давайте обработаем возврат несколько значений.

(multiple-value-bind (a b)
    (gethash 'd *m*)
  (list a b))
; => (NIL NIL)

(multiple-value-bind (a b)
    (gethash 'a *m*)
  (list a b))
; => (1 T)


;;;-----------------------------------------------------------------------------
;;; 3. Функции
;;;-----------------------------------------------------------------------------

;;; Для создания анонимных функций используйте LAMBDA. Функций всегда возвращают
;;; значение последнего своего выражения. Как выглядит функция при выводе в консоль
;;; зависит от реализации.

(lambda () "Привет Мир") ; => #<FUNCTION (LAMBDA ()) {1004E7818B}>

;;; Для вызова анонимной функции пользуйтесь FUNCALL

(funcall (lambda () "Привет Мир"))   ; => "Привет мир"
(funcall #'+ 1 2 3)                   ; => 6

;;; FUNCALL сработает и тогда, когда анонимная функция стоит в начале
;;; неэкранированного списка

((lambda () "Привет Мир"))           ; => "Привет Мир"
((lambda (val) val) "Привет Мир")    ; => "Привет Мир"

;;; FUNCALL используется, когда аргументы заранее известны.
;;; В противном случае используйте APPLY

(apply #'+ '(1 2 3))   ; => 6
(apply (lambda () "Привет Мир") nil) ; => "Привет Мир"

;;; Для обычной функции с именем используйте DEFUN

(defun hello-world () "Привет Мир")
(hello-world) ; => "Привет Мир"

;;; Выше видно пустой список (), это место для определения аргументов

(defun hello (name) (format nil "Hello, ~A" name))
(hello "Григорий") ; => "Привет, Григорий"

;;; Можно указать необязательные аргументы. По умолчанию они будут NIL

(defun hello (name &optional from)
  (if from
      (format t "Приветствие для ~A от ~A" name from)
      (format t "Привет, ~A" name)))

(hello "Георгия" "Василия")       ; => Приветствие для Георгия от Василия

;;; Можно явно задать значения по умолчанию

(defun hello (name &optional (from "Мира"))
   (format nil "Приветствие для ~A от ~A" name from))

(hello "Жоры")               ; => Приветствие для Жоры от Мира
(hello "Жоры" "альпаки")     ; => Приветствие для Жоры от альпаки

;;; Можно также задать именованные параметры

(defun generalized-greeter (name &key (from "Мира") (honorific "Господин"))
  (format t "Здравствуйте, ~A ~A, от ~A" honorific name from))

(generalized-greeter "Григорий")
; => Здравствуйте, Господин Григорий, от Мира

(generalized-greeter "Григорий" :from "альпаки" :honorific "гражданин")
; => Здравствуйте, Гражданин Григорий, от альпаки


;;;-----------------------------------------------------------------------------
;;; 4. Равенство или эквивалентность
;;;-----------------------------------------------------------------------------

;;; У CL сложная система эквивалентности. Взглянем одним глазом.

;;; Для чисел используйте `='
(= 3 3.0)               ; => T
(= 2 1)                 ; => NIL

;;; Для идентичености объектов используйте EQL
(eql 3 3)               ; => T
(eql 3 3.0)             ; => NIL
(eql (list 3) (list 3)) ; => NIL

;;; Для списков, строк, и битовых векторов - EQUAL
(equal (list 'a 'b) (list 'a 'b)) ; => T
(equal (list 'a 'b) (list 'b 'a)) ; => NIL


;;;-----------------------------------------------------------------------------
;;; 5. Циклы и ветвления
;;;-----------------------------------------------------------------------------

;;; Ветвления

(if t                    ; проверямое значение
    "случилась истина"   ; если, оно было истинно
    "случилась ложь")    ; иначе, когда оно было ложно
; => "случилась истина"

;;; В форме ветвления if, все не-NIL значения это `истина`

(member 'Groucho '(Harpo Groucho Zeppo)) ; => '(GROUCHO ZEPPO)
(if (member 'Groucho '(Harpo Groucho Zeppo))
    'yep
    'nope)
; => 'YEP

;;; COND это цепочка проверок для нахождения искомого
(cond ((> 2 2) (error "мимо!"))
      ((< 2 2) (error "опять мимо!"))
      (t 'ok)) ; => 'OK

;;; TYPECASE выбирает ветку исходя из типа выражения
(typecase 1
  (string :string)
  (integer :int))
; => :int


;;; Циклы

;;; С рекурсией

(defun fact (n)
  (if (< n 2)
      1
    (* n (fact(- n 1)))))

(fact 5) ; => 120

;;; И без

(defun fact (n)
  (loop :for result = 1 :then (* result i)
     :for i :from 2 :to n
     :finally (return result)))

(fact 5) ; => 120

(loop :for x :across "abc" :collect x)
; => (#\a #\b #\c #\d)

(dolist (i '(1 2 3 4))
  (format t "~A" i))
; => 1234


;;;-----------------------------------------------------------------------------
;;; 6. Установка значений в переменные (и не только)
;;;-----------------------------------------------------------------------------

;;; Для присвоения переменной нового значения используйте SETF. Это уже было
;;; при работе с хеш таблицами.

(let ((variable 10))
    (setf variable 2))
; => 2

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

;;;-----------------------------------------------------------------------------
;;; 7. Классы и объекты
;;;-----------------------------------------------------------------------------

;;; Никаких больше животных в примерах. Берем устройства приводимые в движение
;;; мускульной силой человека.

(defclass human-powered-conveyance ()
  ((velocity
    :accessor velocity
    :initarg :velocity)
   (average-efficiency
    :accessor average-efficiency
   :initarg :average-efficiency))
  (:documentation "Устройство движимое человеческой силой"))

;;; Аргументы DEFCLASS:
;;; 1. Имя класса
;;; 2. Список родительских классов
;;; 3. Список полей
;;; 4. Необязательная метаинформация

;;; Если родительские классы не заданы, используется "стандартный" класс
;;; Это можно *изменить*, но хорошенько подумайте прежде. Если все-таки
;;; решились вам поможет "Art of the Metaobject Protocol"

(defclass bicycle (human-powered-conveyance)
  ((wheel-size
    :accessor wheel-size
    :initarg :wheel-size
    :documentation "Diameter of the wheel.")
   (height
    :accessor height
    :initarg :height)))

(defclass recumbent (bicycle)
  ((chain-type
    :accessor chain-type
    :initarg :chain-type)))

(defclass unicycle (human-powered-conveyance) nil)

(defclass canoe (human-powered-conveyance)
  ((number-of-rowers
    :accessor number-of-rowers
    :initarg :number-of-rowers)))

;;; Если вызвать DESCRIBE для HUMAN-POWERED-CONVEYANCE то получите следующее:

(describe 'human-powered-conveyance)

; COMMON-LISP-USER::HUMAN-POWERED-CONVEYANCE
;  [symbol]
;
; HUMAN-POWERED-CONVEYANCE names the standard-class #<STANDARD-CLASS
;                                                    HUMAN-POWERED-CONVEYANCE>:
;  Documentation:
;    A human powered conveyance
;  Direct superclasses: STANDARD-OBJECT
;  Direct subclasses: UNICYCLE, BICYCLE, CANOE
;  Not yet finalized.
;  Direct slots:
;    VELOCITY
;      Readers: VELOCITY
;      Writers: (SETF VELOCITY)
;    AVERAGE-EFFICIENCY
;      Readers: AVERAGE-EFFICIENCY
;      Writers: (SETF AVERAGE-EFFICIENCY)

;;; CL задизайнен как интерактивная система. В рантайме доступна информация о
;;; типе объектов.

;;; Давайте посчитаем расстояние, которое пройдет велосипед за один оборот колеса
;;; по формуле C = d * pi

(defmethod circumference ((object bicycle))
  (* pi (wheel-size object)))

;;; PI - это константа в CL

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

;;; Инициализируем объект после его создания:

(defmethod initialize-instance :after ((object canoe) &rest args)
  (setf (average-efficiency object)  (log (1+ (number-of-rowers object)))))


;;; Давайте проверим что получилось с этой самой эффективностью...

(average-efficiency (make-instance 'canoe :number-of-rowers 15))
; => 2.7725887


;;;-----------------------------------------------------------------------------
;;; 8. Макросы
;;;-----------------------------------------------------------------------------

;;; Макросы позволяют расширить синаксис языка. В CL нет например цикла WHILE,
;;; но его проще простого реализовать на макросах. Если мы отбросим наши
;;; ассемблерные (или алгольные) инстинкты, мы взлетим на крыльях:

(defmacro while (condition &body body)
    "Пока `условие` истинно, выполняется `тело`.
`Условие` проверяется перед каждым выполнением `тела`"
    (let ((block-name (gensym)) (done (gensym)))
        `(tagbody
           ,block-name
           (unless ,condition
               (go ,done))
           (progn
           ,@body)
           (go ,block-name)
           ,done)))

;;; Взглянем на более высокоуровневую версию этого макроса:

(defmacro while (condition &body body)
    "Пока `условие` истинно, выполняется `тело`.
`Условие` проверяется перед каждым выполнением `тела`"
  `(loop while ,condition
         do
         (progn
            ,@body)))

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

;;; В макросах используются символы ```, `,` и `@`. ``` - это оператор
;;; квазиквотирования - это значит что форма исполнятся не будет, а вернется
;;; как данные. Оператаор `,` позволяет исполнить форму внутри
;;; квазиквотирования. Оператор `@` исполняет форму внутри квазиквотирования
;;; но полученный список вклеивает по месту.

;;; GENSYM создаёт уникальный символ, который гарантировано больше нигде в
;;; системе не используется. Так надо потому, что макросы разворачиваются
;;; во время компиляции и переменные объявленные в макросе могут совпасть
;;; по имени с переменными в обычном коде.

;;; Дальнйешую информацию о макросах ищите в книгах Practical Common Lisp
;;; и On Lisp
```

## Для чтения

На русском
- [Practical Common Lisp](https://github.com/pcl-ru/pcl-ru/releases/download/v1.1/pcl-ru.pdf)

На английском
- [Practical Common Lisp](http://www.gigamonkeys.com/book/)
- [Common Lisp: A Gentle Introduction to Symbolic Computation](https://www.cs.cmu.edu/~dst/LispBook/book.pdf)


## Дополнительная информация

На русском

- [Сообщество в Telegram](https://t.me/lisp_forever)

На английском

- [CLiki](http://www.cliki.net/)
- [common-lisp.net](https://common-lisp.net/)
- [Awesome Common Lisp](https://github.com/CodyReichert/awesome-cl)
- [Lisp Lang](http://lisp-lang.org/)


## Благодарности в английской версии

Спасибо людям из Scheme за отличную статью, взятую за основу для
Common Lisp.


- [Paul Khuong](https://github.com/pkhuong) за хорошую вычитку.