В этом разделе описываются встроенные функции HomeLisp, принадлежащие "классическому" Лиспу. Следует отметить, что разработчик использовал известные понятия SUBR/FSUBR в несколько ином смысле, нежели Лавров и Силагадзе в своей замечательной книге [1]. В HomeLisp у функций типа SUBR все аргументы вычисляются, но допускаются функции с переменным числом аргументов, тогда как у Лаврова и Силагадзе количество аргументов функций типа SUBR должно быть фиксированным. У функций типа FSUBR вычисляются не все аргументы (какие именно - зависит от конкретной функции). Таким образом, в HomeLisp функции PLUS, TIMES, MAX принадлежат к типу SUBR (тогда, как у Лаврова и Силагадзе эти функции принадлежат к типу FSUBR, т.к. они имеют неопределенное число аргументов).

Функции, возвращающие логические значения T или Nil, называются предикатами. Некоторые предикаты предназначены для проверки типа своего аргумента (FIXEDP, FLOATP и т.д.). В Лиспе принято, что имена таких предикатов оканчиваются буквой p.

Ниже довольно часто используется термин "квотирование". Смысл его отличается от общеупотребительного: квотировать - это не выдавать строго отмеренное количество чего-либо, а применять к S-выражению функцию QUOTE. Квотирование атома a, означает запись (QUOTE a) или, что равнозначно - 'a.

Далее приводится описание всех встроенных в HomeLisp функций. При этом звездочкой (*) выделены функции, отсутствующие в реализации, описанной в книге Лаврова и Силагадзе. Если та или иная функция реализована только в 11-м или только в 13-м ядре, то номер ядра указывается в скобках красным цветом.

Возможно также, что некоторые функции ведут себя по-разному в составе 11-го и 13-го ядер. Эти моменты комментируются явным образом.

Функция ABS принимает единственный аргумент числового типа (FIXED или FLOAT). Она вычисляет абсолютною величину аргумента. Тип результата совпадает с типом аргумента. Примеры:

(ABS -7.0)

==> 7.0 

(PROPLIST (ABS -7.0))

==> (FLOAT)

(ABS 54)

==> 54 

(PROPLIST (ABS 54))

==> (FIXED)

Функция ADD1 принимает единственный аргумент числового типа (FIXED или FLOAT). Она прибавляет единицу к значению аргумента. Тип результата совпадает с типом аргумента. Примеры:

(ADD1 -7.0) 

==> -6.0   

(PROPLIST (ADD1 -7.0)) 

==> (FLOAT)

(ADD1 54)

==> 55

(PROPLIST (ADD1 54))

==> (FIXED)

Функция AND принимает произвольное число аргументов. Первый же аргумент, имеющий значений NIL вызывает прекращение вычисление, а функция возвращает значение NIL. Если значение всех аргументов функции отлично от NIL, то функция принимает значение, равное значению последнего аргумента. Примеры:

(AND 1 2 3)

==> 3

(AND 1 (CDR '(1)) (/ 3 0))

==> NIL

Функция APPLY принимает ровно 2 аргумента. Первым аргументом может быть атом или лямбда-выражение. Вторым аргументом должен быть список. Функция APPLY применяет первый аргумент к элементам списка, которые составляют второй аргумент.
Так, вызов:

(apply 'plus '(1 6))

==>  7

(apply 'cons '(язык (программирования)))

==>  (язык программирования)

(setq f 'Plus)

==>  PLUS

(apply f '(7 8))

==>  15

(apply 'apply '(plus (5 7)))

==>  12

(apply '(lambda (x y) (* x y)) '(9 8))

==>  72

(apply 'plus 1 6)

Третий аргумент APPLY - не список
==>  ERRSTATE

Функция ATOM принимает единственный аргумент. Она проверяет, является ли аргумент атомом (в этом случае возвращается значение T. В противном случае возвращается значение Nil. Примеры:

(ATOM 1)

==> T

(ATOM '(1 2 3))

==> NIL

(ATOM (+ 2 3))

==> T

.EVAL вход:  (ATOM (PLUS 2 3))
..CAR вход: A= (ATOM (PLUS 2 3))
..CAR выход: Рез= ATOM
..CDR вход: A= (ATOM (PLUS 2 3))
..CDR выход: Рез= ((PLUS 2 3))
..APPLY вход: A1= ATOM A2= ((PLUS 2 3))
...EVFUN вход: A1= ATOM A2= ((PLUS 2 3))
....LIST вход: A= ((PLUS 2 3))
.....CAR вход: A= ((PLUS 2 3))
.....CAR выход: Рез= (PLUS 2 3)
.....EVAL вход:  (PLUS 2 3)
......CAR вход: A= (PLUS 2 3)
......CAR выход: Рез= PLUS
......CDR вход: A= (PLUS 2 3)
......CDR выход: Рез= (2 3)
......APPLY вход: A1= PLUS A2= (2 3)
.......EVFUN вход: A1= PLUS A2= (2 3)
........LIST вход: A= (2 3)
.........CAR вход: A= (2 3)
.........CAR выход: Рез= 2
.........EVAL вход:  2
..........EVATOM вход:  2
..........EVATOM выход:  2
.........EVAL выход:  2
.........CDR вход: A= (2 3)
.........CDR выход: Рез= (3)
.........CAR вход: A= (3)
.........CAR выход: Рез= 3
.........EVAL вход:  3
..........EVATOM вход:  3
..........EVATOM выход:  3
.........EVAL выход:  3
.........CDR вход: A= (3)
.........CDR выход: Рез= NIL
........LIST выход: Рез= (2 3)
........PLUS вход: A= (2 3)
.........CAR вход: A= (2 3)
.........CAR выход: Рез= 2
........PLUS Пром. Рез=2
.........CDR вход: A= (2 3)
.........CDR выход: Рез= (3)
.........CAR вход: A= (3)
.........CAR выход: Рез= 3
........PLUS Пром. Рез=5
.........CDR вход: A= (3)
.........CDR выход: Рез= NIL
........PLUS выход: Рез= 5
.......EVFUN выход:  5
......APPLY выход:  5
.....EVAL выход:  5
.....CDR вход: A= ((PLUS 2 3))
.....CDR выход: Рез= NIL
....LIST выход: Рез= (5)
....CAR вход: A= (5)
....CAR выход: Рез= 5
....ATOM вход: A= 5
....ATOM выход: Рез= T
...EVFUN выход:  T
..APPLY выход:  T
.EVAL выход:  T

Функция BACKQUOTE (реализованная только в 13-й редакции ядра) делает почти то же самое, что и классическая функция QUOTE - возвращает свой аргумент без вычисления. Однако имеются два исключения:

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

Если перед атомом или списком, входящим в состав аргумента стоит ,@, то элемент также вычисляется, но "присоединяется" к результату на том же уровне вложенности.

Вызов функции BACKQUOTE можно записывать с помощью символа "`" обратный апростроф (по аналогии с записью QUOTE с помощью обычного апострофа. Вот поясняющие примеры:

(setq p '(1 2 3)) ==> (1 2 3) Создана глобальная переменная p `(1 2 ,p 3 4) ==> (1 2 (1 2 3) 3 4) `(1 2 ,p 3 4 ,@p) ==> (1 2 (1 2 3) 3 4 1 2 3) `(111 222 ,(fact 10) 333) ==> (111 222 3628800 333) `(111 222 ,@(fact 10) 333) BackQoute: Конструкция ",@" стоит перед атомом ==> ERRSTATE `(111 222 ,@(mklist1 10) 333) ==> (111 222 10 9 8 7 6 5 4 3 2 1 333)

Здесь создана глобальная переменная p и ей присвоено значение (1 2 3). При вычислении `(1 2 ,p 3 4) конструкция ,p заменяется на список (1 2 3), причем этот список оказывается на более глубоком уровне вложенности (т.н. включающая обратная блокировка).

Далее показана разница в поведении ,ANY и ,@ANY: конструкция ,p превращается во вложенный список, тогда как список, получаемый при обработке ,@p присоединяется к текущему на том же уровне (т.н. присоединяющая обратная блокировка).

В следующем примере ,(fact 10) заменяется атомом 3628800. А вот попытка использовать конструкцию ,@(fact 10) вызывает ошибку - присоединяющая обратная блокировка может применяться только к спискам. Следующий пример показывает, что список присоединяется успешно.

Наиболее частое применение обратная блокировка находит при программировании macro. Вот пример, иллюстрирующий применение обратной блокировки в макро. Построим макрос, который по заданному списку строит новый "удвоенный" список (каждый элемент верхнего уровня исходного списка в результирующем списке заменяется двумя такими же элементами). Вот как выглядит такой макрос c использованием обратной блокировки:

(defmacro double-list (a-list) `(let ((ret nil)) (dolist (x ,a-list) (setq ret (append ret (list x x)))) ret) ) ==> double-list (double-list '(a b c (d e f))) ==> (a a b b c c (d e f) (d e f)) (macroexpand double-list '(1 2 3)) ==> (LET ((ret NIL)) (DOLIST (x (QUOTE (1 2 3))) (SETQ ret (append ret (LIST x x)))) ret)

В сущности, макро строит предложение LET, в единственное место которого нужно подставить значение параметра (это место выделено красным). С использованием обратной блокировки задача решается очень наглядно и изящно: мы просто пишем нужное выражение, предварив его обратным апострофом, а в нужных местах перед элементами, которые требутся вычислить ставим запятую или пару ",@". Хорошо видно, что тело макро почти не отличается от результата макрорасширения!

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

(defmacro dbl-lst (a-list) (list 'let (list (list 'ret nil)) (list 'dolist (list 'x a-list) (list 'setq 'ret (list 'append 'ret (list 'list 'x 'x)))) 'ret ) ) ==> dbl-lst (dbl-lst '(a b c (d e f))) ==> (a a b b c c (d e f) (d e f)) (macroexpand dbl-lst '(1 2 3)) ==> (LET ((ret NIL)) (DOLIST (x (QUOTE (1 2 3))) (SETQ ret (append ret (LIST x x)))) ret)

Как можно убедиться, тело макроса dbl-lst воспринимается значительно труднее, чем тело макроса double-list. Связь тела макроса с результатом макрорасширения в данном случае совсем не очевидна (хотя результат макрорасширения макросов dbl-lst и double-list одинаков.

Функция-предикат BITSP принимает единственный аргумент. Если значением аргумента является битовое значение, функция возвращает T. В противном случае функция возвращает Nil Примеры:

(BITSP '(1 2 3))

==> Nil

(BITSP &H55)

==> T

(BITSP (FIX2BIT 678))

==> T

Функция BIT2FIX, отсутствующая у Лаврова и Силагадзе, принимает единственный аргумент типа BITS. функция возвращает значение аргумента, преобразованное к типу FIXED. При этом, если старший бит аргумента установлен, то результатом будет отрицательное число (в этом случае предполагается, что отрицательные числа хранятся в дополнительном коде). Если аргумент функции BIT2FIX имеет тип, отличный от BITS, возникает ошибка. Примеры:

(BIT2FIX &H55)

==> 85

(BIT2FIX &HFFFFFFF7)

==> -9

(BIT2FIX 678)

==> Аргумент BIT2FIX должен иметь тип BITS

Функция CAR принимает единственный аргумент - список или точечную пару. Она возвращает голову списка (первый элемент списка на верхнем уровне). Если аргумент - не список и не пара (атом), то возникает ошибка. Примеры:

(CAR '(1 2 3))

==> 1

(CAR '((1 2) 3))

==> (1 2)

(CAR '(a . b))

==> a
       
(CAR 'a)

==> Аргумент CAR - атом (a)

Функция CDR принимает единственный аргумент - список или точечную пару. Она возвращает хвост списка - список без первого элемента. Если аргумент не список и не пара (атом), то возникает ошибка. Примеры:

(CDR '(1 2 3))

==> (2 3)

(CDR '((1 2) 3))

==> (3)

(CDR '(a . b))

==> b
       
(CDR 'a)

==> Аргумент CDR - атом (a)

(CDR '(3))

 ==> Nil

Поскольку функции CAR и CDR применяются для выделения частей списков (разбора списков на составные части), в язык встроено несколько комбинаций CAR и CDR:

(CAAR ... ) это (CAR (CAR ...)) (CADAR ...) это (CAR (CDR (CAR ...))) (CADDR ...) это (CAR (CDR (CDR ...))) (CADDDR ...) это (CAR (CDR (CDR (CDR ...)))) (CADR ...) это (CAR (CDR ...)) (CDAR ...) это (CDR (CAR ...)) (CDDR ...) это (CDR (CDR ...)) (CDDDR ...) это (CDR (CDR (CDR ...)))

Естественно, что эти функции можно вычислить не для всякого значения аргумента. Так, при попытке вычислить (CAAR '(1 2)) возникнет ошибка, поскольку (CAR '(1 2)) равен 1, а попытка вычислить (CAR 1) приведет к ошибке, т.к. здесь аргумент CAR - не список и не точечная пара, а атом.

Функция COND обеспечивает вычисление условных выражений. Общий вид функции COND таков:

(COND 
     ((Условие-1) Результат-1)
     ((Условие-2) Результат-2)
     ...                      
     ((Условие-n) Результат-n)
     (T           Результат)  
)

(COND 
      ((EQ x y) "Равно")
      (T        "Не равно")
 )
 
 ==> "Не равно"

 (COND
      ((EQ (+ x z) y) "Равно") 
      (T              "Не равно") 
 )

 ==> "Равно"

Функция CONS принимает два аргумента и объединяет их в точечную пару. Таким образом, если оба аргумента CONS - атомы, отличные от Nil, то функция вернет точечную пару, составленную из атомов. Если первый аргумент - атом, а второй - список, то результатом CONS будет новый список, получающийся добавлением первого аргумента к началу списка из второго аргумента. В частности, если первый аргумент - атом, а второй аргумент - Nil, то в результате получится одноэлементный список, состоящий из первого аргумента. Это происходит потому, что в Лиспе Nil считается пустым списком. А если оба аргумента CONS - списки, то в результате получится новый двухуровневый список, голова которого есть значение первого аргумента, а хвост - значение второго аргумента. Все это иллюстрируется следующими примерами:

(CONS 'A 'B) 

==> A . B  

(CONS 'A '(1 2 3))

==> (A 1 2 3)

(CONS 'A Nil)

==> (A)

(CONS '(A B C) '(1 2 3))

==> ((A B C) 1 2 3)

Функция CONTEXT (реализованная только в 13-й версии ядра) принимает принимает один необязательный аргумент - атом. Если этот атом есть имя функции типа EXPR/FEXPR/MACRO и функция определена с сохранением лексического окружения (создано замыкание), то функция CONTEXT вернет лексическое окружение в виде списка пар ((Переменная Значение) (Переменная Значение) ... ). Аналогичный результат будет получен в случае, когда значением аргумента CONTEXT является замыкание, созданное на основе лямбда-выражения или FUNCTION. В остальных случаях функция CONTEXT возвращает Nil.

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

Рассмотрим некоторые примеры:

(context) ==> (Nil Nil) (setq p '(1 2 3)) ==> (1 2 3) Создана глобальная переменная p (context) ==> (NIL ((p (1 2 3)))) (defun fff (x y) (printline (context)) (list x y)) ==> fff (fff 666 777) (((y 777) (x 666)) ((p (1 2 3)))) ==> (666 777) (defun ggg (x y &aux z) (printline (context)) (list x y)) ==> ggg (ggg 666 777) (((z NIL) (y 777) (x 666)) ((p (1 2 3)))) ==> (666 777) (prog (x y) (setq x 111) (setq y 222) (printline (context)) (return (+ x y)) ) (((y 222) (x 111)) ((p (1 2 3)))) ==> 333

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

После создания глобальной переменной p эта переменная попадает в глобальный контекст.

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

В следующем примере показана функция ggg с дополнительным параметром. Этот параметр тоже попадает в лексический контекст. Наконец, последний пример показывает, что в лексический контекст попадают и PROG-переменные.

Функция CONTEXT позволяет увидеть лексические переменные замыкания. Ниже показан пример, где с помощью замыкания создается простейший генератор. Функция CONTEXT позволяет увидеть внутреннее значение счетчика:

(setq z 111) ==> 111 Создана глобальная переменная z (let ((c 0)) (defun next-c nil (setq c (add1 c)))) ==> next-c (next-c) ==> 1 (next-c) ==> 2 (context 'next-c) ==> ((c 2))

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

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

(let ((a 111) (b 222)) (setq f (lambda (x) (list a b x)))) ==> (CLOSURE (x) ((LIST a b x)) ((b 222) (a 111))) Создана глобальная переменная f f ==> (CLOSURE (x) ((LIST a b x)) ((b 222) (a 111))) (context f) ==> ((b 222) (a 111)) (funcall f 333) ==> (111 222 333)

Пусть читатель обратит внимание на то, что в приведенном выше примере при вызове CONTEXT аргумент не квотируется. Следующий далее пример в общем аналогичен предыдущему (только замыкание здесь создается с помощью конструкции FUNCTION):

(defun g (x) (+ a b x)) ==> g (g 1) Assoc: Символ a не имеет значения (не связан). ==> ERRSTATE (setq ff (let ((a 111) (b 222)) (function g))) ==> (CLOSURE g ((a 111) (b 222))) Создана глобальная переменная ff (funcall ff 333) ==> 666 (context ff) ==> ((a 111) (b 222))

Функция CSETQ принимает два аргумента; первый аргумент должен быть атомом (он не вычисляется), а второй - произвольным S-выражением. Функция превращает атом (первый аргумент) в константу; при этом константа наследует тип вычисленного S-выражения. Значение константы впоследствии не может быть изменено (в отличие от переменной, создаваемой фунциями SET/SETQ). Если атом-аргумент является переменной, возникает ошибка. При попытке изменить значение константы повторным вызовом CSETQ возникает ошибка c диагностикой "Csetq - попытка изменить значение константы". То же будет иметь место при попытке изменить значение встроенной константы ( Nil, T, ERRSTATE, _Pi, _E, _Ver ). Так же закончится и попытка присвоить одному числу значение другого. Если же попытаться создать переменную, одноименную с константой с помощью функций SETQ/SET, то будет выдана диагностика "Попытка превратить константу ... в переменную". Ниже приводятся примеры на эту тему.

(CSETQ K 12)

==> 12

(CSETQ K -5)

==> Csetq - попытка изменить значение константы
 
(SETQ kk 3)

==> 3

(CSETQ kk 8)

==> Csetq - попытка превратить переменную в константу

(SETQ _Pi 5)

==> Попытка превратить константу _Pi в переменную

(CSETQ 1 2)

==> Csetq - попытка изменить значение константы

(CSETQ "a" "b")

==> Csetq - попытка изменить значение константы

(CSETQ Nil T)

==> Csetq - попытка изменить значение константы

(csetq AA '(a b c))

==> AA

AA

==> (a b c)

(rplaca AA 'd)

RPLACA: попытка модификации защищенной структуры
==> ERRSTATE

AA

==> (a b c)

(setq BB '(a b c))

==> (a b c)

(rplaca BB 'd)

==> (d b c)

BB

==> (d b c)

(csetq n 'a)

==> a

(defun f (t n) (cons t (cons n nil)))

==> f

(f 'b 'c)

==> (t a)

.EVAL вход:  (f (QUOTE b)(QUOTE c))
..APPLY вход: A1= f A2= ((QUOTE b)(QUOTE c))
...EVFUN вход: A1= f A2= ((QUOTE b)(QUOTE c))
....LIST вход: A= ((QUOTE b)(QUOTE c))
.....EVAL вход:  (QUOTE b)
......APPLY вход: A1= QUOTE A2= (b)
.......EVFUN вход: A1= QUOTE A2= (b)
.......EVFUN выход:  b
......APPLY выход:  b
.....EVAL выход:  b
.....EVAL вход:  (QUOTE c)
......APPLY вход: A1= QUOTE A2= (c)
.......EVFUN вход: A1= QUOTE A2= (c)
.......EVFUN выход:  c
......APPLY выход:  c
.....EVAL выход:  c
....LIST выход: Рез= (b c)
....EVLAM вход: A1= ((T n)(CONS T (CONS n NIL))) A2= (b c)
.....PAIRLIS вход: ptrAasso=0 A1= (T n) A2= (b c)
.....
..... Ассоциативный список:
.....
.....  2  ->  (n . c)
.....  1  ->  (T . b)
.....
.....PAIRLIS выход: ptrAsso=2
.....EVAL вход:  (CONS T (CONS n NIL))
......APPLY вход: A1= CONS A2= (T (CONS n NIL))
.......EVFUN вход: A1= CONS A2= (T (CONS n NIL))
.......
....... Ассоциативный список:
.......
.......  2  ->  (n . c)
.......  1  ->  (T . b)
.......
........LIST вход: A= (T (CONS n NIL))
.........EVAL вход:  T
..........EVATOM вход:  T
..........EVATOM выход:  T
.........EVAL выход:  T
.........EVAL вход:  (CONS n NIL)
..........APPLY вход: A1= CONS A2= (n NIL)
...........EVFUN вход: A1= CONS A2= (n NIL)
...........
........... Ассоциативный список:
...........
...........  2  ->  (n . c)
...........  1  ->  (T . b)
...........
............LIST вход: A= (n NIL)
.............EVAL вход:  n
..............EVATOM вход:  n
..............EVATOM выход:  a
.............EVAL выход:  a
.............EVAL вход:  NIL
..............EVATOM вход:  NIL
..............EVATOM выход:  NIL
.............EVAL выход:  NIL
............LIST выход: Рез= (a NIL)
............CONS вход: A1= a A2= (NIL)
............CONS выход: Рез= (a)
...........EVFUN выход:  (a)
..........APPLY выход:  (a)
.........EVAL выход:  (a)
........LIST выход: Рез= (T (a))
........CONS вход: A1= T A2= ((a))
........CONS выход: Рез= (T a)
.......EVFUN выход:  (T a)
......APPLY выход:  (T a)
.....EVAL выход:  (T a)
....EVLAM выход: Рез= (T a)
...EVFUN выход:  (T a)
..APPLY выход:  (T a)
.EVAL выход:  (T a)

(defun f (x y) (cons x (cons y nil)))

==> f

(f 'b 'c)

==> (b c)

Функция DEFDYN реализована только в 13-й редакции ядра. Функция (типа FSUBR) принимает один параметр параметр-атом и один необязательный - произвольное S-выражение. Функция DEFDYN является полным синонимом функции DEFVAR.

Если задан только один параметр-атом, то функция превращает этот символ в динамическую переменную (не присваивая нового значения и не меняя существующего).

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

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

Все сказанное иллюстрируется врезкой:

(defdyn v) ==> v v Assoc: Символ v не имеет значения (не связан). ==> ERRSTATE (defdyn w 111) ==> w w ==> 111 (defdyn w 222) ==> w w ==> 111

Создана динамическая переменная v (точнее, с этого момента символ v будет задавать динамическую переменную). Но символ v пока не получил никакого значения. Далее создается динамическая переменная w с присвоением ей значения 111. Последующая попытка сменить значение переменной w с помощью DEFDYN не имеет успеха.

Ниже приведен пример, показывающий разницу в поведении лексических и динамических переменных.

(defun f (x) (* x a)) ==> f (let ((a 1)) (f 5)) Внутри LET: Assoc: Символ a не имеет значения (не связан). ==> ERRSTATE (let ((a 1)) (printline (+ a 7)) (f 5)) 8 Внутри LET: Assoc: Символ a не имеет значения (не связан). ==> ERRSTATE (defdyn 'a) ==> a (let ((a 1)) (printline (+ a 7)) (f 5)) 8 ==>5

Переменная a (по умолчанию - лексическая) становится динамической после вызова (defdyn 'a). Теперь значение переменной a доступно в теле функции f.

Функция DEFGLOB принадлежит к типу FSUBR и реализована только в 13-й редакции ядра HomeLisp Функция создает глобальную переменную и присваивает ей значение Nil. Другой способ создания глобальной переменной состоит в вызове SET/SETQ. Если переменная, заданная первым параметром SET/SETQ, не существует в текущем лексическом контексте, будет создана глобальная переменная. Поскольку вызовы SET/SETQ на верхнем уровне выполяются в пустом лексическом контексте, то такой вызов всегда создает или модифицирует глобальные переменные. В общем использование SET/SETQ и DEFGLOB совершенно равноправно; без DEFGLOB можно было бы обойтись. DEFGLOB введена в HomeLisp для "синтаксической симметрии". Рассмотрим примеры:

(defglob v) ==> v Создана глобальная переменная v v ==> NIL (setq vv 777) ==> 777 Создана глобальная переменная vv (varlist) +------------------+---------+----------+ | Имя переменной | Тип | Значение | +------------------+---------+----------+ |vv |Глобальн.|777 | |v |Глобальн.|NIL | +------------------+---------+----------+ ==> T

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

(setq v 111) ==> 111 Создана глобальная переменная v (defun f (x) (* x v)) ==> f (defun g (v) (f 7)) ==> g (g 222) ==> 777 (defdyn v) ==> v (g 222) ==> 1554

Создана глобальная переменная v и функция f, относительно которой переменная v свободна. Далее создается функция g, у которой переменная v входит в список параметров. При вычислении (g 222) переменная v является лексической и значение 222 не попадает в функцию f, - берется глобальное значение 111 (результат = 777 = 7 * 111). Далее переменная v делается динамической; теперь при вычислении (g 222) в функции f будет взято значение 222 (фактический параметр при вызове g. Результат получается равным 1554 ( 222 * 7).

Функции DEFMACRO является упрощенной формой функции SMACRO. Понятие макро в Лиспе подробно рассмотрено в разделе, посвященном функции SMACRO. Функцию DEFMACRO разработчик ввел в HomeLisp для совместимости с современными версиями Лиспа.

Функция DEFMACRO принимает три параметра: имя создаваемой функции, список ее формальных параметров и тело функции. При удачном завершении функция возвращает атом-имя, а в системе появляется новая макрофункция.

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

(defmacro arlist (L OP) (cons OP L))

==> arlist

(arlist (1 2 3 4 5 6) *)

==> 720

(macroexpand arlist (1 2 3 4 5 6) *)

==> (* 1 2 3 4 5 6)

(arlist (1 2 3 4 5) +)

==> 15

(macroexpand arlist (1 2 3 4 5 ) +)

==> (+ 1 2 3 4 5)

Функция DEFUN добавлена исключительно для совместимости с более поздними версиями Лиспа. DEFUN позволяет создавать функции типа EXPR несколько проще, чем базовая функция SEXPR. Функция принимает три аргумента: имя вновь создаваемой функции (атом); список формальных параметров (список) и тело функции без атома LAMBDA (тоже список). При успехе DEFUN возвратит имя вновь созданной функции (первый аргумент). Создадим функцию, вычисляющую сумму элементов списка произвольной длины, состоящего из чисел или констант, имеющих числовое значение. Это будет рекурсивная функция, работающая следующим образом: если список пуст, функция должна вернуть нуль. Если аргумент функции - атом, то функция должна вернуть этот атом в качестве значения (предполагаем, что на вход функции подается список из чисел). Наконец, если аргумент - список, то функция берет значение головы списка и прибавляет к нему значение функции, взятой от хвоста списка (стандартное использование рекурсии). Все это выглядит так:

(defun Сумма (x)
             (cond ((null x) 0)
                   ((Atom x) x) 
                   (T (+ (car x) (Сумма (Cdr x))))
              )
)

Функция DEFUNF (как и функция DEFUN) добавлена для совместимости с более поздними версиями Лиспа. DEFUNF позволяет создавать функции типа FEXPR несколько проще, чем базовая функция SFEXPR. Функция принимает три аргумента: имя вновь создаваемой функции (атом); список формальных параметров (список) и тело функции (тоже список). При успехе DEFUNF возвратит имя вновь созданной функции (первый аргумент).

Создадим (следуя книге Лаврова и Силагадзе) функцию PAIRQ, которая объединяет два своих аргумента в список:

(defunf pairq (x y) (cons x (cons y nil)))

==> pairq

(pairq 1 2)

==> (1 2)

(pairq (1 2) (3 4))

==> ((1 2) (3 4))

Функция DEFVAR, реализованная только в 13-й версии ядра, является полным синонимом функции DEFDYN, описанной выше.

Функция DIFFERENCE вычисляет разность значений первого и всех остальных аргументов. Аргументов может быть произвольное количество. Допустимы только значения аргументов FIXED и FLOAT. Если все аргументы DIFFERENCE имеют тип FIXED, то и результат будет иметь тип FIXED. Если же среди аргументов DIFFERENCE встретился аргумент типа FLOAT, то и результат будет иметь тип FLOAT. Для удобства записи допустимо вместо (DIFFERENCE ...) писать (- ...). Вот примеры,иллюстрирующие сказанное:

(- 1 2 3)

==> -4

(PROPLIST (- 1 2 3))

==> (FIXED)

(DIFFERENCE 3 1.0)

==> 2.0

(PROPLIST (DIFFERENCE 3 1.0))

==> (FLOAT)

Функция DIVIDE (отсутствующая у Лаврова и Силагадзе) вычисляет частное от деления значения первого аргумента на значение второго. Аргументов должно быть ровно два. Тип аргументов может быть FIXED или FLOAT. При вычислении частного значения типа FIXED автоматически приводится к типу FLOAT. Результат всегда имеет тип FLOAT. Если абсолютная величина делителя оказывается меньше 1.0D-300, то возникает ошибка "Деление на нуль". В целях упрощения вместо вызова (DIVIDE ...) допустимо писать (/ ...). Следует обратить внимание на то, что функция DIVIDE не предназначена для целочисленного деления; для этого существуют функции QUOTIENT (частное) и REMAINDER (остаток). Примеры вызова:

(/ 1 2)

==> 0.5

(/ -6 0.5)

==> -12.0

Функции DO и DO* - это самые общие функции организации циклов в Лиспе. Тип функций, естественно - FSUBR. Функции отсутствуют у Лаврова и Силагадзе, а в HomeLisp реализованы только в 13-й редакции ядра. Общий синтаксис функций таков:

(DO/DO* ( (переменная1 значение1 шаг1) (переменная2 значение2 шаг2) … (переменнаяn значениеn шагn) ) (условие_окончания форма_ок1 форма_ок2 … форма_окm) (форма1) (форма2) … (формаk) )

Функции выполняется следующим образом:

1. В текущий лексический контекст добавляются переменные цикла (переменная₁, переменная₂ ... переменная_n). Им присваиваются соответствующие значения. При этом для функции DO переменные 1 - n вычисляются "одновременно" (как в LET), а для функции DO* - "параллельно" (как в LET*).

2. Вычисляется условие_окончания. Если оно истинно (т.е. не есть Nil), то вычисляются формы окончания - форма_ок₁ , форма_ок₂ … форма_ок_m Результат вычисления последней формы возвращается как результат DO/DO*.

3. Если условие окончания ложно, вычисляется тело цикла - формы: (форма₁) (форма₂) … (форма_k).

4. Всем переменным (переменная₁ , переменная₂ … переменная_n) присваиваются новые значения путем вычисления соответствующих форм (шаг₁ , шаг₂ … шаг_n) и происходит переход к п.2.

Все это проиллюстрируем примерами:

(DO ( (i 1 (+ i 1)) (j 1 (+ j 1))) ((> j 5) (printline 'ok) (printline 'ok) (printline 'ok)) (print 'i=) (print i) (prints " ") (print 'j=) (printline j) ) i=1 j=1 i=2 j=2 i=3 j=3 i=4 j=4 i=5 j=5 ok ok ok ==> ok

Еще один пример:

(DO ( (i 1 (+ i 1)) (j (+ 1 i) (+ j 1))) ((> j 5) (printline 'ok)) (print 'i=) (print i) (prints " ") (print 'j=) (printline j) ) Символ i не имеет значения (не связан). ==> ERRSTATE

Приведенный выше пример оканчивается ошибкой, поскольку при вычислении начального значения переменной j, переменная i еще недоступна. Но если вместо DO вызвать DO*, то ошибки не возникнет:

(DO* ((i 1 (+ i 1)) (j (+ 1 i) (+ j 1))) ((> j 5) (printline 'ok)) (print 'i=) (print i) (prints " ") (print 'j=) (printline j) ) i=1 j=2 i=2 j=3 i=3 j=4 i=4 j=5 ok ==> ok

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

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

(let ((i 111) (j 222)) (do ((i 1 (+ i 1)) (j 1 (+ j 1))) ((> j 3) (printline 'ok)) (varlist) ) (printline i) (printline j) ) +------------------+---------+----------+ | Имя переменной | Тип | Значение | +------------------+---------+----------+ |i |Лексич. |1 | |j |Лексич. |1 | |j |Лексич. |222 | |i |Лексич. |111 | +------------------+---------+----------+ +------------------+---------+----------+ | Имя переменной | Тип | Значение | +------------------+---------+----------+ |i |Лексич. |2 | |j |Лексич. |2 | |j |Лексич. |222 | |i |Лексич. |111 | +------------------+---------+----------+ +------------------+---------+----------+ | Имя переменной | Тип | Значение | +------------------+---------+----------+ |i |Лексич. |3 | |j |Лексич. |3 | |j |Лексич. |222 | |i |Лексич. |111 | +------------------+---------+----------+ ok 111 222 ==> 222

А вот пример, показывающий, почему сохраняются значения глобальных переменных:

(setq i 111) ==> 111 Создана глобальная переменная i (setq j -111) ==> -111 Создана глобальная переменная j (do ((i 1 (+ i 1)) (j 1 (+ j 1))) ((> j 3) (printline 'ok)) (varlist) ) +------------------+---------+----------+ | Имя переменной | Тип | Значение | +------------------+---------+----------+ |i |Лексич. |1 | |j |Лексич. |1 | |j |Глобальн.|-111 | |i |Глобальн.|111 | +------------------+---------+----------+ +------------------+---------+----------+ | Имя переменной | Тип | Значение | +------------------+---------+----------+ |i |Лексич. |2 | |j |Лексич. |2 | |j |Глобальн.|-111 | |i |Глобальн.|111 | +------------------+---------+----------+ +------------------+---------+----------+ | Имя переменной | Тип | Значение | +------------------+---------+----------+ |i |Лексич. |3 | |j |Лексич. |3 | |j |Глобальн.|-111 | |i |Глобальн.|111 | +------------------+---------+----------+ ok ==> ok i ==> 111 j ==> -111

В заключение следует сказать о том, что если при вызове DO/DO* задать две или более одинаковые переменные цикла, то возбуждается состояние ошибки (переменная выделена красным):

(do ((i 1 (+ i 1)) (i 2 (+ i 3))) ((> i 10) 'ok) (varlist) (printline i) ) DO: повторение имени локальной переменной ==> ERRSTATE

Разработчик полагает, что вызовы DO/DO*, подобные приведенному выше, являются бессмысленными. Отчасти это подтверждается тем обстоятельством, что аналогичный вызов в двух известных системах XLISP и LispWorks работают по-разному. А именно вот так:

LispWorks: (do ((i 1 (+ i 1)) (i 1 (+ i 3))) ((> i 10) 'ok) (print i) ) 1 4 7 10 OK XLISP: (do ((i 1 (+ i 1)) (i 1 (+ i 3))) ((> i 10) 'ok) (print i) ) 1 2 3 4 5 6 7 8 9 10 OK

Очевидно, что в LispWorks приращение переменной цикла выполняет вторая форма приращения, а в XLISP - первая. Поскольку непонятно, какая схема "правильная", то проще предотвратить задание двух одинаковых переменных цикла...

Функция DOLIST (типа FSUBR), отсутствующая у Лаврова и Силагадзе, реализована только в 13-м ядре HomeLisp. Функция организует "пробег" переменной по заданному списку. В современных языках программирования такую организацию цикла принято называть циклом "for each". Синтаксис вызова функции DOLIST :

(dolist (итератор (список) результат) (форма1) (форма2) … (формаn) )

Функция последовательно присваивает переменной-итератору значения элементов списка, после чего выполняется тело цикла (форма₁) - (форма_n). После завершения функция DOLIST возвращает результат, заданный формой результат. Вот пример, поясняющий все сказанное:

(dolist (ite '(1 2 3 4 5 6 7 8 9 10) 'Ok) (printline (fact ite)) ) 1 2 6 24 120 720 5040 40320 362880 3628800 ==> ok

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

(dolist (ite '(1 2 3) 'ok) (dolist (ite '(4 5 6) 'ok) (printline ite))) 4 5 6 4 5 6 4 5 6 ==> ok

Тот же пример с двумя различными переменными цикла дает совершенно предсказуемый результат:

(dolist (ite1 '(1 2 3) 'ok) (dolist (ite2 '(4 5 6) 'ok) (print ite1) (prints " ") (printline ite2))) 1 4 1 5 1 6 2 4 2 5 2 6 3 4 3 5 3 6 ==> ok

Функция DOTIMES (реализованная только в 13-м ядре и отсутствующая у Лаврова и Силагадзе) принадлежит к классу FSUBR. Эта функция обеспечивает выполнение блока кода заданное число раз. Синтаксис вызова функции следующий:

(dotimes (переменная_цикла число_повторений результат) (форма1) (форма2) … (формаn) )

Вычисление происходит так. Переменная цикла последовательно получает значения от 0 до значения число_повторений-1. При каждом значении переменной цикла последовательно вычисляются формы (форма₁) - (форма_n). По завершении цикла вычисляется форма-результат и возвращается в качестве результата DOTIMES. Вот как это выглядит:

(dotimes (i 5 t) (print 'i=) (printline i) ) i=0 i=1 i=2 i=3 i=4 ==> T

Достаточно интересно то, что переменную цикла в теле цикла можно менять! Никакого зацикливания при этом не произойдет:

(dotimes (i 5 t) (setq i -1) (print 'i=) (printline i) ) i=-1 i=-1 i=-1 i=-1 i=-1 ==> T

Для досрочного выхода из цикла можно использовать функцию RETURN:

(dotimes (i 10 t) (print 'i=) (printline i) (if (= i 7) (return 'ok) nil) ) i=0 i=1 i=2 i=3 i=4 i=5 i=6 i=7 ==> ok

В этом случае в качестве результата возвращается результат вызова RETURN.

Функция DOTPRINT (отсутствующая у Лаврова и Силагадзе) позволяет напечатать внутреннюю (точечную) форму значения своего аргумента. Если аргумент - атом, поведение функции не отличается от поведения функции PRINT. Примеры вызова:

(dotprint '(a b c d))

(a . (b . (c . (d . NIL))))

==> (a b c d)

(dotprint '(a))

(a . NIL)

==> (a)

Функция EQ сравнивает два своих аргумента. Если один или оба аргумента функции EQ не являются атомами, функция вернет NIL. Если же оба аргумента функции - атомы, то функция сравнивает их. Если атомы совпадают, возвращается T, в противном случае возвращается NIL. Вот несколько примеров:

(eq 1 2)

==>  NIL

(eq 1 1)

==>  T

(eq 2 (+ 1 1))

==>  T

(eq 'a 'b)

==>  NIL

(eq _pi 3.14)

==>  NIL

(eq _pi 3.1415926535)

==>  T

(eq 'a 'a)

==>  T

(setq x 1)

==>  1

(eq x 1)

==>  T

Функция EQL, отсутствующая у Лаврова и Силагадзе, требует двух аргументов. Если оба аргумента представляют собой один и тот же объект (неважно, атом или список), то функция возвращает T. В противном случае функция возвращает Nil. Вот несколько примеров вызова функции EQL:

(eql 1 1) ==> T (eql 1 2) ==> NIL (eql '(1 2) '(1 2)) ==> NIL (equal '(1 2) '(1 2)) ==> T (setq z '(1 2)) ==> (1 2) (setq w (list z z)) ==> ((1 2) (1 2)) (eql z (car w)) ==> T (eql z (cadr w)) ==> T

Первые два примера воспринимаются вполне естественно. А вот третий пример может вызвать удивление. Действительно, ведь значения обоих аргументов EQL представлены одним и тем же списком - (1 2). Почему же функция показывает, что списки различаются? Дело в том, функция EQL не проверяет, состоят ли списки-аргументы из одних и тех же элементов (как приведеная ниже функция EQUAL). Функция EQL проверяет факт совпадения адресов значений первого и второго аргумента. Чтобы лучше уяснить происходящее, читателю предлагается рассмотреть внутреннюю структуру списка аргументов вызова (EQL '(1 2) '(1 2)).

Функция EQL сравнивает адреса списочных ячеек, залитых желтым и зеленым цветом на идентичность. Из рисунка видно, что хотя содержимое этих ячеек одинаково, но адреса их будут различаться (отюда и результат). А вот функция EQUAL (написанная на Лиспе) рекурсивно сравнивает именно содержимое, поэтому результат (EQUAL '(1 2) '(1 2)) оказывается равным T.

Совсем по-другому будет обстоять дело в том случае, когда сначала переменной z присваивается значение (1 2), затем переменной w присваивается значение выражения (LIST z z). Значение переменной z будет иметь такой вид:

Теперь (CAR w) и (CADR w) представляют собой одну и ту же ячейку. В этом случае функция EQL вернет T.

Функция EVAL вычисляет свой аргумент (который может быть атомом или списком). Вычисление заключается в следующем:

  Если аргументом является числовая и строковая константа {1, 2.5, &H15, "abc"}, имеющих в списке свойств индикаторы FIXED, FLOAT, BITS или STRING соответственно, значением является сама константа.

  Если аргументом является атом с индикатором APVAL, то в качестве значения атома выдается значение его определяющего выражения. В частности, для встроенных констант (_Pi, _E, _Ver) значением являются 3.1415926535, 2.718281828 и "HomeLisp Вер. N.M.KK (Файфель Б.Л.)" соответственно. Полезно заглянуть в список объектов и найти там указанные выше константы. Будет отчетливо видно, что у этих констант в списке свойств имеется индикатор APVAL, а определяющее выражение представляет собой константу соответствующего типа.

  Если аргументом является атом-переменная (она создается вызовом SETQ), в качестве значения EVAL выдается значение выражения, присвоенного атому.

  Если аргументом является список, то его первый элемент рассматривается как имя функции, в все остальные элементы - как список аргументов этой функции. Отсюда следует, что не каждый список можно "вычислить" с помощью функции EVAL. Например, список (a b c) можно вычислить только если a - функция c двумя аргументами. Вот необходимые примеры:

(eval 1)

==> 1

(eval _Pi)

==> 3.1415926535

(eval a)

==> Символ "a" не имеет значения (не связан). 
            
(setq a '(x y z))

==> (x y z)
 
(eval a)

==> Символ "x" не имеет значения (не связан).

(setq a ''(1 2 3))

==>  (QUOTE (1 2 3))

(eval a)

==>  (1 2 3)

(setq myFunct 777)

==> 777

(defun myFunct (x y) (+ (* x x) (* y y)))

==> myFunct

(eval myFunct)

==> 777

(myFunct 3 4)

==> 25

Функция ERRORMESSAGE не требует аргументов. Она возвращает активное сообщение об ошибке в виде текстовой строки. Функцию имеет смысл использовать только совместно с функцией TRY в блоке, размещенном после атома EXCEPT. Если вызвать функцию ERRORMESSAGE в другом контексте (даже сразу же после вычисления, завершившегося ошибкой), то она вернет пустую строку. Вот примеры вызова ERRORMESSAGE:

(/ 1 0) DIVIDE - деление на нуль ==> ERRSTATE (errormessage) ==> "" (try (/ 1 0) except (prog nil (say (strcat "Ошибка: " (errormessage))) (return 0)) ) ==> 0

Здесь при вызове ERRORMESSAGE сразу после ошибки, выдается пустая строка. А при вызове ERRORMESSAGE посредством конструкции TRY-EXCEPT выводится диалоговое окно:

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

Имеется единственная тонкость - некоторые символы, приведенные в расположенной ниже таблице, заменяются на особые атомы.

Символ в исходном атоме	Заменяющий символ
Двойная кавычка (")	&DQ
Точка (.)	&DT
Апостроф (')	&AP
Пробел	&BL
Обратный апостроф (`)	&BQ

Вот примеры вызова:

(explode 'explode)

==> (e x p L O d e)

(explode 1234)

==> (1 2 3 4)

(explode (fact 8))

==> (4 0 3 2 0)

(explode (/ 1 3))

==> (0 &DT 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3)

(explode "abc")

==> (&DQ a b c &DQ)

(explode 'abc)

==> (a b c)

Функция EXPT принимает два аргумента x и y и вычисляет выражение x^y. При этом действуют следующие соглашения:

  Если оба аргумента имеют тип FIXED и показатель степени (y) положителен, то результат будет иметь тип FIXED и соответствующий знак;

(^ 2 3)

==> 8     

(^ 2 100)

==> 1267650600228229401496703205376

(^ -2 100)

==> 1267650600228229401496703205376

(^ -2 101)

==>  -2535301200456458802993406410752

(^ 4 -2)

==> Попытка возведения числа FIXED в отрицательную степень

(^ 4.0 -2)

==>  0.0625

(^ 625.0 0.5)

==>  25.0

(^ 625.0 -0.5)

==>  0.04

(^ -625.0 -4)

==>  6.5536E-12

(^ -625.0 4)

==>  152587890625.0

(^ -625 4.0)

==> Попытка возведения отрицательного числа в вещ. степень

(^ -625 -4.0)

==> Попытка возведения отрицательного числа в вещ. степень

(^ -625.0 -4.0)

==> Попытка возведения отрицательного числа в вещ. степень

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

(FIX 67)

==> 67

(FIX -6.6)

==> -7

(FIX '(1 2 3))

Aргумент FIX - не атом
==> ERRSTATE

(FIX (+ 1 2.5))

==> 4

Функция-предикат FIXEDP (у Лаврова и Силагадзе она называется FIXP) принимает один аргумент. Если значение аргумента имеет тип FIXED, функция возвращает T, в противном случае - Nil

(FIXEDP 67)

==> T

(FIXEDP (+ 5 9))

==> T

(FIXEDP '(1 2 3))

==> Nil

(FIXEDP (+ 1 2.5))

==> Nil

Функция FIX2BIT (отсутствующая у Лаврова и Силагадзе) принимает один аргумент, значение которого должно иметь тип FIXED. Если значение аргумента (как знаковое целое) может быть преобразовано к типу BITS (уместиться в 4 байта), то функция возвращает значение аргумента, как битовую константу. В противном случае выдается сообщение о невозможности преобразования.

(FIX2BIT 67)

==> &H43

(FIX2BIT -1)

==> &HFFFFFFFF

(FIX2BIT 123456789123456789)

==> Значение аргумента FIX2BIT за пределами допустимого диапазона

(FIX2BIT (+ 1 2 3 4.5))

==> Аргумент FIX2BIT - не имеет тип FIXED

Функция FIX2FLO (отсутствующая у Лаврова и Силагадзе) принимает один аргумент, значение которого должно иметь тип FIXED. Если значение аргумента не превышает по модулю 10³⁰⁰, функция преобразует значение аргумента к типу FLOAT. Если же значение аргумента превышает по модулю 10³⁰⁰, то выдается сообщение об ошибке (переполнение). Поскольку в HomeLisp диапазон значений данных типа FIXED значительно шире, чем типа FLOAT, то в процессе преобразования происходит потеря большего количества значащих цифр (остется 15). Вот несколько примеров:

(FIX2FLO 67)

==> 67.0

(FIX2FLO (fact 100))

==> 9.33262154439442E+157

(FIX2FLO (fact 200))

Переполнение при вызове FIX2FLO
==>  ERRSTATE

Функция FLO2FIX (отсутствующая у Лаврова и Силагадзе) принимает один аргумент, значение которого должно иметь тип FLOAT. Функция преобразует результат к типу FIXED. При этом дробное число округляется до ближайшего целого. Для чисел с большим десятичным порядком функция оставляет 15 значаших цифр значения аргумента и добавляет нужное количество нулей. Вот несколько примеров:

(FLO2FIX 67.6)

==> 68

(FLO2FIX (* 1000000.0 _pi))

==> 3141593

(FLO2FIX (FIX2FLO (FACT 100)))

==> 93326215443944200000000000000000000000000000000000
    00000000000000000000000000000000000000000000000000
    00000000000000000000000000000000000000000000000000
    00000000

Функция FLO2STR (отсутствующая у Лаврова и Силагадзе) принимает один аргумент, значение которого должно иметь тип FLOAT. Функция преобразует результат к типу STRING. Делается это очень просто - символьное изображение числа заключается в двойные кавычки. Вот несколько примеров:

(flo2str _Pi)

==> "3.14159265358979323846"

(flo2str (sin _pi))

==> "1.22460635382238E-16"

(flo2str 1)

Аргумент FLO2STR не имеет тип FLOAT
==> ERRSTATE

(flo2str 1.0)

==> "1.0"

(flo2str 6.02E+23)

==> "6.02E+23"

Функция-предикат FLOATP (отсутствующая у Лаврова и Силагадзе) принимает один аргумент. Если значение аргумента имеет тип FLOAT, функция возвращает T, в противном случае - Nil Вот набор примеров вызова FLOATP:

(FLOATP 67)

==> Nil

(FLOATP 67.0)

==> T

(FLOATP (+ 5 9))

==> Nil

(FLOATP (+ 5.0 9))

==> T

(FLOATP '(1 2 3))

==> Nil

Функция FORMAT (отсутствующая у Лаврова и Силагадзе) принимает два аргумента. Первый аргумент должен быть числового типа (FIXED или FLOAT). Второй аргумент должен иметь строковый тип. Функция преобразует значение первого аргумента в строку символов, используя значение второго аргумента как строку формата. Строка формата может содержать следующие символы:

(format 6000.06 "######0.00")

==>  "6000.06"

(format 6000.06 "000000.00")

==>  "006000.06"

(format 6000.06 "0.00E+")

==>  "6.00E+3"

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

(funcall 'times 1 2 3 4 5)

==>  120

(setq sum 'Plus)

==>  PLUS

(funcall sum 1 2 3 4)

==>  10

(funcall (car '(plus difference times divide)) 66 55) 

==>  121

(funcall (cadr '(plus difference times divide)) 66 55) 

==>  11

(funcall (caddr '(plus difference times divide)) 66 55) 

==>  3630

(setq cons 'divide)

==>  DIVIDE

(funcall cons 2 3)

==>  0.666666666666667

(funcall 'cons 2 3)

==>  (2 . 3)

(funcall '(lambda (x y) (+ (* x x) (* y y))) 3 4)

==>  25

Конструкция FUNCTION предназначена для задания т.н. функционального аргумента. Следует отметить, что эта конструкция имеет существенные отличия в разных редакциях ядра HomeLisp. Далее сначала описывается применение FUNCTION в 11-й редакции ядра, а затем - применение FUNCTION в 13-й редакции ядра HomeLisp.

Конструкция в 11-й редакции ядра HomeLisp

Пусть читатель обратит внимание на термин "конструкция" - хотя слово FUNCTION употребляется в виде (FUNCTION имя_функционального_аргумента), эта запись лишь внешне напоминает лисповский вызов функции с одним аргументом. Цель описываемой конструкции состоит не в вычислении.

Чтобы понять назначение описываемой конструкции, рассмотрим функцию:

(defun Calc (f x) (f x) )

Эта функция имеет два аргумента: первый аргумент - имя функции, второй - произвольный список. Она вызывает из своего тела функцию, имя которой задано первым аргументом, а список параметров - вторым.

Аргумент, c которым при вызове связывается функция, а не переменная, называется функциональным. А функция, использующая функциональные аргументы, называется функционалом. Таким образом, Calc - функционал.

Попробуем вызвать этот функционал так: (Calc Car '(1 2 3)). Казалось бы этот вызов должен преобразоваться в вызов (Car '(1 2 3)) и, естественно, дать в результате 1. Однако результат будет обескураживающим:

(calc car '(1 2 3))

==> Символ "CAR" не имеет значения (не связан).

(calc (function car) '(1 2 3))

==> 1

(calc (function cdr) '(1 2 3))

==> (2 3)

(calc 'car '(1 2 3))

==> 1

(calc 'cdr '(1 2 3))

==> (2 3)

(defun f1 (x) (cond ((null x) y) (t x)))

==> f1

(setq y -111)

==> -111

(defun calc (f x) (prog (y) 
                        (setq y 888) 
                        (print y) 
                        (terpri)
                        (return (f x))
                   )
)

==> calc

(Calc (function f1) nil)

 888

 ==>  -111

(Calc 'f1 nil)

 888

 ==>  888

..................... Ассоциативный список:
.....................
.....................  6  ->  (x)
.....................  5  ->  (NIL 1)
.....................  4  ->  (y . 888)
.....................  3  ->  (x)
.....................  2  ->  (f FUNARG f1 1)
.....................  1  ->  (y . -111)

...................  Ассоциативный список:
...................
...................  5  ->  (x)
...................  4  ->  (y . 888)
...................  3  ->  (x)
...................  2  ->  (f . f1)
...................  1  ->  (y . -111)

(defun calc (f x) (prog (Nil) 
                        (setq y 888) 
                        (print y) 
                        (terpri)
                        (return (f x))
                   )
)

==> calc

(Calc (function f1) nil)

 888

 ==>  888

(Calc 'f1 nil)

 888

 ==>  888

         

Функция GC вызывает т.н. уборку мусора. Мусор - это области памяти, которые заняты недоступными ядру Лиспа или бесполезными структурами. Ниже будет объяснено, что имеется в виду под недоступностью и бесполезностью. Если читатель не хочет вникать в суть этих (не слишком простых) вопросов, он может не читать дальше этот раздел и просто принять к сведению, что функция GC освобождает память, занятую мусором и обычно вызывается автоматически, но может быть вызвана и вручную (для чего предусмотрен пункт меню и соответствующая кнопка). При автоматическом вызове сборки мусора пользователь может задать граничный процент увеличения количества занятых ячеек памяти, по достижении которого сборка мусора будет включаться автоматически. По умолчанию это 35% (число достаточно произвольное). Если после выполнения очередной команды пользователя количество атомов в системе увеличится на 35 или более процентов, то после завершения команды и вывода результата будет автоматически вызвана сборка мусора.

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

Любой список (или точечная пара) в конечном итоге состоит из атомов. Каждому атому соответствует особый объект - информационная ячейка атома. Свойства атома HomeLisp (важнейшим из которых является его имя) реализованы как свойства объекта (поля). Создать атом - значит создать его информационную ячейку и занести в ее поля необходимую информацию. Далее мы будем употреблять понятия "атом" и "информационная ячейка атома" как синонимы.

Одних информационных ячеек атомов недостаточно для создания списков произвольной структуры. Ведь список это не просто неупорядоченная совокупность атомов. Для задания порядка соединения атомов в списке служат т.н. списочные ячейки. Списочная ячейка - это тоже объект, важнейшими свойствами которого являются два указателя. По историческим причинам они называются a-указатель и d-указатель. Эти указатели могут ссылаться на информационные ячейки атомов или другие списочные ячейки. Таким образом, при создании списков списочные ячейки играют роль коннекторов.

Для изображения списков обычно используется графическая нотация, в которой списочные ячейки изображаться прямоугольниками, разделенными пополам. Будем считать, что левая половинка прямоугольника содержит a-указатель, а правая - d-указатель. Стрелка, исходящая из соответствующей клетки, будет указывать на тот или иной объект (атом или списочную ячейку). При этом информационные ячейки атомов не рисуются; стрелки просто указывают на атом. Так, точечная пара (A . B) графически изображается так:

Внутренее строение точечной пары

Список (A B C D) устроен так:

Внутренее строение простого списка

А вот как изображается список более сложной структуры ( (A B) C D):

Внутренее строение сложного списка

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

Так изображают список, содержащий одинаковые атомы.

более правильно изображать этот список так:

Информационная ячейка создается один раз. Все последующие ссылки выполняются на один и тот же атом.

Информационные ячейки атомов объединены в коллекцию - список объектов. В списке объектов располагаются все атомы Лиспа. После запуска программы в списке объектов располагаются "стандартные" атомы - Nil (этот атом обычно бывает первым в списке), T, а также все индикаторы (APVAL, FIXED, FLOAT, STRING, BITS ), имена всех встроенных функций (PLUS, DIFFERENCE и т.д.), и ряд служебных атомов. Кроме того, в списке объектов располагаются имена Лисп-констант и ссылки на их значения. Информационная ячейка атома (в системе HomeLisp) устроена заметно сложнее списочной ячейки. Информационная ячейка включает поле имени атома, поле стандартных флагов, поле ссылки на определяющее выражение, поле ссылки на список дополнительных свойств (а также еще ряд дополнительных полей). Схематично информационную ячейку можно изобразить так:

Внутреннее строение информационной ячейки

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

Флаг	Битовый индикатор
SUBR	0000000000000001
FSUBR	0000000000000010
EXPR	0000000000000100
FEXPR	0000000000001000
APVAL	0000000000010000
FIXED	0000000000100000
BITS	0000000001000000
STRING	0000000010000000
FLOAT	0000000100000000
MACRO	0000001000000000
WINDOW	0000010000000000
FILE	0000100000000000
BLOB	0001000000000000
COM	0010000000000000
DIALOG	0100000000000000
CONTROL	1000000000000000

Шесть последних флагов используются для объектов, которые не являются лисповскими объектами, а служат для работы с графикой (GRAPHIC WINDOW), файлами (FILE), большими двоичными объектами (BLOB), ActiveX-компонентами (COM), диалогов (DIALOG) и элементов управления (CONTROL). Все эти средства HomeLisp описываются в соответствующих разделах руководства.

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

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

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

При обработке S-выражения (defun квадрат (x) (* x x)) в списке объектов будет создан атом квадрат; у этого атома будет установлен флаг EXPR. Кроме того, будет построен список ((x)(TIMES x x)) и ссылка на этот список будет занесена в поле "определяющее выражение" информационной ячейки атома "квадрат". В памяти все это займет вот такую конфигурацию:

Внутреннее представление функции

Другой важнейшей внутренней структурой Лиспа помимо списка объектов является ассоциативный список, состоящий из пар (имя . значение). Имя - это имя переменной, создаваемой вызовами SET/SETQ. Значение - это произвольное S-выражение. Если, например, пользователь выполнил команду:

(Setq A '((B C) D E)) ==> ((B C) D E)

то в ассоциативный список будет добавлена пара (A . ((B C) D E)) (совпадающая, разумеется, со списком (A (B C) D E). В графической нотации это будет выглядеть так:

Вершина ассоциативного списка после вызова (Setq A '((B C) D E))

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

(setq a1 '(a b c)) ==> (a b c) (setq a1 1) ==> 1

После выполнения первой из приведенных выше команд произойдет следующее:

- в списке объектов образуется три новых атома - a, b и c;

- в области списочной памяти образуется список (a b c);

- в ассоциативном списке образуется пара a1 . ссылка на список (a b c)

После выполнения второй команды в списке объектов возникнет атом 1 (если его там не было), а пара a1 . ссылка на список (a b c) будет заменена парой a1 . ссылка на атом 1. А куда же делся список (a b c)? Он располагается на том же месте, что и после выполнения первой команды, но теперь недоступен, поскольку имя a1 связано с атомом 1.

Подобные структуры, которые занимают память, но недоступны, называют мусором.

Все сказанное можно проиллюстрировать рисунками:

Результат вычисления (setq a1 '(a b c))

Результат вычисления (setq a1 1). Список (a b c) стал мусором.

При длительной работе мусор может занять значительную область памяти или даже всю свободную память, что сделает дальнейшую работу невозможной.

Здесь нужно обратить внимание на одну особенность реализации системы HomeLisp: атомы и списочные ячейки являются объектами языка реализации (Visual Basic 6.0). Те, кто знаком с ООП-средствами языка Visual Basic, знают, что объект автоматически уничтожается, когда унитожается последняя ссылка на этот объект. Отсюда следует, что в приведенном выше случае, список (a b c d) будет автоматически уничтожен: уничтожение ссылки на первый элемент вызовет уничтожение первого элемента списка (ссылки на атом a и ссылки на подсписок (b c d)) вызовет уничтожение второго элемента (b) и т.д. Все это немного напоминает "эффект домино".

Так может быть, никаких специальных средств для утилизации мусора придумывать и не нужно? К сожалению, не все так просто... Использование функций rplaca и rplacd позволяет создавать циклические списки. Циклический список невозможно распечатать (печать займет бесконечное время) и его невозможно изобразить в скобочной или точечной нотации (по этой же причине). Однако его можно создать и нарисовать, используя стрелки. Ниже приводится внутренняя структура линейного и циклического списков:

Внутренее строение линейного списка

Внутренее строение циклического списка

Красной стрелка на обоих рисунках обозначена ссылка из ассоциативного списка.

Теперь ясно, что если уничтожается связь, обозначенная красной стрелкой, на верхнем рисунке, то будет унитожена первая списковая ячейка. Это приведет к удалению ссылки на вторую ячейку. Поскольку это единственная ссылка на вторую ячейку, то будет уничтожена и вторая ячейка и т.д. - "косточки домино" обрушатся полностью. Все списковые ячейки будут уничтожены. Следует обратить внимание на то, что уничтожатся только списковые ячейки (на рисунке это прямоугольники, разделенные пополам). Атомы a, b, c и d никуда не денутся; они останутся в списке объектов.

Если же уничтожается связь, обозначенная красной стрелкой, на нижнем рисунке, то вообще ничего не произойдет - ведь на первую списковую ячейку имеется две ссылки (красная стрелка и ссылка от последней списковой ячейки). Уничтожив первую ссылку мы ничего не добьемся - вторая ссылка не позволит первой ячейке самоуничтожться. "Косточки домино" устоят. При уничтожении ссылки на циклический список возникает мусор!

Эта ситуация демонстрируется на врезке, приводмой ниже:

(setq L '(a b c)) ==> (a b c) (setq L nil) ==> NIL (gc) Утилизировано ячеек: 0; атомов: 0. (setq L '(a b c)) ==> (a b c) (setq L (rplacd (cdr (cdr L)) L)) ==> (c a b c a b c a b c a b c a b c a b c a b c a b c a b c a b c a b c a b c a b c a b c a b c a b c a b c a b c a b c a b c a b c a b c a b c a b c a b c a b c a b c a b c a b c . ...) (setq L nil) ==> NIL (gc) Утилизировано ячеек: 3; атомов: 0.

Здесь создается линейный список (a b c), и присваивается переменой L. Потом переменной L присваивается значение Nil, и список (a b c) удаляется из памяти автоматически, - вызов функции GC не фиксирует наличие мусора. Затем линейный список (a b c) вновь создается и с помощью функции rplacd "закольцовывается". Видно, как HomeLisp пытается его распечатать. А затем переменной L присваивается значение Nil. Будь список линейным, он бы при этом уничтожился автоматически. Но, поскольку список циклический, он остается в памяти в виде мусора. И видно, что сборщик мусора нашел три списковые ячейки.

Мусор может образоваться и в списке объектов. Убедиться в этом совсем просто. Предположим, пользователь ввел команду и получил соответствующий ответ:

(+ 111 222 333 444) ==> 1110

Если атомы 111, 222, 333, 444 и 1110 (все или некоторые) не существовали, они будут созданы. Но ни одна из существующих списочных структур не ссылается на эти "свежесозданные" атомы. Таким образом, следует признать, что такие атомы хотя и доступны, но бесполезны - их можно удалять из списка объектов. Может показаться, что таких бесполезных атомов образуется немного. Вычислим, однако, число 100!. (для этого есть функция fact, входящая в библиотеку дополнительных функциий). Можно убедиться, что после вычисления образуется 194 новых атома! Это происходит потому, что вычисление арифметических выражений в Лиспе принципиально отличается от вычисления в традиционных языках (Бэйсик, Си, Паскаль).

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

x=x+1

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

Аналогичный оператор в Лиспе запишется так:

(setq x (+ x 1))

Выполнение его пройдет в два этапа: сначала вычисляется (+ x 1); при этом результат будет равен атому 6. Этот атом занесется в список объектов. На втором этапе d-указатель ячейки ассоциативного списка, хранящей переменную x будет исправлен. Теперь этот указатель будет указывать на атом 6. Но атом 5 останется в списке объектов, - его оттуда никто не удалял. Если какое-либо из загруженных в память S-выражений ссылается на атом 5, то этот атом и не нужно удалять. А вот если ни одно из загруженных S-выражений не ссылается на атом 5, то этот атом становится мусором.

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

Осталось сказать несколько слов о том, как реализована уборка мусора. Реализация функции GC в системе HomeLisp выполнена несколько проще, чем описано в книге Лаврова и Силагадзе. Выполнение проходит в два этапа: сначала отмечаются все списочные ячейки и информационные ячейки атомов, входящие в какое-либо S-выражение, находящееся в памяти. Доступ к заголовкам S-выражений осуществляется через ассоциативный список и список объектов. Затем просматриваются все созданные списочные ячейки и информационные ячейки атомов и удаляются те из них, которые непомечены. Для отметки списочных и информационных ячеек, предусмотрены соответствующие флаги. Упрощение по сравнению с реализацией Лаврова и Силагадзе заключается в том, что, во-первых, процедура разметки сделана рекурсивной, и, во-вторых освобождаемую память не требуется собирать в пул свободной памяти (это делает менеджер памяти языка реализации - Visual Basic).

Функция GENSYM (реализованная только в 13-й редакции ядра) создает символ (атом), которого еще гарантировано нет в текущем состоянии Лисп-машины. Функция принимает один необязательный параметр строкового типа (префикс имени символа). Если параметр задан ("PPPP"), то будет построен символ PPPPnnn; если параметр опущен, то строится символ Gnnn. В обоих случаях nnn - число, обеспечивающее уникальность созданного символа.

Все сказанное иллюстрируется примерами:

(gensym) ==> g1 (gensym "q") ==> q2 (gensym "qwerty") ==> qwerty3 (gensym) ==> g4 (setq g5 2) ==> 2 Создана глобальная переменная g5 (gensym) ==> g6

Логика работы функции GENSYM вполне понятна - когда пользователь создал глобальную переменную g5, следующий вызов функции GENSYM вернул символ g6.

Функция GETD принимает единственный аргумент - имя функции и возвращает тело этой функции. Если запрашивается тело функции, отсутствующей в системе, то функция GETD возвращает Nil:

(getd fact)

 ==>  (EXPR (x)(COND
                    ((MINUSP x) ERRSTATE)
                    ((EQ x 0) 1)
                    ((EQ x 1) 1)
                    (T (TIMES x (fact (DIFFERENCE x 1))))))

(getd чушь)

 ==>  NIL

Функция GETEL (отсутствующая у Лаврова и Силагадзе) принимает два аргумента. Значением первого аргумента должен быть непустой список, а значением второго - число типа FIXED. Функция возвращает элемент списка (заданого значением первого аргумента) с номером, равным значению второго аргумента. Если значение второго аргумента неположительно - возбуждается состояние ошибки с соответствующей диагностикой. Если значение второго аргумента выводит за пределы списка, заданого значением первого аргумента, то функция возвращает атом OutOfRange.

Все это продемонстрировано ниже:

(getel '(a b c) 2)

==> b

(getel '(a b (c d e f)) 3)

==> (c d e f)

(getel '(a b (c d e f)) 4)

==> OutOfRange

(getel '(a b (c d e f)) -6)

GETEL: Значение номера элемента неположительно
==> ERRSTATE

Функция GEVAL по своему действию полностью аналогична функции EVAL. Отличие заключается в вычислении значений переменных, входящих в S-выражение, являющееся аргументом. Если функция GEVAL вызвана в теле PROG-конструкции с локальными переменными, и какие-либо из локальных переменных входят в аргумент GEVAL, то в ассоциативном списке ищется одноименная переменная не входящая в список локальных. Если такая переменная найдена - используется ее значение. Если свобдная переменная не найдена - возбуждается состояние ошибки. Другими словами, функция GEVAL не видит локальных переменных (вычисляется в глобальном контексте). Более подробно поведение функции GEVAL рассматривается в разделе, посвященному контексту вычислений.

На приведенной ниже врезке показана разница в поведении функций EVAL и GEVAL:

(setq z 11111)

==> 11111

(defun f1 (n) (prog (z) (setq z 22222) (return (eval n))))

==> f1

(f1 'z)

==> 22222

(defun f2 (n) (prog (z) (setq z 22222) (return (geval n))))

==> f2

(f2 'z)

==> 11111

(unset 'z)

==> 0

(f1 'z)

==> 22222

(f2 'z)

Символ не имеет значения (не связан).
==> ERRSTATE

Функция GO принимает единственный аргумент - атом-метку. После чего управление передается оператору, следующему за заданной меткой. Эта функция может применяться только внутри конструкции PROG. Попытка вызвать функцию GO вне PROG порождает ошибку. Более подробно функция GO будет рассмотрена в разделе, посвященном конструкции PROG.

Функция-предикат GREATERP принимает два аргумента числового типа. Если значение первого аргумента больше значения второго, то функция возвращает T, в противном случае функция возвращает Nil. Примеры вызова GREATERP приводятся ниже:

(greaterp 777.0 999.0)

 ==>  NIL

(greaterp 999.0 777.0)

 ==>  T

(greaterp 999 777)

 ==>  T

(greaterp 777 999)

 ==>  NIL 

Функция-предикат GREQP принимает два аргумента типа FIXED или FLOAT. Если значение первого аргумента больше или равно значению второго, то функция возвращает T, в противном случае функция возвращает Nil. Примеры вызова GREQP приводятся ниже:

(greqp 111 222)


 ==>  NIL

(greqp 222 111)


 ==>  T

(greqp 111 111)


 ==>  T

(greqp 222 111.0)

 ==>  T

Функция GSET ведет себя аналогично функции SET, но не действует на значения локальных PROG-переменных (работает в глобальном контексте). Если глобальной переменной, заданной значением аргумента GSET не существует, то переменная будет создана. При вызове вне PROG-конструкции GSET эквивалентна обычной SET. Другими словами, функция GSET вычисляется в глобальном контексте.

Более подробно поведение функции GSET рассматривается в разделе, посвященному контексту вычислений, а ниже приведен пример, поясняющий разницу в поведении функций SET и GSET:

(prog (z) (set 'z 1111) (print z) (return z)) 
1111
==> 1111

z

Символ z не имеет значения (не связан).
==> ERRSTATE

(prog (z) (gset 'z 1111) (print z) (return z)) 
NIL
==> NIL

z

==> 1111

Функция IF, реализованная только в 13-й редакции ядра HomeLisp и принадлежащая к классу FSUBR, принимает два обязательных параметра и один необязательный. Все параметры должны быть формами. Работа функции заключается в том, что сначала вычисляется значение первого параметра. Если результат отличен от Nil, то вычисляется второй параметр и функция возвращает результат вычисления. Если же значение первого параметра есть Nil, то вычисляется значение третьего параметра (при его наличии) и результат возвращается в качестве результата. Если же третий параметр не задан, а значение первого параметра есть Nil, то функция IF вернет Nil.

Легко видеть, что программная логика вычисления IF в точности соответствует программной логике классического оператора IF (в его краткой или полной форме)

IF (...) Then Полная форма ... Else ... End if или IF (...) Then Краткая форма ... End if

без "синтаксического сахара" (Then, Else, End if). Естественно, вызовы функции IF могут быть вложены.

Примеры:

(let ((x 111)) (if (= 0 (% x 2)) 'Четное 'Нечетное)) ==> Нечетное (let ((x 222)) (if (= 0 (% x 2)) 'Четное 'Нечетное)) ==> Четное (let ((x 333)) (if (= 0 (% x 2)) 'Четное )) ==> NIL

В последнем случае использована краткая форма вызова IF.

Функция IMPLODE, реализованная только в 13-й редакции ядра HomeLisp и принадлежащая к классу SUBR, принимает единственный обязательный параметр - список, состоящий из атомов. Функция "сжимает" все элементы списка и возвращает получившийся символ (атом).

Функция является в некотором смысле обратной по отношению к функции EXPLODE. Особые атомы (&DT,&DQ, &AP, &BL и &BQ) функция при "сжатии" заменяет на точку, двойные кавычки, апостроф, пробел и обратный апостроф соответственно.

Примеры:

(implode '(a b c)) ==> abc (implode '(a b &bl c)) IMPLODE: Попытка внести пробел в имя атома ==> ERRSTATE (implode '(&dq a b &bl c &dq)) ==> "ab c" (implode '(a b &dt c)) ==> ab.c

Видно, что функция IMPLODE не позволит занести пробел в имя атома (при условии, что этот атом - не строка).

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

Конструкция LAMBDA позволяет задавать т.н. безымянные функции. LAMBDA не является функцией - если посмотреть список свойств атома LAMBDA, то можно убедиться, что список включает единственный стандартный флаг APVAL (а, скажем, у CAR в списке свойств будет флаг SUBR). Безымянная функция представляет собой следующую конструкцию:

((lambda (x) (* x x)) 6)

==> 36

((lambda (x) (* x x)) 6 7)

==> Список значений и список переменных имеют разную длину

((lambda (x) 1234) 7)

==> 1234

Функция LEFTSHIFT принимает два аргумента. Первый аргумент должен иметь тип BITS, т.е. быть 32-х битовой логической шкалой. Второй аргумент должен иметь тип FIXED. Функция возвращает значение первого аргумента, сдвинутое влево или вправо на количество разрядов, равное модулю значения второго аргумента. При этом, если значение второго аргумента положительно, сдвиг происходит влево. При отрицательном значении второго аргумента сдвиг происходит вправо. При сдвиге влево освободившиеся разряды заполняются нулями. При сдвиге вправо в освободившиеся разряды заносится самый старший разряд.

Примеры вызова LEFTSHIFT приводятся ниже:

(leftshift &h77 3)


 ==>  &H3B8

(leftshift &h77 -3)


 ==>  &HE

(leftshift &hEEEEEEEE -3)

 ==>  &HFDDDDDDD

Функция-предикат LESSP принимает два аргумента числового типа и возвращает T если значение первого аргумента меньше значения второго. В противном случае возвращается Nil. LESSP допускает аргументы типа FIXED и FLOAT. Примеры вызова LESSP приводятся ниже:

(lessp 1 2)

 ==>  T

(lessp 2 1)

 ==>  NIL

(lessp 2.0 1)

 ==>  NIL

(lessp 2.0 1.0)

 ==>  NIL

(lessp 1.0 2.0)

 ==>  T

Функции LET/LET* (типа FSUBR), реализованные только в 13-й редакции ядра, предназначены для управления лексическим контекстом (создания локальных переменных). Функции имеют следующую синтаксическую форму:

(LET/LET* (список переменых) форма₁ форма₂ … форма_n)

Список переменных является списком, состоящим из духэлементных списков (имя форма_вычисления_значения). Функция вычисляется следующим образом: создается новый лексический контекст и в него заносятся переменые из списка переменных, значения которых вычисляются.

Если LET вычисляется в непустом лексическом контексте, переменные из списка переменных заносятся в начало нового контекста.

Далее последовательно вычисляются формы форма₁, форма₂ … форма_n. Вычисления происходят в созданном лексическом контексте. Результат вычисления последней формы возвращается как результат LET, а лексический контекст вычислений восстанавливается.

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

Примеры:

(let ((a 111) (b 222)) (printline a) (printline b)) 111 222 ==> 222 a Assoc: Символ a не имеет значения (не связан). ==> ERRSTATE b Assoc: Символ b не имеет значения (не связан). ==> ERRSTATE

Здесь созданы две локальные переменные, доступные в теле LET. Попытка получения этих переменных вне контекста их определения вызывает ошибку.

Еще пример:

(let ((a 111) (b (* a 222))) (printline a) (printline b)) Внутри LET: Символ a не имеет значения (не связан). ==> ERRSTATE (let* ((a 111) (b (* a 222))) (printline a) (printline b)) 111 24642 ==> 24642

Первый вызов завершается ошибкой, поскольку при вычислении локальной переменной b требуется значение переменной a, а оно еще не доступно. Если же вместо LET использовать LET*, то значение переменной a будет доступно и вычисления завершаются предсказуемым результатом.

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

(setq a 333) ==> 333 Создана глобальная переменная a (let ((a 111) (b (* a 222))) (printline a) (printline b)) 111 73926 ==> 73926

Понятно, почему это происходит: при вычислении формы (* a 222) будет использовано не значение локальной переменной (оно еще не доступно), а значение глобальной переменной a.

Вызовы LET могут быть вложенными. Вот пример вложенных вызовов LET:

(let ((a 111) (b 222)) (printline (context)) (let ((a 333) (c (* 2 a))) (printline (context)) 'ok ) ) (((b 222) (a 111)) NIL) (((c 222) (a 333) (b 222) (a 111)) NIL) ==> ok

При первом вызове создается контекст из двух переменных a и b со значениями 111 и 222 соответственно. Этот контекст печатается. Далее вызывается внутренняя LET и к текщему контексту в начало добавляется переменная а со значением 333 и переменная с со значением, равным 2*a, но берется значение из внешего LET (оно доступно). После чего снова печатается текущий контекст. Кстати, все сказанное означает, что во внутреннем LET значением a будет 333, а не 111 (при вычислении значений контекст просматривается от начала к концу и сначала попадется значение 333.

Лексические замыкания 1.

Функции LET и LET* позволяют строить лексические замыкания, рассматриваемые ниже. Лексическое замыкание (или просто замыкание) это определение функции с зафиксированными связями свободных переменных. Замыкание можно построить, если вызвать функцию DEFUN или SEXPR в контексте, созданным вызовом LET:

(let ((c 0)) (defun next nil (setq c (add1 c)))) ==> next (next) ==> 1 (next) ==> 2 (context 'next) ==> ((c 2))

Здесь у функции next переменная c является свободной. Если бы определение функции next вводилось на верхнем уровне и отсутствовала бы глобальная переменная c, то функция была бесполезной: при вызове возникала бы ошибка при вычислении (add1 c). В приведенном же выше случае переменная c входит в лексический контекст, который запоминается в предназначенном для этого поле информационной ячейки атома next. Каждый вызов next увеличивает значение докальной переменной с на единицу и возвращает значение этой переменной. Подобная конструкция называется генератором. Созданный выше генератор позволяет только "шагать вперед" (нет возможности сбросить значение внутренней переменной). Чтобы обеспечить такую возможность, нужно определить функцию сброса в том же контексте, что и функцию next:

(let ((c 0)) (defun next nil (setq c (add1 c))) (defun reset nil (setq c 0)) ) ==> reset (next) ==> 1 (next) ==> 2 (next) ==> 3 (reset) ==> 0 (next) ==> 1 (eql (context 'next) (context 'reset)) ==> T

Здесь создано два замыкания - next и reset, причем, лексический контекст у них общий. Это приводит к тому, что обнуление переменной c при вызове reset заставляет next считать с нуля.

Функция LIST принимает произвольное число аргументов, строит из них список и возвращает его в качестве значения. Поскольку функция принадлежит к типу SUBR, ее аргументы вычисляются. Для предотвращения вычисления следует использовать квотирование. Примеры вызова LIST приводятся ниже:

(list 1 2 3)

 ==>  (1 2 3)

(list 1 2 (3 4))

 ==>  Не найдена функция 3

(list 1 2 '(3 4))

 ==> (1 2 (3 4))

Функция LOGAND принимает произвольное количество аргументов типа BITS и возвращает их логическое произведение. Логическое произведение - это битовая операция AND, которой соответствует таблица истиности:

(logand &H11 &H22)

 ==>  &H0

(logand &H7734 &HFF00)

 ==>  &H7700

(leftshift (logand &H7734 &HFF00) -8)

 ==> &H77

Функция LOGOR принимает произвольное количество аргументов типа BITS и возвращает их логическую сумму. Логическая сумма - это битовая операция OR, которой соответствует таблица истиности:

(logor &H11 &H22)

 ==>  &H33

(logor &H7734 &HFF00)

 ==>  &HFF34

(leftshift (logor &H7734 &HFF00) -8)

 ==> &HFF

Функция LOGXOR принимает произвольное количество аргументов типа BITS и возвращает их побитовое отрицание равнозначности - результат битовой операции XOR, которой соответствует таблица истиности:

(logxor &H11 &H22)

 ==>  &H33

(logxor &H7734 &HFF00)

 ==>  &H8834

(leftshift (logxor &H6634 &HFF00) 8)

 ==> &H993400

Фунция LOOP (типа FSUBR) отсутствует в реализации Лаврова и Силагадзе. В HomeLisp она реализована только в 13-м ядре. Это простейшая функция организации циклов - она организует бесконечный цикл (тело которого может составлять из произвольного числа форм). Цикл прерывается вызовом RETURN. Контроль числа повторений и выход из цикла - обязанность программиста. Пример:

(let ((i 0)) (loop (setq i (add1 i)) (printline i) (if (>= i 23) (return 'ok) nil) ) ) 1 2 3 … 22 23 ==> ok

Функция MACROEXPAND предназначена для генерация промежуточного S-выражения, являющегося результатом макрорасширения (первого этапа выполнения) функции типа MACRO. Такие функции вычисляются в два этапа: на первом этапе строится S-выражение, которое вычисляется на втором этапе (передается на вход EVAL). Функция MACROEXPAND, позволяющая увидеть это промежуточное S-выражение, ожидает на входе список переменной длины, первым элементом которого является атом - имя тестируемой функции типа MACRO, а последующими элементами - параметры тестируемой функции.
Если, например, есть макро-функция MF, требующая на входе список из двух элементов, то, чтобы увидеть промежуточное S-выражение, возникающее при вызове (MF a1 a2), следует задать (macroexpand MF a1 a2).

Рассмотрим (следуя замечательному двухтомнику Э. Хювенен и И. Сеппянен [6]), следующую макро-функцию:

(smacro setqq 
              (lambda  
                 (x y)
                 (list 'setq x (list 'quote y))
              )
)

(setqq x (1 2 3))

 ==>  (1 2 3)

x

 ==>  (1 2 3)

(macroexpand setqq x (1 2 3))

 ==>  (SETQ x (QUOTE (1 2 3)))

Функция MAX в HomeLisp принимает произвольное число аргументов типа FIXED или FLOAT и возвращает максимальное значение из значений всех аргументов. Если все аргументы имеют тип FIXED, то и результат будет иметь тип FIXED. Если среди аргументов есть хоть один типа FLOAT, то и результат будет иметь тип FLOAT. Все сказанное можно проиллюстрировать следующим:

(max 1 2 34 88 4 5)

 ==>  88

(proplist (max 1 2 34 88 4 5))

 ==>  (FIXED)

(max 1 2 34 88 4 5.0)

 ==>  88.0

(proplist (max 1 2 34 88 4 5.0))

 ==>  (FLOAT)

Функция MIN в HomeLisp принимает произвольное число аргументов типа FIXED или FLOAT и возвращает минимальное значение из значений всех аргументов. Если все аргументы имеют тип FIXED, то и результат будет иметь тип FIXED. Если среди аргументов есть хоть один типа FLOAT, то и результат будет иметь тип FLOAT. Все сказанное можно проиллюстрировать следующим:

(min 88 2 34 1 4 5)

 ==>  1

(proplist (min 88 2 34 1 4 5))

 ==>  (FIXED)

(min 88 2 34 1 4 5.0)

 ==>  1.0

(proplist (min 88 2 34 1 4 5.0))

 ==>  (FLOAT)

Функция MINUS ожидает ровно один аргумент типа FIXED или FLOAT и возвращает значение этого аргумента с противоположным знаком. Тип результата совпадает с типом аргумента. Примеры приводятся ниже.

(minus 6)

 ==>  -6

(proplist (minus 6))

 ==>  (FIXED)

(minus 5.0)

 ==>  -5.0

(proplist (minus 5.0))

 ==>  (FLOAT)

Функция-предикат MINUSP ожидает ровно один аргумент типа FIXED или FLOAT и возвращает T, если значение этого аргумента отрицательно. В противном случае функция возвращает Nil. Примеры приводятся ниже.

(minusp 6)

 ==>  Nil

(minusp 0)

 ==>  Nil

(minusp -5)

 ==>  T

(minusp -5.0)

 ==>  T

Конструкция NLAMBDA (реализованная только в 13-й редакции ядра), порождает анонимную функцию, но отличается от конструкции LAMBDA ) двумя моментами:

аргументы NLAMBDA не вычисляются;

NLAMBDA не порождает замыканий.

((nlambda (x y) (list x y)) (1 2 3) (4 5 6)) ==> ((1 2 3) (4 5 6)) (nlambda (x y) (list x y)) EVFUN: Не найдена функция NLAMBDA ==> ERRSTATE (lambda (x y) (list x y)) ==> (CLOSURE (x y) ((LIST x y)) NIL)

Первый запуск показыает, что NLAMBDA задает анонимную функцию с невычисляемыми при вызове аргументами. Второй вызов, показывает, что NLAMBDA не порождает замыканий (в отличие от LAMBDA).

Две функции NOT и NULL выполняют одно и то же: если их единственный аргумент есть Nil, функции возвращают T; в противном случае возвращается Nil:

(not 6)

 ==>  Nil

(not Nil)

 ==>  T

(Null 'a)

 ==>  Nil

(Null Nil)

 ==>  T

Функция-предикат NUMBERP проверяет, является значение ее единственного аргумента числом (FIXED или FLOAT); в этом случае возвращается T. В противном случае возвращается Nil:

(numberp 111)

 ==>  T

(numberp 'a)

 ==>  Nil

(numberp (+ 6 7))

 ==>  T

Функция-предикат ONEP проверяет, является значение ее единственного аргумента типа FIXED атомом 1; в этом случае возвращается T. В противном случае возвращается Nil. При попытке обратиться к предикату с аргументом, имеющим тип, отличный от FIXED, возникает ошибка. Вот примеры:

(onep 1)

 ==>  T

(onep 2)

 ==>  Nil

(onep 1.0)

 ==>  Аргумент ONEP не число FIXED

(onep (+ 1 0))

 ==>  T

Функция OR класса FSUBR принимает произвольное число аргументов. В процессе вычисления первый же же аргумент, имеющий значение, отличное от Nil, вызывает прекращение вычисления, и возвращается в качестве значения функции. Если значение всех аргументов функции равно Nil, то функция принимает значение Nil. Примеры:

(OR 1 2 3)

==> 1

(or (CAR '(1)) (/ 3 0))

==> 1

Функция PARSE, отсутствующая у Лаврова и Силагадзе, принимает единственный аргумент типа STRING, содержащий алгебраическое выражение в естественной нотации, а возвращет это же выражение, разбитое на лексемы (токены). Круглые скобки становятся структурными скобками результирующего S-выражения. Лексемами являются символические имена переменых, числовые константы и знаки алгебраических операций:

(parse "1+3")

 ==>  (1 + 3)

(parse "(a+b)/(a-b)")

 ==>  ((a + b) / (a - b))

(parse "(a+b)\(a-b)")

 ==>  ((a + b) \ (a - b))

(parse "(a+b)%(a-b)")

 ==>  ((a + b) % (a - b))

(parse "a - c ^ 2")

 ==>  (a - c ^ 2)

(parse "(a plus (d difference e)")

Не сбалансированы скобки во входном выражении
==> ERRSTATE

(parse "(a plus (d difference e))")

==> ((a PLUS (d DIFFERENCE e)))

Функция PLUS,(вместо PLUS можно писать +) вычисляет сумму значений своих аргументов, которых может быть произвольное количество. Тип аргументов должен быть FIXED или FLOAT. При этом, если среди аргументов есть хотя бы один аргумент типа FLOAT, то и результат будет иметь тип FLOAT. Рассмотрим примеры:

(plus 1 3 5 7)

 ==>  16

(+ 1 2 3)

 ==>  6

(+ 1 2.0 3)

 ==>  6.0

Функция PRINT выводит значение своего единственного аргумента в область вывода. Функция выводит данные сплошным потоком символов - следующий вызов функции PRINT выводит свои данные вплотную к результатам предыдущего вызова функции PRINT. Для перехода на новую строку служит функция TERPRI. Данные типа STRING выводится с объемлющими двойными кавычками:

(print 'a)

a
 ==> a

(print (+ 7 8))

15
 ==>  15

(print "проба пера")

"проба пера"
 ==>  "проба пера"

Функции PRINTS и PRINTSLINE отличаются от функций PRINT и PRINTLINE только тем, что строки печатаются без объемлющих кавычек.

(print "a")

"a"

==> "a"

(prints "a")

a

==> "a"

(prints 56)

56

==>  56

Функция PROG введена в Лисп с целью обеспечить в декларативном функциональном языке возможности императивного программирования. Общая схема конструкции PROG такова:

(PROG (список локальных переменных)
 [метка] Оператор              
 [метка] Оператор
 [метка] Оператор
 ...     ...   
)

(setq a nil)

(setq b nil)

(setq c nil)

(defun sumOdd (x) (prog (i s n)

                        (setq s 0) 
       
                        (setq i 1)

                   L    (setq n (- (* 2 i) 1))
 
                        (setq s (+ s n))

                        (print n)

                        (terpri)

                        (setq i (+ i 1))

                        (cond ((greaterp i x) (return s)))
                         
                        (go L)

                    )
)

(sumOdd 6)

1
3
5
7
9
11

 ==>  36

(prog nil 

      A (print 'Начало) 

        (terpri) 

        (prog nil 

               (setq x 1) 

            A  (print x)

               (terpri)

               (setq x (+ 1 x))

               (cond ((lessp x 10) (go A)))
        )
)

Начало
 1
 2
 3
 4
 5
 6
 7
 8
 9

 ==>  NIL

(setq x 111)

==> 111

(prog (x) 

      (setq x -777)
      (print 'x=)
      (print x)
      (terpri) 
)

x=-777

==> Nil

x

==> 111

проба

==> Символ "проба" не имеет значения (не связан).

(prog (проба) 

      (setq проба -777)
      (print 'проба=)
      (print проба)
      (terpri) 
)


проба=-777

==>  NIL

проба

==> Символ "проба" не имеет значения (не связан).

(setq x 111)

==> 111

(prog nil 

      (setq x -777)
      (print 'x=)
      (print x)
      (terpri) 
)

x=-777

==> Nil

x

==> -777

Функции PROG1, PROG2 и PROGN отсутствуют у Лаврова и Силагадзе и реализованы только в 13-й редакции ядра. Все функции имеют тип FSUBR. Назначение этих функций состоит в последовательном вычислении своих аргументов. В качестве результата функция PROG1 возращает значение первого аргумента, функция PROG2 - первого аргумента, а функция PROGN - последнего аргумента.

Описываемая тройка функций отличается от функции PROG двумя моментами:

функции PROG1, PROG2 и PROGN не создают локальных переменных;

в теле функций PROG1, PROG2 и PROGN нельзя использовать функции GO и RETURN (функции задают последовательное вычисление аргументов).

Вот примеры, поясняющие все сказанное:

(let ((a 0) (b 0) (c 0)) (prog1 (setq a 111) (setq b 222) (setq c 333))) ==> 111 (let ((a 0) (b 0) (c 0)) (prog2 (setq a 111) (setq b 222) (setq c 333))) ==> 222 (let ((a 0) (b 0) (c 0)) (progn (setq a 111) (setq b 222) (setq c 333))) ==> 333

Красным выделены формы, значения которых возвращет соответствующая функция.

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

Здесь следует сказать несколько слов о том, что представляет собой список свойств. Понятие свойства является первичным. Наличие свойства означает наличие некоторого признака (или группы признаков). Например свойство "быть числом" или "быть целым числом". Свойства можно разделить на встроеные и создаваемые пользователем.
Свойства быть числом, битовой константой, функцией типа EXPR и т.д - встроенные. Когда в системе создается атом-константа (числовая или строковая) соответствующее свойство назначается ему автоматически. Когда создается переменная (вызовом SET/SETQ), то в случае, когда значение переменной есть числовая или строковая константа, соответствующее свойство назначается и переменой. То же самое имеет место, когда создается константа (вызовом CSETQ); в дополнение к типу константы добавляется еще свойство "быть константой (иметь определяющее выражение)".
Каждое свойство идентифицируется (обозначается) атомом - ведь в Лиспе нет ничего, кроме атомов и списков! Каждому встроенному свойству соответствует атом: BITS, FIXED, FLOAT, STRING, EXPR, FEXPR, MACRO, SUBR, FSUBR, APVAL. Если свойство описывает единственный признак двоичного толка (есть/нет), то какое свойство называется флагом. Если же свойство не является двоичным, то для его полного описания недостаточно одного атома: нужно обозначить наличие свойства и его значение. В этом случае атом-идентификатор свойства называется индикатором, а значением свойства может быть произвольное S-выражение.

Теперь можно объяснить, что представляет собой список свойств. Это список, существующий для каждого атома, и включающий все флаги, индикаторы и значения свойств. Пользователь может создавать свои (произвольные) свойства. Чтобы создать свойство, сначало нужно создать атом-идентификатор. А затем добавить его в список свойств (если это флаг) или добавить в список свойств этот атом-индикатор и S-выражение, задающее значение свойства. Разумеется, список свойств может быть и пустым. Функции, предназначенные для манипулирования индикаторами и флагами приводятся в описании библиотеки дополнительных функций. Из всех функций, обслуживающих список свойств, только две (PROPLIST и SPROPL) являются функциями типа SUBR; остальные реализованы на HomeLisp-е

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

Примеры работы с функцией PROPLIST:

(proplist 'h)

==> Nil

(proplist (+ 1 2))

==> (FIXED)

(setq h 111)

==> 111

(proplist 'h)

==> (FIXED)

(spropl 'h '(i1 (1 2 3) i2 (4 5 6) i3 (a b c d)))

==> (i1 (1 2 3) i2 (4 5 6) i3 (a b c d))

(proplist 'h)

==> (FIXED i1 (1 2 3) i2 (4 5 6) i3 (a b c d))

(getprop 'h 'i1)

==>  (1 2 3)

(getprop 'h 'i2)

==>  (4 5 6)

(getprop 'h 'i3)

==>  (a b c d)

(getprop 'h 'i4)

==>  NIL

(getprop 'h FIXED)

==>  FIXED

Функция PUTD (отсутствующая у Лаврова и Силагадзе) позволяет заменить тело функции новым. Функция PUTD не является необходимой, - всегда можно переопределить функцию, вызвав SEXPR/SFEXPR/DEFUN. Разработчик ввел функцию PUTD, руководствуясь только соображениями симметрии (есть GETD - пусть будет и PUTD!).

Как пользоваться функцией PUTD? Функция принадлежит классу FSUBR - ее аргументы не вычисляются. Первым аргументом функции должен быть атом-имя функции, тело которой будет изменено. Вторым параметром должен быть список, состоящий из двух списков: первый - новый список аргументов функции, второй - новое тело функции.

Примеры работы с функцией PUTD:

(defun f1 (x) (+ x x x))

==> f1

(f1 5 5 5)

==> 15

(proplist f1)

==> (EXPR)

(putd f1 ((x) (* x x x)))

==> ((x)(TIMES x x x))

(f1 5)

==> 125

(proplist f1)

==> (EXPR)

(putd f1 '((x y) (* x y)))

==>  ((x y)(TIMES x y))

(f1 6 7)

==>  42

(proplist f1)

==> (EXPR)

Функция PUTEL (отсутствующая у Лаврова и Силагадзе) позволяет заменить элемент списка, заданного значением первого аргумента другим значением. Функция ожидает три параметра: модифицируемый список, номер заменяемого элемента и новое значение заменяемого элемента. При успешном завершении функция возвращает модифицированный список. Если значение номера элемента превышает длину верхнего уровня списка, функция возвращает атом OutOfRange.

Вот примеры работы с функцией PUTEL:

(putEl '(a b c) 2 '(1 2 3))

==> (a (1 2 3) c)

(putEl '(a b c) 4 'd)

==> OutOfRange

(putEl '(a b c) -3 'f)

PUTEL: Значение номера элемента неположительно
==> ERRSTATE

(setq z '(1 2 3))

==> (1 2 3)

(putEl z 2 -2)

==> (1 -2 3)

Z

==> (1 -2 3)

Функция QUOTE - классическая (и, вероятно, самая странная для понимания новичка) функция Лиспа. Эта функция на самом деле не делает ничего, она просто блокирует вычисление своего единственного аргумента (который может быть любым мыслимым S-выражением). Название функции, вероятно, происходит от английского to quote - брать в кавычки. В классическом Лиспе вызов QUOTE записывается в виде (QUOTE нечто). В современных версиях Лиспа (и в HomeLisp) эта запись полностью эквивалентна записи 'нечто. Не следует путать апостроф с двойной кавычкой. Примеры работы с функцией QUOTE:

(setq a 777)

==> 777

a

==> 777

(quote a)

==> a

'a

==> a

''a

==> (QUOTE a)

(eval a)

==> 777

(eval 'a)

==> 777

(eval ''a)

==> a