Руководство к пользованию TURBO PROLOG

И наконец, чтобы проиллюстрировать литерный тип домена,

определим в программе 8 предикат isletter (является_ )

который при обработке таких целей, как

isletter('z').

isletter('Q').

будет возвращать соответственно ложь и истину.

/* Программа 8*/

predicates

isletter(char)

clauses

isletter(Ch) if Ch<='z' and 'a'<=Ch.

isletter(Ch) if Ch<='z' and 'A'<=Ch.

Упражнение. Набейте программму 7 и попробуйте по очереди

ввести каждую из следующих целей:

(1) reference("Carol",Y).

(2) referenceX,"01-191951").

(3) reference("Mavis",Y)

(4) reference(X,Y).

Ким живет в той же квартире, что и Дороти, а потому имеет тот

же самый номер телефона. Добавьте эту информацию к предложе-

ниям, относящимся к предикату reference и убедитесь в пра-

вильности ваших действий, попробовав ввести цель

reference(X,"01-191051").

Набейте программу 8 и попробуйте по очереди ввести каждую

из следующих целей:

(1) isletter('x').

(2) isletter('2').

(3) isletter("hello").

(4) isletter(a).

(5) isletter(x).

Составные объекты могут упростить ваши предложения!

~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

Турбо Пролог позволяет вам строить объекты, содержащие

другие объекты. Такие объекты называются составными. Состав-

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

объект, что в значительной степени упрощает программирование.

Рассмотрим, например, факт

owns(john,boock("From Here to Eternity","James Jones")).

в котором утверждается, что john (Джон) обладает книгой

(Путь в вечность), которую написал jomes jones

(Джеймс Джонс). Точно так же мы могли бы написать

owns(john,horse(blacky)).

что можно интерпретировать следующим образом: Джон имеет ло-

шадь по имени Блэки. Два составных объекта, участвующие в

этих примерах, имеют вид

boock("From Here to Eternity","James Jones").

horse(blacky)

Если вместо всего этого мы написали бы два факта

owns(john,"From Here to Eternity").

owns(john,blacky).

то мы не смогли бы решить, является ли blacky (Блэки) назва-

нием книги или это - имя лошади. С другой стороны, первый ком-

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

для того, чтобы различать разные объекты. В примере, приве-

денном выше, мы показали существующее различие, воспользовав-

шись двумя функторами book (книга) и horse 9(лошадь).

Составные объекты состоят из функтора и относящихся к не-

му подобъектов:

функтор(объект_1,объект_2,...,объект_N)

При отсутствии объектов функтор записывается, как

функтор()

или непосредственно:

функтор

Декларация доменов для составных объектов

~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

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

объекты при использовании деклараций доменов. В подцели

owns(john,X).

переменная Х может быть связана с объектами разных типов - с

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

Ввиду этой причины мы больше не можем употреблять старое оп-

ределение предиката owns (обладает)

owns(symbol,symbol)

где второй аргумент должен относиться к объектам, принадлежа-

щим домену символьного типа. Вместо этого мы воспользуемся

новой записью декларации предиката:

owns(name,articles)

Предметы (articles) можно описать в таких декларациях доменов:

domains

articles = boock(title,autor) ; horse(name)

title, autor, name, = symbol

Точку с запятой в данном случае следует читать, как "или".

Здесь возможны две альтернативы: книгу (book) можно идентифи-

цировать ее названием (title) и автором (author), а лошадь

(horse) можно идентифицировать ее именем (name). Каждый из

доменов title, author и name имеет символьный тип.

К рассмотренной декларации доменов можно легко добавить

новые альтернативы: в домен articles можно включить, напри-

мер, объект boat (лодка) или объект bankbook банковская книж-

ка.

Объект boat можно определить как объект, состоящий из

функтора, который не имеет объектов. С другой стороны, в ка-

честве составной части объекта bankbook хотелось бы видеть

банковский счет. В этом случае декларация домена articles бы-

ла бы расширена следующим образом:

articles=boock(title,autor);horse(name);boat;bankbook(integer)

Ниже приведено несколько примеров, показывающих, как мож-

но использовать составные объекты из домена articles при за-

писи тех или иных фактов, определяющих предикат owns:

owns(john,book("A friend of the family",Irving Shaw")).

owns(john,horse(blacky)).

owns(john,boat).

owns(john,bankbook(1000)).

Если теперь имеется цель

qwns(john,Thing).

то мы получим следующие ответы:

Thing = book("A friend of the family",Irving Shaw")

Thing = horse(blacky)

Thing = boat

Thing = bankbook(1000)

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

домен = альтернатива_1(Д,Д,...);

альтернатива_2(Д,Д,...);...

Альтернатива_1 и альтернатива_2 - это произвольные (но

различные) функторы. Запись (Д,Д,...) обозначает список имен

доменов, которые либо декларированы где-то еще, либо предс-

тавляют собой один из стандартных доменов символьного, цело-

го, вещественного или литерного типа.

Обратите внимание:

1. Альтернативы разделяются точками с запятой.

2. Каждая альтернатива состоит из функтора и, возможно,

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

В программе 9 используются функторы, приводящие к переме-

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

"побочный эффект", сопутствующий обработке той или иной цели.

Например, цель

move_cursor(4,9,up(2)).

приводит к перемещению курсора на две строки вверх из началь-

ного положения, соответствующего 4-ой строке и 9-ому столбцу

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

cursor(Row,Column)

вызывающий перемещение курсора на заданные строку (row) и

столбец (column).

/* Программа 9 */

domains

row,column,step = integer

movement = up(step); down(step);

left(step); right(step)

predicates

move_cursor(row,column,movement)

clauses

move_cursor(R,C,up(Step)):-

R1=R-Step,cursor(R1,C).

move_cursor(R,C,down(Step)):-

R1=R+Step,cursor(R1,C).

move_cursor(R,C,left(Step)):-

C1=C-Step,cursor(R1,C).

move_cursor(R,C,right(Step)):-

C1=C-Step,cursor(R1,C).

Если бы мы добавили альтернативу no (нет), то перемещение

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

move_cursor(R,C,no)

Обратите внимание, что функтор no вполне достаточен, чтобы

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

ном случае не требуется.

Спуск по уровням

~~~~~~~~~~~~~~~~

Турбо Пролог позволяет строить составные объекты на нес-

кольких уровнях. Например, в составном объекте

book("A Ugly Duckling","Andersen")

вместо фамилии автора можно было бы воспользоваться новой

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

себя как имя автора, так и его фамилию, Если функтор, требуе-

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

author (автор), то описание объекта-книги теперь примет вид:

book("A Ugly Duckling",autor("Hans Christian","Andersen")

В старой декларации домена

book(title,autor)

второй аргумент функтора book - это author. Но старая деклара-

ция

autor = symbol

может содержать только одно имя, и поэтому теперь это уже не-

достаточно. Сейчас мы должны описать, что author - это также

составной объект, включающий в себя имя автора и его фамилию.

Это достигается с помощью следующего утверждения о домене:

autor = autor(firstname,surname)

Это приводит нас к таким декларациям:

domains

articles = book(title,autor);......

autor = autor(firstname,surname)

title,firstname,surname = symbol

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

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

вается полезным построить "дерево":

boock

/ \

title autor

/ \

firstname surname

Какое-нибудь одно утверждение о домене описывает только один

уровень дерева, а не все дерево в целом. Например, об-

ъект-книгу нельзя определить полностью с помощью следующего

утверждения о домене:

book = book(title,autor(name,surname))

В качестве другого примера рассмотрим, каким образом мож-

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

"ellen owns the book" "Эллен владеет книгой"

воспользовавшись при этом составным объектом.

Структура самого простого предложения (sentence) включает

в себя существительное (noun) и глагольную форму (verbphrase):

sentence = sentence(noun,verbphrase)

Существительное - это просто слово (word):

noun = noun(word)

Глагольная форма представляет собой либо глагол (verb) и су-

ществительное, либо просто глагол:

verbphase = verbphase(verb,noun) ; verb(word)

verb = verb(word)

Если воспользоваться теперь указанными декларациями доменов

(verbphase и муки ),то предложение "ellen owns the book"

примет такой вид:

sentence(noun(ellen),verbphase(verb(owns),noun(book))

Соответствующее дерево выглядит следующим образом:

sentence

/ \

noun verbphase

| / \

| verb noun

| | |

ellen owns the book

Упражнение. Напишите подходящую декларацию domains, ис-

пользуя составные объекты, которыми можно было бы воспользо-

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

ном на Турбо Прологе. Типовой элемент каталога может иметь

следующий вид:

Шоу: Вестсайдская история

Стихи: Стефен Сондхейм

Музыка:Леонард Бернштейн

Упражнение. По возможности используя составные объекты,

напишите на Турбо Прологе программу, содержащую базу данных с

записями о выступлениях текущей "Лучшей десятки". Элемент ба-

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

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

а также число недель, указанное в досье.

Рекурсия

Программа 10 иллюстрирует важный прием программирования

на Турбо Прологе, называемый рекурсией. Рекурсия обычно ис-

пользуется в двух ситуациях:

- когда отношения описываются с помощью самих этих отно-

шений;

- когда составные объекты представляют собой часть других

составных объектов (т.е. они являются рекурсивными объектами).

Первая из указанных ситуаций встречается в программе 10.

Она содержит факт и правило для единственного предиката

factorial(факториал), который, будучи исльзованным в такой

цели, как

factorial(N,F)

будет давать истину, если F равно N!,т.е. если

F = N*(N-1)*(N-2* .... *3*2*1

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

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

следующие цели:

factorial(1,Ansver). /* цель 1 */

factorial(2,Ansver). /* цель 2 */

factorial(3,Ansver). /* цель 3 */

factorial(4,Ansver). /* цель 4 */

factorial(5,Ansver). /* цель 5 */

factorial(6,620). /* цель 6 */

factorial(10,2000). /* цель 7 */

/* Программа 10 */

domains

n,f=integer

predicates

factorial(n,f)

clauses

factorial(1,1).

factorial(N,Res) if

N>0 and

N1=N-1 and

factorial(N1,PacN1) and

Res = N*PackN1.

Запись N1 = N - 1 в этой программе следует рассматривать

как более наглядную форму предложения

minus(N1,N,1)

где "-" представляет собой функтор. Таким образом, соотноше-

ние N1 = N - 1 дает истину при условии, что переменная N1

связана со значением N - 1.

Давайте посмотрим, каким образом проводится работа с фак-

ториалом при попытке удовлетворить цель

factorial(2,Answer)

Воспользовавшись правилом, получаем:

factorial(2,Res) if

2>1,N1=N-1,factorial(N1,FacN1),Res=2*FacN1.

Отсюда вытекает, что мы должны выполнять цель

factorial(1,FacN1)

Учитывая факт

factorial(1,1)

эта цель удовлетворяется, если связать переменную FacN1 с

единицей. Теперь, в свою очередь, нам надо вычислить

Res=2*FacN1

что достигается, если связать переменную Res с 2*1. Поэтому

первоначальная цель удовлетворяется, если переменная Answer

(ответ) связана с 2.

В случае более сложного вычисления, например

factorial(4,Answer)

мы получаем следующую последовательность вычислений:

factorial(4,Res) if

4>1,N1=4-1,factorial(4-1,FacN1),Res=4*FacN1

factorial(3,FacN1) if

3>1,N11=3-1,factorial(3-1,FacN11),Res=3*FacN11

factorial(2,Answer) if

2>1,N111=2-1,factorial(2-1,FacN111),Res=2*FacN111

Цель factorial(2-1,FacN111) удовлетворяется, если связать

с 1.

Цель factorial(3-1,FacN11) удовлетворяется, если связать

с 2.

Цель factorial(4-1,FacN1) удовлетворяется, если связать

с 6.

Цель factorial(4,Res) удовлетворяется, если связать

с 24.

Следовательно, цель factorial(4,Answer) удовлетворяется, если

связать переменную Answer с 24.

вызовы: factorial(4,Res)

вызовы: factorial(4-1,FacN1),4*FacN1

вызовы: factorial(4-1-1,FacN11),(4-1)*FacN11

вызовы: factorial(4-1-1-1,FacN111),(4-1-1)*FacN111

вызовы: factorial(1,1)

Рис. 4-1. Выполнение цели factorial(4,Ansver)

Упражнение. Добавьте декларации domains и predicates к

следующим фактам и правилам:

factorial(X,Y) if newfactorial(0,1,X,Y).

newfactorial(X,Y,X,Y).

newfactorial(U,V,X,Y) if

U1=U+1,

U1V=U1*V,

newfactorial(U1,U1V,X,Y).

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

лями:

1. factorial(3,Answer).

2. factorial(4,Answer).

3. factorial(5,Answer).

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

первой цели.

Рекурсивные объекты

~~~~~~~~~~~~~~~~~~~

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

при описании объектов, когда число элементов заранее не из-

вестно. Рассмотрим такую задачу: какой объект может описывать

имена всех учащихся в школьном классе, если число учащихся

заранее не известно?

Чтобы решить эту задачу, попробуем написать соответствую-

щую декларацию domains для домена classlist (список класса),

причем будем делать это шаг за шагом. Начнем с описания пус-

того класса, в котором учащиеся отсутствуют.

classlist = empty

Теперь напишем рекурсивное определение

classlist = class(name,classlist)

Так, например, типичным объектом может быть

class(peter,X)

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

ется peter. Переменная Х обозначает список класса в меньшем

составе (где peter отсутствует). Следовательно, класс, состо-

ящий из двух учащихся, можно описать, как

class(peter,class(james,empty))

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

образом:

class(andrew,class(peter,class(james,empty)))

Отметим, что

class(name,classlist)

представляет собой составной объект, где class (класс) - фун-

ктор, name (имя) соответствует одному учащемуся из класса, а

остальные учащиеся входят в список classlist. И наконец,

окончательная декларация domains состоит из двух альтернатив-

ных определений:

classlist = class(name,classlist) ; empty

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

можно было бы определить, например, следующим образом:

integerlist = list(integer,integerlist) ; empty

Упражнение. Опираясь на составные понятия Турбо Пролога,

напишите описание следующего списка чисел:

1, 3, 6, 0, 3

и постройте соответствующее дерево.

Упражнение. Для удобства составления программ на Турбо

Прологе нам хотелось бы рассматривать арифметические выраже-

ния, например, 1 + 2 - 3, как объекты. Во многом это достига-

ется за счет такой декларации domains:

expr=plus(expr,expr) ; number(integer)

Это дает возможность, например, работать с объектом

plus(number(2),number(3))

считая его соответствующим арифметическому выражению 4 + 5.

Аналогично выражение 1 + 2 + 3 можно было бы написать, как

plus(number(1),plus(number(2),number(3)))

или

plus(plus(number(1),number(2),number(3)))

Добавьте новые альтернативы в приведенную выше декларацию

domains так, чтобы можно было работать с объектами, описываю-

щими такие выражения, как 2 - 4 или 2 + 3 - log (5).

Чарующие миры списков и рекурсий

~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

Списки представляют собой основную структуру данных, ис-

пользуемую в программах на Турбо Прологе. Это примерно иден-

тично использованию Паскале массивов. Поскольку списки ис-

пользуются так часто, в Турбо Прологе существует более прос-

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

объектами. Список, состоящий из чисел 1, 2 и 3, можно запи-

сать, как

[1,2,3,4]

Элементы списка разделяются запятыми и заключаются в квадрат-

ные скобки. Приведем несколько примеров:

[dog,cat,canary]

["valery ann","jonatan","michael"]

Чтобы описать домен для списков из целых чисел, восполь-

зуемся такой декларацией, как

domains

integerlist = integer*

где звездочка показывает, что в списке присутствует 0 или бо-

лее элементов.

Объекты в списке могут быть какими угодно и в том числе

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

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

объектов должна существовать декларация domains, которая за-

писывается в следующем виде:

domains

objectlist = object*

object = .........

При обработке списков на Турбо Прологе они разделяются на

две части: голову и остаток. Голова списка [1, 2, 3] - это

элемент 1. Остаток этого списка получается, если удалить из

него голову, т.е. в данном случае остаток - это список [2,3].

Для разделения головы и остатка списка в Турбо Прологе

используется вертикальная черта ( ). Следовательно, список с

головой Х и остатком У записывается, как

[X|Y]

Таблица 4-3

Обработка списков

-------------------------------------------------------------

Список Голова Остаток

_____________________________________________________________

['a','b','c'] 'a' ['b','c']

[1] 1 (пустой список)

[] не определена не определен

[[1,2,3],[2,3,4],[]] [1,2,3] [[2,3,4],[]]

--------------------------------------------------------------

Если Турбо Пролог будет пытаться удовлетворить цель

scores([X|Y])

и найдет факт

scores([0,1,0,2,6,0,0,1,2,3])

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

числом 0, а переменная У окажется связанной с остатком спис-

ка, т.е. со списком

[0,1,0,2,6,0,0,1,2,3]

В таблице 4-4 даются некоторые примеры соответствия спис-

ков. Свободные переменные связываются тем же путем, что пере-

менные Х и У в предыдущем примере.

Таблица 4-4

Соответствие списков

--------------------------------------------------------------

Список 1 Список 2 Связывание переменных

--------------------------------------------------------------

[Х,Y,Z] [эгберт,ест,мороженое] Х=экберт,Y=ест,Z=мороженое

[7] [Х|У] Х=7,Y=[ ]

[1,2,3,4] [Х,Y|Z] Х=1,Y=2,Z=[3,4]

[1,2] [3|Х] Сравнения не произошло,

так как головы двух списков

различны

--------------------------------------------------------------

Используемые списки

~~~~~~~~~~~~~~~~~~~

В этом и в двух следующих разделах мы будем исследовать

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

для обработки списков.

Члены списка

~~~~~~~~~~~~

Допустим, что у нас есть список имен

[john,leonhard,eric,frank]

и нам хочется воспользоваться Турбо Прологом, чтобы выяснить,

присутствует ли заданное имя в списке. Иными словами, мы дол-

жны выразить отношение member (член) между двумя объектами -

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

предикате:

member(name,namelist)

Первое предложение программы 11 проверяет голову списка.

Если голова соответствует переменной Name (имя), которую мы

ищем, то можно сделать вывод, что Name - это член списка. По-

скольку остаток списка интереса не представляет, он обеспечи-

вается с помощью переменной "_". В силу рассматриваемого пер-

вого предложения такая цель, как

member([john,leonhard,eric,frank])

удовлетворяется.

/* Программа 11 */

domains

namelist = name*

name = symbol

predicates

member(name,nemelist)

clauses

member(Name,[Name|_]).

member(Name,[_|Tail]) if member(Name,Tail).

Если голова списка отличается от переменной Name, то нам

надо проверить, можно ли найти Name в остатке этого списка.

Иными словами:

"Name - это член списка, если Name - это член остатка"

На Турбо Прологе это выглядит так:

member(Name,[_|Tail]) if member(Name,Tail).

Упражнение. Набейте приведенную выше программу и попро-

буйте выполнить следующую цель:

member(susan,[ivan,susan,john]).

Добавьте утверждения о домене и предикате так, чтобы предикат

member можно было бы использовать также, чтобы выяснить, яв-

ляется ли некоторое число членом списка, состоящего из чисел.

Попробуйте несколько целей, чтобы проверить полученную вами

новую программу, и в том числе - цель

member(X,[1,2,3,4]).

Упражнение. Имеет ли хоть какое-то значение порядок запи-

си двух предложений, соответствующих предикату member? Пос-

мотрите на поведение программы, поменяв эти предложения мес-

тами. Различие в этих двух ситуациях проявится, если прове-

рить следующую цель:

member(X,[1,2,3,4,5])

Выписывание элементов списка

~~~~~~~~~~~~~~~~~~~~~~~~~~~~

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

списка на отдельных строках. И вновь мы должны мыслить рекур-

сивно.

write_a_list([]).

write_a_list([Head|Tail]) if

write(Head),nl,write_a_list(Tail).

В первом предложении сказано: завершите выполнение, если

элементов в списке больше нет (т.е. список пустой). Во втором

предложении говорится: выпишите голову списка, перейдите на

новую строку, а затем обрабатывайте остаток.

Упражнение. Доведите до конца приведенную выше программу

с предикатом (выписать_список), после чего про-

верьте следующую цель:

write_a_list([2,4,6,8,10])

Добавление одного списка к другому,

~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

декларативное и процедурное программирование

~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

Предикат member, рассмотренный нами в программе 11, может

работать двумя способами. Посмотрим на соответствующие ему

предложения еще раз:

member(Name,[Name|_]).

member(Name,[_|Tail]) if member(Name,Tail).

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

ния. С декларативной точки зрения здесь говорится, что имеет-

ся список, переменная Name есть член этого списка, если его

голова - это Name; если же нет, то Name есть член списка, ес-

ли Name - член его остатка. С процедурной точки зрения эти

предложения можно было бы интерпретировать так: чтобы найти

член списка, найдите его голову, а если не удалось, то найди-

те член остатка списка.

Эти две точки зрения соответствуют целям

member(2,[1,2,3,4]).

и

member(X,[1,2,3,4]).

так как, на самом деле, первая цель просит Турбо Пролог про-

верить, что нечто является истиной, в то время как вторая

цель просит его отыскать все члены списка [1,2,3,4].

Прелесть Турбо Пролога часто заключается в том, что если

мы строим предложения для некоторого предиката с одной точки

зрения, то работать они будут совсем с другой. В качестве

примера, подтверждающего это, мы построим сейчас предикат,

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

например, соединим списки [1,2,3] и [4,5], чтобы получить

список [1,2,3,4,5]. Определим предикат append (присоединить),

имеющий три аргумента:

append(List1,List2,List3)

Этот предикат объединяет списки List1 и List2 в список List3.

В данном случае мы еще раз пользуемся рекурсией (с процедур-

ной точки зрения).

Если список List1 пуст, то результат соединения списков

List1 b List2 , будет совпадать со списком List2. На Турбо

Прологе это выглядит следующим образом:

append([],List2,List2)

В противном случае мы можем объединить списки List1 и List2 в

список List3,сделав голову списка List1 головой списка List3.

(Ниже в качестве общей головы списков List1 и List3 использу-

ется переменная Х). Оставшаяся часть списка List3 (его оста-

ток) получается за счет объединения оставшейся части списка

List1 и всего списка List2. (Остаток списка List3 - это L3,

что является результатом объединения оставшейся части списка

List1, именуемой L1, и всего списка List2.). На Турбо Прологе

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

append([X|L1],List2,[X|L3]) if

append(L1,List2,L3)

Таким образом, предикат append (присоединить) действует так:

пока список List1 не пуст, рекурсивное правило каждый раз пе-

реводит один его элемент в список List3. Когда список List1

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

нение списка List2 к хвосту списка List3.

Упражнение. В программе на Турбо Прологе, приведенной ни-

же, определены два предиката append и writelist (вывод_спис-

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

Руководство к пользованию TURBO PROLOG

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