mirror of
https://github.com/adambard/learnxinyminutes-docs.git
synced 2024-12-23 17:41:41 +00:00
Merge pull request #3113 from filonenko-mikhail/master
[commonlisp/ru-ru] Added russian translation
This commit is contained in:
Divay Prakash
GitHub
commit
5e4c651c6c
704
ru-ru/common-lisp-ru.html.markdown
Normal file
704
ru-ru/common-lisp-ru.html.markdown
Normal file
@ -0,0 +1,704 @@
|
||||
---
|
||||
|
||||
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 на практике (перевод)](http://lisper.ru/pcl/).
|
||||
Ещё одна популярная книга [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](http://www.gigamonkeys.com/book/)
|
||||
|
||||
На английском
|
||||
- [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)
|
||||
|
||||
|
||||
## Дополнительная информация
|
||||
|
||||
На русском
|
||||
|
||||
- [Lisper.ru](http://lisper.ru/)
|
||||
|
||||
На английском
|
||||
|
||||
- [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) за хорошую вычитку.
|
||||
Loading…
Reference in New Issue
Block a user