На приведенных выше примерах вы уже приобрели опыт применения программ и научились их изменять, а также успели написать и свои собственные программы. Теперь самое время заняться вопросом: что делать, когда программа ведет себя не так, как ожидалось. Подобные неожиданности связаны с наличием ошибок в программе, а процесс устранения этих ошибок называется отладкой. По нашему убеждению самым разумным подходом к программированию является тот, который может быть охарактеризован как «программирование с предупреждением ошибок». Перефразируя старую поговорку, можно сказать, что грамм тщательного программирования стоит килограмма отладки. В этой главе мы расскажем о некоторых методах отладки, но начнем с того, как избежать проникновения ошибок в программы. Сознавая, что в общем виде эта проблема неразрешима, мы хотим просто поделиться некоторыми неформальными приемами, которые уже приносили пользу другим программистам, работающим на Прологе.

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

Новички, впервые столкнувшиеся с задачей выбора проектных решений, часто испытывают трудности. Помочь им может знание возможных вариантов решений, и, кроме того, важно, чтобы руководитель разъяснил им методику программирования в целом, поскольку искусство принятия проектных решений в программировании – это самостоятельная дисциплина. Мы уже пытались затронуть эту проблему в разд. 1.1, где обсуждались различные способы интерпретации утверждений. Эти вопросы связаны с представлением объектов и отношений. В разд. 7.7 мы снова столкнулись с этой проблемой при описании трех различных способов упорядочения списка объектов. Эти вопросы связаны с разными способами обработки объектов и отношений.

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

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

равмнож(Х,Х):-!.

равмнож(Х,Y):- равспис(Х,Y).

равспис([],[]).

равспис([Х|L1],L2):- удалить(Х,L2,LЗ), равспис(L1,LЗ).

удалить(Х,[Х|Y],Y).

удалить(Х,[Y|L1],[Y|L2]):- удалить(Х,L1,L2).

Данный пример, возможно, не является наилучшим определением эквивалентности множеств, однако он показывает, как нужно размещать тексты процедур. Заметим, что утверждения каждой процедуры сгруппированы вместе, а процедуры разделяются пустой строкой. Другое соглашение, которого придерживаются многие программисты на Прологе, - это писать каждое утверждение на отдельной строке, если оно на ней умещается. Если нет, то писать заголовок утверждения и знак ':-' на первой строке, а каждую цель в конъюнкции целей писать с новой строки со сдвигом. Для примера рассмотрим запись программы порождения всех перестановок списка:

перест([],[]).

перест(L,[Н|Т]):-

 присоединить(Y,[Н|U],L),

 присоединить(V,U,W),

 перест(W,T).

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

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

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

Еще один момент, который влияет на легкость чтения Пролог-программ, - это использование точки с запятой («или») и восклицательного знака («отсечение»). С проблемами, связанными с чрезмерно широким использованием «отсечения», мы познакомились в гл. 4. Всегда следует пытаться обойтись без ';', возможно за счет дополнительных утверждений. Например, следующая программа:

nospy(X):-

 проверить(Х,Функтор,ЧисАрг,А), !,

 (контрточка(_,Функтор,А), !,

  (отказ(контрточка(Заголовок, Функтор, ЧисАрг),_),

  устконтрточку(Заголовок, Тело),

  отказ(3аголовок, Тело),

  write('контр.точка с терма'), печтерм(Функтор, ЧисАрг),

  write(' удалена.'),nl,

  fail

   ; true

 )

 ; write('Heт контр.точек на терме'),

  write(X), put(46), nl

),

!.

гораздо труднее для понимания, нежели:

nospy(X):-проверить(Х,Функтор,ЧисАрг,А),!,

попыт_убр(Х,Функтор,ЧисАрг,А).

попыт_убр(_,Функтор, ЧисАрг,А):- контрточка(_,Функтор,А),!,убрконтрточку(Функтор, ЧисАрг, А).

попыт_убр(Х,_,_,_):- write('Heт контр.точек на терме '), write(X), put(46), nl,!.

убрконтрточку(Функтор, ЧисАрг, А):-

 отказ(контрточка(Заголовок,Функтор, ЧисАрг), _), устконтрточку(Заголовок,Тело), отказ(3аголовок, Тело),

 write('Koнтp.точка с терма'), печтерм(Функтор, ЧисАрг), write(' удалена.'), nl, fail.

убрконтрточку (_,_,_).

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

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

Разбирая Пролог-процедуру всегда полезно обращать внимание на следующие важнейшие моменты ее записи:

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

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

• Выделите из утверждений все операторы и определите их приоритет, ассоциативность, а также то, где находятся их аргументы. Это можно сделать на основании определений операторов, и исходя из наличия скобок. Если есть сомнения, добавьте дополнительные скобки. Для проверки соответствия действия оператора вашим представлениям попробуйте распечатать некоторые простые термы, используя display.

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

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

• Выделите утверждения, составляющие граничные условия. Проверьте, учтены ли все возможные граничные условия.

После того как подобным образом процедура будет разобрана «по косточкам», вы поймете ее гораздо лучше.

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

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

• Одной из типичных синтаксических ошибок является отсутствие точки '.' в конце утверждения. Точкой должен заканчиваться и любой терм, считываемый с помощью предиката read. После точки нужно оставлять хотя бы один пробел. Поэтому избегайте заканчивать файл вместе с вводом точки последнего утверждения – убедитесь в том, что в самом конце вы не забыли нажать клавишу RETURN.

• Некоторые специальные литеры используются парами. К ним относятся круглые скобки '(' и ')', используемые для группирования термов, квадратные скобки '[' и ']', используемые для задания списков, и фигурные скобки '{' и '}', используемые для записи правил грамматики (см. гл. 9). Сюда же относятся двойные кавычки '"' используемые для ограничения строк и одиночная кавычка '", используемая для задания атомов. Составные скобки '/*' и '*/' используются для ограничения комментариев. Убедитесь, что скобок каждого вида задано не больше и не меньше чем необходимо.

• Остерегайтесь неправильного написания слов, особенно имен встроенных предикатов. Это может привести к самым неожиданным ошибкам, поскольку неверно записанные имена предикатов вряд ли сопоставятся с каким-либо утверждением в базе данных. Или наоборот, они могут неожиданно сопоставиться с утверждениями, заголовок которых случайно совпадает с получившимся именем.

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

• Когда имеете дело с операциями над списками, проверяйте себя с помощью следующих вопросов и ответов:

• Как сопоставляются [а,b,с] и [X|Y]? (X конкретизируется значением a, a Y - значением [b,с]).

• Сопоставимы ли [а] и [X|Y]? (Да, причем X конкретизируется значением a, a Y – значением []).

• Сопоставимы ли [] и [X|Y]? (Нет).

• Имеет ли смысл запись[X, Y|Z]? (Да).

• Имеет ли смысл запись [X|Y,Z]? (Нет).

• Имеет ли смысл запись [Х|[Y|Z]? (Да, это то же самое, что [X,Y|Z])

• Как сопоставляются [a, b] и [А |В]? (А конкретизируется значением а, а В - значением [b]).

• Существует ли более одного способа сопоставления приведенных выражений? (Нет, никогда).

Необходимо подчеркнуть, что когда приходится иметь дело со списками или другими структурами подобного рода, полезно прибегать к помощи «древовидных диаграмм», о которых говорилось в гл. 2.

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

• Циклические определения, о которых упоминалось в гл. 3.

• Недостаточность граничных условий или какая-либо другая недоопределенность задачи.

• Бесполезные процедуры, которые переопределяют встроенные предикаты.

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

• Неожиданный выход на конец файла при выполнении предиката чтения read.

Остерегайтесь следующих заблуждений относительно принципов работы механизма возврата:

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

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

• Заблуждение: Запись списка [X|Y] может быть сопоставлена с любым отрезком списка, и при этом разбиение списков на части может быть осуществлено несколькими разными способами. Именно этим объясняется действие предиката присоединить (X, Y, [a,b,c,d]).

На самом деле: В записи списка [X|Y] X сопоставляется только с головой списка, a Y сопоставляется только с его хвостом. Цели с предикатом присоединить способны находить разные разбиения списков благодаря возможностям возвратного хода, а не возможностям сопоставления.

Метод, используемый Прологом при попытках согласовать цели с базой данных, можно рассматривать с разных точек зрения. Мы уже познакомились с одной моделью описания этого метода, которую можно представить в виде «цепочки доказательств», проходящей через прямоугольники, изображающие цели. Теперь мы познакомимся с другой моделью описания работы Пролога, которая применяется во многих средствах отладки программ, таких как трассировка. Существованием этой модели мы обязаны главным образом нашему коллеге Лоренсу Бэрду. Вам следует изучить эту модель, прежде чем вы приступите к использованию средств отладки Пролога.

При использовании трассировки Пролог-система выводит на печать информацию о последовательности отработки целей, чтобы показать, какой стадии выполнения достигла программа. При этом, для того чтобы разобраться в том, что происходит, важно понять, когда и почему определенные цели выводятся на печать. В обычных языках программирования особый интерес представляют моменты входа в подпрограммы и выхода из них. Однако Пролог допускает написание недетерминированных программ, а это вносит сложности, связанные с механизмом возврата. Дело не ограничивается последовательностью входов в утверждения и выходов из них. Механизм возврата может неожиданно вновь запустить выполнение каких-либо утверждений, чтобы построить альтернативное решение. Кроме того предикат отсечения 'Г указывает для каких целей нельзя искать другие решения. Наибольшие трудности, с которыми приходится сталкиваться начинающим программистам, связаны именно с пониманием принципов работы механизма возврата: что на самом деле происходит, когда попытка согласования цели завершается неудачей и система неожиданно начинает возвратный ход. Мы надеемся, что этот процесс достаточно подробно описан в предыдущих главах. Впрочем, в предыдущих главах рассматривалась не только последовательность обработки целей, но также и то, как происходит конкретизация переменных, как цели сопоставляются с заголовками утверждений из базы данных, и, наконец, как согласуются с базой данных подцели. В модели трассировки выполнение Пролог-программ описывается в терминах четырех видов происходящих событий: CALL(ВЫЗОВ), ЕХIT(ВЫХОД), REDО(ПЕРЕДЕЛКА), FAIL(HEУДАЧА).

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

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

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

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

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

Обратимся к примеру. Рассмотрим следующее определение предиката потомок:

потомок(Х,Y):- отпрыск(Х,Y).

потомок(X,Z):- отпрыск(Х,Y), потомок(Y,Z).

Этот фрагмент программы находит прямых потомков некоторого лица по заданным в базе данных фактам отпрыск, например:

отпрыск(авраам,измаил).

отпрыск(авраам,исаак).

отпрыск(исаак,исав).

. . .

Первое утверждение программы указывает, что Y является потомком X если Y есть отпрыск X, а второе утверждение указывает, что Z является потомком X если Y есть отпрыск X и если Z является потомком Y. Рассмотрим вопрос:

?- потомок(авраам,Ответ), fail.

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

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

В начале мы имеем прямоугольники, обозначающие две цели, в которые пока не входила стрелка, представляющая цепочку доказательств (см. рис. 8.1). Первое событие состоит в ВЫЗОВе (CALL) цели потомок. Это - обращение номер 1.

Риc. 8.1

(1) CALL: потомок(авраам,Ответ)

(2) CALL: отпрыск(авраам,Ответ)

Мы сопоставили с целью первое утверждение процедуры потомок и это привело к ВЫЗОВ цели отпрыск. В результате возникла ситуация, где стрелка движется вниз (см. рис. 8.2). Мы продолжаем:

Рис. 8.2.

(2) EXIT: отпрыск (авраам,измаил)

Сразу успешно согласуется первое утверждение и следует ВЫХОД (EXIT) из цели.

(1) EXIT: потомок(авраам,измаил)

Таким образом, мы согласовали первое утверждение процедуры потомок.

(3) CALL: fail

(3) FAIL: fail

(1) REDO: потомок(авраам,измаил)

Затем мы пытаемся согласовать fail, и, как и следовало ожидать, эта попытка завершается НЕУДАЧЕЙ (FAIL). Стрелка возвращается из прямоугольника fail назад выше в прямоугольник потомок. Изображение этой ситуации приведено на рис. 8.3. Стрелка движется вверх. Продолжаем:

Рис. 8.3.

(2) REDO: отпрыск(авраам,измаил)

(2) EXIT: отпрыск(авраам,исаак)

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

(1) EXIT: потомок(авраам,исаак)

(4) CALL: fail

(4) FAIL: fail

(1) REDO: потомок(авраам,исаак)

И снова fail заставляет нас отвергнуть это решение и начать возвратный ход. Заметим, что это было совершенно новое обращение к fail (мы вошли в него заново «сверху»).

(2) REDO: отпрыск(авраам,исаак)

(2) FAIL: отпрыск(авраам,Ответ)

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

(5) CALL: отпрыск(авраам,Y)

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

Рис. 8.4.

(5) EXIT: отпрыск(авраам,измаил)

(6) CALL: потомок(измаил,Ответ)

Это дает решение, с которым мы теперь уже рекурсивно вызываем потомок. Следует новое обращение к потомок.

(7) CALL: отпрыск(измаил,Ответ)

(7) FAIL: отпрыск(измаил,Ответ)

(8) CALL: отпрыск(измаил, Y2)

(8) FAIL: отпрыск(измаил,Y2)

(6) FAIL: потомок(измаил,Ответ)

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

(5) REDO: отпрыск(авраам,измаил)

Мы возвращаемся назад для выбора новой альтернативы.

(5) EXIT: отпрыск(авраам.исаак)

(9) CALL: потомок(исаак,Ответ)

(10) CALL: отпрыск(исаак,Ответ)

(10) EXIT: отпрыск(исаак,исав)

Запускаем новое обращение к потомок и попытка согласовать подцель отпрыск завершается удачно (рис. 8.5). Продолжаем:

(9) EXIT: потомок(исаак,исав)

(1) EXIT: потомок(авраам,исав)

(11) CALL: fail

(11) FAIL: fail

(1) REDO: потомок(исаак,исав)

(9) REDO: потомок(исаак,исав)

Это дает окончательное решение исходного вопроса, однако fail вновь вынуждает включиться механизм возврата, поэтому мы возвращаемся назад по событиям REDO:

(10) REDO: отпрыск(исаак,исав)

(10) EXIT: отпрыск(исаак,иаков)

(9) EXIT: потомок(исаак,иаков)

(1) EXIT: потомок(авраам,иаков)

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

(12) CALL: fail

(12) FAIL: fail

(1) REDO: потомок(авраам,иаков)

(9) REDO: потомок(исаак,иаков)

(10) REDO: отпрыск(исаак,иаков)

(10) FAIL: отпрыск(исаак,Ответ)

(13) CALL: отпрыск(исаак,YЗ)

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

(13) EXIT: отпрыск(исаак,исав)

(14) CALL; потомок(исав, Ответ)

Еще одна рекурсия

(15) CALL: отпрыск(исав,Ответ)

(15) FAIL: отпрыск(исав,Ответ)

(16) CALL: отпрыск(исав,Y4)

(16) FAIL: отпрыск(исав,Y4)

(14) FAIL: потомок(исав,Ответ)

(13) REDO: отпрыск(исаак,исав)

(13) EXIT: отпрыск(исаак,иаков)

(17) CALL: потомок(иаков,Ответ)

Пытаемся использовать Иакова.

(18) CALL: отпрыск (иаков,Ответ)

(18) FAIL: отпрыск (иаков, Ответ)

(19) CALL: отпрыск(иаков,Y5)

(19) FAIL: отпрыск (иаков, Y5)

(17) FAIL: потомок(иаков,Ответ)

(13) REDO: отпрыск(исаак,иаков)

(13) FAIL: отпрыск(исаак,YЗ)

(9) FAIL: потомок(исаак,Ответ)

(1) FAIL: потомок(авраам,Ответ) нет

Наконец мы закончили. Надеемся, что этот утомительный пример дал вам возможность понять последовательность событий, происходящих при выполнении Пролог-программы. Вы, вероятно, уже заметили, что для любой цели всегда бывает только один ВЫЗОВ (событие CALL) и одна НЕУДАЧА (событие FAIL), хотя может быть сколько угодно ПЕРЕДЕЛОК (событие REDO) и соответствующих ВЫХОДов (событие EXIT). В следующем разделе мы рассмотрим процесс трассировки для более сложного примера – предиката присоединить.

Упражнение 8.1. В приведенной выше модели ничего не говорится о том, как обрабатывается цель – отсечение '!'. Расширьте эту модель, включив туда учет действия отсечения.

Обнаружив, что программа не работает (порождает сообщения об ошибках, просто отвечает 'нет' или выдает неверный ответ) вы, наверное, захотите побыстрее найти ошибки с тем, чтобы исправить их. В этом разделе описывается набор встроенных предикатов, позволяющих «проследить» за выполнением программы. С их помощью вы можете вновь запустить программу на той же задаче и проследить за ее выполнением, чтобы найти место, с которого она начинает работать неверно. При этом вы увидите, когда происходят разные события трассировочной модели, подобно тому, как это было в предыдущем разделе, где мы наблюдали за процедурой потомок. Точный набор возможностей, предоставляемых предикатами отладки, зависит от конкретной реализации Пролога, однако то, что мы собираемся сообщить вам, даст представление об имеющихся средствах, так что вы сможете разобраться в том, что предлагает вам ваша система. В любом случае мы настоятельно советуем ознакомиться с документацией по вашей Пролог-системе, прежде чем начать использование средств отладки.

Основное назначение трассировки и контрольных точек состоит в том, чтобы программист получил информацию о попытках согласования определенных целей, возникающих в ходе выполнения его программы. Программист может принять решения относительно интересующих его целей и относительно уровня своего вмешательства в процесс их согласования. Первое решение сводится к выбору определенной комбинации полной трассировки и трассировки по контрольным точкам. Вообще говоря, полная трассировка означает выдачу информации обо всех целях, а контрольные точки позволяют программисту получить информацию лишь о тех предикатах, которые он задал. Однако эти возможности могут различными способами комбинироваться. Используемые при этом встроенные предикаты рассмотрены в разд. 6.13. Контрольная точка для какого-либо предиката устанавливается с помощью предиката spy (отмена контрольной точки выполняется предикатом nospy). Установка режима полной трассировки осуществляется предикатом trace (а ее отмена – предикатом notrace).

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

• Когда впервые делается попытка согласовать некоторую цель с базой данных, когда данная цель встречается впервые (событие CALL);

• Когда цель успешно согласована (событие EXIT);

• Когда готовится попытка повторного согласования цели (событие REDO), и

• Когда устанавливается несогласуемость цели с базой данных, поскольку все попытки вновь согласовать ее оказались безуспешными (событие FAIL).

Например, разумным представляется такой выбор: задать трассировку событий CALL и REDO как управляемую, а трассировку событий EXIT и FAIL – как неуправляемую. Более подробное описание этих четырех событий, происходящих при согласовании целей с базой данных, приведено в разд. 8.3,

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

?- [user].

присоединить([],Y,Y).

присоединить([А|В],С,[А|D]):- присоединить(В,С,D).

/* введите здесь литеру – признак конца файла */

да

?- присоединить ([а][b],Х).

CALL присоединить([a],[b],_43)

CALL присоединить([],[b],_103)

EXIT присоединить([],[b],[b])

EXIT присоединить([a],[b],[a,b])

X = [a,b];

REDO присоединить([a],[b],[a,b])

REDO присоединить([],[b],[b])

FAIL присоединить([],[b],_103)

FAIL присоединить ([a], [b],_43)

нет

?- присоединить(Х,Y,[а])

CALL присоединить(_37,_38,[а])

EXIT присоединить([],[а],[а])

X = [], Y = [a];

REDO присоединить([],[a],[a])

CALL присоединить(_93,_38,[])

EXIT присоединить([],[],[])

EXIT присоединить([а],[],[a])

X = [a], Y = [];

REDO присоединить([a],[],[a])

REDO присоединить([],[],[])

FAIL присоединить (_93,_38,[])

FAIL присоединить(_37,_38,[])

нет

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

Прежде чем перейти к рассмотрению управляемой трассировки, следует сделать несколько замечаний о том, как Пролог выдает сведения о целях во время трассировки. На самом деле, способ выдачи сведений о целях средствами трассировки не обязательно совпадает с тем, который используется предикатом write. Это происходит потому, что для выдачи сведений о целях пользователю разрешается задавать свои собственные определения. Вы можете воспользоваться этой возможностью для того, чтобы вывести какие-либо общие структуры, используемые в вашей программе, особым способом, который обеспечивает большую наглядность и выразительность, чем обычный вывод с помощью предиката write. Эта возможность осуществляется следующим образом. Стандартный способ выдачи сведений о целях опирается на использование встроенного предиката print с единственным аргументом. Предикат print действует, как если бы он был определён следующим образом:

print(X):- portray(X),!.

print(X):- write(X).

Предикат portray уже не является встроенным, поэтому вы можете сами задать утверждения для его определения. Если эти утверждения таковы, что они позволяют согласовать с базой данных цель portray(X) для одной из ваших целей Х,то считается, что выдачу всех необходимых сведений сделают эти утверждения. В противном же случае данные об этой цели X будут выданы с помощью предиката write. Например, если по каким-то причинам вы не хотите выдавать значение третьего аргумента цели присоединить, то это может быть обеспечено с помощью следующего утверждения:

portray(присоединить(А,В,С)):- writе('присоединить('), write(A), write(','), write(B), write(','), write('‹foo›)').

Каждый раз когда встретится цель X, содержащая предикат присоединить, приведенное утверждение будет обеспечивать успешное согласование цели portray(X), и вывод трассировочной информации будет полностью возложен на данное утверждение. В случае цели, содержащей любой другой предикат, цель port-гау(Х) не согласуется с базой данных и потому сведения об X будут выданы с помощью предиката write(X). Если бы приведенное выше утверждение присутствовало в базе данных, то соответствующая часть приведенного выше протокола трассировки выглядела бы следующим образом:

?- присоединить ([a],[b],X).

CALL присоединить([а],[b],‹fоо›)

CALL присоединить ([],[b],‹foo›)

EXIT присоединить([],[b],‹fоо›)

EXIT присоединить([a],[b],‹foo›)

X = [a,b];

REDO присоединить([a],[b],‹foo›)

REDO присоединить([],[b],‹foо›)

FAIL присоединить([],[b],‹foo›)

FAIL присоединить ([a],[b],‹foo›) нет

Т

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

?- присоединить ([а],[b],Х).

CALL присоединить([а],[b],_43)?

После вывода литеры '?' программа останавливается. Теперь от вас требуется ответ – команда, которой вы зададите одно из возможных действий. Если затребованное вами действие означает продолжение обычного выполнения программы, то она продолжит выполнение до тех пор, пока трассировка не дойдет до следующего управляемого события для прослеживаемого предиката. И опять вам будет задан вопрос вида:

CALL присоединить([],[b],_103)?

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

Первая группа команд предназначена для выдачи информации о цели в различных форматах. Как мы уже знаем, стандартным средством выдачи сведений о цели является предикат print, в рамках которого с помощью определяемого пользователем предиката portray можно выводить нужные сведения в нужном формате. Однако у пользователя могут возникнуть сомнения в правильности утверждений, определяющих portray, или он может пожелать увидеть цель в обычной форме. Поэтому Пролог предоставляет команду, дающую вам возможность вывести сведения о текущей цело с помощью предиката write или display. В этом случае программа не продолжает выполняться, а пользователя просят задать еще одну команду, которая укажет как следует продолжать выполнение программы. Как правило, этот диалог имеет следующий вид:

?- присоединить([a],[b],X).

CALL присоединить([а],[b],‹fоо›)? write

CALL присоединить([а],[b],_103)?

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

Предшественниками данной цели называются те цели, согласованность которых зависит от согласованности данной цели. На наших диаграммах с прямоугольниками это те цели, прямоугольники которых включают данную цель. Так, каждая цель имеет предшественника, который в свою очередь является одной из целей исходного вопроса – той целью, согласованию которой помогает текущая цель. Аналогично, когда речь идет о правиле, каждая цель, порожденная телом правила, имеет в качестве предшественника ту цель, которая сопоставлена с заголовком правила. Рассмотрим некоторые примеры предшественников. Обратимся к следующей простой программе обращения списка (которая рассматривалась в разд. 7.5):

обр([],[]).

oбp([H|T],L):- oбp(T,Z), присоединить(Z,[H],L).

присоединить([],X,Х).

присоединить([А|В],С,[А|D]):- присоединить(В,С,D).

Пусть мы задали исходный вопрос:

?- oбp([a,b,c,d],X). (A)

Тогда, вследствие второго утверждения, возникают две подцели, каждая из которых в качестве своего непосредственного предшественника имеет цель, составляющую содержание исходного вопроса. Вот эти подцели:

oбp([b,c,d],Z) (B)

присоединить(Z,[a],X) (C)

Поскольку второе утверждение будет снова использовано при согласовании (B), снова возникают две подцели:

oбp([c,d],Z1) (D)

присоединить(Z1,[a],Z) (E)

Их предшественниками являются цели (A) и (B). Заметим, что цель (C) не является их предшественником, поскольку от них непосредственно зависит только согласованность (B), от которой, в свою очередь, зависит согласованность (А). Цели (D) и (E) никак не влияют на согласованность (C). Когда процесс согласования исходного вопроса заходит уже достаточно далеко, возникает цель вида:

присоединить([с],[b],Y)

На этом этапе текущая цель и ее предшественники могут быть представлены в следующем виде:

oбp([a,b,c,d],_46) (цель A)

oбp([b,c,d],[d|_50]) (цель B)

присоединить([d,с],[b],[d|_51])

присоединить([с],[b],_52)

Прежде чем читать дальше, вам следует убедиться в том, что вы понимаете, почему это предшественники данной цели, а также почему у нее нет никаких других предшественников. С приведенным здесь изображением предшественников связана одна особенность, которая может проявиться и в вашей Пролог-системе. Существуют два способа выдачи информации о предшественнике на печать – при первом способе информация соответствует состоянию предшественника при первой попытке согласовать его, при втором – текущему состоянию, с теми значениями переменных, которые они получили в результате конкретизации. Здесь у нас принят второй способ. Когда выполнение впервые дошло до цели (B), второй аргумент предиката обр не был конкретизирован. Тем не менее, в списке предшественников этот аргумент показан как имеющий значение. Это объясняется тем, что теперь переменная, которая задана в этой позиции, оказалась конкретизированной, а именно, теперь мы выяснили, что для [b, с, d] первым элементом обращенного списка является d.

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

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

• Удаление всех контрольных точек. Это имеет тот же эффект, что и вызов цели nodebug (см. разд. 6.13).

• Отключение полной трассировки. Это имеет тот же эффект, что и вызов цели notrace (см. разд. 6.13).

• Включение полной трассировки. Это имеет тот же эффект, что и вызов цели trace (см. разд. 6.13).

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

• «creep» (ползти): Продолжить выполнение программы с полной трассировкой до тех пор, пока не поступит новое указание (при наступлении следующего управляемого события).

• «skip» (пропустить): Продолжить выполнение программы без выдачи какой-бы то ни было трассировочной информации до тех пор, пока не наступит какое-либо событие, относящееся к текущей цели.

• «leap» (перескочить); Продолжить выполнение программы без выдачи трассировочной информации до тех пор, пока либо не будет достигнута контрольная точка, либо не наступит событие, относящееся к текущей цели.

Первая из этих команд соответствует случаю, когда вы хотите, начиная с данного момента, тщательно проследить за ходом выполнения программы. Вторая команда соответствует случаю, когда вас не интересует ход согласования какой-либо цели, а нужно побыстрее перейти к тому, что происходит дальше. Третья команда относится к случаю, когда в ходе согласования некоторой цели выполняется большой объем не интересующей вас деятельности, но где-то в середине возникает интересующая вас цель (имеющая контрольную точку). Поэтому вам желательно пропускать все до тех пор, пока не будет достигнута нужная контрольная точка или (если программа ошибочна) пока текущая цель не окажется согласованной или несогласованной не достигнув контрольной точки. Ниже приводится пример использования команд «creep» и «skip». Предположим, что в простой программе сортировки, приведенной в разд. 7.7, есть ошибка, но при этом мы уверены, что наша программа порождения перестановок работает правильно. Если вы помните, определение программы наивсорт начинается так:

наивсорт(Х,Y):- перестановка(Х,Y), отсортировано(Y),!.

Чтобы избежать необходимости просматривать массу детальных сведений о том, как работает программа перестановка, можно воспользоваться командой «skip» и получить трассировку, которая начинается так:

CALL наивсорт([3,6,2,9,20],_45)? creep

CALL перестановка([3,6,2,9,20],_45)? skip

EXIT перестановка([3,6,2,9,20],[3,6,2,9,20])? creep

CALL упорядочено(ЕЗ,6,2,9,20])? creep

CALL упорядочено(0,[3,6,2,9,20])? creep

CALL 0‹3?

. . .

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

• «retry» (повторить): Если вы задали команду «retry» после какого-либо события для некоторой цели, то Пролог вернется к тому месту, где он первоначально осуществил ВЫЗОВ (событие CALL) этой цели. Все будет в точности так же, как и в момент первоначального появления этой цели (кроме каких-либо добавлений к базе данных, которые могли быть сделаны). Это означает, что вы можете еще раз проследить за тем, что происходит при согласовании данной цели. На практике обычно сочетают использование команд «retry» и «skip». Если вы сомневаетесь в том, что ошибка возникает при согласовании некоторой цели, вы можете сперва пропустить (с помощью команды «skip») трассировку процесса ее согласования. Это означает, что вы не намерены пробираться через массу трассировочных данных, относящихся к цели, процесс согласования которой выполняется совершенно правильно. Если же возникла ошибка, и цель либо не согласуется с базой данных, либо дает неверный результат, то у вас сохраняется возможность после всего этого (с помощью команды «retry») вернуться назад и проследить за всем более внимательно.

• «or» (или): Эта команда, в точности как ';', означает просьбу о выборе альтернативного решения некоторого вопроса. Если вы находитесь в точке ВЫХОДа из цели (событие EXIT), вы также можете попросить о выборе альтернативы. Таким образом, если известно, что первый найденный ответ не позволяет успешно завершить остальную часть программы, можно тут же попросить о поиске другого решения. Это означает, что вы сможете быстрее добраться до той части программы, где содержится ошибка. Без такого режима вам пришлось бы «караулить» возможную неудачу процесса согласования после того, как была найдена первая альтернатива.

• «fail» (неудача): Эта команда в основном используется при наступлении события CALL. Если вы знаете, что данная цель в конце концов окажется несогласованной с базой данных, и что эта цель для вас не представляет интереса, то вы можете тут же принудительно завершить процесс согласования неудачно, задав эту команду.

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

?- принадлежит(Х,[а,b,с]), принадлежит(Х,[b,d,е]).

CALL принадлежит(_ 44,[a, b,с])? creep

EXIT принадлежит(a, [а,b,с])? or

REDO принадлежит(a, [а,b,с])? creep

CALL принадлежит(_44,[b,с])? fail

FAIL принадлежит(_44,[b,с])? creep

FAIL принадлежит(_44,[a,b,с])? retry

CALL принадлежит(_44,[а,b,с])? creep

EXIT принадлежит(а,[а,b,с])? creep

CALL принадлежит(а,[d,с,е])? fail

FAIL принадлежит(a,[d,c,e])? creep

REDO принадлежит(а,[а,b,с])? creep

CALL принадлежит(_44,[b,с])? creep

EXIT принадлежит(b,[b,с])? or

REDO принадлежит(b,[b,с])? creep

CALL принадлежит(_ 44,[с])? fail

FAIL принадлежит(_44,[с])? retry

CALL принадлежит(_44,[с])? creep E

XIT принадлежит(с,[с])? creep

EXIT принадлежит(с,[b,c])? creep

EXIT принадлежит(c,[a,b,с])? creep

CALL принадлежит(c,[d,c,e])? creep

CALL принадлежит(c,[c,e])? creep

EXIT принадлежит(c,[c,e])? creep

EXIT принадлежит(c,[d,c,e])? or

REDO принадлежит(c,[d,c,e])? creep

REDO принадлежит(c,[c,e])? creep

CALL принадлежит(c,[e])? creep

CALL принадлежит(c,[])? creep

FAIL принадлежит(c,[])? creep

FAIL принадлежит(c,[е])? creep

FAIL принадлежит(c,[с,е])? retry

CALL принадлежит(c,[с,e])? creep

EXIT принадлежит(c,[c,e])? creep

EXIT принадлежит(с,[d,с,е])? creep

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

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

• «abort» (аварийное завершение): Эта команда вызывает прекращение выполнения всех ваших текущих программ, и вы «проваливаетесь» в Пролог-интерпретатор, который готов к вашему новому вопросу.

• «halt» (стоп): Эта команда вызывает полный выход из Пролога. Она может потребоваться вам, когда вы обнаружите ошибку и захотите для ее исправления отредактировать файл с той программой, где находится ошибка.

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

1. За какими целями вы собираетесь следить? Если вы хотите следить за всем (задав полную трассировку с помощью предиката trace), то вы можете захлебнуться тем потоком информации, который будет поступать на ваш терминал. С другой стороны, если прослеживать только то, что происходит с небольшим числом предикатов (расставляя контрольные точки с помощью предиката spy), то можно пропустить момент, когда программа начинает работать неверно. Вероятно, лучшим решением является компромисс между аккуратным использованием контрольных точек, позволяющих сузить район поиска, и полной трассировкой на заключительном этапе, что позволяет точно обнаружить место ошибки.

2. Какой уровень управления выполнением программы вы намерены осуществить через терминал? Если задать все типы событий как неуправляемые, то вы не сможете оказать никакого влияния на ход выполнения программы, которая быстро проскочит через место ошибки прежде чем вы сможете это заметить, а тем более – внимательно рассмотреть. С другой стороны, если вы зададите все события как управляемые, то вам придется постоянно подталкивать программу, сообщая ей, что нужно продолжить выполнение при каждом новом событии.

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

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

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

• Если ваша Пролог-система не позволяет вернуться к прежнему состоянию после использования редактора и изменения ваших программных файлов, то вам придется запустить Пролог и применить предикат consult ко всем вашим программным файлам, находящимся на внешней памяти.

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

?- [filel,file2,file3].

?- [file4,file5,fileб].

то в результате будут считаны в память все файлы file1, file2, file3, file4, file5, file6.

Иногда изменения в программе кажутся столь незначительными, что их можно ввести с терминала с помощью предикатов consult(user) или reconsult(user). Однако не следует пользоваться этим способом слишком часто. По невнимательности можно легко забыть какие-либо мелкие изменения, которые вносились таким способом, и при выполнении программы вновь столкнуться с теми же ошибками, которые встречались при прошлом запуске программы. Кроме того, поскольку в конечном итоге вы намерены внести исправления в ваши программные файлы, то нерационально повторять их прямой ввод с терминала. Итак, не поддавайтесь искушению вводить утверждения прямо с терминала в надежде поскорее заставить программу работать.

Ниже приводится небольшой пример того, как можно использовать предикаты consult и reconsult, чтобы внести изменения в программу с терминала. Этот сеанс работы начинается, когда в базе данных программиста нет ни одного утверждения.

?- присоединить([а,b,с,d],[е],Х).

нет

?- consult (user).

присоединить([А|В],С,[А|D]):- присоединить(А,С,D).

присоединить([],Х,Х).

обр([],[]).

обр([А|В],С):- o6p(B,D), присоединить(D,[А],С).

/* ввод литеры – признак конца файла */

да

?- обр([a,b,c,d,e],X).

нет

?- присоединить([а,b,с,d,е], [f],Х).

нет

?- присоединить([],[а,b,-],Х).

X = [а,b,с]

да

?- reconsult(user)

присоединить([А|В],С,[А|D]):- присоединить(В,С,D).

/* ввод литеры – признак конца файла */

да

?- oбp([a,b,c,d],X).

нет

?- consult (user).

присоединить([],Х,Х).

/* ввод литеры – признак конца файла */

да

?- oбp([a,b,c,d,e],X). X = [e,d,c,b,a].

да

В приведенном сеансе работы наш беспечный программист начинает с ввода через терминал утверждений для предикатов присоединить и обр. Конечно, он мог бы сначала ввести их в файл, а затем предложить Прологу применить к этому файлу предикат consult. Впрочем, для такого маленького примера этого, может быть, и не стоило делать. К несчастью, в первом утверждении для присоединить допущена ошибка – в цели задано А, хотя на этом месте должно быть В. Эта ошибка обнаруживается, когда система не может ответить на вопросы, содержащие присоединить и обр. Каким-то образом программист догадывается, что его определение присоединить неверно (в реальном сеансе для этого, вероятно, потребовалось бы использовать средства отладки). Так или иначе, он решает заменить имеющееся определение новым, используя для этого предикат reconsult. К сожалению, в своем новом определении он забывает задать граничное условие (случай []). Поэтому программа по-прежнему не работает. К этому моменту исходное определение для присоединить, состоящее из двух утверждений, заменено новым определением из одного утверждения, которое оказалось неполным. Наш программист замечает, что он допустил ошибку и что ситуацию можно исправить, просто добавив к уже имеющемуся определению одно утверждение. Это делается также с помощью предиката consult. На этот раз программа заработала.

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