Пратт Т. Языки программирования. Разработка и реализация

Подождите немного. Документ загружается.

617

Строка 6. LISP печатает имя функции SUMNEXT как результат выполнения

строк 3–5.

Строки 7–11. В этих строках определяется функция GetInput, имеющая два па

раметра: указатель входного файла f и количество элементов вектора, которое ос

талось прочитать, c. Это определение демонстрирует синтаксис функции defun, ис

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

define. Функция GetInput возвращает список значений прочитанных данных.

Строка 9. Функция cond сначала сравнивает счетчик c с нулем, и если он равен

нулю, возвращает пустой список.

Строка 10. Если счетчик не равен нулю, функция GetInput создает новый век

тор, читая атом из файла f и добавляя его в голову списка, возвращаемого после

рекурсивного вызова GetInput с параметрами f и счетчиком, уменьшенным на еди

ницу.

Строки 12–18. Здесь определяется основная управляющая функция програм

мы. Функция DoIt не имеет параметров.

Строка 13. Функция progn последовательно выполняет выражения строк 14–17.

Строка 14. Функция open открывает файл lisp.data и возвращает указатель на

файл. Функция setq присваивает этот указатель переменной infile. Последова

тельность действий следующая: вычисляется аргумент open, а затем осуществляет

ся присваивание переменной infile.

Строка 15. Вызывается функция GetInput (строки 8–10) с параметром infile,

который был определен в строке 14, и результатом выполнения функции read, ко

торый будет счетчиком количества элементов вектора, подлежащих суммирова

нию. Функция setq присваивает эти входные данные переменной array.

Строка 17. Входные данные (список array) передаются функции SumNext, опре

деленной в строках 3–5, которая возвращает сумму членов списка.

Строка 19. Вызывается функция DoIt.

Строки 20–24. Если файл lisp.data содержит следующие данные:

4 1 2 3 4

то в строках 20–23 представлен результат работы программы. В этом примере дваж

ды напечатано число 10 — один раз как результат выполнения функции print в стро

ке 17, второй раз как значение, возвращенное функцией DoIt.

П.6.1. Объекты данных

Элементарные типы данных

Элементарными типами объектов данных в языке LISP являются списки и атомы.

Определения функций и списки свойств являются специальными типами спис

ков особой важности. Во всех реализациях обычно также предусмотрены масси

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

Переменные и константы. В языке LISP атом является основным элементар

ным типом объектов данных. Атом иногда называют литеральным атомом (literal

atom), чтобы отличить от числа (numeric atom), которое большинством функций

языка LISP также классифицируется как атом. Синтаксически атом является иден

тификатором — это последовательность букв и цифр, начинающаяся с буквы. Для

П.6. LISP

618 Приложение. Обзоры языков

идентификаторов обычно не учитывается регистр задания букв. В определениях

функций языка LISP атомы выполняют обычную роль идентификаторов — они

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

ит.д.

Однако во время выполнения атомы языка LISP являются не просто иденти

фикаторами. Любой атом — это сложный объект данных, представленный обла

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

список свойств. Список свойств содержит различные свойства, ассоциированные

с атомом, одним из которых всегда является его печатное имя — символьная стро

ка, представляющая атом при вводе и выводе. Другие свойства представляют со

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

нем, соответствующим имени атома, и другие свойства, назначаемые программой

во время выполнения.

Когда бы атом ни появлялся в качестве компонента другого объекта данных,

например списка, он представляется указателем на область памяти, служащим пред

ставлением этого атома во время выполнения. Таким образом, любая ссылка на

атом ABC во время выполнения программы LISP представлена указателем на эту

область памяти.

Каждый атом также обыкновенно появляется как компонент в определяемой

системой центральной таблице, называемой списком объектов (ob_list). Таблица

ob_list обычно организуется как хэштаблица, которая позволяет осуществлять

эффективный поиск печатного имени (символьной строки) и получать значение

указателя на атом с этим печатным именем. Например, когда вводится список и оче

редной элемент является символьной строкой "ABC", представляющей атом ABC,

функция read ищет в таблице ob_list элемент "ABC", который также содержит указа

тель на область памяти, где хранится атом ABC. Этот указатель вставляется в спи

сок, конструируемый в соответствующей точке.

Можно использовать числа (числовые атомы) в целом формате или формате

с плавающей точкой. Используется аппаратное представление, но требуется так

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

два слова. Однако это представление хорошо сочетается с представлением, исполь

зуемым для литеральных атомов; число — это атом, обозначенный как принадле

жащий специальному типу, с указателем на битовую строку, представляющую чис

ло, вместо указателя на список свойств.

Строки в языке LISP представляются обычными строками символов. Следует

знать, что одиночная кавычка (') интерпретируется как функция quote для лите

ральных (не вычисляемых) аргументов функции.

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

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

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

LISP, отличающийся только тем, что его элементы располагаются в чередующей

ся последовательности логическими парами èìÿ ñâîéñòâà/çíà÷åíèå ñâîéñòâà. Если

атом является именем функции, его список свойств содержит имя свойства, даю

щее тип функции, и указатель на список, представляющий собой определение функ

ции. Программист может добавлять другие требуемые свойства, некоторые эле

ментарные операции также могут добавлять свойства.

619

Структурированные типы данных

В большинстве реализаций языка LISP предусмотрены некоторые разновидности

таких объектов данных, как векторы или массивы. Однако в разных реализациях

эти объекты представлены весьма неодинаково, что объясняется сравнительно не

большой их значимостью для написания программ на языке LISP. Типичная реа

лизация содержит функцию mkvect(bound), которая создает векторный объект дан

ных с диапазоном изменения индексов от 0 до заданной границы bound. Каждый

компонент вектора может содержать указатель на любой объект данных LISP; из

начально значения указателей установлены равными nil. Функция getv(vector,

subscript)

возвращает указатель, хранящийся в указанном компоненте вектора

аргумента. Таким образом, функция getv является LISPверсией операции индек

сации для получения значения компонента вектора. Функция putv используется

для присвоения нового значения компоненту вектора.

Определяемые программистом функции пишутся в форме списков для ввода,

как видно из листинга П.8. Программы ввода в языке LISP не делают различий

между определениями функций и списками данных, а просто преобразуют все спи

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

ищется в таблице ob_list, и если атом уже существует, то возвращается указатель

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

Инициализация и присваивание. В отличие от других языков прямое присваи

вание не играет важной роли в программировании на языке LISP. Многие про

граммы на языке LISP написаны вообще без операций присваивания, а для до

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

параметров. Однако присваивание используется внутри сегментов prog, где про

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

Основной операцией присваивания является setq. Выражение (setq x val) при

сваивает переменной x новое значение val, причем результатом этого выражения

является величина val (таким образом, setq — это функция, но ее значение обычно

игнорируется). Элементарная операция set аналогична setq, за исключением того,

что переменная (а именно атом), которой присваивается значение, может быть

вычислена. Например, (set(car L) val) эквивалентно (setq x val), если атом x яв

ляется первым элементом списка L. Функции rplaca и rplacd позволяют присваи

вать значения соответственно полям car и cdr любого элемента списка. Например,

(rplaca L val) присвоит значение val в качестве первого элемента списка L, заме

стив текущий первый элемент.

П.6.2. Управление последовательностью

действий

LISP не делает различий между данными LISP и программами LISP. Этим объяс

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

рассматриваются в данной книге, выполнение программы на языке LISP интерес

но тем, что основной интерпретатор может быть описан на LISP. Функции apply

передается указатель на функцию, которую следует выполнить, и apply интерпре

тирует определение этой функции, используя вторую функцию eval для вычисле

ния каждого аргумента.

П.6. LISP

620 Приложение. Обзоры языков

Транслятор языка LISP — это просто функция read. Функция read сканирует

символьную строку из входного файла или с терминала, ища правильный иденти

фикатор или списковую структуру. Если найден одиночный идентификатор, функ

ция просматривает таблицу ob_list для получения указателя на соответствующий

атом (или для создания нового атома, если не найден атом с заданным печатным

именем). Если найдена списковая структура, начинающаяся с символа «(», то ска

нируется каждый элемент списка, пока не будет найден соответствующий символ

«(». Каждый элемент списка транслируется во внутреннюю форму, и в соответ

ствующем месте в список вставляется указатель car. Числа транслируются в их

двоичный эквивалент с дескриптором в отдельном слове. Если найден подсписок,

начинающийся с другого символа «(», то рекурсивно вызывается функция read

для построения внутреннего представления подсписка. Указатель на подсписок

вставляется как указатель car следующего компонента основного списка. Заме

тим, что этот процесс трансляции не зависит от того, является ли список определе

нием функции или списком данных; все списки обрабатываются одинаково.

Выполнение программы на языке LISP состоит из вычислений функций LISP.

Последовательность выполнения программы обычно задается последовательно

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

Выражения

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

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

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

выполняемых последовательностей в программе на языке LISP является услов

ное выражение. Его синтаксис следующий:

(cond âàðèàíò

âàðèàíò

...

âàðèàíò

(T âûðàæåíèå_ïî_óìîë÷àíèþ))

где каждый из перечисленных вариантов — это пара(ïðåäèêàò

, âûðàæåíèå

Функция cond выполняется путем последовательного вычисления каждого

ïðåäèêàòà

, и вычисления âûðàæåíèÿ

для первого предиката, вернувшего значение

èñòèíà (T). Если все предикаты ложны, то выполняется âûðàæåíèå_ïî_óìîë÷àíèþ.

Операции над атомами. Обычно операции над атомами включают: тестовую

функцию atom, которая распознает указатель на слово списка и указатель на атом

(путем проверки дескриптора слова), функцию numberp, которая проверяет, явля

ется ли атом литеральным или числовым, функцию eq, которая проверяет, явля

ются ли два литеральных атома одним и тем же атомом (простой проверкой того,

указывают ли оба ее аргумента на одну и ту же область памяти), функцию gensym,

генерирующую новый атом (и не помещающую его в таблицу ob_list), функцию

intern, помещающую атом в таблицу ob_list, и функцию remob, удаляющую атом из

таблицы ob_list.

Язык LISP содержит основные арифметические операции: +, –, *, / — и некото

рые другие. Их синтаксис такой же, как и у других операций языка LISP. Так,

A + B * C записывается как (+ A (* B C)). Все арифметические операции являют

621

ся общими операциями и принимают аргументы как целого, так и вещественного

типа и при необходимости осуществляют преобразование типов.

Операция сравнения zerop проверяет, не равен ли нулю ее аргумент, операции

greaterp и lessp представляют собой стандартные операции сравнения больше чем

и меньше чем. Результатом этих операций является либо атом nil, представляю

щий ëîæü, либо атом T, представляющий èñòèíó (любое значение, не равное nil, обыч

но представляет èñòèíó в языке LISP).

В языке LISP нет булева типа. Булевы операции and, or и not представлены в форме

функций. Операция and обрабатывает произвольный список не вычисленных аргу

ментов, вычисляя их все по очереди и возвращая значение nil, если один из ее аргу

ментов оказывается равным nil. Операция or работает подобным же образом.

Операции над списками. Элементарные операции car и cdr возвращают, соот

ветственно указатель car и указатель cdr заданного элемента списка. Если список L

является операндом этих операций, то (car L) возвращает указатель на первый

элемент этого списка, а (cdr L) возвращает указатель на список, из которого уда

лен первый элемент.

Элементарная операция cons получает в качестве операндов два указателя, от

водит для нового элемента списка слово памяти, сохраняет два указателя в car

и cdrполях слова и возвращает указатель на новое слово. Если второй операнд

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

указатель на расширенный список.

Элементарные операции car, cdr и cons являются основными операциями для

выборки компонентов списка и создания списков. С помощью операции cons мож

но элемент за элементом создать любой список. Например,

(cons A (cons B (cons C nil)))

создает список из трех элементов, на которые ссылаются как на A, B и C. Аналогично,

если L = (A B C) — список, то (car L) возвращает A, (car(cdr L)) — B, (car(cdr(cdr L))) — C.

Используя операции car, cdr и cons, любой список можно разбить на составные

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

Элементарную операцию list можно использовать в качестве замены длинных

последовательностей операций cons. Операция list получает любое количество ар

гументов и конструирует из них список, возвращая указатель на получившийся

список.

Операция quote позволяет записать в программе любой список или атом в виде

литерала, как описано в разделе 6.1.7.

Элементарная операция replaca используется для замены поля указателя car

в слове списка на новый указатель; replacd используется для замены указателя cdr.

Эти две операции следует использовать осторожно, поскольку они действительно

изменяют содержимое слова списка, а также возвращают значение, следователь

но, имеют побочные эффекты. Изза сложного способа связывания списков в LISP

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

который модифицируется.

Операция null проверяет, пуст ли данный список (равняется ли атому nil), опе

рацию append можно использовать для соединения двух списков, а операция equal

сравнивает два списка на равенство соответствующих элементов (вызывая себя

рекурсивно для соответствующих пар элементов).

П.6. LISP

622 Приложение. Обзоры языков

Операции над списками свойств. Основные функции обеспечивают вставку,

удаление и доступ к свойствам списков свойств. Функция put используется для

добавления пары èìÿ ñâîéñòâà/çíà÷åíèå ñâîéñòâà в список свойств. Функция get

возвращает текущее значение, ассоциированное с заданным именем свойства.

Функция remprop удаляет пару «имя–значение» из списка свойств. Например, для

добавления пары «имя–значение» (age, 40) в список свойств атома mary следует

записать:

(put 'mary 'age 40)

Далее в программе значение свойства age атома mary можно получить через вы

зов функции

(get 'mary 'age)

Удаление свойства age атома mary выполняется с помощью вызова:

(remprop 'mary 'age)

Элементарные операции, которые определяют функции, также могут изменять

списки свойств для специальных имен свойств, таких как expr или fexpr (см. да

лее).

Ввод и вывод

Ввод и вывод осуществляется просто через вызов функций. Функция read считы

вает следующий атом с клавиатуры. В строках 14–15 листинга П.8 показано, как

можно открыть файл данных с помощью функции open и прочитать его содержи

мое с помощью вызова (read óêàçàòåëü_ôàéëà).

Вызов (print îáúåêò) распечатает указанный объект в читаемом формате.

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

Функция defun используется для создания новых функций. Она имеет следующий

синтаксис

(defun èìÿ_ôóíêöèè(àðãóìåíòû)âûðàæåíèå)

где àðãóìåíòû являются формальными параметрами функции, а телом функции —

единственное âûðàæåíèå (которое может быть последовательностью progn или дру

гими сложными выполняемыми последовательностями).

В Scheme для определения функций можно использовать синтаксис

(define (èìÿ_ôóíêöèè àðãóìåíòû) âûðàæåíèå)

В начале 60х гг., когда был разработан первый вариант языка LISP, определение

функций основывалось на λвыражениях, которые мы обсуждали в разделе 4.2.2.

λвыражения можно использовать для определения функций

(define èìÿ_ôóíêöèè (lambda(ïàðàìåòðû)(òåëî)))

где имя функции и имя каждого параметра — атомы, а тело может быть любым

выражением, включающим элементарные операции или определенные програм

мистом функции.

Действие объявления функции достаточно просто. Определения интерпрети

руемых функций обычно хранятся как пары «атрибут–значение» в списке свойств

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

ленные ранее, используется имя атрибута expr, а связанное с ним значение являет

623

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

Таким образом, выполнение ранее описанной операции define эквивалентно вы

полнению следующей операции:

(put 'èìÿ_ôóíêöèè 'expr '(lambda(ïàðàìåòðû)(òåëî)))

Многие системы LISP отводят специальную область в атоме (заголовочный

блок) для определения функции, названной по этому атому, чтобы избежать необ

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

вызывается. Специальная область памяти отведена для обозначения типа функ

ции (expr, fexpr и т. д.) и содержит указатель на списочную структуру, представля

ющую определение функции. В таких реализациях обычно используются спе

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

определений функций из специальной области.

Стандартные функции

Многие из перечисленных далее функций существуют в большинстве реализаций

LISP. Однако прежде, чем их использовать, лучше ознакомиться с руководством

по используемой версии LISP.

Функции работы со списками:

 (car L) возвращает первый элемент списка L. (caar L) = (car(car L)), и т. д.

 (cdr L) возвращает список L без первого элемента. (cddr L) = (cdr(cdr L)), ит.д.

Функции car и cdr могут использоваться совместно в произвольном порядке,

например, (caddr L) =(car(cdr(cdr L))).

 (cons x y) возвращает список L такой, что (car L) = x, а (cdr L) = y.

 (list x y z) возвращает список (x y z).

 (quote x)(or 'x) не вычисляет x.

Предикаты:

 (atom x) возвращает èñòèíó, если x — атом.

 (numberp x) возвращает èñòèíó, если x — число.

 (greaterp x y) возвращает èñòèíó, если x > y.

 (lessp x y) возвращает èñòèíó, если x < y.

 (null x) возвращает èñòèíó, если x — пустой атом nil.

 (and x y) возвращает x ∧ y.

 (or x y) возвращает x ∨ y.

 (not x) возвращает ~ x.

 (eq x y) возвращает èñòèíó, если x и y — одинаковые атомы или списки.

 (equal x y) возвращает èñòèíó, если x и y — списки с одинаковыми элементами.

Арифметические функции:

 (+ x y) возвращает x + y для атомов x и y. Аналогично работают *, / и –.

 (rem x y) возвращает остаток от деления x/y.

Функции ввода и вывода. Многие из этих функций различаются в различных

реализациях LISP.

П.6. LISP

624 Приложение. Обзоры языков

 (load èìÿ_ôàéëà) считывает файл с указанным именем как последователь

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

из файлов.

 (print x) печатает элемент x. В Scheme эта функция называется также display.

 (open èìÿ_ôàéëà) открывает файл с указанным именем и возвращает указа

тель на этот файл. Обычный способ использования этой функции — сохра

нение указателя на данный файл с помощью функции setq:

(setq infile (open 'èìÿ_ôàéëà))

и использование переменной infile в операторе read.

 (read) считывает с терминала следующий атомарный символ (число, сим

вол или строку). (read óêàçàòåëü_ôàéëà) считывает из файла, заданного сво

им указателем, следующий атомарный символ, если данный файл был пред

варительно открыт.

 (help) или (help 'command) может предоставить полезную информацию.

 (trace èìÿ_ôóíêöèè) осуществляет трассировку выполнения указанной функ

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

 (bye) осуществляет выход из LISP.

Абстракции и инкапсуляция

Базовый LISP не предусматривает возможности абстракции данных. Однако Com

mon LISP содержит объектную систему Common LISP Object System (CLOS).

CLOS стал результатом слияния четырех объектноориентированных расширений

LISP в середине 80 гг.: New Flavors, CommonLoops, Object LISP и Common Object

[106]. CLOS предоставляет следующие возможности:

1. Множественное наследование, которое обеспечивается наследованием mixin

(раздел 7.2.3).

2. Общие функции.

3. Метаклассы и метаобъекты.

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

тельское управление процессом.

П.7. ML

Пример с пояснениями

В листинге П.9 представлен пример суммирования элементов массива. Язык ML

работает как интерпретатор, в этом примере используется Standard ML, разрабо

танный в НьюДжерси.

Листинг П.9. Суммирование элементов массива на языке ML

1 %editor prog.sml

2 fun digit(c:string):int = ord(c)-ord("0");

3 (* Çíà÷åíèÿ ñîõðàíÿþòñÿ â âèäå ñïèñêà ñèìâîëîâ *)

4 fun SumNext(V) = if V=[ ] then (print("\n Sum="); 0)

625

5 else (print(hd(V));

6 SumNext(tl(V))+digit(hd(V)));

7 fun SumValues(x:string):int= SumNext(explode(x));

8 fun ProcessData() =

9 (let val infile = open_in("data.sml");

10 val count = digit(input(infile,1))

11 in

12 print(SumValues(input(infile,count)))

13 end;

14 print("\n"));

15 %editor data.sml

16 41234

17 %sml

18 — use "prog.sml";

19 [opening prog.sml]

20 val digit = fn : string -> int

21 val SumNext = fn : string list -> int

22 val SumValues = fn : string -> int

23 val ProcessData = fn : unit -> unit

24 val it = () : unit

25 — ProcessData();

26 1234

27 Sum=10

28 val it = () : unit

Строки 1–14. Для создания программы вызывается редактор. Текст програм

мы может быть напечатан прямо в сеансе работы с ML, а не подключаться с помо

щью команды use, как в строке 18.

Строка 2. Функции перед их использованием необходимо объявлять. Функ

ция digit получает в качестве аргумента один символ и возвращает целое значе

ние, преобразуя полученный символ в целое число, как и в вышеописанном при

мере на языке C из раздела П.2. Символ «1» на единицу больше, чем символ «0»,

«2» больше, чем «0», на 2 и т. д. Функция ord возвращает целое значение первого

символа своего строкового аргумента.

Строка 3. Так выглядят комментарии на языке ML.

Строки 4–6. Здесь определяется функция, которая рекурсивно выбирает оче

редную начальную цифру из массива и добавляет ее значение к сумме.

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

Печатается заголовок списка. Строки 5–6 формируют последовательность из двух

выражений, которые нужно вычислять как часть выражения else.

Строка 7. Здесь инициализируется сумма элементов списка. Входная строка

преобразуется в список символов с помощью встроенной функции explode, затем

функция SumNext вычисляет значение каждого символа из списка.

Строка 9. Прежде чем вычислять выражение в строке 12, вычисляются выра

жения let в строках 9 и 10. infile инициализируется как указатель на файл дан

ных. Побочным эффектом вычисления этого выражения является открытие фай

ла данных.

Строка 12. Переменная count содержит количество символов, которые следует

прочитать. Это количество символов считывается, и результирующая строка пе

редается для обработки в функцию SumValues. Получившееся значение выводится

на печать.

П.7. ML

626 Приложение. Обзоры языков

Строка 14. Печатается символ конца строки.

Строки 15–16. Для создания файла данных вызывается редактор.

Строки 17–18. Загружается Standard ML, и считывается файл prog.sml, содер

жащий последовательность определений функций.

Строки 19–24. Вывод интерпретатора ML, указывающий, что он обрабатывал

определения функций из входного файла. Печатаются сигнатуры функций digit,

SumNext, SumValues и ProcessData.

Строка 25. Вызывается функция ProcessData().

Строки 26–28. Приведенные данные (в том числе вычисленная сумма) — ре

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

конца файла — обычно это сочетание клавиш <Ctrl+D>, введенное с клавиатуры.

П.7.1. Объекты данных

Элементарные типы данных

Переменные и константы. В языке ML существуют целые (int) константы (на

пример, 1, 2, 3, 4), вещественные числа (real) (например, 1.2, 3.4, 10.E3) с записью

в общепринятой нотации, булевы значения (bool) (то есть èñòèíà или ëîæü) и стро

ки (string) (например, "1", "abc"). Как для вещественных, так и для целых отрица

тельных чисел используется символ «~» (тильда). В языке ML регистры различа

ются, так что True и ABC — не то же самое, что true и abc. Только true и false являются

булевыми литеральными константами.

В ML используются соглашения языка C для представления управляющих сим

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

следовательность символов \n для символа новой строки, \" — для кавычек (без

экранирующего символа обратной наклонной черты кавычки в строке восприни

мались бы как признак ее завершения), \t для символа табуляции и \ddd, где ddd —

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

Идентификаторы — это последовательности символов, начинающиеся с буквы

или символа апострофа (') и содержащие буквы, цифры и символ подчеркивания

(_). Идентификаторы, начинающиеся с апострофа, рассматриваются как иденти

фикаторы типов.

Структурированные типы данных

В языке ML существуют следующие структурированные объекты: кортежи, спис

ки и записи.

Кортеж (tuple) представляет собой последовательность объектов, разделенных

запятыми и заключенных в скобки. (12, "abc", 3) — это кортеж типа int*string*int.

Кортеж может иметь неограниченное количество уровней вложенности. Кортеж

(2, "a", (3, 4.3), "xyz", (true, 7))

имеет тип (int*string*(int*real)*string*(bool*int)).

К iму элементу кортежа можно обратиться с помощью конструкции #i. На

пример, второй элемент кортежа определяется как #2, например #2(2, 4, 6) = 4.

Список (list) является кортежем объектов одного типа. Четыре строки в спис

ке можно было бы задать как ["a", "b", "c", "d"], а результирующий тип обозна