wikiru.visual-prolog.com - Вклад [ru]

Что нового в VIP 7.3

2010-03-26T13:14:25Z

SergeMukhin: /* Other language features */

{{Preliminary Documentation}}

== Язык ==

=== Generic интерфейсы и классы ===

смотри [http://wiki.visual-prolog.com/index.php?title=Language_Reference/Generic_Interfaces_and_Classes Generic интерфейсы и классы (en)].

=== Conversion to Generic Type ===

=== Мониторы ===

[http://wiki.visual-prolog.com/index.php?title=Language_Reference/Monitors Мониторы (en)] с [http://wiki.visual-prolog.com/index.php?title=Language_Reference/Monitors#Guards гардами (en)]

=== Must Unify оператор ===

Новый оператор == (must-unify)

=== Термы универсального типа ===

<vp>any</vp> и предикат <vp>toAny/1-></vp>

=== Подготовка к 64-битной реализации ===

Подготовка к 64-битной реализации 64bit systems: built-in типы <vp>integerNative</vp> и <vp>unsignedNative</vp>

=== Интерфейс с другими языками ===

Native interfaces support (attributes):
* [http://wiki.visual-prolog.com/index.php?title=Language_Reference/Attributes#inline inline (en)]: встроенные структуры и строки.
* [http://wiki.visual-prolog.com/index.php?title=Language_Reference/Attributes#union union (en)]: безфункторное объединение.
* [http://wiki.visual-prolog.com/index.php?title=Language_Reference/Attributes#byVal byVal (en)]: передача параметра по значению.

По умолчанию, для соглашения о вызове <vp>apicall</vp>, применяется внешнее разрешение.
* Они не могут иметь clauses
* Явное внешнее разрешение правильно только с динамической DLL
* Является процедурой

=== Other language features ===

* Приоритет унарного минуса изменен (теперь операция возведения имеет наивысший приоритет)
* Новые версии встроенных предикатов <vp>toTerm/2-></vp> м <vp>tryToTerm/2-></vp> (добавлен первый параметр - тип).
* Новый встроенный предикат <vp>fromEllipsis : (...) -> any* Terms</vp>

Новые аттрибуты:
* retired
* noDefaultConstructor
* used

Новая или улучшенная диагностика:
* Локальный объектный предикат не использует <vp>This</vp> (и может быть объявлен как классный)
* не используемая локальная константа
* Условие в <vp>foreach</vp> не имеет точек бактракинга (должно быть или <vp>multi</vp> или <vp>nondeterm</vp>)
* Конверсия <vp>unheckedConversion</vp> не верна для 64 bit платформ (например <vp>pointer</vp> -> <vp>integer</vp>)

== IDE ==

=== Проектное окно ===

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

Окна '''IncludedIn''' и '''Includes''' перенесены в проектное окно в правую панель предоосмотра.

Появилась возможность создания в проекте несколько одноименных пакетов (для поддержки разных namespace например).

=== Диалог просмотра===

Диалог '''Browse''' ускорен и улучшен:

=== Поиск в файлах===

Поиск в файлах ('''Find In Files''') ускорен и улучшен:
* окно результата может переиспользоваться
* Кнопки F8 и Shift+F8 служат для навигации
* добавлен режим "Prolog case sensitive"
* Запоминается последнее состояние

=== поддержка Namespace ===

Поддержка '''Namespaces''' улучшена.

=== IntelliSense ===

Свойство '''IntelliSense''' улучшено.

=== Tab navigation диалог (Ctrl+Tab) ===

Добавлена функциональность '''tab navigation''' диалога:
* при использовании кнопки ALT фильтруются все [ReadOnly] окна
* при нажатии Del - соответствующее окно закрывается

=== Go to Position on Clipboard ===

Свойство '''Go to Position on Clipboard''' (Shift+F2) улучшено.

=== Сортировка в некоторых окнах ===

Окно ошибок (Errors Window), точек останова (Break points Window) и некоторые другие появилась возможность сортировать колонки. Для этого надо просто нажать на вверх колонки.
* '''Optimal Set of Includes improved''' (output, local scopes, etc.)

== Debugger ==

* Измененные переменные и их значения показываются выделением '''Highlighting'''
* Улучшен просмотр длинных списков
* Ускорен рестарт отладчика
* Появились точки останова ('''Memory break points''') по памяти и для некоторых типов фактов
* Улучшена работа с несколькими thread (добавлена возможность указания имени thread, улучшена обработка прерываний в thread)
* При длинных значениях tooltip может показываеться в несколько строк

== PFC ==

=== Новые пакеты ===

* [[Collection library]]
** Algebraic: <vp>redBlackSet</vp>, <vp>leftistPriorityQueue</vp>
** Modifiable: <vp>mapM_redBlack</vp>, <vp>priorityQueueM_leftist</vp>, <vp>queueM_fact</vp>, <vp>setM_redBlack</vp>
** Persistent: <vp>mapP_redBlack</vp>, <vp>priorityQueueP_leftist</vp>, <vp>queueP_fact</vp>, <vp>setP_redBlack</vp>
* <vp>varM</vp> modifiable variable
* <vp>linkControl</vp> PFC version of the Link common control
* <vp>richEditControl</vp> PFC version of the RichEdit common control
* <vp>treeControl</vp> PFC model based version of the TreeView common control
* <vp>gdiplus</vp> PFC version of GDI+
* <vp>cryptography</vp> hash, sha1, md5 & base64
* <vp>eventSource</vp> generalization of event notification/listening
* <vp>monitorQueue</vp> thread safe queue class based on the monitor facility
* <vp>reflection</vp> basic functionalty for code reflection
* <vp>inputStream_null</vp> & <vp>outputStream_null</vp> media-less streams (input is exhausted; outpt throws away)
* <vp>lZ_fileSystem_native</vp> Interface to Lempel-Ziv Decompression API functionality
* <vp>shell_api</vp> Api level interface to the Windows Shell
* <vp>winsock2_native</vp> native bindings to Windows Sockets 2

=== Extensions and improvements ===

* <vp>list</vp> package:
** speed: <vp>sort</vp>, <vp>removeDuplicate</vp>, <vp>drop</vp>, <vp>min</vp>/<vp>max</vp>, etc.)
** functionality: <vp>isMemberEq</vp> (and similar predicates) that uses a <vp>determ</vp> predicate as test
* <vp>listControl</vp> with owner-drawing capabilities
* <vp>uxTheme_native</vp> extended with the rest of the functions and the constants from vsStyle.h, etc.
* Add moving listener/responder to <vp>splitTwoControl</vp>
* Add the fraction handling from <vp>format</vp> to <vp>formatTime</vp>
* '''Speed''' improvements for:
** <vp>string</vp>
** <vp>fileName</vp>
** <vp>listViewControl</vp>
* <vp>string::rear/2-></vp> returns the rear part of a string
* '''Math''' package: predicates <vp>roundToInteger64/1-></vp> and <vp>roundToUnsigned64/1-></vp>
* Better handling of '''default button size'''
* <vp>msXLM_api</vp> update to version 6.0 of various COMponent classes

== Others ==

* Более эффективное '''управление памятью'''; во многих случаях используется типовая аллокация памяти, для составных доменов, списков и цепочек баз данных
* Несколько различных оптимизаций для увеличения скорости и уменьшения генерируемого кода
* Новые примеры для демонстрации (Demo Examples) (только для коммерческой версии):
** Parser Generator
** LZDecompression
** TreeControlDemo
* Help on built-in entities
* VipBuilder: новая опция для игнорирования директивы <vp>#requires</vp>
* В библиотеку '''Win32''' добавлены имена из многих MS библиотек.
* При ошибки выполнения предиката consult выдается добавочная информация, позволяющая локализовать ошибку в базе данных
* Ускорен линкер
* Интеграция со службой Vault теперь работает с версией 5.0.1

[[Category:Release Notes]]

Что нового в VIP 7.3

2010-03-26T13:14:07Z

SergeMukhin: /* Проектное окно */

{{Preliminary Documentation}}

== Язык ==

=== Generic интерфейсы и классы ===

смотри [http://wiki.visual-prolog.com/index.php?title=Language_Reference/Generic_Interfaces_and_Classes Generic интерфейсы и классы (en)].

=== Conversion to Generic Type ===

=== Мониторы ===

[http://wiki.visual-prolog.com/index.php?title=Language_Reference/Monitors Мониторы (en)] с [http://wiki.visual-prolog.com/index.php?title=Language_Reference/Monitors#Guards гардами (en)]

=== Must Unify оператор ===

Новый оператор == (must-unify)

=== Термы универсального типа ===

<vp>any</vp> и предикат <vp>toAny/1-></vp>

=== Подготовка к 64-битной реализации ===

Подготовка к 64-битной реализации 64bit systems: built-in типы <vp>integerNative</vp> и <vp>unsignedNative</vp>

=== Интерфейс с другими языками ===

Native interfaces support (attributes):
* [http://wiki.visual-prolog.com/index.php?title=Language_Reference/Attributes#inline inline (en)]: встроенные структуры и строки.
* [http://wiki.visual-prolog.com/index.php?title=Language_Reference/Attributes#union union (en)]: безфункторное объединение.
* [http://wiki.visual-prolog.com/index.php?title=Language_Reference/Attributes#byVal byVal (en)]: передача параметра по значению.

По умолчанию, для соглашения о вызове <vp>apicall</vp>, применяется внешнее разрешение.
* Они не могут иметь clauses
* Явное внешнее разрешение правильно только с динамической DLL
* Является процедурой

=== Other language features ===

* Приоритет унарного минуса изменен (теперь операция возведения имеет наивысший приоритет)
* Новые версии встроенных предикатов <vp>toTerm/2-></vp> м <vp>tryToTerm/2-></vp> (добавлен первый параметр - тип).
* Новый встроенный предикат <vp>fromEllipsis : (...) -> any* Terms</vp>
* Удалено отличие между приватными и публичными интерфейсами в суппорт

Новые аттрибуты:
* retired
* noDefaultConstructor
* used

Новая или улучшенная диагностика:
* Локальный объектный предикат не использует <vp>This</vp> (и может быть объявлен как классный)
* не используемая локальная константа
* Условие в <vp>foreach</vp> не имеет точек бактракинга (должно быть или <vp>multi</vp> или <vp>nondeterm</vp>)
* Конверсия <vp>unheckedConversion</vp> не верна для 64 bit платформ (например <vp>pointer</vp> -> <vp>integer</vp>)

== IDE ==

=== Проектное окно ===

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

Окна '''IncludedIn''' и '''Includes''' перенесены в проектное окно в правую панель предоосмотра.

Появилась возможность создания в проекте несколько одноименных пакетов (для поддержки разных namespace например).

=== Диалог просмотра===

Диалог '''Browse''' ускорен и улучшен:

=== Поиск в файлах===

Поиск в файлах ('''Find In Files''') ускорен и улучшен:
* окно результата может переиспользоваться
* Кнопки F8 и Shift+F8 служат для навигации
* добавлен режим "Prolog case sensitive"
* Запоминается последнее состояние

=== поддержка Namespace ===

Поддержка '''Namespaces''' улучшена.

=== IntelliSense ===

Свойство '''IntelliSense''' улучшено.

=== Tab navigation диалог (Ctrl+Tab) ===

Добавлена функциональность '''tab navigation''' диалога:
* при использовании кнопки ALT фильтруются все [ReadOnly] окна
* при нажатии Del - соответствующее окно закрывается

=== Go to Position on Clipboard ===

Свойство '''Go to Position on Clipboard''' (Shift+F2) улучшено.

=== Сортировка в некоторых окнах ===

Окно ошибок (Errors Window), точек останова (Break points Window) и некоторые другие появилась возможность сортировать колонки. Для этого надо просто нажать на вверх колонки.
* '''Optimal Set of Includes improved''' (output, local scopes, etc.)

== Debugger ==

* Измененные переменные и их значения показываются выделением '''Highlighting'''
* Улучшен просмотр длинных списков
* Ускорен рестарт отладчика
* Появились точки останова ('''Memory break points''') по памяти и для некоторых типов фактов
* Улучшена работа с несколькими thread (добавлена возможность указания имени thread, улучшена обработка прерываний в thread)
* При длинных значениях tooltip может показываеться в несколько строк

== PFC ==

=== Новые пакеты ===

* [[Collection library]]
** Algebraic: <vp>redBlackSet</vp>, <vp>leftistPriorityQueue</vp>
** Modifiable: <vp>mapM_redBlack</vp>, <vp>priorityQueueM_leftist</vp>, <vp>queueM_fact</vp>, <vp>setM_redBlack</vp>
** Persistent: <vp>mapP_redBlack</vp>, <vp>priorityQueueP_leftist</vp>, <vp>queueP_fact</vp>, <vp>setP_redBlack</vp>
* <vp>varM</vp> modifiable variable
* <vp>linkControl</vp> PFC version of the Link common control
* <vp>richEditControl</vp> PFC version of the RichEdit common control
* <vp>treeControl</vp> PFC model based version of the TreeView common control
* <vp>gdiplus</vp> PFC version of GDI+
* <vp>cryptography</vp> hash, sha1, md5 & base64
* <vp>eventSource</vp> generalization of event notification/listening
* <vp>monitorQueue</vp> thread safe queue class based on the monitor facility
* <vp>reflection</vp> basic functionalty for code reflection
* <vp>inputStream_null</vp> & <vp>outputStream_null</vp> media-less streams (input is exhausted; outpt throws away)
* <vp>lZ_fileSystem_native</vp> Interface to Lempel-Ziv Decompression API functionality
* <vp>shell_api</vp> Api level interface to the Windows Shell
* <vp>winsock2_native</vp> native bindings to Windows Sockets 2

=== Extensions and improvements ===

* <vp>list</vp> package:
** speed: <vp>sort</vp>, <vp>removeDuplicate</vp>, <vp>drop</vp>, <vp>min</vp>/<vp>max</vp>, etc.)
** functionality: <vp>isMemberEq</vp> (and similar predicates) that uses a <vp>determ</vp> predicate as test
* <vp>listControl</vp> with owner-drawing capabilities
* <vp>uxTheme_native</vp> extended with the rest of the functions and the constants from vsStyle.h, etc.
* Add moving listener/responder to <vp>splitTwoControl</vp>
* Add the fraction handling from <vp>format</vp> to <vp>formatTime</vp>
* '''Speed''' improvements for:
** <vp>string</vp>
** <vp>fileName</vp>
** <vp>listViewControl</vp>
* <vp>string::rear/2-></vp> returns the rear part of a string
* '''Math''' package: predicates <vp>roundToInteger64/1-></vp> and <vp>roundToUnsigned64/1-></vp>
* Better handling of '''default button size'''
* <vp>msXLM_api</vp> update to version 6.0 of various COMponent classes

== Others ==

* Более эффективное '''управление памятью'''; во многих случаях используется типовая аллокация памяти, для составных доменов, списков и цепочек баз данных
* Несколько различных оптимизаций для увеличения скорости и уменьшения генерируемого кода
* Новые примеры для демонстрации (Demo Examples) (только для коммерческой версии):
** Parser Generator
** LZDecompression
** TreeControlDemo
* Help on built-in entities
* VipBuilder: новая опция для игнорирования директивы <vp>#requires</vp>
* В библиотеку '''Win32''' добавлены имена из многих MS библиотек.
* При ошибки выполнения предиката consult выдается добавочная информация, позволяющая локализовать ошибку в базе данных
* Ускорен линкер
* Интеграция со службой Vault теперь работает с версией 5.0.1

[[Category:Release Notes]]

Что нового в VIP 7.3

2010-03-26T13:13:46Z

SergeMukhin: /* IDE */

{{Preliminary Documentation}}

== Язык ==

=== Generic интерфейсы и классы ===

смотри [http://wiki.visual-prolog.com/index.php?title=Language_Reference/Generic_Interfaces_and_Classes Generic интерфейсы и классы (en)].

=== Conversion to Generic Type ===

=== Мониторы ===

[http://wiki.visual-prolog.com/index.php?title=Language_Reference/Monitors Мониторы (en)] с [http://wiki.visual-prolog.com/index.php?title=Language_Reference/Monitors#Guards гардами (en)]

=== Must Unify оператор ===

Новый оператор == (must-unify)

=== Термы универсального типа ===

<vp>any</vp> и предикат <vp>toAny/1-></vp>

=== Подготовка к 64-битной реализации ===

Подготовка к 64-битной реализации 64bit systems: built-in типы <vp>integerNative</vp> и <vp>unsignedNative</vp>

=== Интерфейс с другими языками ===

Native interfaces support (attributes):
* [http://wiki.visual-prolog.com/index.php?title=Language_Reference/Attributes#inline inline (en)]: встроенные структуры и строки.
* [http://wiki.visual-prolog.com/index.php?title=Language_Reference/Attributes#union union (en)]: безфункторное объединение.
* [http://wiki.visual-prolog.com/index.php?title=Language_Reference/Attributes#byVal byVal (en)]: передача параметра по значению.

По умолчанию, для соглашения о вызове <vp>apicall</vp>, применяется внешнее разрешение.
* Они не могут иметь clauses
* Явное внешнее разрешение правильно только с динамической DLL
* Является процедурой

=== Other language features ===

* Приоритет унарного минуса изменен (теперь операция возведения имеет наивысший приоритет)
* Новые версии встроенных предикатов <vp>toTerm/2-></vp> м <vp>tryToTerm/2-></vp> (добавлен первый параметр - тип).
* Новый встроенный предикат <vp>fromEllipsis : (...) -> any* Terms</vp>
* Удалено отличие между приватными и публичными интерфейсами в суппорт

Новые аттрибуты:
* retired
* noDefaultConstructor
* used

Новая или улучшенная диагностика:
* Локальный объектный предикат не использует <vp>This</vp> (и может быть объявлен как классный)
* не используемая локальная константа
* Условие в <vp>foreach</vp> не имеет точек бактракинга (должно быть или <vp>multi</vp> или <vp>nondeterm</vp>)
* Конверсия <vp>unheckedConversion</vp> не верна для 64 bit платформ (например <vp>pointer</vp> -> <vp>integer</vp>)

== IDE ==

=== Проектное окно ===

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

Окна '''IncludedIn''' и '''Includes''' перенесены в проектное окно в правую панель предоосмотра.

Появилась возможность создания в проекте несколько одноименных пакетов (для поддержки разных namesapce например).

=== Диалог просмотра===

Диалог '''Browse''' ускорен и улучшен:

=== Поиск в файлах===

Поиск в файлах ('''Find In Files''') ускорен и улучшен:
* окно результата может переиспользоваться
* Кнопки F8 и Shift+F8 служат для навигации
* добавлен режим "Prolog case sensitive"
* Запоминается последнее состояние

=== поддержка Namespace ===

Поддержка '''Namespaces''' улучшена.

=== IntelliSense ===

Свойство '''IntelliSense''' улучшено.

=== Tab navigation диалог (Ctrl+Tab) ===

Добавлена функциональность '''tab navigation''' диалога:
* при использовании кнопки ALT фильтруются все [ReadOnly] окна
* при нажатии Del - соответствующее окно закрывается

=== Go to Position on Clipboard ===

Свойство '''Go to Position on Clipboard''' (Shift+F2) улучшено.

=== Сортировка в некоторых окнах ===

Окно ошибок (Errors Window), точек останова (Break points Window) и некоторые другие появилась возможность сортировать колонки. Для этого надо просто нажать на вверх колонки.
* '''Optimal Set of Includes improved''' (output, local scopes, etc.)

== Debugger ==

* Измененные переменные и их значения показываются выделением '''Highlighting'''
* Улучшен просмотр длинных списков
* Ускорен рестарт отладчика
* Появились точки останова ('''Memory break points''') по памяти и для некоторых типов фактов
* Улучшена работа с несколькими thread (добавлена возможность указания имени thread, улучшена обработка прерываний в thread)
* При длинных значениях tooltip может показываеться в несколько строк

== PFC ==

=== Новые пакеты ===

* [[Collection library]]
** Algebraic: <vp>redBlackSet</vp>, <vp>leftistPriorityQueue</vp>
** Modifiable: <vp>mapM_redBlack</vp>, <vp>priorityQueueM_leftist</vp>, <vp>queueM_fact</vp>, <vp>setM_redBlack</vp>
** Persistent: <vp>mapP_redBlack</vp>, <vp>priorityQueueP_leftist</vp>, <vp>queueP_fact</vp>, <vp>setP_redBlack</vp>
* <vp>varM</vp> modifiable variable
* <vp>linkControl</vp> PFC version of the Link common control
* <vp>richEditControl</vp> PFC version of the RichEdit common control
* <vp>treeControl</vp> PFC model based version of the TreeView common control
* <vp>gdiplus</vp> PFC version of GDI+
* <vp>cryptography</vp> hash, sha1, md5 & base64
* <vp>eventSource</vp> generalization of event notification/listening
* <vp>monitorQueue</vp> thread safe queue class based on the monitor facility
* <vp>reflection</vp> basic functionalty for code reflection
* <vp>inputStream_null</vp> & <vp>outputStream_null</vp> media-less streams (input is exhausted; outpt throws away)
* <vp>lZ_fileSystem_native</vp> Interface to Lempel-Ziv Decompression API functionality
* <vp>shell_api</vp> Api level interface to the Windows Shell
* <vp>winsock2_native</vp> native bindings to Windows Sockets 2

=== Extensions and improvements ===

* <vp>list</vp> package:
** speed: <vp>sort</vp>, <vp>removeDuplicate</vp>, <vp>drop</vp>, <vp>min</vp>/<vp>max</vp>, etc.)
** functionality: <vp>isMemberEq</vp> (and similar predicates) that uses a <vp>determ</vp> predicate as test
* <vp>listControl</vp> with owner-drawing capabilities
* <vp>uxTheme_native</vp> extended with the rest of the functions and the constants from vsStyle.h, etc.
* Add moving listener/responder to <vp>splitTwoControl</vp>
* Add the fraction handling from <vp>format</vp> to <vp>formatTime</vp>
* '''Speed''' improvements for:
** <vp>string</vp>
** <vp>fileName</vp>
** <vp>listViewControl</vp>
* <vp>string::rear/2-></vp> returns the rear part of a string
* '''Math''' package: predicates <vp>roundToInteger64/1-></vp> and <vp>roundToUnsigned64/1-></vp>
* Better handling of '''default button size'''
* <vp>msXLM_api</vp> update to version 6.0 of various COMponent classes

== Others ==

* Более эффективное '''управление памятью'''; во многих случаях используется типовая аллокация памяти, для составных доменов, списков и цепочек баз данных
* Несколько различных оптимизаций для увеличения скорости и уменьшения генерируемого кода
* Новые примеры для демонстрации (Demo Examples) (только для коммерческой версии):
** Parser Generator
** LZDecompression
** TreeControlDemo
* Help on built-in entities
* VipBuilder: новая опция для игнорирования директивы <vp>#requires</vp>
* В библиотеку '''Win32''' добавлены имена из многих MS библиотек.
* При ошибки выполнения предиката consult выдается добавочная информация, позволяющая локализовать ошибку в базе данных
* Ускорен линкер
* Интеграция со службой Vault теперь работает с версией 5.0.1

[[Category:Release Notes]]

Что нового в VIP 7.3

2010-03-26T13:06:27Z

SergeMukhin: /* Other language features */

{{Preliminary Documentation}}

== Язык ==

=== Generic интерфейсы и классы ===

смотри [http://wiki.visual-prolog.com/index.php?title=Language_Reference/Generic_Interfaces_and_Classes Generic интерфейсы и классы (en)].

=== Conversion to Generic Type ===

=== Мониторы ===

[http://wiki.visual-prolog.com/index.php?title=Language_Reference/Monitors Мониторы (en)] с [http://wiki.visual-prolog.com/index.php?title=Language_Reference/Monitors#Guards гардами (en)]

=== Must Unify оператор ===

Новый оператор == (must-unify)

=== Термы универсального типа ===

<vp>any</vp> и предикат <vp>toAny/1-></vp>

=== Подготовка к 64-битной реализации ===

Подготовка к 64-битной реализации 64bit systems: built-in типы <vp>integerNative</vp> и <vp>unsignedNative</vp>

=== Интерфейс с другими языками ===

Native interfaces support (attributes):
* [http://wiki.visual-prolog.com/index.php?title=Language_Reference/Attributes#inline inline (en)]: встроенные структуры и строки.
* [http://wiki.visual-prolog.com/index.php?title=Language_Reference/Attributes#union union (en)]: безфункторное объединение.
* [http://wiki.visual-prolog.com/index.php?title=Language_Reference/Attributes#byVal byVal (en)]: передача параметра по значению.

По умолчанию, для соглашения о вызове <vp>apicall</vp>, применяется внешнее разрешение.
* Они не могут иметь clauses
* Явное внешнее разрешение правильно только с динамической DLL
* Является процедурой

=== Other language features ===

* Приоритет унарного минуса изменен (теперь операция возведения имеет наивысший приоритет)
* Новые версии встроенных предикатов <vp>toTerm/2-></vp> м <vp>tryToTerm/2-></vp> (добавлен первый параметр - тип).
* Новый встроенный предикат <vp>fromEllipsis : (...) -> any* Terms</vp>
* Удалено отличие между приватными и публичными интерфейсами в суппорт

Новые аттрибуты:
* retired
* noDefaultConstructor
* used

Новая или улучшенная диагностика:
* Локальный объектный предикат не использует <vp>This</vp> (и может быть объявлен как классный)
* не используемая локальная константа
* Условие в <vp>foreach</vp> не имеет точек бактракинга (должно быть или <vp>multi</vp> или <vp>nondeterm</vp>)
* Конверсия <vp>unheckedConversion</vp> не верна для 64 bit платформ (например <vp>pointer</vp> -> <vp>integer</vp>)

== IDE ==

=== Project tree ===

The project tree is redesigned and reimplemented. The functionality is more or less unchanged, but the performance is improved.

The '''IncludedIn''' and '''Includes''' windows has been moved to preview pane of project window.

It is not possible to have several packages with same name in a project (which can make much sense when using namespaces).

=== Browse dialog ===

The '''Browse''' dialog is improved in several smaller respects, including:
* It automatically jump to the 1st occurrence of search entity on locate
* The last dialog position is saved for next appearence

=== Find In Files ===

The '''Find In Files''' dialog is improved in several respects, including:
* result window is reused for subsequent searches
* F8 button for next match (Shift+F8 - previous)
* Prolog case sensitive search mode
* state is saved for next appearence

=== Namespace support ===

The '''Namespaces support''' is improved, so that forms, dialogs, etc can be places in namespaces when created.

=== IntelliSense ===

The '''IntelliSense''' feature is improved for better overview, speed typing and convenience of work.

=== Tab navigation диалог (Ctrl+Tab) ===

Добавлена функциональность '''tab navigation''' диалога:
* при использовании кнопки ALT фильтруются все [ReadOnly] окна
* при нажатии Del - соответствующее окно закрывается

=== Go to Position on Clipboard ===

The '''Go to Position on Clipboard''' (Shift+F2) has been extended to accept a complete exception dump. F8 will go to the next stack entry.

=== Сортировка в некоторых окнах ===

Окно ошибок (Errors Window), точек останова (Break points Window) и некоторые другие появилась возможность сортировать колонки. Для этого надо просто нажать на вверх колонки.
* '''Optimal Set of Includes improved''' (output, local scopes, etc.)

== Debugger ==

* Измененные переменные и их значения показываются выделением '''Highlighting'''
* Улучшен просмотр длинных списков
* Ускорен рестарт отладчика
* Появились точки останова ('''Memory break points''') по памяти и для некоторых типов фактов
* Улучшена работа с несколькими thread (добавлена возможность указания имени thread, улучшена обработка прерываний в thread)
* При длинных значениях tooltip может показываеться в несколько строк

== PFC ==

=== Новые пакеты ===

* [[Collection library]]
** Algebraic: <vp>redBlackSet</vp>, <vp>leftistPriorityQueue</vp>
** Modifiable: <vp>mapM_redBlack</vp>, <vp>priorityQueueM_leftist</vp>, <vp>queueM_fact</vp>, <vp>setM_redBlack</vp>
** Persistent: <vp>mapP_redBlack</vp>, <vp>priorityQueueP_leftist</vp>, <vp>queueP_fact</vp>, <vp>setP_redBlack</vp>
* <vp>varM</vp> modifiable variable
* <vp>linkControl</vp> PFC version of the Link common control
* <vp>richEditControl</vp> PFC version of the RichEdit common control
* <vp>treeControl</vp> PFC model based version of the TreeView common control
* <vp>gdiplus</vp> PFC version of GDI+
* <vp>cryptography</vp> hash, sha1, md5 & base64
* <vp>eventSource</vp> generalization of event notification/listening
* <vp>monitorQueue</vp> thread safe queue class based on the monitor facility
* <vp>reflection</vp> basic functionalty for code reflection
* <vp>inputStream_null</vp> & <vp>outputStream_null</vp> media-less streams (input is exhausted; outpt throws away)
* <vp>lZ_fileSystem_native</vp> Interface to Lempel-Ziv Decompression API functionality
* <vp>shell_api</vp> Api level interface to the Windows Shell
* <vp>winsock2_native</vp> native bindings to Windows Sockets 2

=== Extensions and improvements ===

* <vp>list</vp> package:
** speed: <vp>sort</vp>, <vp>removeDuplicate</vp>, <vp>drop</vp>, <vp>min</vp>/<vp>max</vp>, etc.)
** functionality: <vp>isMemberEq</vp> (and similar predicates) that uses a <vp>determ</vp> predicate as test
* <vp>listControl</vp> with owner-drawing capabilities
* <vp>uxTheme_native</vp> extended with the rest of the functions and the constants from vsStyle.h, etc.
* Add moving listener/responder to <vp>splitTwoControl</vp>
* Add the fraction handling from <vp>format</vp> to <vp>formatTime</vp>
* '''Speed''' improvements for:
** <vp>string</vp>
** <vp>fileName</vp>
** <vp>listViewControl</vp>
* <vp>string::rear/2-></vp> returns the rear part of a string
* '''Math''' package: predicates <vp>roundToInteger64/1-></vp> and <vp>roundToUnsigned64/1-></vp>
* Better handling of '''default button size'''
* <vp>msXLM_api</vp> update to version 6.0 of various COMponent classes

== Others ==

* Более эффективное '''управление памятью'''; во многих случаях используется типовая аллокация памяти, для составных доменов, списков и цепочек баз данных
* Несколько различных оптимизаций для увеличения скорости и уменьшения генерируемого кода
* Новые примеры для демонстрации (Demo Examples) (только для коммерческой версии):
** Parser Generator
** LZDecompression
** TreeControlDemo
* Help on built-in entities
* VipBuilder: новая опция для игнорирования директивы <vp>#requires</vp>
* В библиотеку '''Win32''' добавлены имена из многих MS библиотек.
* При ошибки выполнения предиката consult выдается добавочная информация, позволяющая локализовать ошибку в базе данных
* Ускорен линкер
* Интеграция со службой Vault теперь работает с версией 5.0.1

[[Category:Release Notes]]

Что нового в VIP 7.3

2010-03-26T07:27:15Z

SergeMukhin: /* Other language features */

{{Preliminary Documentation}}

== Язык ==

=== Generic интерфейсы и классы ===

смотри [http://wiki.visual-prolog.com/index.php?title=Language_Reference/Generic_Interfaces_and_Classes Generic интерфейсы и классы (en)].

=== Conversion to Generic Type ===

=== Мониторы ===

[http://wiki.visual-prolog.com/index.php?title=Language_Reference/Monitors Мониторы (en)] с [http://wiki.visual-prolog.com/index.php?title=Language_Reference/Monitors#Guards гардами (en)]

=== Must Unify оператор ===

Новый оператор == (must-unify)

=== Термы универсального типа ===

<vp>any</vp> и предикат <vp>toAny/1-></vp>

=== Подготовка к 64-битной реализации ===

Подготовка к 64-битной реализации 64bit systems: built-in типы <vp>integerNative</vp> и <vp>unsignedNative</vp>

=== Интерфейс с другими языками ===

Native interfaces support (attributes):
* [http://wiki.visual-prolog.com/index.php?title=Language_Reference/Attributes#inline inline (en)]: встроенные структуры и строки.
* [http://wiki.visual-prolog.com/index.php?title=Language_Reference/Attributes#union union (en)]: безфункторное объединение.
* [http://wiki.visual-prolog.com/index.php?title=Language_Reference/Attributes#byVal byVal (en)]: передача параметра по значению.

По умолчанию, для соглашения о вызове <vp>apicall</vp>, применяется внешнее разрешение.
* Они не могут иметь clauses
* Явное внешнее разрешение правильно только с динамической DLL
* Является процедурой

=== Other language features ===

* Приоритет унарного минуса изменен (теперь операция возведения имеет наивысший приоритет)
* Новые версии встроенных предикатов <vp>toTerm/2-></vp> м <vp>tryToTerm/2-></vp> (добавлен первый параметр - тип).
* Новый встроенный предикат <vp>fromEllipsis : (...) -> any* Terms</vp>
* Runtime distinction between privately and publicly supported interfaces is removed

Новые аттрибуты:
* retired
* noDefaultConstructor
* used

Новая или улучшенная диагностика:
* Локальный объектный предикат не использует <vp>This</vp> (и может быть объявлен как классный)
* не используемая локальная константа
* Условие в <vp>foreach</vp> не имеет точек бактракинга (должно быть или <vp>multi</vp> или <vp>nondeterm</vp>)
* Конверсия <vp>unheckedConversion</vp> не верна для 64 bit платформ (например <vp>pointer</vp> -> <vp>integer</vp>)

== IDE ==

=== Project tree ===

The project tree is redesigned and reimplemented. The functionality is more or less unchanged, but the performance is improved.

The '''IncludedIn''' and '''Includes''' windows has been moved to preview pane of project window.

It is not possible to have several packages with same name in a project (which can make much sense when using namespaces).

=== Browse dialog ===

The '''Browse''' dialog is improved in several smaller respects, including:
* It automatically jump to the 1st occurrence of search entity on locate
* The last dialog position is saved for next appearence

=== Find In Files ===

The '''Find In Files''' dialog is improved in several respects, including:
* result window is reused for subsequent searches
* F8 button for next match (Shift+F8 - previous)
* Prolog case sensitive search mode
* state is saved for next appearence

=== Namespace support ===

The '''Namespaces support''' is improved, so that forms, dialogs, etc can be places in namespaces when created.

=== IntelliSense ===

The '''IntelliSense''' feature is improved for better overview, speed typing and convenience of work.

=== Tab navigation диалог (Ctrl+Tab) ===

Добавлена функциональность '''tab navigation''' диалога:
* при использовании кнопки ALT фильтруются все [ReadOnly] окна
* при нажатии Del - соответствующее окно закрывается

=== Go to Position on Clipboard ===

The '''Go to Position on Clipboard''' (Shift+F2) has been extended to accept a complete exception dump. F8 will go to the next stack entry.

=== Сортировка в некоторых окнах ===

Окно ошибок (Errors Window), точек останова (Break points Window) и некоторые другие появилась возможность сортировать колонки. Для этого надо просто нажать на вверх колонки.
* '''Optimal Set of Includes improved''' (output, local scopes, etc.)

== Debugger ==

* Измененные переменные и их значения показываются выделением '''Highlighting'''
* Улучшен просмотр длинных списков
* Ускорен рестарт отладчика
* Появились точки останова ('''Memory break points''') по памяти и для некоторых типов фактов
* Улучшена работа с несколькими thread (добавлена возможность указания имени thread, улучшена обработка прерываний в thread)
* При длинных значениях tooltip может показываеться в несколько строк

== PFC ==

=== Новые пакеты ===

* [[Collection library]]
** Algebraic: <vp>redBlackSet</vp>, <vp>leftistPriorityQueue</vp>
** Modifiable: <vp>mapM_redBlack</vp>, <vp>priorityQueueM_leftist</vp>, <vp>queueM_fact</vp>, <vp>setM_redBlack</vp>
** Persistent: <vp>mapP_redBlack</vp>, <vp>priorityQueueP_leftist</vp>, <vp>queueP_fact</vp>, <vp>setP_redBlack</vp>
* <vp>varM</vp> modifiable variable
* <vp>linkControl</vp> PFC version of the Link common control
* <vp>richEditControl</vp> PFC version of the RichEdit common control
* <vp>treeControl</vp> PFC model based version of the TreeView common control
* <vp>gdiplus</vp> PFC version of GDI+
* <vp>cryptography</vp> hash, sha1, md5 & base64
* <vp>eventSource</vp> generalization of event notification/listening
* <vp>monitorQueue</vp> thread safe queue class based on the monitor facility
* <vp>reflection</vp> basic functionalty for code reflection
* <vp>inputStream_null</vp> & <vp>outputStream_null</vp> media-less streams (input is exhausted; outpt throws away)
* <vp>lZ_fileSystem_native</vp> Interface to Lempel-Ziv Decompression API functionality
* <vp>shell_api</vp> Api level interface to the Windows Shell
* <vp>winsock2_native</vp> native bindings to Windows Sockets 2

=== Extensions and improvements ===

* <vp>list</vp> package:
** speed: <vp>sort</vp>, <vp>removeDuplicate</vp>, <vp>drop</vp>, <vp>min</vp>/<vp>max</vp>, etc.)
** functionality: <vp>isMemberEq</vp> (and similar predicates) that uses a <vp>determ</vp> predicate as test
* <vp>listControl</vp> with owner-drawing capabilities
* <vp>uxTheme_native</vp> extended with the rest of the functions and the constants from vsStyle.h, etc.
* Add moving listener/responder to <vp>splitTwoControl</vp>
* Add the fraction handling from <vp>format</vp> to <vp>formatTime</vp>
* '''Speed''' improvements for:
** <vp>string</vp>
** <vp>fileName</vp>
** <vp>listViewControl</vp>
* <vp>string::rear/2-></vp> returns the rear part of a string
* '''Math''' package: predicates <vp>roundToInteger64/1-></vp> and <vp>roundToUnsigned64/1-></vp>
* Better handling of '''default button size'''
* <vp>msXLM_api</vp> update to version 6.0 of various COMponent classes

== Others ==

* Более эффективное '''управление памятью'''; во многих случаях используется типовая аллокация памяти, для составных доменов, списков и цепочек баз данных
* Несколько различных оптимизаций для увеличения скорости и уменьшения генерируемого кода
* Новые примеры для демонстрации (Demo Examples) (только для коммерческой версии):
** Parser Generator
** LZDecompression
** TreeControlDemo
* Help on built-in entities
* VipBuilder: новая опция для игнорирования директивы <vp>#requires</vp>
* В библиотеку '''Win32''' добавлены имена из многих MS библиотек.
* При ошибки выполнения предиката consult выдается добавочная информация, позволяющая локализовать ошибку в базе данных
* Ускорен линкер
* Интеграция со службой Vault теперь работает с версией 5.0.1

[[Category:Release Notes]]

Что нового в VIP 7.3

2010-03-26T07:20:43Z

SergeMukhin: /* Интерфейс с другими языками */

{{Preliminary Documentation}}

== Язык ==

=== Generic интерфейсы и классы ===

смотри [http://wiki.visual-prolog.com/index.php?title=Language_Reference/Generic_Interfaces_and_Classes Generic интерфейсы и классы (en)].

=== Conversion to Generic Type ===

=== Мониторы ===

[http://wiki.visual-prolog.com/index.php?title=Language_Reference/Monitors Мониторы (en)] с [http://wiki.visual-prolog.com/index.php?title=Language_Reference/Monitors#Guards гардами (en)]

=== Must Unify оператор ===

Новый оператор == (must-unify)

=== Термы универсального типа ===

<vp>any</vp> и предикат <vp>toAny/1-></vp>

=== Подготовка к 64-битной реализации ===

Подготовка к 64-битной реализации 64bit systems: built-in типы <vp>integerNative</vp> и <vp>unsignedNative</vp>

=== Интерфейс с другими языками ===

Native interfaces support (attributes):
* [http://wiki.visual-prolog.com/index.php?title=Language_Reference/Attributes#inline inline (en)]: встроенные структуры и строки.
* [http://wiki.visual-prolog.com/index.php?title=Language_Reference/Attributes#union union (en)]: безфункторное объединение.
* [http://wiki.visual-prolog.com/index.php?title=Language_Reference/Attributes#byVal byVal (en)]: передача параметра по значению.

По умолчанию, для соглашения о вызове <vp>apicall</vp>, применяется внешнее разрешение.
* Они не могут иметь clauses
* Явное внешнее разрешение правильно только с динамической DLL
* Является процедурой

=== Other language features ===

* The precedence of unary minus is changed (so that power operator has higher precedence)
* Extended versions of built-in predicates <vp>toTerm/2-></vp> and <vp>tryToTerm/2-></vp> (type as the first parameter).
* New built-in predicate <vp>fromEllipsis : (...) -> any* Terms</vp>
* Runtime distinction between privately and publicly supported interfaces is removed

New attributes
* {{lang2|Attributes|retired|retired}}
* {{lang2|Attributes|noDefaultConstructor|noDefaultConstructor}}
* {{lang2|Attributes|used|used}}

Warnings:
* Local object predicates which do not use <vp>This</vp> (and therefore can be declared as class predicates)
* Unused local constants
* Condition of foreach statement which has no backtrack point (i.e. mode is not <vp>multi</vp> or <vp>nondeterm</vp>)
* <vp>unheckedConversion</vp>'s that would be illegal on 64 bit platforms (e.g. <vp>pointer</vp> -> <vp>integer</vp>)

== IDE ==

=== Project tree ===

The project tree is redesigned and reimplemented. The functionality is more or less unchanged, but the performance is improved.

The '''IncludedIn''' and '''Includes''' windows has been moved to preview pane of project window.

It is not possible to have several packages with same name in a project (which can make much sense when using namespaces).

=== Browse dialog ===

The '''Browse''' dialog is improved in several smaller respects, including:
* It automatically jump to the 1st occurrence of search entity on locate
* The last dialog position is saved for next appearence

=== Find In Files ===

The '''Find In Files''' dialog is improved in several respects, including:
* result window is reused for subsequent searches
* F8 button for next match (Shift+F8 - previous)
* Prolog case sensitive search mode
* state is saved for next appearence

=== Namespace support ===

The '''Namespaces support''' is improved, so that forms, dialogs, etc can be places in namespaces when created.

=== IntelliSense ===

The '''IntelliSense''' feature is improved for better overview, speed typing and convenience of work.

=== Tab navigation диалог (Ctrl+Tab) ===

Добавлена функциональность '''tab navigation''' диалога:
* при использовании кнопки ALT фильтруются все [ReadOnly] окна
* при нажатии Del - соответствующее окно закрывается

=== Go to Position on Clipboard ===

The '''Go to Position on Clipboard''' (Shift+F2) has been extended to accept a complete exception dump. F8 will go to the next stack entry.

=== Сортировка в некоторых окнах ===

Окно ошибок (Errors Window), точек останова (Break points Window) и некоторые другие появилась возможность сортировать колонки. Для этого надо просто нажать на вверх колонки.
* '''Optimal Set of Includes improved''' (output, local scopes, etc.)

== Debugger ==

* Измененные переменные и их значения показываются выделением '''Highlighting'''
* Улучшен просмотр длинных списков
* Ускорен рестарт отладчика
* Появились точки останова ('''Memory break points''') по памяти и для некоторых типов фактов
* Улучшена работа с несколькими thread (добавлена возможность указания имени thread, улучшена обработка прерываний в thread)
* При длинных значениях tooltip может показываеться в несколько строк

== PFC ==

=== Новые пакеты ===

* [[Collection library]]
** Algebraic: <vp>redBlackSet</vp>, <vp>leftistPriorityQueue</vp>
** Modifiable: <vp>mapM_redBlack</vp>, <vp>priorityQueueM_leftist</vp>, <vp>queueM_fact</vp>, <vp>setM_redBlack</vp>
** Persistent: <vp>mapP_redBlack</vp>, <vp>priorityQueueP_leftist</vp>, <vp>queueP_fact</vp>, <vp>setP_redBlack</vp>
* <vp>varM</vp> modifiable variable
* <vp>linkControl</vp> PFC version of the Link common control
* <vp>richEditControl</vp> PFC version of the RichEdit common control
* <vp>treeControl</vp> PFC model based version of the TreeView common control
* <vp>gdiplus</vp> PFC version of GDI+
* <vp>cryptography</vp> hash, sha1, md5 & base64
* <vp>eventSource</vp> generalization of event notification/listening
* <vp>monitorQueue</vp> thread safe queue class based on the monitor facility
* <vp>reflection</vp> basic functionalty for code reflection
* <vp>inputStream_null</vp> & <vp>outputStream_null</vp> media-less streams (input is exhausted; outpt throws away)
* <vp>lZ_fileSystem_native</vp> Interface to Lempel-Ziv Decompression API functionality
* <vp>shell_api</vp> Api level interface to the Windows Shell
* <vp>winsock2_native</vp> native bindings to Windows Sockets 2

=== Extensions and improvements ===

* <vp>list</vp> package:
** speed: <vp>sort</vp>, <vp>removeDuplicate</vp>, <vp>drop</vp>, <vp>min</vp>/<vp>max</vp>, etc.)
** functionality: <vp>isMemberEq</vp> (and similar predicates) that uses a <vp>determ</vp> predicate as test
* <vp>listControl</vp> with owner-drawing capabilities
* <vp>uxTheme_native</vp> extended with the rest of the functions and the constants from vsStyle.h, etc.
* Add moving listener/responder to <vp>splitTwoControl</vp>
* Add the fraction handling from <vp>format</vp> to <vp>formatTime</vp>
* '''Speed''' improvements for:
** <vp>string</vp>
** <vp>fileName</vp>
** <vp>listViewControl</vp>
* <vp>string::rear/2-></vp> returns the rear part of a string
* '''Math''' package: predicates <vp>roundToInteger64/1-></vp> and <vp>roundToUnsigned64/1-></vp>
* Better handling of '''default button size'''
* <vp>msXLM_api</vp> update to version 6.0 of various COMponent classes

== Others ==

* Более эффективное '''управление памятью'''; во многих случаях используется типовая аллокация памяти, для составных доменов, списков и цепочек баз данных
* Несколько различных оптимизаций для увеличения скорости и уменьшения генерируемого кода
* Новые примеры для демонстрации (Demo Examples) (только для коммерческой версии):
** Parser Generator
** LZDecompression
** TreeControlDemo
* Help on built-in entities
* VipBuilder: новая опция для игнорирования директивы <vp>#requires</vp>
* В библиотеку '''Win32''' добавлены имена из многих MS библиотек.
* При ошибки выполнения предиката consult выдается добавочная информация, позволяющая локализовать ошибку в базе данных
* Ускорен линкер
* Интеграция со службой Vault теперь работает с версией 5.0.1

[[Category:Release Notes]]

Что нового в VIP 7.3

2010-03-26T07:15:33Z

SergeMukhin: /* Язык */

{{Preliminary Documentation}}

== Язык ==

=== Generic интерфейсы и классы ===

смотри [http://wiki.visual-prolog.com/index.php?title=Language_Reference/Generic_Interfaces_and_Classes Generic интерфейсы и классы (en)].

=== Conversion to Generic Type ===

=== Мониторы ===

[http://wiki.visual-prolog.com/index.php?title=Language_Reference/Monitors Мониторы (en)] с [http://wiki.visual-prolog.com/index.php?title=Language_Reference/Monitors#Guards гардами (en)]

=== Must Unify оператор ===

Новый оператор == (must-unify)

=== Термы универсального типа ===

<vp>any</vp> и предикат <vp>toAny/1-></vp>

=== Подготовка к 64-битной реализации ===

Подготовка к 64-битной реализации 64bit systems: built-in типы <vp>integerNative</vp> и <vp>unsignedNative</vp>

=== Интерфейс с другими языками ===

Native interfaces support (attributes):
* {{lang2|Attributes|inline|inline}}: Inline structures and strings.
* {{lang2|Attributes|union|union}}: Functor-less unions.
* {{lang2|Attributes|byVal|byVal}}: Passing parameters by value.

External resolution is default for predicates declared with <vp>apicall</vp> calling convention.
* They cannot have clauses
* explicit externally resolution is only legal when a DLL is stated

=== Other language features ===

* The precedence of unary minus is changed (so that power operator has higher precedence)
* Extended versions of built-in predicates <vp>toTerm/2-></vp> and <vp>tryToTerm/2-></vp> (type as the first parameter).
* New built-in predicate <vp>fromEllipsis : (...) -> any* Terms</vp>
* Runtime distinction between privately and publicly supported interfaces is removed

New attributes
* {{lang2|Attributes|retired|retired}}
* {{lang2|Attributes|noDefaultConstructor|noDefaultConstructor}}
* {{lang2|Attributes|used|used}}

Warnings:
* Local object predicates which do not use <vp>This</vp> (and therefore can be declared as class predicates)
* Unused local constants
* Condition of foreach statement which has no backtrack point (i.e. mode is not <vp>multi</vp> or <vp>nondeterm</vp>)
* <vp>unheckedConversion</vp>'s that would be illegal on 64 bit platforms (e.g. <vp>pointer</vp> -> <vp>integer</vp>)

== IDE ==

=== Project tree ===

The project tree is redesigned and reimplemented. The functionality is more or less unchanged, but the performance is improved.

The '''IncludedIn''' and '''Includes''' windows has been moved to preview pane of project window.

It is not possible to have several packages with same name in a project (which can make much sense when using namespaces).

=== Browse dialog ===

The '''Browse''' dialog is improved in several smaller respects, including:
* It automatically jump to the 1st occurrence of search entity on locate
* The last dialog position is saved for next appearence

=== Find In Files ===

The '''Find In Files''' dialog is improved in several respects, including:
* result window is reused for subsequent searches
* F8 button for next match (Shift+F8 - previous)
* Prolog case sensitive search mode
* state is saved for next appearence

=== Namespace support ===

The '''Namespaces support''' is improved, so that forms, dialogs, etc can be places in namespaces when created.

=== IntelliSense ===

The '''IntelliSense''' feature is improved for better overview, speed typing and convenience of work.

=== Tab navigation диалог (Ctrl+Tab) ===

Добавлена функциональность '''tab navigation''' диалога:
* при использовании кнопки ALT фильтруются все [ReadOnly] окна
* при нажатии Del - соответствующее окно закрывается

=== Go to Position on Clipboard ===

The '''Go to Position on Clipboard''' (Shift+F2) has been extended to accept a complete exception dump. F8 will go to the next stack entry.

=== Сортировка в некоторых окнах ===

Окно ошибок (Errors Window), точек останова (Break points Window) и некоторые другие появилась возможность сортировать колонки. Для этого надо просто нажать на вверх колонки.
* '''Optimal Set of Includes improved''' (output, local scopes, etc.)

== Debugger ==

* Измененные переменные и их значения показываются выделением '''Highlighting'''
* Улучшен просмотр длинных списков
* Ускорен рестарт отладчика
* Появились точки останова ('''Memory break points''') по памяти и для некоторых типов фактов
* Улучшена работа с несколькими thread (добавлена возможность указания имени thread, улучшена обработка прерываний в thread)
* При длинных значениях tooltip может показываеться в несколько строк

== PFC ==

=== Новые пакеты ===

* [[Collection library]]
** Algebraic: <vp>redBlackSet</vp>, <vp>leftistPriorityQueue</vp>
** Modifiable: <vp>mapM_redBlack</vp>, <vp>priorityQueueM_leftist</vp>, <vp>queueM_fact</vp>, <vp>setM_redBlack</vp>
** Persistent: <vp>mapP_redBlack</vp>, <vp>priorityQueueP_leftist</vp>, <vp>queueP_fact</vp>, <vp>setP_redBlack</vp>
* <vp>varM</vp> modifiable variable
* <vp>linkControl</vp> PFC version of the Link common control
* <vp>richEditControl</vp> PFC version of the RichEdit common control
* <vp>treeControl</vp> PFC model based version of the TreeView common control
* <vp>gdiplus</vp> PFC version of GDI+
* <vp>cryptography</vp> hash, sha1, md5 & base64
* <vp>eventSource</vp> generalization of event notification/listening
* <vp>monitorQueue</vp> thread safe queue class based on the monitor facility
* <vp>reflection</vp> basic functionalty for code reflection
* <vp>inputStream_null</vp> & <vp>outputStream_null</vp> media-less streams (input is exhausted; outpt throws away)
* <vp>lZ_fileSystem_native</vp> Interface to Lempel-Ziv Decompression API functionality
* <vp>shell_api</vp> Api level interface to the Windows Shell
* <vp>winsock2_native</vp> native bindings to Windows Sockets 2

=== Extensions and improvements ===

* <vp>list</vp> package:
** speed: <vp>sort</vp>, <vp>removeDuplicate</vp>, <vp>drop</vp>, <vp>min</vp>/<vp>max</vp>, etc.)
** functionality: <vp>isMemberEq</vp> (and similar predicates) that uses a <vp>determ</vp> predicate as test
* <vp>listControl</vp> with owner-drawing capabilities
* <vp>uxTheme_native</vp> extended with the rest of the functions and the constants from vsStyle.h, etc.
* Add moving listener/responder to <vp>splitTwoControl</vp>
* Add the fraction handling from <vp>format</vp> to <vp>formatTime</vp>
* '''Speed''' improvements for:
** <vp>string</vp>
** <vp>fileName</vp>
** <vp>listViewControl</vp>
* <vp>string::rear/2-></vp> returns the rear part of a string
* '''Math''' package: predicates <vp>roundToInteger64/1-></vp> and <vp>roundToUnsigned64/1-></vp>
* Better handling of '''default button size'''
* <vp>msXLM_api</vp> update to version 6.0 of various COMponent classes

== Others ==

* Более эффективное '''управление памятью'''; во многих случаях используется типовая аллокация памяти, для составных доменов, списков и цепочек баз данных
* Несколько различных оптимизаций для увеличения скорости и уменьшения генерируемого кода
* Новые примеры для демонстрации (Demo Examples) (только для коммерческой версии):
** Parser Generator
** LZDecompression
** TreeControlDemo
* Help on built-in entities
* VipBuilder: новая опция для игнорирования директивы <vp>#requires</vp>
* В библиотеку '''Win32''' добавлены имена из многих MS библиотек.
* При ошибки выполнения предиката consult выдается добавочная информация, позволяющая локализовать ошибку в базе данных
* Ускорен линкер
* Интеграция со службой Vault теперь работает с версией 5.0.1

[[Category:Release Notes]]

Что нового в VIP 7.3

2010-03-25T15:40:47Z

SergeMukhin: /* Debugger */

{{Preliminary Documentation}}

== Язык ==

=== Generic Interfaces and Classes ===

See {{lang|Generic Interfaces and Classes|Generic Interfaces and Classes}}.

=== Conversion to Generic Type ===

=== Monitors ===

{{lang|Monitors|Monitors}} with {{lang2|Monitors|Guards|guards}}

=== Must Unify оператор ===

Новый оператор == (must-unify)

=== Термы универсального типа ===

<vp>any</vp> и предикат <vp>toAny/1-></vp>

=== Подготовка к 64-битной реализации ===

Подготовка к 64-битной реализации 64bit systems: built-in типы <vp>integerNative</vp> и <vp>unsignedNative</vp>

=== Интерфейс с другими языками ===

Native interfaces support (attributes):
* {{lang2|Attributes|inline|inline}}: Inline structures and strings.
* {{lang2|Attributes|union|union}}: Functor-less unions.
* {{lang2|Attributes|byVal|byVal}}: Passing parameters by value.

External resolution is default for predicates declared with <vp>apicall</vp> calling convention.
* They cannot have clauses
* explicit externally resolution is only legal when a DLL is stated

=== Other language features ===

* The precedence of unary minus is changed (so that power operator has higher precedence)
* Extended versions of built-in predicates <vp>toTerm/2-></vp> and <vp>tryToTerm/2-></vp> (type as the first parameter).
* New built-in predicate <vp>fromEllipsis : (...) -> any* Terms</vp>
* Runtime distinction between privately and publicly supported interfaces is removed

New attributes
* {{lang2|Attributes|retired|retired}}
* {{lang2|Attributes|noDefaultConstructor|noDefaultConstructor}}
* {{lang2|Attributes|used|used}}

Warnings:
* Local object predicates which do not use <vp>This</vp> (and therefore can be declared as class predicates)
* Unused local constants
* Condition of foreach statement which has no backtrack point (i.e. mode is not <vp>multi</vp> or <vp>nondeterm</vp>)
* <vp>unheckedConversion</vp>'s that would be illegal on 64 bit platforms (e.g. <vp>pointer</vp> -> <vp>integer</vp>)

== IDE ==

=== Project tree ===

The project tree is redesigned and reimplemented. The functionality is more or less unchanged, but the performance is improved.

The '''IncludedIn''' and '''Includes''' windows has been moved to preview pane of project window.

It is not possible to have several packages with same name in a project (which can make much sense when using namespaces).

=== Browse dialog ===

The '''Browse''' dialog is improved in several smaller respects, including:
* It automatically jump to the 1st occurrence of search entity on locate
* The last dialog position is saved for next appearence

=== Find In Files ===

The '''Find In Files''' dialog is improved in several respects, including:
* result window is reused for subsequent searches
* F8 button for next match (Shift+F8 - previous)
* Prolog case sensitive search mode
* state is saved for next appearence

=== Namespace support ===

The '''Namespaces support''' is improved, so that forms, dialogs, etc can be places in namespaces when created.

=== IntelliSense ===

The '''IntelliSense''' feature is improved for better overview, speed typing and convenience of work.

=== Tab navigation диалог (Ctrl+Tab) ===

Добавлена функциональность '''tab navigation''' диалога:
* при использовании кнопки ALT фильтруются все [ReadOnly] окна
* при нажатии Del - соответствующее окно закрывается

=== Go to Position on Clipboard ===

The '''Go to Position on Clipboard''' (Shift+F2) has been extended to accept a complete exception dump. F8 will go to the next stack entry.

=== Сортировка в некоторых окнах ===

Окно ошибок (Errors Window), точек останова (Break points Window) и некоторые другие появилась возможность сортировать колонки. Для этого надо просто нажать на вверх колонки.
* '''Optimal Set of Includes improved''' (output, local scopes, etc.)

== Debugger ==

* Измененные переменные и их значения показываются выделением '''Highlighting'''
* Улучшен просмотр длинных списков
* Ускорен рестарт отладчика
* Появились точки останова ('''Memory break points''') по памяти и для некоторых типов фактов
* Улучшена работа с несколькими thread (добавлена возможность указания имени thread, улучшена обработка прерываний в thread)
* При длинных значениях tooltip может показываеться в несколько строк

== PFC ==

=== Новые пакеты ===

* [[Collection library]]
** Algebraic: <vp>redBlackSet</vp>, <vp>leftistPriorityQueue</vp>
** Modifiable: <vp>mapM_redBlack</vp>, <vp>priorityQueueM_leftist</vp>, <vp>queueM_fact</vp>, <vp>setM_redBlack</vp>
** Persistent: <vp>mapP_redBlack</vp>, <vp>priorityQueueP_leftist</vp>, <vp>queueP_fact</vp>, <vp>setP_redBlack</vp>
* <vp>varM</vp> modifiable variable
* <vp>linkControl</vp> PFC version of the Link common control
* <vp>richEditControl</vp> PFC version of the RichEdit common control
* <vp>treeControl</vp> PFC model based version of the TreeView common control
* <vp>gdiplus</vp> PFC version of GDI+
* <vp>cryptography</vp> hash, sha1, md5 & base64
* <vp>eventSource</vp> generalization of event notification/listening
* <vp>monitorQueue</vp> thread safe queue class based on the monitor facility
* <vp>reflection</vp> basic functionalty for code reflection
* <vp>inputStream_null</vp> & <vp>outputStream_null</vp> media-less streams (input is exhausted; outpt throws away)
* <vp>lZ_fileSystem_native</vp> Interface to Lempel-Ziv Decompression API functionality
* <vp>shell_api</vp> Api level interface to the Windows Shell
* <vp>winsock2_native</vp> native bindings to Windows Sockets 2

=== Extensions and improvements ===

* <vp>list</vp> package:
** speed: <vp>sort</vp>, <vp>removeDuplicate</vp>, <vp>drop</vp>, <vp>min</vp>/<vp>max</vp>, etc.)
** functionality: <vp>isMemberEq</vp> (and similar predicates) that uses a <vp>determ</vp> predicate as test
* <vp>listControl</vp> with owner-drawing capabilities
* <vp>uxTheme_native</vp> extended with the rest of the functions and the constants from vsStyle.h, etc.
* Add moving listener/responder to <vp>splitTwoControl</vp>
* Add the fraction handling from <vp>format</vp> to <vp>formatTime</vp>
* '''Speed''' improvements for:
** <vp>string</vp>
** <vp>fileName</vp>
** <vp>listViewControl</vp>
* <vp>string::rear/2-></vp> returns the rear part of a string
* '''Math''' package: predicates <vp>roundToInteger64/1-></vp> and <vp>roundToUnsigned64/1-></vp>
* Better handling of '''default button size'''
* <vp>msXLM_api</vp> update to version 6.0 of various COMponent classes

== Others ==

* Более эффективное '''управление памятью'''; во многих случаях используется типовая аллокация памяти, для составных доменов, списков и цепочек баз данных
* Несколько различных оптимизаций для увеличения скорости и уменьшения генерируемого кода
* Новые примеры для демонстрации (Demo Examples) (только для коммерческой версии):
** Parser Generator
** LZDecompression
** TreeControlDemo
* Help on built-in entities
* VipBuilder: новая опция для игнорирования директивы <vp>#requires</vp>
* В библиотеку '''Win32''' добавлены имена из многих MS библиотек.
* При ошибки выполнения предиката consult выдается добавочная информация, позволяющая локализовать ошибку в базе данных
* Ускорен линкер
* Интеграция со службой Vault теперь работает с версией 5.0.1

[[Category:Release Notes]]

Что нового в VIP 7.3

2010-03-25T15:36:22Z

SergeMukhin: /* Others */

{{Preliminary Documentation}}

== Язык ==

=== Generic Interfaces and Classes ===

See {{lang|Generic Interfaces and Classes|Generic Interfaces and Classes}}.

=== Conversion to Generic Type ===

=== Monitors ===

{{lang|Monitors|Monitors}} with {{lang2|Monitors|Guards|guards}}

=== Must Unify оператор ===

Новый оператор == (must-unify)

=== Термы универсального типа ===

<vp>any</vp> и предикат <vp>toAny/1-></vp>

=== Подготовка к 64-битной реализации ===

Подготовка к 64-битной реализации 64bit systems: built-in типы <vp>integerNative</vp> и <vp>unsignedNative</vp>

=== Интерфейс с другими языками ===

Native interfaces support (attributes):
* {{lang2|Attributes|inline|inline}}: Inline structures and strings.
* {{lang2|Attributes|union|union}}: Functor-less unions.
* {{lang2|Attributes|byVal|byVal}}: Passing parameters by value.

External resolution is default for predicates declared with <vp>apicall</vp> calling convention.
* They cannot have clauses
* explicit externally resolution is only legal when a DLL is stated

=== Other language features ===

* The precedence of unary minus is changed (so that power operator has higher precedence)
* Extended versions of built-in predicates <vp>toTerm/2-></vp> and <vp>tryToTerm/2-></vp> (type as the first parameter).
* New built-in predicate <vp>fromEllipsis : (...) -> any* Terms</vp>
* Runtime distinction between privately and publicly supported interfaces is removed

New attributes
* {{lang2|Attributes|retired|retired}}
* {{lang2|Attributes|noDefaultConstructor|noDefaultConstructor}}
* {{lang2|Attributes|used|used}}

Warnings:
* Local object predicates which do not use <vp>This</vp> (and therefore can be declared as class predicates)
* Unused local constants
* Condition of foreach statement which has no backtrack point (i.e. mode is not <vp>multi</vp> or <vp>nondeterm</vp>)
* <vp>unheckedConversion</vp>'s that would be illegal on 64 bit platforms (e.g. <vp>pointer</vp> -> <vp>integer</vp>)

== IDE ==

=== Project tree ===

The project tree is redesigned and reimplemented. The functionality is more or less unchanged, but the performance is improved.

The '''IncludedIn''' and '''Includes''' windows has been moved to preview pane of project window.

It is not possible to have several packages with same name in a project (which can make much sense when using namespaces).

=== Browse dialog ===

The '''Browse''' dialog is improved in several smaller respects, including:
* It automatically jump to the 1st occurrence of search entity on locate
* The last dialog position is saved for next appearence

=== Find In Files ===

The '''Find In Files''' dialog is improved in several respects, including:
* result window is reused for subsequent searches
* F8 button for next match (Shift+F8 - previous)
* Prolog case sensitive search mode
* state is saved for next appearence

=== Namespace support ===

The '''Namespaces support''' is improved, so that forms, dialogs, etc can be places in namespaces when created.

=== IntelliSense ===

The '''IntelliSense''' feature is improved for better overview, speed typing and convenience of work.

=== Tab navigation диалог (Ctrl+Tab) ===

Добавлена функциональность '''tab navigation''' диалога:
* при использовании кнопки ALT фильтруются все [ReadOnly] окна
* при нажатии Del - соответствующее окно закрывается

=== Go to Position on Clipboard ===

The '''Go to Position on Clipboard''' (Shift+F2) has been extended to accept a complete exception dump. F8 will go to the next stack entry.

=== Сортировка в некоторых окнах ===

Окно ошибок (Errors Window), точек останова (Break points Window) и некоторые другие появилась возможность сортировать колонки. Для этого надо просто нажать на вверх колонки.
* '''Optimal Set of Includes improved''' (output, local scopes, etc.)

== Debugger ==

* '''Highlighting''' changed values in variable window
* View of '''long lists''' improvement
* '''Speed''' of restarting is improved
* '''Memory break points''' and fact access (for some types)
* '''Multi-threaded''' application debugging is improved (thread names, break points handling)
* Multi-line '''tool tips'''

== PFC ==

=== Новые пакеты ===

* [[Collection library]]
** Algebraic: <vp>redBlackSet</vp>, <vp>leftistPriorityQueue</vp>
** Modifiable: <vp>mapM_redBlack</vp>, <vp>priorityQueueM_leftist</vp>, <vp>queueM_fact</vp>, <vp>setM_redBlack</vp>
** Persistent: <vp>mapP_redBlack</vp>, <vp>priorityQueueP_leftist</vp>, <vp>queueP_fact</vp>, <vp>setP_redBlack</vp>
* <vp>varM</vp> modifiable variable
* <vp>linkControl</vp> PFC version of the Link common control
* <vp>richEditControl</vp> PFC version of the RichEdit common control
* <vp>treeControl</vp> PFC model based version of the TreeView common control
* <vp>gdiplus</vp> PFC version of GDI+
* <vp>cryptography</vp> hash, sha1, md5 & base64
* <vp>eventSource</vp> generalization of event notification/listening
* <vp>monitorQueue</vp> thread safe queue class based on the monitor facility
* <vp>reflection</vp> basic functionalty for code reflection
* <vp>inputStream_null</vp> & <vp>outputStream_null</vp> media-less streams (input is exhausted; outpt throws away)
* <vp>lZ_fileSystem_native</vp> Interface to Lempel-Ziv Decompression API functionality
* <vp>shell_api</vp> Api level interface to the Windows Shell
* <vp>winsock2_native</vp> native bindings to Windows Sockets 2

=== Extensions and improvements ===

* <vp>list</vp> package:
** speed: <vp>sort</vp>, <vp>removeDuplicate</vp>, <vp>drop</vp>, <vp>min</vp>/<vp>max</vp>, etc.)
** functionality: <vp>isMemberEq</vp> (and similar predicates) that uses a <vp>determ</vp> predicate as test
* <vp>listControl</vp> with owner-drawing capabilities
* <vp>uxTheme_native</vp> extended with the rest of the functions and the constants from vsStyle.h, etc.
* Add moving listener/responder to <vp>splitTwoControl</vp>
* Add the fraction handling from <vp>format</vp> to <vp>formatTime</vp>
* '''Speed''' improvements for:
** <vp>string</vp>
** <vp>fileName</vp>
** <vp>listViewControl</vp>
* <vp>string::rear/2-></vp> returns the rear part of a string
* '''Math''' package: predicates <vp>roundToInteger64/1-></vp> and <vp>roundToUnsigned64/1-></vp>
* Better handling of '''default button size'''
* <vp>msXLM_api</vp> update to version 6.0 of various COMponent classes

== Others ==

* Более эффективное '''управление памятью'''; во многих случаях используется типовая аллокация памяти, для составных доменов, списков и цепочек баз данных
* Несколько различных оптимизаций для увеличения скорости и уменьшения генерируемого кода
* Новые примеры для демонстрации (Demo Examples) (только для коммерческой версии):
** Parser Generator
** LZDecompression
** TreeControlDemo
* Help on built-in entities
* VipBuilder: новая опция для игнорирования директивы <vp>#requires</vp>
* В библиотеку '''Win32''' добавлены имена из многих MS библиотек.
* При ошибки выполнения предиката consult выдается добавочная информация, позволяющая локализовать ошибку в базе данных
* Ускорен линкер
* Интеграция со службой Vault теперь работает с версией 5.0.1

[[Category:Release Notes]]

Что нового в VIP 7.3

2010-03-25T15:29:20Z

SergeMukhin: /* New entities */

{{Preliminary Documentation}}

== Язык ==

=== Generic Interfaces and Classes ===

See {{lang|Generic Interfaces and Classes|Generic Interfaces and Classes}}.

=== Conversion to Generic Type ===

=== Monitors ===

{{lang|Monitors|Monitors}} with {{lang2|Monitors|Guards|guards}}

=== Must Unify оператор ===

Новый оператор == (must-unify)

=== Термы универсального типа ===

<vp>any</vp> и предикат <vp>toAny/1-></vp>

=== Подготовка к 64-битной реализации ===

Подготовка к 64-битной реализации 64bit systems: built-in типы <vp>integerNative</vp> и <vp>unsignedNative</vp>

=== Интерфейс с другими языками ===

Native interfaces support (attributes):
* {{lang2|Attributes|inline|inline}}: Inline structures and strings.
* {{lang2|Attributes|union|union}}: Functor-less unions.
* {{lang2|Attributes|byVal|byVal}}: Passing parameters by value.

External resolution is default for predicates declared with <vp>apicall</vp> calling convention.
* They cannot have clauses
* explicit externally resolution is only legal when a DLL is stated

=== Other language features ===

* The precedence of unary minus is changed (so that power operator has higher precedence)
* Extended versions of built-in predicates <vp>toTerm/2-></vp> and <vp>tryToTerm/2-></vp> (type as the first parameter).
* New built-in predicate <vp>fromEllipsis : (...) -> any* Terms</vp>
* Runtime distinction between privately and publicly supported interfaces is removed

New attributes
* {{lang2|Attributes|retired|retired}}
* {{lang2|Attributes|noDefaultConstructor|noDefaultConstructor}}
* {{lang2|Attributes|used|used}}

Warnings:
* Local object predicates which do not use <vp>This</vp> (and therefore can be declared as class predicates)
* Unused local constants
* Condition of foreach statement which has no backtrack point (i.e. mode is not <vp>multi</vp> or <vp>nondeterm</vp>)
* <vp>unheckedConversion</vp>'s that would be illegal on 64 bit platforms (e.g. <vp>pointer</vp> -> <vp>integer</vp>)

== IDE ==

=== Project tree ===

The project tree is redesigned and reimplemented. The functionality is more or less unchanged, but the performance is improved.

The '''IncludedIn''' and '''Includes''' windows has been moved to preview pane of project window.

It is not possible to have several packages with same name in a project (which can make much sense when using namespaces).

=== Browse dialog ===

The '''Browse''' dialog is improved in several smaller respects, including:
* It automatically jump to the 1st occurrence of search entity on locate
* The last dialog position is saved for next appearence

=== Find In Files ===

The '''Find In Files''' dialog is improved in several respects, including:
* result window is reused for subsequent searches
* F8 button for next match (Shift+F8 - previous)
* Prolog case sensitive search mode
* state is saved for next appearence

=== Namespace support ===

The '''Namespaces support''' is improved, so that forms, dialogs, etc can be places in namespaces when created.

=== IntelliSense ===

The '''IntelliSense''' feature is improved for better overview, speed typing and convenience of work.

=== Tab navigation диалог (Ctrl+Tab) ===

Добавлена функциональность '''tab navigation''' диалога:
* при использовании кнопки ALT фильтруются все [ReadOnly] окна
* при нажатии Del - соответствующее окно закрывается

=== Go to Position on Clipboard ===

The '''Go to Position on Clipboard''' (Shift+F2) has been extended to accept a complete exception dump. F8 will go to the next stack entry.

=== Сортировка в некоторых окнах ===

Окно ошибок (Errors Window), точек останова (Break points Window) и некоторые другие появилась возможность сортировать колонки. Для этого надо просто нажать на вверх колонки.
* '''Optimal Set of Includes improved''' (output, local scopes, etc.)

== Debugger ==

* '''Highlighting''' changed values in variable window
* View of '''long lists''' improvement
* '''Speed''' of restarting is improved
* '''Memory break points''' and fact access (for some types)
* '''Multi-threaded''' application debugging is improved (thread names, break points handling)
* Multi-line '''tool tips'''

== PFC ==

=== Новые пакеты ===

* [[Collection library]]
** Algebraic: <vp>redBlackSet</vp>, <vp>leftistPriorityQueue</vp>
** Modifiable: <vp>mapM_redBlack</vp>, <vp>priorityQueueM_leftist</vp>, <vp>queueM_fact</vp>, <vp>setM_redBlack</vp>
** Persistent: <vp>mapP_redBlack</vp>, <vp>priorityQueueP_leftist</vp>, <vp>queueP_fact</vp>, <vp>setP_redBlack</vp>
* <vp>varM</vp> modifiable variable
* <vp>linkControl</vp> PFC version of the Link common control
* <vp>richEditControl</vp> PFC version of the RichEdit common control
* <vp>treeControl</vp> PFC model based version of the TreeView common control
* <vp>gdiplus</vp> PFC version of GDI+
* <vp>cryptography</vp> hash, sha1, md5 & base64
* <vp>eventSource</vp> generalization of event notification/listening
* <vp>monitorQueue</vp> thread safe queue class based on the monitor facility
* <vp>reflection</vp> basic functionalty for code reflection
* <vp>inputStream_null</vp> & <vp>outputStream_null</vp> media-less streams (input is exhausted; outpt throws away)
* <vp>lZ_fileSystem_native</vp> Interface to Lempel-Ziv Decompression API functionality
* <vp>shell_api</vp> Api level interface to the Windows Shell
* <vp>winsock2_native</vp> native bindings to Windows Sockets 2

=== Extensions and improvements ===

* <vp>list</vp> package:
** speed: <vp>sort</vp>, <vp>removeDuplicate</vp>, <vp>drop</vp>, <vp>min</vp>/<vp>max</vp>, etc.)
** functionality: <vp>isMemberEq</vp> (and similar predicates) that uses a <vp>determ</vp> predicate as test
* <vp>listControl</vp> with owner-drawing capabilities
* <vp>uxTheme_native</vp> extended with the rest of the functions and the constants from vsStyle.h, etc.
* Add moving listener/responder to <vp>splitTwoControl</vp>
* Add the fraction handling from <vp>format</vp> to <vp>formatTime</vp>
* '''Speed''' improvements for:
** <vp>string</vp>
** <vp>fileName</vp>
** <vp>listViewControl</vp>
* <vp>string::rear/2-></vp> returns the rear part of a string
* '''Math''' package: predicates <vp>roundToInteger64/1-></vp> and <vp>roundToUnsigned64/1-></vp>
* Better handling of '''default button size'''
* <vp>msXLM_api</vp> update to version 6.0 of various COMponent classes

== Others ==

* More efficient '''memory handling'''; using typed memory allocation for compound terms and internal facts chains
* Various optimizations for speed and size of generated code
* New Demo Examples (Commercial Edition only):
** Parser Generator
** LZDecompression
** TreeControlDemo
* Help on built-in entities
* VipBuilder: extra option to ignore <vp>#requires</vp> directives
* Extend '''Win32''' library (with more names from MS libraries).
* More context to consult exceptions
* Linker speed improvement
* Vault Integration updated to version 5.0.1

[[Category:Release Notes]]

Что нового в VIP 7.3

2010-03-25T15:28:41Z

SergeMukhin: /* Sorting in various windows */

{{Preliminary Documentation}}

== Язык ==

=== Generic Interfaces and Classes ===

See {{lang|Generic Interfaces and Classes|Generic Interfaces and Classes}}.

=== Conversion to Generic Type ===

=== Monitors ===

{{lang|Monitors|Monitors}} with {{lang2|Monitors|Guards|guards}}

=== Must Unify оператор ===

Новый оператор == (must-unify)

=== Термы универсального типа ===

<vp>any</vp> и предикат <vp>toAny/1-></vp>

=== Подготовка к 64-битной реализации ===

Подготовка к 64-битной реализации 64bit systems: built-in типы <vp>integerNative</vp> и <vp>unsignedNative</vp>

=== Интерфейс с другими языками ===

Native interfaces support (attributes):
* {{lang2|Attributes|inline|inline}}: Inline structures and strings.
* {{lang2|Attributes|union|union}}: Functor-less unions.
* {{lang2|Attributes|byVal|byVal}}: Passing parameters by value.

External resolution is default for predicates declared with <vp>apicall</vp> calling convention.
* They cannot have clauses
* explicit externally resolution is only legal when a DLL is stated

=== Other language features ===

* The precedence of unary minus is changed (so that power operator has higher precedence)
* Extended versions of built-in predicates <vp>toTerm/2-></vp> and <vp>tryToTerm/2-></vp> (type as the first parameter).
* New built-in predicate <vp>fromEllipsis : (...) -> any* Terms</vp>
* Runtime distinction between privately and publicly supported interfaces is removed

New attributes
* {{lang2|Attributes|retired|retired}}
* {{lang2|Attributes|noDefaultConstructor|noDefaultConstructor}}
* {{lang2|Attributes|used|used}}

Warnings:
* Local object predicates which do not use <vp>This</vp> (and therefore can be declared as class predicates)
* Unused local constants
* Condition of foreach statement which has no backtrack point (i.e. mode is not <vp>multi</vp> or <vp>nondeterm</vp>)
* <vp>unheckedConversion</vp>'s that would be illegal on 64 bit platforms (e.g. <vp>pointer</vp> -> <vp>integer</vp>)

== IDE ==

=== Project tree ===

The project tree is redesigned and reimplemented. The functionality is more or less unchanged, but the performance is improved.

The '''IncludedIn''' and '''Includes''' windows has been moved to preview pane of project window.

It is not possible to have several packages with same name in a project (which can make much sense when using namespaces).

=== Browse dialog ===

The '''Browse''' dialog is improved in several smaller respects, including:
* It automatically jump to the 1st occurrence of search entity on locate
* The last dialog position is saved for next appearence

=== Find In Files ===

The '''Find In Files''' dialog is improved in several respects, including:
* result window is reused for subsequent searches
* F8 button for next match (Shift+F8 - previous)
* Prolog case sensitive search mode
* state is saved for next appearence

=== Namespace support ===

The '''Namespaces support''' is improved, so that forms, dialogs, etc can be places in namespaces when created.

=== IntelliSense ===

The '''IntelliSense''' feature is improved for better overview, speed typing and convenience of work.

=== Tab navigation диалог (Ctrl+Tab) ===

Добавлена функциональность '''tab navigation''' диалога:
* при использовании кнопки ALT фильтруются все [ReadOnly] окна
* при нажатии Del - соответствующее окно закрывается

=== Go to Position on Clipboard ===

The '''Go to Position on Clipboard''' (Shift+F2) has been extended to accept a complete exception dump. F8 will go to the next stack entry.

=== Сортировка в некоторых окнах ===

Окно ошибок (Errors Window), точек останова (Break points Window) и некоторые другие появилась возможность сортировать колонки. Для этого надо просто нажать на вверх колонки.
* '''Optimal Set of Includes improved''' (output, local scopes, etc.)

== Debugger ==

* '''Highlighting''' changed values in variable window
* View of '''long lists''' improvement
* '''Speed''' of restarting is improved
* '''Memory break points''' and fact access (for some types)
* '''Multi-threaded''' application debugging is improved (thread names, break points handling)
* Multi-line '''tool tips'''

== PFC ==

=== New entities ===

* [[Collection library]]
** Algebraic: <vp>redBlackSet</vp>, <vp>leftistPriorityQueue</vp>
** Modifiable: <vp>mapM_redBlack</vp>, <vp>priorityQueueM_leftist</vp>, <vp>queueM_fact</vp>, <vp>setM_redBlack</vp>
** Persistent: <vp>mapP_redBlack</vp>, <vp>priorityQueueP_leftist</vp>, <vp>queueP_fact</vp>, <vp>setP_redBlack</vp>
* <vp>varM</vp> modifiable variable
* <vp>linkControl</vp> PFC version of the Link common control
* <vp>richEditControl</vp> PFC version of the RichEdit common control
* <vp>treeControl</vp> PFC model based version of the TreeView common control
* <vp>gdiplus</vp> PFC version of GDI+
* <vp>cryptography</vp> hash, sha1, md5 & base64
* <vp>eventSource</vp> generalization of event notification/listening
* <vp>monitorQueue</vp> thread safe queue class based on the monitor facility
* <vp>reflection</vp> basic functionalty for code reflection
* <vp>inputStream_null</vp> & <vp>outputStream_null</vp> media-less streams (input is exhausted; outpt throws away)
* <vp>lZ_fileSystem_native</vp> Interface to Lempel-Ziv Decompression API functionality
* <vp>shell_api</vp> Api level interface to the Windows Shell
* <vp>winsock2_native</vp> native bindings to Windows Sockets 2

=== Extensions and improvements ===

* <vp>list</vp> package:
** speed: <vp>sort</vp>, <vp>removeDuplicate</vp>, <vp>drop</vp>, <vp>min</vp>/<vp>max</vp>, etc.)
** functionality: <vp>isMemberEq</vp> (and similar predicates) that uses a <vp>determ</vp> predicate as test
* <vp>listControl</vp> with owner-drawing capabilities
* <vp>uxTheme_native</vp> extended with the rest of the functions and the constants from vsStyle.h, etc.
* Add moving listener/responder to <vp>splitTwoControl</vp>
* Add the fraction handling from <vp>format</vp> to <vp>formatTime</vp>
* '''Speed''' improvements for:
** <vp>string</vp>
** <vp>fileName</vp>
** <vp>listViewControl</vp>
* <vp>string::rear/2-></vp> returns the rear part of a string
* '''Math''' package: predicates <vp>roundToInteger64/1-></vp> and <vp>roundToUnsigned64/1-></vp>
* Better handling of '''default button size'''
* <vp>msXLM_api</vp> update to version 6.0 of various COMponent classes

== Others ==

* More efficient '''memory handling'''; using typed memory allocation for compound terms and internal facts chains
* Various optimizations for speed and size of generated code
* New Demo Examples (Commercial Edition only):
** Parser Generator
** LZDecompression
** TreeControlDemo
* Help on built-in entities
* VipBuilder: extra option to ignore <vp>#requires</vp> directives
* Extend '''Win32''' library (with more names from MS libraries).
* More context to consult exceptions
* Linker speed improvement
* Vault Integration updated to version 5.0.1

[[Category:Release Notes]]

Что нового в VIP 7.3

2010-03-25T15:26:33Z

SergeMukhin: /* Tab navigation dialog */

{{Preliminary Documentation}}

== Язык ==

=== Generic Interfaces and Classes ===

See {{lang|Generic Interfaces and Classes|Generic Interfaces and Classes}}.

=== Conversion to Generic Type ===

=== Monitors ===

{{lang|Monitors|Monitors}} with {{lang2|Monitors|Guards|guards}}

=== Must Unify оператор ===

Новый оператор == (must-unify)

=== Термы универсального типа ===

<vp>any</vp> и предикат <vp>toAny/1-></vp>

=== Подготовка к 64-битной реализации ===

Подготовка к 64-битной реализации 64bit systems: built-in типы <vp>integerNative</vp> и <vp>unsignedNative</vp>

=== Интерфейс с другими языками ===

Native interfaces support (attributes):
* {{lang2|Attributes|inline|inline}}: Inline structures and strings.
* {{lang2|Attributes|union|union}}: Functor-less unions.
* {{lang2|Attributes|byVal|byVal}}: Passing parameters by value.

External resolution is default for predicates declared with <vp>apicall</vp> calling convention.
* They cannot have clauses
* explicit externally resolution is only legal when a DLL is stated

=== Other language features ===

* The precedence of unary minus is changed (so that power operator has higher precedence)
* Extended versions of built-in predicates <vp>toTerm/2-></vp> and <vp>tryToTerm/2-></vp> (type as the first parameter).
* New built-in predicate <vp>fromEllipsis : (...) -> any* Terms</vp>
* Runtime distinction between privately and publicly supported interfaces is removed

New attributes
* {{lang2|Attributes|retired|retired}}
* {{lang2|Attributes|noDefaultConstructor|noDefaultConstructor}}
* {{lang2|Attributes|used|used}}

Warnings:
* Local object predicates which do not use <vp>This</vp> (and therefore can be declared as class predicates)
* Unused local constants
* Condition of foreach statement which has no backtrack point (i.e. mode is not <vp>multi</vp> or <vp>nondeterm</vp>)
* <vp>unheckedConversion</vp>'s that would be illegal on 64 bit platforms (e.g. <vp>pointer</vp> -> <vp>integer</vp>)

== IDE ==

=== Project tree ===

The project tree is redesigned and reimplemented. The functionality is more or less unchanged, but the performance is improved.

The '''IncludedIn''' and '''Includes''' windows has been moved to preview pane of project window.

It is not possible to have several packages with same name in a project (which can make much sense when using namespaces).

=== Browse dialog ===

The '''Browse''' dialog is improved in several smaller respects, including:
* It automatically jump to the 1st occurrence of search entity on locate
* The last dialog position is saved for next appearence

=== Find In Files ===

The '''Find In Files''' dialog is improved in several respects, including:
* result window is reused for subsequent searches
* F8 button for next match (Shift+F8 - previous)
* Prolog case sensitive search mode
* state is saved for next appearence

=== Namespace support ===

The '''Namespaces support''' is improved, so that forms, dialogs, etc can be places in namespaces when created.

=== IntelliSense ===

The '''IntelliSense''' feature is improved for better overview, speed typing and convenience of work.

=== Tab navigation диалог (Ctrl+Tab) ===

Добавлена функциональность '''tab navigation''' диалога:
* при использовании кнопки ALT фильтруются все [ReadOnly] окна
* при нажатии Del - соответствующее окно закрывается

=== Go to Position on Clipboard ===

The '''Go to Position on Clipboard''' (Shift+F2) has been extended to accept a complete exception dump. F8 will go to the next stack entry.

=== Sorting in various windows ===

The Errors Window, the Break points Window, etc. has been extended with sorting capabilities (clicking on the top banner).
* '''Optimal Set of Includes improved''' (output, local scopes, etc.)

== Debugger ==

* '''Highlighting''' changed values in variable window
* View of '''long lists''' improvement
* '''Speed''' of restarting is improved
* '''Memory break points''' and fact access (for some types)
* '''Multi-threaded''' application debugging is improved (thread names, break points handling)
* Multi-line '''tool tips'''

== PFC ==

=== New entities ===

* [[Collection library]]
** Algebraic: <vp>redBlackSet</vp>, <vp>leftistPriorityQueue</vp>
** Modifiable: <vp>mapM_redBlack</vp>, <vp>priorityQueueM_leftist</vp>, <vp>queueM_fact</vp>, <vp>setM_redBlack</vp>
** Persistent: <vp>mapP_redBlack</vp>, <vp>priorityQueueP_leftist</vp>, <vp>queueP_fact</vp>, <vp>setP_redBlack</vp>
* <vp>varM</vp> modifiable variable
* <vp>linkControl</vp> PFC version of the Link common control
* <vp>richEditControl</vp> PFC version of the RichEdit common control
* <vp>treeControl</vp> PFC model based version of the TreeView common control
* <vp>gdiplus</vp> PFC version of GDI+
* <vp>cryptography</vp> hash, sha1, md5 & base64
* <vp>eventSource</vp> generalization of event notification/listening
* <vp>monitorQueue</vp> thread safe queue class based on the monitor facility
* <vp>reflection</vp> basic functionalty for code reflection
* <vp>inputStream_null</vp> & <vp>outputStream_null</vp> media-less streams (input is exhausted; outpt throws away)
* <vp>lZ_fileSystem_native</vp> Interface to Lempel-Ziv Decompression API functionality
* <vp>shell_api</vp> Api level interface to the Windows Shell
* <vp>winsock2_native</vp> native bindings to Windows Sockets 2

=== Extensions and improvements ===

* <vp>list</vp> package:
** speed: <vp>sort</vp>, <vp>removeDuplicate</vp>, <vp>drop</vp>, <vp>min</vp>/<vp>max</vp>, etc.)
** functionality: <vp>isMemberEq</vp> (and similar predicates) that uses a <vp>determ</vp> predicate as test
* <vp>listControl</vp> with owner-drawing capabilities
* <vp>uxTheme_native</vp> extended with the rest of the functions and the constants from vsStyle.h, etc.
* Add moving listener/responder to <vp>splitTwoControl</vp>
* Add the fraction handling from <vp>format</vp> to <vp>formatTime</vp>
* '''Speed''' improvements for:
** <vp>string</vp>
** <vp>fileName</vp>
** <vp>listViewControl</vp>
* <vp>string::rear/2-></vp> returns the rear part of a string
* '''Math''' package: predicates <vp>roundToInteger64/1-></vp> and <vp>roundToUnsigned64/1-></vp>
* Better handling of '''default button size'''
* <vp>msXLM_api</vp> update to version 6.0 of various COMponent classes

== Others ==

* More efficient '''memory handling'''; using typed memory allocation for compound terms and internal facts chains
* Various optimizations for speed and size of generated code
* New Demo Examples (Commercial Edition only):
** Parser Generator
** LZDecompression
** TreeControlDemo
* Help on built-in entities
* VipBuilder: extra option to ignore <vp>#requires</vp> directives
* Extend '''Win32''' library (with more names from MS libraries).
* More context to consult exceptions
* Linker speed improvement
* Vault Integration updated to version 5.0.1

[[Category:Release Notes]]

Что нового в VIP 7.3

2010-03-25T12:55:42Z

SergeMukhin:

{{Preliminary Documentation}}

== Язык ==

=== Generic Interfaces and Classes ===

See {{lang|Generic Interfaces and Classes|Generic Interfaces and Classes}}.

=== Conversion to Generic Type ===

=== Monitors ===

{{lang|Monitors|Monitors}} with {{lang2|Monitors|Guards|guards}}

=== Must Unify оператор ===

Новый оператор == (must-unify)

=== Термы универсального типа ===

<vp>any</vp> и предикат <vp>toAny/1-></vp>

=== Подготовка к 64-битной реализации ===

Подготовка к 64-битной реализации 64bit systems: built-in типы <vp>integerNative</vp> и <vp>unsignedNative</vp>

=== Интерфейс с другими языками ===

Native interfaces support (attributes):
* {{lang2|Attributes|inline|inline}}: Inline structures and strings.
* {{lang2|Attributes|union|union}}: Functor-less unions.
* {{lang2|Attributes|byVal|byVal}}: Passing parameters by value.

External resolution is default for predicates declared with <vp>apicall</vp> calling convention.
* They cannot have clauses
* explicit externally resolution is only legal when a DLL is stated

=== Other language features ===

* The precedence of unary minus is changed (so that power operator has higher precedence)
* Extended versions of built-in predicates <vp>toTerm/2-></vp> and <vp>tryToTerm/2-></vp> (type as the first parameter).
* New built-in predicate <vp>fromEllipsis : (...) -> any* Terms</vp>
* Runtime distinction between privately and publicly supported interfaces is removed

New attributes
* {{lang2|Attributes|retired|retired}}
* {{lang2|Attributes|noDefaultConstructor|noDefaultConstructor}}
* {{lang2|Attributes|used|used}}

Warnings:
* Local object predicates which do not use <vp>This</vp> (and therefore can be declared as class predicates)
* Unused local constants
* Condition of foreach statement which has no backtrack point (i.e. mode is not <vp>multi</vp> or <vp>nondeterm</vp>)
* <vp>unheckedConversion</vp>'s that would be illegal on 64 bit platforms (e.g. <vp>pointer</vp> -> <vp>integer</vp>)

== IDE ==

=== Project tree ===

The project tree is redesigned and reimplemented. The functionality is more or less unchanged, but the performance is improved.

The '''IncludedIn''' and '''Includes''' windows has been moved to preview pane of project window.

It is not possible to have several packages with same name in a project (which can make much sense when using namespaces).

=== Browse dialog ===

The '''Browse''' dialog is improved in several smaller respects, including:
* It automatically jump to the 1st occurrence of search entity on locate
* The last dialog position is saved for next appearence

=== Find In Files ===

The '''Find In Files''' dialog is improved in several respects, including:
* result window is reused for subsequent searches
* F8 button for next match (Shift+F8 - previous)
* Prolog case sensitive search mode
* state is saved for next appearence

=== Namespace support ===

The '''Namespaces support''' is improved, so that forms, dialogs, etc can be places in namespaces when created.

=== IntelliSense ===

The '''IntelliSense''' feature is improved for better overview, speed typing and convenience of work.

=== Tab navigation dialog ===

The '''tab navigation''' dialog functionality has been extended:
* use ALT button for filtering [ReadOnly] windows
* use Del for closing windows

=== Go to Position on Clipboard ===

The '''Go to Position on Clipboard''' (Shift+F2) has been extended to accept a complete exception dump. F8 will go to the next stack entry.

=== Sorting in various windows ===

The Errors Window, the Break points Window, etc. has been extended with sorting capabilities (clicking on the top banner).
* '''Optimal Set of Includes improved''' (output, local scopes, etc.)

== Debugger ==

* '''Highlighting''' changed values in variable window
* View of '''long lists''' improvement
* '''Speed''' of restarting is improved
* '''Memory break points''' and fact access (for some types)
* '''Multi-threaded''' application debugging is improved (thread names, break points handling)
* Multi-line '''tool tips'''

== PFC ==

=== New entities ===

* [[Collection library]]
** Algebraic: <vp>redBlackSet</vp>, <vp>leftistPriorityQueue</vp>
** Modifiable: <vp>mapM_redBlack</vp>, <vp>priorityQueueM_leftist</vp>, <vp>queueM_fact</vp>, <vp>setM_redBlack</vp>
** Persistent: <vp>mapP_redBlack</vp>, <vp>priorityQueueP_leftist</vp>, <vp>queueP_fact</vp>, <vp>setP_redBlack</vp>
* <vp>varM</vp> modifiable variable
* <vp>linkControl</vp> PFC version of the Link common control
* <vp>richEditControl</vp> PFC version of the RichEdit common control
* <vp>treeControl</vp> PFC model based version of the TreeView common control
* <vp>gdiplus</vp> PFC version of GDI+
* <vp>cryptography</vp> hash, sha1, md5 & base64
* <vp>eventSource</vp> generalization of event notification/listening
* <vp>monitorQueue</vp> thread safe queue class based on the monitor facility
* <vp>reflection</vp> basic functionalty for code reflection
* <vp>inputStream_null</vp> & <vp>outputStream_null</vp> media-less streams (input is exhausted; outpt throws away)
* <vp>lZ_fileSystem_native</vp> Interface to Lempel-Ziv Decompression API functionality
* <vp>shell_api</vp> Api level interface to the Windows Shell
* <vp>winsock2_native</vp> native bindings to Windows Sockets 2

=== Extensions and improvements ===

* <vp>list</vp> package:
** speed: <vp>sort</vp>, <vp>removeDuplicate</vp>, <vp>drop</vp>, <vp>min</vp>/<vp>max</vp>, etc.)
** functionality: <vp>isMemberEq</vp> (and similar predicates) that uses a <vp>determ</vp> predicate as test
* <vp>listControl</vp> with owner-drawing capabilities
* <vp>uxTheme_native</vp> extended with the rest of the functions and the constants from vsStyle.h, etc.
* Add moving listener/responder to <vp>splitTwoControl</vp>
* Add the fraction handling from <vp>format</vp> to <vp>formatTime</vp>
* '''Speed''' improvements for:
** <vp>string</vp>
** <vp>fileName</vp>
** <vp>listViewControl</vp>
* <vp>string::rear/2-></vp> returns the rear part of a string
* '''Math''' package: predicates <vp>roundToInteger64/1-></vp> and <vp>roundToUnsigned64/1-></vp>
* Better handling of '''default button size'''
* <vp>msXLM_api</vp> update to version 6.0 of various COMponent classes

== Others ==

* More efficient '''memory handling'''; using typed memory allocation for compound terms and internal facts chains
* Various optimizations for speed and size of generated code
* New Demo Examples (Commercial Edition only):
** Parser Generator
** LZDecompression
** TreeControlDemo
* Help on built-in entities
* VipBuilder: extra option to ignore <vp>#requires</vp> directives
* Extend '''Win32''' library (with more names from MS libraries).
* More context to consult exceptions
* Linker speed improvement
* Vault Integration updated to version 5.0.1

[[Category:Release Notes]]

Что нового в VIP 7.3

2010-03-25T12:53:50Z

SergeMukhin: /* Термы универсального типа */

{{Preliminary Documentation}}

== Language ==

=== Generic Interfaces and Classes ===

See {{lang|Generic Interfaces and Classes|Generic Interfaces and Classes}}.

=== Conversion to Generic Type ===

=== Monitors ===

{{lang|Monitors|Monitors}} with {{lang2|Monitors|Guards|guards}}

=== Must Unify оператор ===

Новый оператор == (must-unify)

=== Термы универсального типа ===

<vp>any</vp> и предикат <vp>toAny/1-></vp>

=== Подготовка к 64-битной реализации ===

Preparations for supporting 64bit systems: built-in types <vp>integerNative</vp> and <vp>unsignedNative</vp>

=== Foreign language interfacing ===

Native interfaces support (attributes):
* {{lang2|Attributes|inline|inline}}: Inline structures and strings.
* {{lang2|Attributes|union|union}}: Functor-less unions.
* {{lang2|Attributes|byVal|byVal}}: Passing parameters by value.

External resolution is default for predicates declared with <vp>apicall</vp> calling convention.
* They cannot have clauses
* explicit externally resolution is only legal when a DLL is stated

=== Other language features ===

* The precedence of unary minus is changed (so that power operator has higher precedence)
* Extended versions of built-in predicates <vp>toTerm/2-></vp> and <vp>tryToTerm/2-></vp> (type as the first parameter).
* New built-in predicate <vp>fromEllipsis : (...) -> any* Terms</vp>
* Runtime distinction between privately and publicly supported interfaces is removed

New attributes
* {{lang2|Attributes|retired|retired}}
* {{lang2|Attributes|noDefaultConstructor|noDefaultConstructor}}
* {{lang2|Attributes|used|used}}

Warnings:
* Local object predicates which do not use <vp>This</vp> (and therefore can be declared as class predicates)
* Unused local constants
* Condition of foreach statement which has no backtrack point (i.e. mode is not <vp>multi</vp> or <vp>nondeterm</vp>)
* <vp>unheckedConversion</vp>'s that would be illegal on 64 bit platforms (e.g. <vp>pointer</vp> -> <vp>integer</vp>)

== IDE ==

=== Project tree ===

The project tree is redesigned and reimplemented. The functionality is more or less unchanged, but the performance is improved.

The '''IncludedIn''' and '''Includes''' windows has been moved to preview pane of project window.

It is not possible to have several packages with same name in a project (which can make much sense when using namespaces).

=== Browse dialog ===

The '''Browse''' dialog is improved in several smaller respects, including:
* It automatically jump to the 1st occurrence of search entity on locate
* The last dialog position is saved for next appearence

=== Find In Files ===

The '''Find In Files''' dialog is improved in several respects, including:
* result window is reused for subsequent searches
* F8 button for next match (Shift+F8 - previous)
* Prolog case sensitive search mode
* state is saved for next appearence

=== Namespace support ===

The '''Namespaces support''' is improved, so that forms, dialogs, etc can be places in namespaces when created.

=== IntelliSense ===

The '''IntelliSense''' feature is improved for better overview, speed typing and convenience of work.

=== Tab navigation dialog ===

The '''tab navigation''' dialog functionality has been extended:
* use ALT button for filtering [ReadOnly] windows
* use Del for closing windows

=== Go to Position on Clipboard ===

The '''Go to Position on Clipboard''' (Shift+F2) has been extended to accept a complete exception dump. F8 will go to the next stack entry.

=== Sorting in various windows ===

The Errors Window, the Break points Window, etc. has been extended with sorting capabilities (clicking on the top banner).
* '''Optimal Set of Includes improved''' (output, local scopes, etc.)

== Debugger ==

* '''Highlighting''' changed values in variable window
* View of '''long lists''' improvement
* '''Speed''' of restarting is improved
* '''Memory break points''' and fact access (for some types)
* '''Multi-threaded''' application debugging is improved (thread names, break points handling)
* Multi-line '''tool tips'''

== PFC ==

=== New entities ===

* [[Collection library]]
** Algebraic: <vp>redBlackSet</vp>, <vp>leftistPriorityQueue</vp>
** Modifiable: <vp>mapM_redBlack</vp>, <vp>priorityQueueM_leftist</vp>, <vp>queueM_fact</vp>, <vp>setM_redBlack</vp>
** Persistent: <vp>mapP_redBlack</vp>, <vp>priorityQueueP_leftist</vp>, <vp>queueP_fact</vp>, <vp>setP_redBlack</vp>
* <vp>varM</vp> modifiable variable
* <vp>linkControl</vp> PFC version of the Link common control
* <vp>richEditControl</vp> PFC version of the RichEdit common control
* <vp>treeControl</vp> PFC model based version of the TreeView common control
* <vp>gdiplus</vp> PFC version of GDI+
* <vp>cryptography</vp> hash, sha1, md5 & base64
* <vp>eventSource</vp> generalization of event notification/listening
* <vp>monitorQueue</vp> thread safe queue class based on the monitor facility
* <vp>reflection</vp> basic functionalty for code reflection
* <vp>inputStream_null</vp> & <vp>outputStream_null</vp> media-less streams (input is exhausted; outpt throws away)
* <vp>lZ_fileSystem_native</vp> Interface to Lempel-Ziv Decompression API functionality
* <vp>shell_api</vp> Api level interface to the Windows Shell
* <vp>winsock2_native</vp> native bindings to Windows Sockets 2

=== Extensions and improvements ===

* <vp>list</vp> package:
** speed: <vp>sort</vp>, <vp>removeDuplicate</vp>, <vp>drop</vp>, <vp>min</vp>/<vp>max</vp>, etc.)
** functionality: <vp>isMemberEq</vp> (and similar predicates) that uses a <vp>determ</vp> predicate as test
* <vp>listControl</vp> with owner-drawing capabilities
* <vp>uxTheme_native</vp> extended with the rest of the functions and the constants from vsStyle.h, etc.
* Add moving listener/responder to <vp>splitTwoControl</vp>
* Add the fraction handling from <vp>format</vp> to <vp>formatTime</vp>
* '''Speed''' improvements for:
** <vp>string</vp>
** <vp>fileName</vp>
** <vp>listViewControl</vp>
* <vp>string::rear/2-></vp> returns the rear part of a string
* '''Math''' package: predicates <vp>roundToInteger64/1-></vp> and <vp>roundToUnsigned64/1-></vp>
* Better handling of '''default button size'''
* <vp>msXLM_api</vp> update to version 6.0 of various COMponent classes

== Others ==

* More efficient '''memory handling'''; using typed memory allocation for compound terms and internal facts chains
* Various optimizations for speed and size of generated code
* New Demo Examples (Commercial Edition only):
** Parser Generator
** LZDecompression
** TreeControlDemo
* Help on built-in entities
* VipBuilder: extra option to ignore <vp>#requires</vp> directives
* Extend '''Win32''' library (with more names from MS libraries).
* More context to consult exceptions
* Linker speed improvement
* Vault Integration updated to version 5.0.1

[[Category:Release Notes]]

Что нового в VIP 7.3

2010-03-25T12:53:29Z

SergeMukhin:

{{Preliminary Documentation}}

== Language ==

=== Generic Interfaces and Classes ===

See {{lang|Generic Interfaces and Classes|Generic Interfaces and Classes}}.

=== Conversion to Generic Type ===

=== Monitors ===

{{lang|Monitors|Monitors}} with {{lang2|Monitors|Guards|guards}}

=== Must Unify оператор ===

Новый оператор == (must-unify)

=== Термы универсального типа ===

<vp>any</vp> и предикат<vp>toAny/1-></vp>

=== Подготовка к 64-битной реализации ===

Preparations for supporting 64bit systems: built-in types <vp>integerNative</vp> and <vp>unsignedNative</vp>

=== Foreign language interfacing ===

Native interfaces support (attributes):
* {{lang2|Attributes|inline|inline}}: Inline structures and strings.
* {{lang2|Attributes|union|union}}: Functor-less unions.
* {{lang2|Attributes|byVal|byVal}}: Passing parameters by value.

External resolution is default for predicates declared with <vp>apicall</vp> calling convention.
* They cannot have clauses
* explicit externally resolution is only legal when a DLL is stated

=== Other language features ===

* The precedence of unary minus is changed (so that power operator has higher precedence)
* Extended versions of built-in predicates <vp>toTerm/2-></vp> and <vp>tryToTerm/2-></vp> (type as the first parameter).
* New built-in predicate <vp>fromEllipsis : (...) -> any* Terms</vp>
* Runtime distinction between privately and publicly supported interfaces is removed

New attributes
* {{lang2|Attributes|retired|retired}}
* {{lang2|Attributes|noDefaultConstructor|noDefaultConstructor}}
* {{lang2|Attributes|used|used}}

Warnings:
* Local object predicates which do not use <vp>This</vp> (and therefore can be declared as class predicates)
* Unused local constants
* Condition of foreach statement which has no backtrack point (i.e. mode is not <vp>multi</vp> or <vp>nondeterm</vp>)
* <vp>unheckedConversion</vp>'s that would be illegal on 64 bit platforms (e.g. <vp>pointer</vp> -> <vp>integer</vp>)

== IDE ==

=== Project tree ===

The project tree is redesigned and reimplemented. The functionality is more or less unchanged, but the performance is improved.

The '''IncludedIn''' and '''Includes''' windows has been moved to preview pane of project window.

It is not possible to have several packages with same name in a project (which can make much sense when using namespaces).

=== Browse dialog ===

The '''Browse''' dialog is improved in several smaller respects, including:
* It automatically jump to the 1st occurrence of search entity on locate
* The last dialog position is saved for next appearence

=== Find In Files ===

The '''Find In Files''' dialog is improved in several respects, including:
* result window is reused for subsequent searches
* F8 button for next match (Shift+F8 - previous)
* Prolog case sensitive search mode
* state is saved for next appearence

=== Namespace support ===

The '''Namespaces support''' is improved, so that forms, dialogs, etc can be places in namespaces when created.

=== IntelliSense ===

The '''IntelliSense''' feature is improved for better overview, speed typing and convenience of work.

=== Tab navigation dialog ===

The '''tab navigation''' dialog functionality has been extended:
* use ALT button for filtering [ReadOnly] windows
* use Del for closing windows

=== Go to Position on Clipboard ===

The '''Go to Position on Clipboard''' (Shift+F2) has been extended to accept a complete exception dump. F8 will go to the next stack entry.

=== Sorting in various windows ===

The Errors Window, the Break points Window, etc. has been extended with sorting capabilities (clicking on the top banner).
* '''Optimal Set of Includes improved''' (output, local scopes, etc.)

== Debugger ==

* '''Highlighting''' changed values in variable window
* View of '''long lists''' improvement
* '''Speed''' of restarting is improved
* '''Memory break points''' and fact access (for some types)
* '''Multi-threaded''' application debugging is improved (thread names, break points handling)
* Multi-line '''tool tips'''

== PFC ==

=== New entities ===

* [[Collection library]]
** Algebraic: <vp>redBlackSet</vp>, <vp>leftistPriorityQueue</vp>
** Modifiable: <vp>mapM_redBlack</vp>, <vp>priorityQueueM_leftist</vp>, <vp>queueM_fact</vp>, <vp>setM_redBlack</vp>
** Persistent: <vp>mapP_redBlack</vp>, <vp>priorityQueueP_leftist</vp>, <vp>queueP_fact</vp>, <vp>setP_redBlack</vp>
* <vp>varM</vp> modifiable variable
* <vp>linkControl</vp> PFC version of the Link common control
* <vp>richEditControl</vp> PFC version of the RichEdit common control
* <vp>treeControl</vp> PFC model based version of the TreeView common control
* <vp>gdiplus</vp> PFC version of GDI+
* <vp>cryptography</vp> hash, sha1, md5 & base64
* <vp>eventSource</vp> generalization of event notification/listening
* <vp>monitorQueue</vp> thread safe queue class based on the monitor facility
* <vp>reflection</vp> basic functionalty for code reflection
* <vp>inputStream_null</vp> & <vp>outputStream_null</vp> media-less streams (input is exhausted; outpt throws away)
* <vp>lZ_fileSystem_native</vp> Interface to Lempel-Ziv Decompression API functionality
* <vp>shell_api</vp> Api level interface to the Windows Shell
* <vp>winsock2_native</vp> native bindings to Windows Sockets 2

=== Extensions and improvements ===

* <vp>list</vp> package:
** speed: <vp>sort</vp>, <vp>removeDuplicate</vp>, <vp>drop</vp>, <vp>min</vp>/<vp>max</vp>, etc.)
** functionality: <vp>isMemberEq</vp> (and similar predicates) that uses a <vp>determ</vp> predicate as test
* <vp>listControl</vp> with owner-drawing capabilities
* <vp>uxTheme_native</vp> extended with the rest of the functions and the constants from vsStyle.h, etc.
* Add moving listener/responder to <vp>splitTwoControl</vp>
* Add the fraction handling from <vp>format</vp> to <vp>formatTime</vp>
* '''Speed''' improvements for:
** <vp>string</vp>
** <vp>fileName</vp>
** <vp>listViewControl</vp>
* <vp>string::rear/2-></vp> returns the rear part of a string
* '''Math''' package: predicates <vp>roundToInteger64/1-></vp> and <vp>roundToUnsigned64/1-></vp>
* Better handling of '''default button size'''
* <vp>msXLM_api</vp> update to version 6.0 of various COMponent classes

== Others ==

* More efficient '''memory handling'''; using typed memory allocation for compound terms and internal facts chains
* Various optimizations for speed and size of generated code
* New Demo Examples (Commercial Edition only):
** Parser Generator
** LZDecompression
** TreeControlDemo
* Help on built-in entities
* VipBuilder: extra option to ignore <vp>#requires</vp> directives
* Extend '''Win32''' library (with more names from MS libraries).
* More context to consult exceptions
* Linker speed improvement
* Vault Integration updated to version 5.0.1

[[Category:Release Notes]]

Что нового в VIP 7.3

2010-03-25T12:51:07Z

SergeMukhin: Новая: {{Preliminary Documentation}} == Language == === Generic Interfaces and Classes === See {{lang|Generic Interfaces and Classes|Generic Interfaces and Classes}}. === Conversion to Gene...

{{Preliminary Documentation}}

== Language ==

=== Generic Interfaces and Classes ===

See {{lang|Generic Interfaces and Classes|Generic Interfaces and Classes}}.

=== Conversion to Generic Type ===

=== Monitors ===

{{lang|Monitors|Monitors}} with {{lang2|Monitors|Guards|guards}}

=== Must Unify Operator ===

New operator == (must-unify)

=== Universal term type ===

<vp>any</vp> and the predicate <vp>toAny/1-></vp>

=== 64 bit preparation ===

Preparations for supporting 64bit systems: built-in types <vp>integerNative</vp> and <vp>unsignedNative</vp>

=== Foreign language interfacing ===

Native interfaces support (attributes):
* {{lang2|Attributes|inline|inline}}: Inline structures and strings.
* {{lang2|Attributes|union|union}}: Functor-less unions.
* {{lang2|Attributes|byVal|byVal}}: Passing parameters by value.

External resolution is default for predicates declared with <vp>apicall</vp> calling convention.
* They cannot have clauses
* explicit externally resolution is only legal when a DLL is stated

=== Other language features ===

* The precedence of unary minus is changed (so that power operator has higher precedence)
* Extended versions of built-in predicates <vp>toTerm/2-></vp> and <vp>tryToTerm/2-></vp> (type as the first parameter).
* New built-in predicate <vp>fromEllipsis : (...) -> any* Terms</vp>
* Runtime distinction between privately and publicly supported interfaces is removed

New attributes
* {{lang2|Attributes|retired|retired}}
* {{lang2|Attributes|noDefaultConstructor|noDefaultConstructor}}
* {{lang2|Attributes|used|used}}

Warnings:
* Local object predicates which do not use <vp>This</vp> (and therefore can be declared as class predicates)
* Unused local constants
* Condition of foreach statement which has no backtrack point (i.e. mode is not <vp>multi</vp> or <vp>nondeterm</vp>)
* <vp>unheckedConversion</vp>'s that would be illegal on 64 bit platforms (e.g. <vp>pointer</vp> -> <vp>integer</vp>)

== IDE ==

=== Project tree ===

The project tree is redesigned and reimplemented. The functionality is more or less unchanged, but the performance is improved.

The '''IncludedIn''' and '''Includes''' windows has been moved to preview pane of project window.

It is not possible to have several packages with same name in a project (which can make much sense when using namespaces).

=== Browse dialog ===

The '''Browse''' dialog is improved in several smaller respects, including:
* It automatically jump to the 1st occurrence of search entity on locate
* The last dialog position is saved for next appearence

=== Find In Files ===

The '''Find In Files''' dialog is improved in several respects, including:
* result window is reused for subsequent searches
* F8 button for next match (Shift+F8 - previous)
* Prolog case sensitive search mode
* state is saved for next appearence

=== Namespace support ===

The '''Namespaces support''' is improved, so that forms, dialogs, etc can be places in namespaces when created.

=== IntelliSense ===

The '''IntelliSense''' feature is improved for better overview, speed typing and convenience of work.

=== Tab navigation dialog ===

The '''tab navigation''' dialog functionality has been extended:
* use ALT button for filtering [ReadOnly] windows
* use Del for closing windows

=== Go to Position on Clipboard ===

The '''Go to Position on Clipboard''' (Shift+F2) has been extended to accept a complete exception dump. F8 will go to the next stack entry.

=== Sorting in various windows ===

The Errors Window, the Break points Window, etc. has been extended with sorting capabilities (clicking on the top banner).
* '''Optimal Set of Includes improved''' (output, local scopes, etc.)

== Debugger ==

* '''Highlighting''' changed values in variable window
* View of '''long lists''' improvement
* '''Speed''' of restarting is improved
* '''Memory break points''' and fact access (for some types)
* '''Multi-threaded''' application debugging is improved (thread names, break points handling)
* Multi-line '''tool tips'''

== PFC ==

=== New entities ===

* [[Collection library]]
** Algebraic: <vp>redBlackSet</vp>, <vp>leftistPriorityQueue</vp>
** Modifiable: <vp>mapM_redBlack</vp>, <vp>priorityQueueM_leftist</vp>, <vp>queueM_fact</vp>, <vp>setM_redBlack</vp>
** Persistent: <vp>mapP_redBlack</vp>, <vp>priorityQueueP_leftist</vp>, <vp>queueP_fact</vp>, <vp>setP_redBlack</vp>
* <vp>varM</vp> modifiable variable
* <vp>linkControl</vp> PFC version of the Link common control
* <vp>richEditControl</vp> PFC version of the RichEdit common control
* <vp>treeControl</vp> PFC model based version of the TreeView common control
* <vp>gdiplus</vp> PFC version of GDI+
* <vp>cryptography</vp> hash, sha1, md5 & base64
* <vp>eventSource</vp> generalization of event notification/listening
* <vp>monitorQueue</vp> thread safe queue class based on the monitor facility
* <vp>reflection</vp> basic functionalty for code reflection
* <vp>inputStream_null</vp> & <vp>outputStream_null</vp> media-less streams (input is exhausted; outpt throws away)
* <vp>lZ_fileSystem_native</vp> Interface to Lempel-Ziv Decompression API functionality
* <vp>shell_api</vp> Api level interface to the Windows Shell
* <vp>winsock2_native</vp> native bindings to Windows Sockets 2

=== Extensions and improvements ===

* <vp>list</vp> package:
** speed: <vp>sort</vp>, <vp>removeDuplicate</vp>, <vp>drop</vp>, <vp>min</vp>/<vp>max</vp>, etc.)
** functionality: <vp>isMemberEq</vp> (and similar predicates) that uses a <vp>determ</vp> predicate as test
* <vp>listControl</vp> with owner-drawing capabilities
* <vp>uxTheme_native</vp> extended with the rest of the functions and the constants from vsStyle.h, etc.
* Add moving listener/responder to <vp>splitTwoControl</vp>
* Add the fraction handling from <vp>format</vp> to <vp>formatTime</vp>
* '''Speed''' improvements for:
** <vp>string</vp>
** <vp>fileName</vp>
** <vp>listViewControl</vp>
* <vp>string::rear/2-></vp> returns the rear part of a string
* '''Math''' package: predicates <vp>roundToInteger64/1-></vp> and <vp>roundToUnsigned64/1-></vp>
* Better handling of '''default button size'''
* <vp>msXLM_api</vp> update to version 6.0 of various COMponent classes

== Others ==

* More efficient '''memory handling'''; using typed memory allocation for compound terms and internal facts chains
* Various optimizations for speed and size of generated code
* New Demo Examples (Commercial Edition only):
** Parser Generator
** LZDecompression
** TreeControlDemo
* Help on built-in entities
* VipBuilder: extra option to ignore <vp>#requires</vp> directives
* Extend '''Win32''' library (with more names from MS libraries).
* More context to consult exceptions
* Linker speed improvement
* Vault Integration updated to version 5.0.1

[[Category:Release Notes]]

Классы. Статические и динамические сущности

2008-08-08T08:43:09Z

SergeMukhin: /* Особенности использования фактов-переменных */

==Классы==
Каждый класс должен иметь декларацию класса и имплементацию.

'''Декларация класса''' содержит набор объявлений констант, доменов, предикатов, видимых извне.

'''Имплементация класса''' содержит
*собственно реализацию предикатов (клаузы), объявленных в декларации,
*декларации констант,
*декларации и реализации предикатов, используемых в клаузах,
*декларации фактов.
*Факты и предикаты, объявленные в имплементации класса, извне не видны.

'''Cтатический класс''' - класс не способный порождать объекты (экземпляры или точные копии).
Все предикаты и разделы фактов статического класса существуют в единственном экземпляре во всем проекте.

'''Динамический класс''' - класс, способный порождать объекты (экземпляры или точные копии),
Динамические классы могут содержать как статические, так и динамические предикаты, а также статические и динамические факты.
Каждый экземпляр динамического класса содержит свою копию динамического предиката и свою копию динамического раздела фактов.
Создание объекта (экземпляра или копии класса) осуществляется вызовом предиката-конструктора. Как правило, это предикат-функция ''new()'', но может быть и любой другой, объявленный как конструктор в разделе ''constructors'' декларации класса.

'''Статический класс''' - это класс, не имеющий интерфейса.
Или, что то же самое, - если класс не имеет инерфейса, то он - статический,

Если класс имеет интерфейс - то он - динамический.

==Статические классы==
Например, класс ''staticClass'' является статическим классом.

<vip>
class staticClass
end class staticClass

implement staticClass
end implement staticClass
</vip>
но этот класс ничего не способен делать.
Чтобы что-то делать, добавим в этот класс декларации предикатов и клаузы.

<vip>class staticClass
predicates
visibleStaticPred:().
end class staticClass

implement staticClass
clauses
visibleStaticPred():-
...
invisibleStaticPred(),
...

class predicates
invisibleStaticPred:().
clauses
invisibleStaticPred():-
...
end implement staticClass
</vip>
Обращения к предикатам этого класса записываются как

<vip>...
staticClass::staticVisiblePred(),
...
</vip>
(существенно использования именно '''::''' для обращения к статической сущности)

Здесь предикат ''invisibleStaticPred'' является предикатом, объявленным внутри имплементации, и только внутри этой имплементации может быть вызван.
То есть предикаты, объявленные в декларации класса, являются заведомо всегда статическими предикатами, а раздел объявлений предикатов внутри имплементации статического класса всегда должен имет вид class predicates
Если попробовать создать экземпляр класса ''staticClass'' с помощью вызова конструктора ''new()''
<vip>...
staticClass::new(),
...</vip>
то это не пропустит компилятор.
Таким образом, статические классы - это просто модули проекта.
Проект, построенный только на модулях (статических классах) - не имеет никакого отношения к объекто-ориентированной концепции программирования.

==Динамические классы==
Например, класс ''dynamicClass'' является динамическим классом, что определяется
конструкцией ''dynamicClass:justInterface''.
<vip>class dynamicClass:justInterface
end class dynamicClass

implement dynamicClass
end implement dynamicClass

interface justInterface
end interface justInterface</vip>
Опять-таки, синтаксически все правильно, но практически бесполезно.
Теперь добавим какие-нибудь полезности и вынесем вперед декларацию интерфейса.
<vip>interface justInterface
predicates
visibleDynamicPred:().
end interface justInterface

class dynamicClass:justInterface
predicates
visibleStaticPred:().
end class dynamicClass

implement dynamicClass
clauses
visibleStaticPred():-
...
invisibleStaticPred(),
...

clauses
visibleDynamicPred():-
...
invisibleStaticPred(),
...

class predicates
invisibleStaticPred:().
clauses
invisibleStaticPred():-
...

predicates
invisibleDynamicPred:().
clauses
invisibleDynamicPred():-
...

end implement dynamicClass
</vip>
Здесь мы имеем четыре предиката, которые имеют различные динамические особенности.
''visibleDynamicPred'' - динамический предикат, принадлежащий интерфесу ''justInterface'', видимый извне.
''visibleStaticPred'' - статический предикат, видимый извне.
''invisibleStaticPred'' - статический предикат, определенный в имплементации класса ''dynamicClass'', невидимый извне.
''invisibleDynamicPred'' - динамический предикат, определенный в имплементации класса ''dynamicClass'', невидимый извне.
К такому классу можно обратиться как к статическому
<vip>...
dynamicClass::visibleStaticPred(),
...</vip>
но нельзя так:
<vip>...
dynamicClass::visibleDynamicPred(),
...</vip>
Чтобы вызвать предикат ''visibleDynamicPred()'', необходимо с помощью конструктора создать экземпляр класса и обратиться к этому экземпляру:
<vip>...
ЭкземплярDynamicClass=dynamicClass::new(),
ЭкземплярDynamicClass:visibleDynamicPred(),
...</vip>
Примечания:
* Конструктор ''new()'' является предопределенным конструктором, объявление которого не требуется, если в имплементации нет для него клауза;
* В обращении к экземпляру класса (объекту) используется разделитель ':' (а не '::', как этого требует обращение к статической сущности).

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

<vip>implement example
...
class facts
myFact_F:(string,string).
...
end implement example</vip>
В имплементациях динамических классов факты могут быть объявлены либо как статические, либо как динамические:
<vip>class example1:example1interface
predicates
запомнитьГород:(string Город).
запомнитьИмяАдрес:(string Имя, string Адрес).
получитьГород:()->string Город.
получитьИмяАдрес:(string Имя, string Адрес).
end class example1

implement example1
...
class facts
город_V:string Город.
...
facts
имяАдрес_F:(string Адрес, string Имя).

clauses
запомнитьГород(Город):-
город_V:=Город.
...
clauses
запомнитьИмяАдрес(Имя,Адрес):-
assert(имяАдрес_F:(Адрес,Имя)).

clauses
получитьГород(город_V).
...
clauses
получитьИмяАдрес(Имя,Адрес):-
имяАдрес_F(Адрес,Имя),
!,
...
end implement example1
</vip>
В приведенном примере класса ''example1'' факт ''город_V'' является статическим, а факты ''имяАдрес_F(...)'' являются динамическими,
что определяется разницей в имени раздела ''class facts'' и просто ''facts''.
Поскольку статическая сущность любого класса всего одна, а динамическая - по одной на каждый экземпляр - то и в нашем примере запрос ''получитьГород()'', переданный любому экземпляру, вернет один и тот же результат, а запрос ''получитьИмяАдрес(...)'' вернет для каждого экземпляра свое значение.
===Особенности использования фактов-переменных===
В примере выше использовался факт-переменная ''город_V'', особенностью которого является то, что такой факт всегда один и он сам несет значение терма, объявленного в декларации.
<vip>
class facts
город_V:string Город.</vip>
Здесь факт ''город_V'' имеет строковое значение. Возможны значения любых объявленных доменов, например
<vip>domains
мойДомен=персона(string Имя,unsigned Возраст).
class facts
персона_V:мойДомен.</vip>
В отличие от обычных фактов, факт-переменная всегда существует и должен иметь начальное значение.
Начальное значение факту-переменной можно задать при объявлении
<vip>domains
мойДомен=персона(string Имя,unsigned Возраст).
class facts
персона_V:мойДомен:=персона("Старик",80).
город_V:string:="НеИзвестен".
</vip>
В динамических классах начальное значение вместо декларации можно задать в клаузе конструктора
<vip>implement dynamicClass
domains
мойДомен=персона(string Имя,unsigned Возраст).
class facts
персона_V:мойДомен.
clauses
new():-
персона_V:=персона("Старик",80),
...
end implement dynamicClass</vip>
Бывает, что конкретное начальное значение установить невозможно по смыслу реализации.
Тогда начальное значение может быть установлено как "неустановленное".
<vip>class facts
город_V:string:=erroneous.</vip>
где ''erroneous'' - ключевое слово языка. Факт со значением erroneous не может быть использован (точнее: при попытке его использования будет выдана соответствующая ошибка), можно только проверить является ли значение факта неустановленным с помощью детерминированного предиката ''isErroneous(...)''
<vip>implement dynamicClass
domains
мойДомен=персона(string Имя,unsigned Возраст).
class facts
город_V:string:=erroneous.
персона_V:мойДомен.
clauses
new():-
персона_V:=персона("Старик",80),
...
clauses
...
isErroneous(город_V),
...
end implement dynamicClass</vip>
С учетом сказанного наш пример
<vip>class facts
город_V:string Город.</vip>
на этапе компиляции выдаст ошибку, поскольку статический факт не инициализирован при объявлении.

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

''<имя декларации класса или интерфейса>::<имя домена или константы>''.

==Взаимоотношени статических и динамических сущностей==
Клаузы предикатов, объявленных статическими, не могут обращаться к динамическим сущностям (предикатам и фактам).
То есть нельзя так:
<vip>implement dynamicClass
clauses
staticPred():-
...
dynamicPred(),
...
end implement dynamicClass</vip>
Клаузы предикатов, объявленных динамическими, такого ограничения не имеют.
Как статические так и динамические факты могут хранить указатели на динамические предикаты и экземпляры классов.
[[Категория:VipLanguage]]

Классы. Статические и динамические сущности

2008-08-08T08:40:31Z

SergeMukhin: очепятки

==Классы==
Каждый класс должен иметь декларацию класса и имплементацию.

'''Декларация класса''' содержит набор объявлений констант, доменов, предикатов, видимых извне.

'''Имплементация класса''' содержит
*собственно реализацию предикатов (клаузы), объявленных в декларации,
*декларации констант,
*декларации и реализации предикатов, используемых в клаузах,
*декларации фактов.
*Факты и предикаты, объявленные в имплементации класса, извне не видны.

'''Cтатический класс''' - класс не способный порождать объекты (экземпляры или точные копии).
Все предикаты и разделы фактов статического класса существуют в единственном экземпляре во всем проекте.

'''Динамический класс''' - класс, способный порождать объекты (экземпляры или точные копии),
Динамические классы могут содержать как статические, так и динамические предикаты, а также статические и динамические факты.
Каждый экземпляр динамического класса содержит свою копию динамического предиката и свою копию динамического раздела фактов.
Создание объекта (экземпляра или копии класса) осуществляется вызовом предиката-конструктора. Как правило, это предикат-функция ''new()'', но может быть и любой другой, объявленный как конструктор в разделе ''constructors'' декларации класса.

'''Статический класс''' - это класс, не имеющий интерфейса.
Или, что то же самое, - если класс не имеет инерфейса, то он - статический,

Если класс имеет интерфейс - то он - динамический.

==Статические классы==
Например, класс ''staticClass'' является статическим классом.

<vip>
class staticClass
end class staticClass

implement staticClass
end implement staticClass
</vip>
но этот класс ничего не способен делать.
Чтобы что-то делать, добавим в этот класс декларации предикатов и клаузы.

<vip>class staticClass
predicates
visibleStaticPred:().
end class staticClass

implement staticClass
clauses
visibleStaticPred():-
...
invisibleStaticPred(),
...

class predicates
invisibleStaticPred:().
clauses
invisibleStaticPred():-
...
end implement staticClass
</vip>
Обращения к предикатам этого класса записываются как

<vip>...
staticClass::staticVisiblePred(),
...
</vip>
(существенно использования именно '''::''' для обращения к статической сущности)

Здесь предикат ''invisibleStaticPred'' является предикатом, объявленным внутри имплементации, и только внутри этой имплементации может быть вызван.
То есть предикаты, объявленные в декларации класса, являются заведомо всегда статическими предикатами, а раздел объявлений предикатов внутри имплементации статического класса всегда должен имет вид class predicates
Если попробовать создать экземпляр класса ''staticClass'' с помощью вызова конструктора ''new()''
<vip>...
staticClass::new(),
...</vip>
то это не пропустит компилятор.
Таким образом, статические классы - это просто модули проекта.
Проект, построенный только на модулях (статических классах) - не имеет никакого отношения к объекто-ориентированной концепции программирования.

==Динамические классы==
Например, класс ''dynamicClass'' является динамическим классом, что определяется
конструкцией ''dynamicClass:justInterface''.
<vip>class dynamicClass:justInterface
end class dynamicClass

implement dynamicClass
end implement dynamicClass

interface justInterface
end interface justInterface</vip>
Опять-таки, синтаксически все правильно, но практически бесполезно.
Теперь добавим какие-нибудь полезности и вынесем вперед декларацию интерфейса.
<vip>interface justInterface
predicates
visibleDynamicPred:().
end interface justInterface

class dynamicClass:justInterface
predicates
visibleStaticPred:().
end class dynamicClass

implement dynamicClass
clauses
visibleStaticPred():-
...
invisibleStaticPred(),
...

clauses
visibleDynamicPred():-
...
invisibleStaticPred(),
...

class predicates
invisibleStaticPred:().
clauses
invisibleStaticPred():-
...

predicates
invisibleDynamicPred:().
clauses
invisibleDynamicPred():-
...

end implement dynamicClass
</vip>
Здесь мы имеем четыре предиката, которые имеют различные динамические особенности.
''visibleDynamicPred'' - динамический предикат, принадлежащий интерфесу ''justInterface'', видимый извне.
''visibleStaticPred'' - статический предикат, видимый извне.
''invisibleStaticPred'' - статический предикат, определенный в имплементации класса ''dynamicClass'', невидимый извне.
''invisibleDynamicPred'' - динамический предикат, определенный в имплементации класса ''dynamicClass'', невидимый извне.
К такому классу можно обратиться как к статическому
<vip>...
dynamicClass::visibleStaticPred(),
...</vip>
но нельзя так:
<vip>...
dynamicClass::visibleDynamicPred(),
...</vip>
Чтобы вызвать предикат ''visibleDynamicPred()'', необходимо с помощью конструктора создать экземпляр класса и обратиться к этому экземпляру:
<vip>...
ЭкземплярDynamicClass=dynamicClass::new(),
ЭкземплярDynamicClass:visibleDynamicPred(),
...</vip>
Примечания:
* Конструктор ''new()'' является предопределенным конструктором, объявление которого не требуется, если в имплементации нет для него клауза;
* В обращении к экземпляру класса (объекту) используется разделитель ':' (а не '::', как этого требует обращение к статической сущности).

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

<vip>implement example
...
class facts
myFact_F:(string,string).
...
end implement example</vip>
В имплементациях динамических классов факты могут быть объявлены либо как статические, либо как динамические:
<vip>class example1:example1interface
predicates
запомнитьГород:(string Город).
запомнитьИмяАдрес:(string Имя, string Адрес).
получитьГород:()->string Город.
получитьИмяАдрес:(string Имя, string Адрес).
end class example1

implement example1
...
class facts
город_V:string Город.
...
facts
имяАдрес_F:(string Адрес, string Имя).

clauses
запомнитьГород(Город):-
город_V:=Город.
...
clauses
запомнитьИмяАдрес(Имя,Адрес):-
assert(имяАдрес_F:(Адрес,Имя)).

clauses
получитьГород(город_V).
...
clauses
получитьИмяАдрес(Имя,Адрес):-
имяАдрес_F(Адрес,Имя),
!,
...
end implement example1
</vip>
В приведенном примере класса ''example1'' факт ''город_V'' является статическим, а факты ''имяАдрес_F(...)'' являются динамическими,
что определяется разницей в имени раздела ''class facts'' и просто ''facts''.
Поскольку статическая сущность любого класса всего одна, а динамическая - по одной на каждый экземпляр - то и в нашем примере запрос ''получитьГород()'', переданный любому экземпляру, вернет один и тот же результат, а запрос ''получитьИмяАдрес(...)'' вернет для каждого экземпляра свое значение.
===Особенности использования фактов-переменных===
В примере выше использовался факт-переменная ''город_V'', особенностью которого является то, что такой факт всегда один и он сам несет значение терма, объявленного в декларации.
<vip>
class facts
город_V:string Город.</vip>
Здесь факт ''город_V'' имеет строковое значение. Возможны значения любых объявленных доменов, например
<vip>domains
мойДомен=персона(string Имя,unsigned Возраст).
class facts
персона_V:мойДомен.</vip>
В отличие от обычных фактов, факт-переменная всегда существует и должен иметь начальное значение.
Начальное значение факту-переменной можно задать при объявлении
<vip>domains
мойДомен=персона(string Имя,unsigned Возраст).
class facts
персона_V:мойДомен:=персона("Старик",80).
город_V:string:="НеИзвестен".
</vip>
В динамических классах начальное значение вместо декларации можно задать в клаузе конструктора
<vip>implement dynamicClass
domains
мойДомен=персона(string Имя,unsigned Возраст).
class facts
персона_V:мойДомен.
clauses
new():-
персона_V:=персона("Старик",80),
...
end implement dynamicClass</vip>
Бывает, что конкретное начальное значение установить невозможно по смыслу реализации.
Тогда начальное значение может быть установлено как "неустановленное".
<vip>class facts
город_V:string:=erroneous.</vip>
где ''erroneous'' - ключевое слово языка. Факт со значением erroneous не может быть использован, можно только проверить является ли значение факта неустановленным с помощью детерминированного предиката ''isErroneous(...)''
<vip>implement dynamicClass
domains
мойДомен=персона(string Имя,unsigned Возраст).
class facts
город_V:string:=erroneous.
персона_V:мойДомен.
clauses
new():-
персона_V:=персона("Старик",80),
...
clauses
...
isErroneous(город_V),
...
end implement dynamicClass</vip>
С учетом сказанного наш пример
<vip>class facts
город_V:string Город.</vip>
на этапе компиляции выдаст ошибку, поскольку статический факт не инициализирован при объявлении.
==Константы и домены==
Константы и домены могут объявляться везде - в декларациях классов, интерфейсов и в имплементациях. По своей сущности они, естественно, имеют статический характер.
Объявления, сделанные в имплементации, видимы только внутри этой же имплементации.
Объявления констант и доменов, сделанные в декларации класса или интерфейса, являются глобальными.
Конкретное использование осуществляется путем добавления префикса декларации соответствующего класса или интерфейса в формате

''<имя декларации класса или интерфейса>::<имя домена или константы>''.

==Взаимоотношени статических и динамических сущностей==
Клаузы предикатов, объявленных статическими, не могут обращаться к динамическим сущностям (предикатам и фактам).
То есть нельзя так:
<vip>implement dynamicClass
clauses
staticPred():-
...
dynamicPred(),
...
end implement dynamicClass</vip>
Клаузы предикатов, объявленных динамическими, такого ограничения не имеют.
Как статические так и динамические факты могут хранить указатели на динамические предикаты и экземпляры классов.
[[Категория:VipLanguage]]

Обработка исключений

2008-01-10T11:31:50Z

SergeMukhin:

Исключение - это отклонение программы от маршрута "нормального" выполнения. Пакет exception из состава PFC содержит предикаты помогающие обрабатывать и распространять исключения, которые возникают в программах на Прологе. Это руководство объясняет:

*Как обрабатывать исключения;
*Как возбуждать ваши собственные исключения;
*Как продолжать другое исключение.

==Как перехватывать исключения==

Рассмотрим программу, которая читает текстовый файл и выводит его содержимое на консоль. PFC предлагает предикат '''file::readString''', который позволяет выполнить эту задачу. Однако, некоторые обстоятельства могут помешать эту задачу; например, заданное имя файла ссылается на несуществующий файл. Когда предикат '''file::readString''' не может выполнить задачу, он генерирует исключение.

Visual Prolog предлагает конструкцию '''try/catch''' (см. [[#trap vs try|Try вместо Trap]]), которая перехватывает исключение и позволяет его обработать. Детальное описание этой конструкции можно найти в справке по Visual Prolog ('''Language Reference -> Exception Handling''').

Соответственно, код для перехвата исключения будет выглядеть так:
<vip>try
MyTxtFileContent = file::readString(myFileName, _IsUnicode)
catch ErrorCode do
handleFileReadError(ErrorCode)
end try,
...</vip>

Самое интересное здесь это - имплементация предиката handleFileReadError:

<vip>class predicates
handleFileReadError : (exception::traceID TraceId) failure.
clauses
handleFileReadError(TraceId):-
Descriptor = exception::tryGetDescriptor(TraceId, fileSystem_api::cannotcreate),
!, % файл не может быт загружен
exception::descriptor(_ErrorCode, % ErrorCode используется, если пользователь сам вызывает errorExit.
_ClassInfo, % информация о классе, который возбудил исключение.
_Exception, % на самом деле это fileSystem_api::cannotcreate,
% но параметр не может участвовать в сравнении с помощью ' = '.
% смотрите exceptionState::equals
_Kind, % исключение может быть возбуждено или продолжено
ExtraInfo,
_TraceId, % здесь идентификатор ошибки, но необходимости в проверке нет
_GMTTime, % время возникновения исключения
ExceptionDescription,
_ThreadId) = Descriptor,
FileName = namedValue::mapLookUp(ExtraInfo,
fileSystem_api::fileName_parameter, string("")),
Reason = namedValue::mapLookUp(ExtraInfo,
common_exception::errorDescription_parameter, string("")),
stdIO::write("Невозможно загрузить файл по причине: ",ExceptionDescription,
"\nИмя файла: ", FileName,
"\nПричина: ", Reason ),
fail.
handleFileReadError(ErrorCode):-
isDebugMode = true, % режим отладки
!,
exceptionDump::dumpToStdOutput(ErrorCode),
% выводим на консоль, поскольку режим отладки
fail.
handleFileReadError(_ErrorCode):-
% программа не может обработать исключение и не информирует о нем
fail.</vip>

Когда предполагается исключение '''fileSystem_api::cannotcreate''', предикат '''exception::tryGetDescriptor''' вызывается именно с этим параметром для перехвата и обработки такого исключения. В нашем случае используется вывод на консоль:

<vip>stdIO::write("Невозможно загрузить файл по причине: ", ExceptionDescription,
"\nИмяФайла: ", FileName,
"\nПричина: ", Reason ),</vip>

с объяснением причины исключения.

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

Полный пример содержится в проекте '''catchException\catchException.prj6'''.

==Как вызвать исключение==
Рассмотрим программу, которая проверяет размер заданного файла. PFC предлагает предикат file::getFileProperties, который возвращает размер заданного файла. Если файл имеет нулевой размер, то мы можем вызвать исключение с помощью предиката exception::raise. Необходимо при этом создать предикат, который будет характеризовать исключение. С этой целью мы создаём предикат myExceptionZeroFileSize. Код, вызывающий исключение, будет выглядеть так:

<vip>clauses
run():-
console::init(),
try
file::getFileProperties(myFileName,_Attributes,Size,_Creation,_LastAccess,_LastChange)
catch ErrorCode do
handleFileGetPropertiesError(ErrorCode)
end try,

Size = unsigned64(0, 0), % file size is zero
!,
exception::raise
(
classInfo,
myExceptionZeroFileSize,
[namedValue(fileSystem_api::fileName_parameter, string(myFileName))]
).
run().</vip>

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

Предикат myExceptionZeroFileSize создаётся по шаблону:

<vip>clauses
myExceptionZeroFileSize
(
classInfo,
predicate_Name(),
"Размер файла не может быть нулевым"
).</vip>

Здесь первый и второй параметры предикатов исключений всегда есть classInfo и predicate_Name() соответственно, а третий параметр содержит текстовое пояснение причины исключения.

Полностью пример представлен в проекте '''raiseException\raiseException.prj6'''.

==Продолжение другого исключения==

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

<vip>constants
dllVersion = "1.20.0.0".
clauses
loadFile(FileName) = FileContent :-
try
FileContent = file::readString(FileName, _IsUnicode)
catch ErrorCode do
exception::continue(ErrorCode, classInfo, continuedFromDll,
[namedValue(version_Parameter,string(dllVersion))])
end try.</vip>

Предикат continuedFromDll объявлен как:

<vip>predicates
continuedFromDll : core::exception as "_ContinuedFromDll@12"</vip>

и этот предикат экспортируется из DLL. Имплементация предиката continuedFromDll создаётся по шаблону (аналогично предикату myExceptionZeroFileSizeabove):

<vip>clauses
continuedFromDll
(
classInfo,
predicate_Name(),
"Exception continued from continueException.DLL"
).</vip>

При продолжении исключения предикат exception::continue добавляет информацию о версии DLL.

Полностью пример представлен в проекте '''continueException\continueException.prj6'''.

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

<vip>constants
myFileName = "my.txt".
clauses
run():-
console::init(),
initExceptionState(exception::getExceptionState()),
try
MyTxtFileContent = loadFile(myFileName)
catch TraceID do
handleFileReadError(TraceID)
end try,
!,
stdIO::write("The content of ",myFileName,"is:\n",MyTxtFileContent).
run().

class predicates
handleFileReadError : ( exception::traceID TraceId )failure .
clauses
handleFileReadError(TraceId):-
DescriptorContinued = exception::tryGetDescriptor(TraceId, continuedFromDll),
ErrorDescriptorInformation = exception::tryGetErrorDescriptorInformation(TraceId),
ContinueException = ErrorDescriptorInformation:tryGetContinueException(),
!, % ясно, что файл не загрузился
exception::descriptor
(_ErrorCodeContinued,
_ClassInfoContinued,
_ExceptionContinued,
_KindContinued,
ExtraInfoContinued,
_,
_GMTTimeContinued,
ExceptionDescriptionContinued,
_ThreadIdContinued) = DescriptorContinued,
Version = namedValue::mapLookUp(ExtraInfoContinued, version_Parameter, string("")),
stdIO::write("Продолженное исключение : ",ExceptionDescriptionContinued,"\nВерсия Dll: ", Version,"\n"),
ExtraInfo = ContinueException:getExtraInfo(),
ExceptionDescription = ContinueException:getExceptionDescription(),
FileName = namedValue::mapLookUp(ExtraInfo,fileSystem_api::fileName_parameter, string("")),
Reason = namedValue::mapLookUp(ExtraInfo,common_exception::errorDescription_parameter, string("")),
stdIO::write
(
"Файл не загружен по причине: ",ExceptionDescription,
"\nИмя файла: ", FileName,
"\nПричина: ", Reason ),
fail.
handleFileReadError(TraceId):-
isDebugMode = true, % режим отладки
!,
exceptionDump::dumpToStdOutput(TraceId),
fail.
handleFileReadError(_TraceId):-
fail.</vip>

Мы пытаемся здесь найти исключение '''continuedFromDll''' и мы вызываем продолжающееся предикатом исключение '''tryGetContinueException'''. Это ясно показывает, что, если исключение продолжающееся, то мы можем получить дополнительную информацию касательно самого исключения.

Полностью пример представлен в проекте '''continueException\testContinuedException\testContinuedException.prj6'''. Необходимо построить сначала приложение '''continueException\continueException.prj6''' перед тем как вызывать на выполнение исполняемое приложение testContinuedException.

==trap vs try==
Начиная с версии 7.0 появилась конструкция '''try/catch/finally''', которая заменяет встроенные предикаты '''trap/3''' и '''finally/2'''.

==Ссылки==
[[en:Exceptions Handling]]
[[Категория:VipLanguage]]
[[Категория:VipРуководства]]

Жизненный цикл объекта

2007-12-20T10:17:11Z

SergeMukhin: /* Финализатор */

===Создание объекта===
Других способов создания объектов (экземпляров класса), кроме как с использованием предикатов, объявленных для данного класса конструктором (явно или не явно), нет. Если конструктор не объявлен, то может быть использован предопределенный конструктор new().

===Гибель объекта===
VIP не содержит никаких средств для уничтожения объектов. Тем не менее они не живут вечно (до конца жизни приложения). Время жизни объектов определяется сборщиком мусора (''GarbageCollector''), встроенного в ''RunTime'' часть VIP. Сборщик мусора считает, что память, занимаемая объектом (экземпляром), может быть освобождена, когда исчезнут все ссылки на объект. И это почти единственное правило, определяющее время жизни объекта (экземпляра).
Исходя из этого правила объект, созданный в пределах одного клоза, если ссылка на него не сохранена, погибает по завершении клоза.
Например,
<vip>clauses
мойПример():-
МойОбъект=мойОбъект::new(),
МойОбъект:мойПредикатИзМойОбъект(),
...
последнийПредикатКлоза().
</vip>
Здесь указатель на экземпляр класса ''мойОбъект'' сохраняется в переменной ''МойОбъект''. Поэтому, пока клоз ''мойПример'' выполняется, живет и доступен через указатель ''МойОбъект'' и экземпляр ''мойОбъект''.
По правилам Пролога, переменные в клозах являются локальными и сохраняют свои значения только в пределах клоза. Следовательно, по завершении выполнения клоза ''мойПример'' объект''мойОбъект'' считается недоступным и может умереть. Если, конечно, он не породил ссылок на себя самого в какой-нибудь постоянной памяти во время вызова конструктора или других своих предикатов.
Случай
<vip>clauses
мойПример():-
МойОбъект=мойОбъект::new(),
МойОбъект:мойПредикатИзМойОбъект(...),
...
вызовПредикатаДругогоКлоза(МойОбъект),
...
последнийПредикатКлоза(...).</vip>
не меняет сути - пока выполняется предикат ''вызовПредикатаДругогоКлоза(МойОбъект)'' экземпляр продолжает жить и умрет после завершения выполнения предиката ''последнийПредикатКлоза(...)''.

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

Для этой цели используется хранение указателей на объекты в фактах. В VIP как предикаты, так и факты типизированы. А это значит, что при декларировании факта (а равно и предиката) необходимо указание домена - либо предопределённого в языке, либо объявленного в программе.
Применительно к указателям на объекты, специального объявления домена, связанного с объектами, не существует. Здесь действует правило: объявление интерфейса класса является одновременно и объявлением домена, определяющего этот класс.

Поэтому имя интерфейса используется в качестве домена при декларировании фактов для хранения указателей или их передачи в качестве параметров.
Например,
<vip>class мойКласс:мойИнтерфейс
end class мойКласс</vip>
уже определяет то обстоятельство, что все экземпляры класса мойКласс принадлежат домену ''мойИнтерфейс''.
Поэтому объявление факта либо в виде
<vip>facts
мойУказатель_F:(string УдобноеИмяЭкземпляра,мойИнтерфейс УказательНаЭкземпляр).</vip>
либо в виде
<vip>facts
мойУказатель_V:мойИнтерфейс:=erroneous.</vip>
Являются правильными (не путать с целесообразностью) объявлениями.
Тогда в примере
<vip>clauses
мойПример():-
МойОбъект=мойОбъект::new(),
МойОбъект:мойПредикатИзМойОбъект(...),
мойУказатель_V:=МойОбъект,
...
вызовПредикатаДругогоКлоза(МойОбъект),
...
последнийПредикатКлоза(...).</vip>
время жизни объекта продлевается за пределы времени жизни клоза. Объект будет существовать все то время, пока на него существует указатель.
Когда объект больше не нужен, достаточно удалить ссылку на него, например так:
<vip> ...
мойУказатель_V:=erroneous,
...</vip>
или так
<vip> ...
retract(мойУказатель_F("ПочтовыеАдреса",_УказательНаЭкземпляр)),
...</vip>
При этом следует иметь в виду, что смерть объекта ведет к смерти всех объектов, на которые данный объект хранит ссылки.

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

Следует, однако, иметь в виду некоторые исключения из этого правила:
Как показал опыт, если объект хранит указатель на окно (домен ''vpiDomains::windowHandle''), то сборщик мусора будет рассматривать этот объект, как используемый.

То есть физически окно может быть закрыто, но не удаление указателя на это окно оставит объект в памяти. Аналогично часто указатели на COM-объекты могут быть причиной не освобождения памяти сборщиком мусора.

Существует один замечательный предопределённый интерфейс, который, как и все интерфейсы является и доменом. Это интерфейс - object.

Все экземпляры, принадлежащие доменам своих интерфейсов, в то же время являются дочерними доменами домена object.
Это значит, что практически возможно вместо
<vip>facts
мойУказатель_V:мойИнтерфейс:=erroneous.</vip>
объявлять
<vip>facts
мойУказатель_V:object:=erroneous.</vip>
При этом будет компилироваться и работать
<vip>clauses
мойПример():-
мойУказатель_V:=мойОбъект::new(),
...</vip>
Но вот вызов
<vip> ...
мойУказатель_V:мойПредикатИзМойОбъект(...),
...</vip>
в этом случае не пропустит компилятор.
Вместо этого необходимо производить конвертацию
<vip> ...
МойУказатель=convert(мойИнтерфейс,мойУказатель_V),
МойУказатель:мойПредикатИзМойОбъект(...),
...</vip>
Примерно то же происходит, если интерфейс поддерживает другие интерфейсы.
Сборщик мусора можно подтолкнуть предикатом
<vip>memory::garbageCollect()</vip> но обычно в этом нет никакой необходимости.

===Финализатор===
Существует специальный предикат, который вызывается в момент гибели объекта, перед освобождением памяти объекта. Этот предикат - '''finalize'''. Его нельзя объявить, но для объектных классов можно написать реализацию (клауз).
Следует иметь в виду, что момент, когда память будет фактически освобождена, и будет вызван предикат '''finalize''' (если он есть), не контролируется и определяется внутренней логикой сборщика мусора и его взаимодействием с операционной системой. Также нельзя делать никаких предположений о порядке освобождения объектов и, соответственно, о порядке вызова '''finalize''' для разных объектов. Рекомендуется предикат '''finalize''' использовать исключительно для освобождения ресурсов, при этом объектные факты освобождать нет никакой необходимости. Раз уж объект удаляется, то и все его факты постигнет аналогичная участь.
Так же не рекомендуется закладывать в финализатор выполнение каких-нибудь логических действий. Например, если закрытие файла делать в финализаторе, то файл будет отрыт, а доступ других программ будет заблокировано, до неизвестного момента, пока сборщик мусора соизволит удалить данный объект.
Следует учитывать и то, что финализатор может быть вызван на не полностью инициализированном объекте. Например, если произошёл сбой при выполнении конструктора, то не все факты будут правильно инициализированы. Поэтому всегда следует проверять факт, например на '''erroneous'''.

Ещё одно замечание, нельзя заранее сказать на каком потоке (thread) будет выполняться сборщик мусора (неявный вызов) и, соответственно, выполняться финализаторы. Распространение исключения из финализатора может повредить логику работы сборщика. В связи с эти все исключения из финализаторов перехватываются [[Обработка исключений|try/catch]] и игнорируется. Т.е. как будто вызов финализатора происходит так:
<Vip>try
Object:finalize()
catch _ do
succeed()
end try</Vip>

[[Категория:VipLanguage]]

ProfileCount

2007-12-19T13:28:37Z

SergeMukhin:

Для измерения времени выполнения предикатов можно использовать класс '''profileCount''' из пакета '''pfc\profile'''. Перед его использованием необходимо добавить опцию компилятора '''/PROFILE''' и перестроить проект. Также необходимо вставить вызовы запускающие профилирование '''start''', обычно при инициализации приложения, останова '''stop''' и вывода результатов '''print''' (обычно в конце приложения).

Вот типичный пример использования в консольном приложении:

<vip>
clauses
run():-
console::init(),
profileCount::start(),
try
главныйПредикат()
finally
profileCount::stop(),
Out = console::getConsoleOutputStream(),
profileCount::print(Out)
end try.
</vip>

Для всех предикатов выводится количество их вызовов, а для некоторых и суммарное время выполнения. Следует учесть, что данный инструмент (как впрочем и все) влияет на выполняемую программу (даже если предикат '''start''' не был выполнен). Программа становится больше и выполняется медленней. Это надо учитывать при анализе полученных результатов. {{note|picsize=30|content=Самое главное, не забыть убрать опцию '''/PROFILE''' после, того, как все замеры будут произведены.}} Если модуль построен без опции '''/PROFILE''', то предикат '''start''' не имеет никакого эффекта.

Пример результат работы:

Predicate invocations count information:
1. outputStream::write/0... 1 0.00017656
2. bufferSupport::getBuffer/2 2 0.00014974
3. outputStream::write/0... 1 0.00009526
4. outputStream_console::writeToStdDevice/4 2 0.00007683
5. outputStream::flush/0 1 0.00007599
6. outputStream_console::bufferFullCB/2 2 0.00006397
7. list::filter/2-> 1 0.00003436
8. авто::new/1-> 3 0.00003241
9. list::getMember_nd/1-> 6 0.00002123
10. fileSystem_api::lf_crlf/4 2 0.00002039
11. outputStream_console::convertLF2CRLF_ifNeeded/4 2 0.00001062
12. main::run$1/0 3 0.00000726
13. fileSystem_api::searchLineFeeds/6 2 0.00000698
14. авто::цена/0-> 4 0.00000670
15. stream::getMode/0-> 4 0.00000615
16. console::write/0... 1 0.00000615
17. авто::new/1 3 0.00000475
18. fileSystem_api::convertToCRLF_IfNeeded/4-> 2 0.00000419
19. console_api::getStdHandle/1-> 2 0.00000391
20. fileSystem_api::getSize/2-> 2 0.00000363
21. outputSupport::doNotFlush/0 1 0.00000307
22. console::getConsoleOutputStream/0-> 1 0.00000251

[[Категория:Profile]]

ProfileCount

2007-12-19T13:27:42Z

SergeMukhin:

Жизненный цикл объекта

2007-12-19T08:31:35Z

SergeMukhin: /* Финализатор */

===Создание объекта===
Других способов создания объектов (экземпляров класса), кроме как с использованием предикатов, объявленных для данного класса конструктором (явно или не явно), нет. Если конструктор не объявлен, то может быть использован предопределенный конструктор new().

===Гибель объекта===
VIP не содержит никаких средств для уничтожения объектов. Тем не менее они не живут вечно (до конца жизни приложения). Время жизни объектов определяется сборщиком мусора (''GarbageCollector''), встроенного в ''RunTime'' часть VIP. Сборщик мусора считает, что память, занимаемая объектом (экземпляром), может быть освобождена, когда исчезнут все ссылки на объект. И это почти единственное правило, определяющее время жизни объекта (экземпляра).
Исходя из этого правила объект, созданный в пределах одного клоза, если ссылка на него не сохранена, погибает по завершении клоза.
Например,
<vip>clauses
мойПример():-
МойОбъект=мойОбъект::new(),
МойОбъект:мойПредикатИзМойОбъект(),
...
последнийПредикатКлоза().
</vip>
Здесь указатель на экземпляр класса ''мойОбъект'' сохраняется в переменной ''МойОбъект''. Поэтому, пока клоз ''мойПример'' выполняется, живет и доступен через указатель ''МойОбъект'' и экземпляр ''мойОбъект''.
По правилам Пролога, переменные в клозах являются локальными и сохраняют свои значения только в пределах клоза. Следовательно, по завершении выполнения клоза ''мойПример'' объект''мойОбъект'' считается недоступным и может умереть. Если, конечно, он не породил ссылок на себя самого в какой-нибудь постоянной памяти во время вызова конструктора или других своих предикатов.
Случай
<vip>clauses
мойПример():-
МойОбъект=мойОбъект::new(),
МойОбъект:мойПредикатИзМойОбъект(...),
...
вызовПредикатаДругогоКлоза(МойОбъект),
...
последнийПредикатКлоза(...).</vip>
не меняет сути - пока выполняется предикат ''вызовПредикатаДругогоКлоза(МойОбъект)'' экземпляр продолжает жить и умрет после завершения выполнения предиката ''последнийПредикатКлоза(...)''.

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

Для этой цели используется хранение указателей на объекты в фактах. В VIP как предикаты, так и факты типизированы. А это значит, что при декларировании факта (а равно и предиката) необходимо указание домена - либо предопределённого в языке, либо объявленного в программе.
Применительно к указателям на объекты, специального объявления домена, связанного с объектами, не существует. Здесь действует правило: объявление интерфейса класса является одновременно и объявлением домена, определяющего этот класс.

Поэтому имя интерфейса используется в качестве домена при декларировании фактов для хранения указателей или их передачи в качестве параметров.
Например,
<vip>class мойКласс:мойИнтерфейс
end class мойКласс</vip>
уже определяет то обстоятельство, что все экземпляры класса мойКласс принадлежат домену ''мойИнтерфейс''.
Поэтому объявление факта либо в виде
<vip>facts
мойУказатель_F:(string УдобноеИмяЭкземпляра,мойИнтерфейс УказательНаЭкземпляр).</vip>
либо в виде
<vip>facts
мойУказатель_V:мойИнтерфейс:=erroneous.</vip>
Являются правильными (не путать с целесообразностью) объявлениями.
Тогда в примере
<vip>clauses
мойПример():-
МойОбъект=мойОбъект::new(),
МойОбъект:мойПредикатИзМойОбъект(...),
мойУказатель_V:=МойОбъект,
...
вызовПредикатаДругогоКлоза(МойОбъект),
...
последнийПредикатКлоза(...).</vip>
время жизни объекта продлевается за пределы времени жизни клоза. Объект будет существовать все то время, пока на него существует указатель.
Когда объект больше не нужен, достаточно удалить ссылку на него, например так:
<vip> ...
мойУказатель_V:=erroneous,
...</vip>
или так
<vip> ...
retract(мойУказатель_F("ПочтовыеАдреса",_УказательНаЭкземпляр)),
...</vip>
При этом следует иметь в виду, что смерть объекта ведет к смерти всех объектов, на которые данный объект хранит ссылки.

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

Следует, однако, иметь в виду некоторые исключения из этого правила:
Как показал опыт, если объект хранит указатель на окно (домен ''vpiDomains::windowHandle''), то сборщик мусора будет рассматривать этот объект, как используемый.

То есть физически окно может быть закрыто, но не удаление указателя на это окно оставит объект в памяти. Аналогично часто указатели на COM-объекты могут быть причиной не освобождения памяти сборщиком мусора.

Существует один замечательный предопределённый интерфейс, который, как и все интерфейсы является и доменом. Это интерфейс - object.

Все экземпляры, принадлежащие доменам своих интерфейсов, в то же время являются дочерними доменами домена object.
Это значит, что практически возможно вместо
<vip>facts
мойУказатель_V:мойИнтерфейс:=erroneous.</vip>
объявлять
<vip>facts
мойУказатель_V:object:=erroneous.</vip>
При этом будет компилироваться и работать
<vip>clauses
мойПример():-
мойУказатель_V:=мойОбъект::new(),
...</vip>
Но вот вызов
<vip> ...
мойУказатель_V:мойПредикатИзМойОбъект(...),
...</vip>
в этом случае не пропустит компилятор.
Вместо этого необходимо производить конвертацию
<vip> ...
МойУказатель=convert(мойИнтерфейс,мойУказатель_V),
МойУказатель:мойПредикатИзМойОбъект(...),
...</vip>
Примерно то же происходит, если интерфейс поддерживает другие интерфейсы.
Сборщик мусора можно подтолкнуть предикатом
<vip>memory::garbageCollect()</vip> но обычно в этом нет никакой необходимости.

===Финализатор===
Существует специальный предикат, который вызывается в момент гибели объекта, перед освобождением памяти объекта. Этот предикат - finalize. Его нельзя объявить, но для объектных классов можно написать реализацию (клауз).
Следует иметь в виду, что момент, когда память будет фактически освобождена, и будет вызван предикат finalize (если он есть), не контролируется и определяется внутренней логикой сборщика мусора и его взаимодействием с операционной системой. Также нельзя делать никаких предположений о порядке освобождения объектов и, соответственно, о порядке вызова finalize для разных объектов. Рекомендуется предикат finalize использовать исключительно для освобождения ресурсов, при этом объектные факты освобождать нет никакой необходимости. Раз уж объект удаляется, то и все его факты постигнет аналогичная участь.
[[Категория:VipLanguage]]

Жизненный цикл объекта

2007-12-19T08:14:39Z

SergeMukhin:

===Создание объекта===
Других способов создания объектов (экземпляров класса), кроме как с использованием предикатов, объявленных для данного класса конструктором (явно или не явно), нет. Если конструктор не объявлен, то может быть использован предопределенный конструктор new().

===Гибель объекта===
VIP не содержит никаких средств для уничтожения объектов. Тем не менее они не живут вечно (до конца жизни приложения). Время жизни объектов определяется сборщиком мусора (''GarbageCollector''), встроенного в ''RunTime'' часть VIP. Сборщик мусора считает, что память, занимаемая объектом (экземпляром), может быть освобождена, когда исчезнут все ссылки на объект. И это почти единственное правило, определяющее время жизни объекта (экземпляра).
Исходя из этого правила объект, созданный в пределах одного клоза, если ссылка на него не сохранена, погибает по завершении клоза.
Например,
<vip>clauses
мойПример():-
МойОбъект=мойОбъект::new(),
МойОбъект:мойПредикатИзМойОбъект(),
...
последнийПредикатКлоза().
</vip>
Здесь указатель на экземпляр класса ''мойОбъект'' сохраняется в переменной ''МойОбъект''. Поэтому, пока клоз ''мойПример'' выполняется, живет и доступен через указатель ''МойОбъект'' и экземпляр ''мойОбъект''.
По правилам Пролога, переменные в клозах являются локальными и сохраняют свои значения только в пределах клоза. Следовательно, по завершении выполнения клоза ''мойПример'' объект''мойОбъект'' считается недоступным и может умереть. Если, конечно, он не породил ссылок на себя самого в какой-нибудь постоянной памяти во время вызова конструктора или других своих предикатов.
Случай
<vip>clauses
мойПример():-
МойОбъект=мойОбъект::new(),
МойОбъект:мойПредикатИзМойОбъект(...),
...
вызовПредикатаДругогоКлоза(МойОбъект),
...
последнийПредикатКлоза(...).</vip>
не меняет сути - пока выполняется предикат ''вызовПредикатаДругогоКлоза(МойОбъект)'' экземпляр продолжает жить и умрет после завершения выполнения предиката ''последнийПредикатКлоза(...)''.

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

Для этой цели используется хранение указателей на объекты в фактах. В VIP как предикаты, так и факты типизированы. А это значит, что при декларировании факта (а равно и предиката) необходимо указание домена - либо предопределённого в языке, либо объявленного в программе.
Применительно к указателям на объекты, специального объявления домена, связанного с объектами, не существует. Здесь действует правило: объявление интерфейса класса является одновременно и объявлением домена, определяющего этот класс.

Поэтому имя интерфейса используется в качестве домена при декларировании фактов для хранения указателей или их передачи в качестве параметров.
Например,
<vip>class мойКласс:мойИнтерфейс
end class мойКласс</vip>
уже определяет то обстоятельство, что все экземпляры класса мойКласс принадлежат домену ''мойИнтерфейс''.
Поэтому объявление факта либо в виде
<vip>facts
мойУказатель_F:(string УдобноеИмяЭкземпляра,мойИнтерфейс УказательНаЭкземпляр).</vip>
либо в виде
<vip>facts
мойУказатель_V:мойИнтерфейс:=erroneous.</vip>
Являются правильными (не путать с целесообразностью) объявлениями.
Тогда в примере
<vip>clauses
мойПример():-
МойОбъект=мойОбъект::new(),
МойОбъект:мойПредикатИзМойОбъект(...),
мойУказатель_V:=МойОбъект,
...
вызовПредикатаДругогоКлоза(МойОбъект),
...
последнийПредикатКлоза(...).</vip>
время жизни объекта продлевается за пределы времени жизни клоза. Объект будет существовать все то время, пока на него существует указатель.
Когда объект больше не нужен, достаточно удалить ссылку на него, например так:
<vip> ...
мойУказатель_V:=erroneous,
...</vip>
или так
<vip> ...
retract(мойУказатель_F("ПочтовыеАдреса",_УказательНаЭкземпляр)),
...</vip>
При этом следует иметь в виду, что смерть объекта ведет к смерти всех объектов, на которые данный объект хранит ссылки.

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

Следует, однако, иметь в виду некоторые исключения из этого правила:
Как показал опыт, если объект хранит указатель на окно (домен ''vpiDomains::windowHandle''), то сборщик мусора будет рассматривать этот объект, как используемый.

То есть физически окно может быть закрыто, но не удаление указателя на это окно оставит объект в памяти. Аналогично часто указатели на COM-объекты могут быть причиной не освобождения памяти сборщиком мусора.

Существует один замечательный предопределённый интерфейс, который, как и все интерфейсы является и доменом. Это интерфейс - object.

Все экземпляры, принадлежащие доменам своих интерфейсов, в то же время являются дочерними доменами домена object.
Это значит, что практически возможно вместо
<vip>facts
мойУказатель_V:мойИнтерфейс:=erroneous.</vip>
объявлять
<vip>facts
мойУказатель_V:object:=erroneous.</vip>
При этом будет компилироваться и работать
<vip>clauses
мойПример():-
мойУказатель_V:=мойОбъект::new(),
...</vip>
Но вот вызов
<vip> ...
мойУказатель_V:мойПредикатИзМойОбъект(...),
...</vip>
в этом случае не пропустит компилятор.
Вместо этого необходимо производить конвертацию
<vip> ...
МойУказатель=convert(мойИнтерфейс,мойУказатель_V),
МойУказатель:мойПредикатИзМойОбъект(...),
...</vip>
Примерно то же происходит, если интерфейс поддерживает другие интерфейсы.
Сборщик мусора можно подтолкнуть предикатом
<vip>memory::garbageCollect()</vip> но обычно в этом нет никакой необходимости.

===Финализатор===
Следует иметь в виду, что момент, когда память будет фактически освобождена, и будет вызван предикат finalize (если он есть), не контролируется и определяется внутренней логикой сборщика мусора и его взаимодействием с операционной системой. Также нельзя делать никаких предположений о порядке освобождения объектов и, соответственно, о порядке вызова finalize для разных объектов. Рекомендуется предикат finalize использовать исключительно для освобождения ресурсов, при этом объектные факты освобождать нет никакой необходимости. Раз уж объект удаляется, то и все его факты постигнет аналогичная участь.
[[Категория:VipLanguage]]

Жизненный цикл объекта

2007-12-18T21:56:44Z

SergeMukhin:

===Создание объекта===
Других способов создания объектов (экземпляров класса), кроме как с использованием предикатов, объявленных для данного класса конструктором (явно или не явно), нет. Если конструктор не объявлен, то может быть использован предопределенный конструктор new().

===Гибель объекта===
VIP не содержит никаких средств для уничтожения объектов. Тем не менее они не живут вечно (до конца жизни приложения). Время жизни объектов определяется сборщиком мусора (''GarbageCollector''), встроенного в ''RunTime'' часть VIP. Сборщик мусора считает, что память, занимаемая объектом (экземпляром), может быть освобождена, когда исчезнут все ссылки на объект. И это почти единственное правило, определяющее время жизни объекта (экземпляра).
Исходя из этого правила объект, созданный в пределах одного клоза, если ссылка на него не сохранена, погибает по завершении клоза.
Например,
<vip>clauses
мойПример():-
МойОбъект=мойОбъект::new(),
МойОбъект:мойПредикатИзМойОбъект(),
...
последнийПредикатКлоза().
</vip>
Здесь указатель на экземпляр класса ''мойОбъект'' сохраняется в переменной ''МойОбъект''. Поэтому, пока клоз ''мойПример'' выполняется, живет и доступен через указатель ''МойОбъект'' и экземпляр ''мойОбъект''.
По правилам Пролога, переменные в клозах являются локальными и сохраняют свои значения только в пределах клоза. Следовательно, по завершении выполнения клоза ''мойПример'' объект''мойОбъект'' считается недоступным и может умереть. Если, конечно, он не породил ссылок на себя самого в какой-нибудь постоянной памяти во время вызова конструктора или других своих предикатов.
Случай
<vip>clauses
мойПример():-
МойОбъект=мойОбъект::new(),
МойОбъект:мойПредикатИзМойОбъект(...),
...
вызовПредикатаДругогоКлоза(МойОбъект),
...
последнийПредикатКлоза(...).</vip>
не меняет сути - пока выполняется предикат ''вызовПредикатаДругогоКлоза(МойОбъект)'' экземпляр продолжает жить и умрет после завершения выполнения предиката ''последнийПредикатКлоза(...)''.

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

Для этой цели используется хранение указателей на объекты в фактах. В VIP как предикаты, так и факты типизированы. А это значит, что при декларировании факта (а равно и предиката) необходимо указание домена - либо предопределённого в языке, либо объявленного в программе.
Применительно к указателям на объекты, специального объявления домена, связанного с объектами, не существует. Здесь действует правило: объявление интерфейса класса является одновременно и объявлением домена, определяющего этот класс.

Поэтому имя интерфейса используется в качестве домена при декларировании фактов для хранения указателей или их передачи в качестве параметров.
Например,
<vip>class мойКласс:мойИнтерфейс
end class мойКласс</vip>
уже определяет то обстоятельство, что все экземпляры класса мойКласс принадлежат домену ''мойИнтерфейс''.
Поэтому объявление факта либо в виде
<vip>facts
мойУказатель_F:(string УдобноеИмяЭкземпляра,мойИнтерфейс УказательНаЭкземпляр).</vip>
либо в виде
<vip>facts
мойУказатель_V:мойИнтерфейс:=erroneous.</vip>
Являются правильными (не путать с целесообразностью) объявлениями.
Тогда в примере
<vip>clauses
мойПример():-
МойОбъект=мойОбъект::new(),
МойОбъект:мойПредикатИзМойОбъект(...),
мойУказатель_V:=МойОбъект,
...
вызовПредикатаДругогоКлоза(МойОбъект),
...
последнийПредикатКлоза(...).</vip>
время жизни объекта продлевается за пределы времени жизни клоза. Объект будет существовать все то время, пока на него существует указатель.
Когда объект больше не нужен, достаточно удалить ссылку на него, например так:
<vip> ...
мойУказатель_V:=erroneous,
...</vip>
или так
<vip> ...
retract(мойУказатель_F("ПочтовыеАдреса",_УказательНаЭкземпляр)),
...</vip>
При этом следует иметь в виду, что смерть объекта ведет к смерти всех объектов, на которые данный объект хранит ссылки.

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

Следует, однако, иметь в виду некоторые исключения из этого правила:
Как показал опыт, если объект хранит указатель на окно (домен ''vpiDomains::windowHandle''), то сборщик мусора будет рассматривать этот объект, как используемый.

То есть физически окно может быть закрыто, но не удаление указателя на это окно оставит объект в памяти. Аналогично часто указатели на COM-объекты могут быть причиной не освобождения памяти сборщиком мусора.

Существует один замечательный предопределённый интерфейс, который, как и все интерфейсы является и доменом. Это интерфейс - object.

Все экземпляры, принадлежащие доменам своих интерфейсов, в то же время являются дочерними доменами домена object.
Это значит, что практически возможно вместо
<vip>facts
мойУказатель_V:мойИнтерфейс:=erroneous.</vip>
объявлять
<vip>facts
мойУказатель_V:object:=erroneous.</vip>
При этом будет компилироваться и работать
<vip>clauses
мойПример():-
мойУказатель_V:=мойОбъект::new(),
...</vip>
Но вот вызов
<vip> ...
мойУказатель_V:мойПредикатИзМойОбъект(...),
...</vip>
в этом случае не пропустит компилятор.
Вместо этого необходимо производить конвертацию
<vip> ...
МойУказатель=convert(мойИнтерфейс,мойУказатель_V),
МойУказатель:мойПредикатИзМойОбъект(...),
...</vip>
Примерно то же происходит, если интерфейс поддерживает другие интерфейсы.
Сборщик мусора можно подтолкнуть предикатом
<vip>memory::garbageCollect()</vip> но обычно в этом нет никакой необходимости.

Следует иметь в виду, что момент, когда память будет фактически освобождена, и будет вызван предикат finalize (если он есть), не контролируется и определяется внутренней логикой сборщика мусора и его взаимодействием с операционной системой. Также нельзя делать никаких предположений о порядке освобождения объектов и, соответственно, о порядке вызова finalize для разных объектов. Рекомендуется предикат finalize использовать исключительно для освобождения ресурсов, при этом объектные факты освобождать нет никакой необходимости. Раз уж объект удаляется, то и все его факты постигнет аналогичная участь.
[[Категория:VipLanguage]]

Жизненный цикл объекта

2007-12-18T21:52:45Z

SergeMukhin: Гибель объекта

===Создание объекта===
Других способов создания объектов (экземпляров класса), кроме как с использованием предикатов, объявленных для данного класса конструктором (явно или не явно), нет. Если конструктор не объявлен, то может быть использован предопределенный конструктор new().

===Гибель объекта===
VIP не содержит никаких средств для уничтожения объектов. Тем не менее они не живут вечно (до конца жизни приложения). Время жизни объектов определяется сборщиком мусора (''GarbageCollector''), встроенного в ''RunTime'' часть VIP. Сборщик мусора считает, что память, занимаемая объектом (экземпляром), может быть освобождена, когда исчезнут все ссылки на объект. И это почти единственное правило, определяющее время жизни объекта (экземпляра).
Исходя из этого правила объект, созданный в пределах одного клоза, если ссылка на него не сохранена, погибает по завершении клоза.
Например,
<vip>clauses
мойПример():-
МойОбъект=мойОбъект::new(),
МойОбъект:мойПредикатИзМойОбъект(),
...
последнийПредикатКлоза().
</vip>
Здесь указатель на экземпляр класса ''мойОбъект'' сохраняется в переменной ''МойОбъект''. Поэтому, пока клоз ''мойПример'' выполняется, живет и доступен через указатель ''МойОбъект'' и экземпляр ''мойОбъект''.
По правилам Пролога, переменные в клозах являются локальными и сохраняют свои значения только в пределах клоза. Следовательно, по завершении выполнения клоза ''мойПример'' объект''мойОбъект'' считается недоступным и может умереть. Если, конечно, он не породил ссылок на себя самого в какой-нибудь постоянной памяти во время вызова конструктора или других своих предикатов.
Случай
<vip>clauses
мойПример():-
МойОбъект=мойОбъект::new(),
МойОбъект:мойПредикатИзМойОбъект(...),
...
вызовПредикатаДругогоКлоза(МойОбъект),
...
последнийПредикатКлоза(...).</vip>
не меняет сути - пока выполняется предикат ''вызовПредикатаДругогоКлоза(МойОбъект)'' экземпляр продолжает жить и умрет после завершения выполнения предиката ''последнийПредикатКлоза(...)''.

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

Для этой цели используется хранение указателей на объекты в фактах. В VIP как предикаты, так и факты типизированы. А это значит, что при декларировании факта (а равно и предиката) необходимо указание домена - либо предопределённого в языке, либо объявленного в программе.
Применительно к указателям на объекты, специального объявления домена, связанного с объектами, не существует. Здесь действует правило: объявление интерфейса класса является одновременно и объявлением домена, определяющего этот класс.

Поэтому имя интерфейса используется в качестве домена при декларировании фактов для хранения указателей или их передачи в качестве параметров.
Например,
<vip>class мойКласс:мойИнтерфейс
end classмойКласс</vip>
уже определяет то обстоятельство, что все экземпляры класса мойКласс принадлежат домену ''мойИнтерфейс''.
Поэтому объявление факта либо в виде
<vip>facts
мойУказатель_F:(string УдобноеИмяЭкземпляра,мойИнтерфейс УказательНаЭкземпляр).</vip>
либо в виде
<vip>facts
мойУказатель_V:мойИнтерфейс:=erroneous.</vip>
Являются правильными (не путать с целесообразностью) объявлениями.
Тогда в примере
<vip>clauses
мойПример():-
МойОбъект=мойОбъект::new(),
МойОбъект:мойПредикатИзМойОбъект(...),
мойУказатель_V:=МойОбъект,
...
вызовПредикатаДругогоКлоза(МойОбъект),
...
последнийПредикатКлоза(...).</vip>
время жизни объекта продлевается за пределы времени жизни клоза. Объект будет существовать все то время, пока на него существует указатель.
Когда объект больше не нужен, достаточно удалить ссылку на него, например так:
<vip> ...
мойУказатель_V:=erroneous,
...</vip>
или так
<vip> ...
retract(мойУказатель_F("ПочтовыеАдреса",_УказательНаЭкземпляр)),
...</vip>
При этом следует иметь в виду, что смерть объекта ведет к смерти всех объектов, на которые данный объект хранит ссылки.

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

Следует, однако, иметь в виду некоторые исключения из этого правила:
Как показал опыт, если объект хранит указатель на окно (домен ''vpiDomains::windowHandle''), то сборщик мусора будет рассматривать этот объект, как используемый.

То есть физически окно может быть закрыто, но не удаление указателя на это окно оставит объект в памяти. Аналогично часто указатели на COM-объекты могут быть причиной не освобождения памяти сборщиком мусора.

Существует один замечательный предопределенный интерфейс, который, как и все интерфейсы является и доменом. Это интерфейс - object.

Все экземпляры, принадлежащие доменам своих интерфейсов, в то же время являются дочерними доменами домена object.
Это значит, что практически возможно вместо
<vip>facts
мойУказатель_V:мойИнтерфейс:=erroneous.</vip>
объявлять
<vip>facts
мойУказатель_V:object:=erroneous.</vip>
При этом будет компилироваться и работать
<vip>clauses
мойПример():-
мойУказатель_V:=мойОбъект::new(),
...</vip>
Но вот вызов
<vip> ...
мойУказатель_V:мойПредикатИзМойОбъект(...),
...</vip>
в этом случае не пропустит компилятор.
Вместо этого необходимо прoизводить конвертацию
<vip> ...
МойУказатель=convert(мойИнтерфейс,мойУказатель_V),
МойУказатель:мойПредикатИзМойОбъект(...),
...</vip>
Примерно то же происходит, если интерфейс поддерживает другие интерфейсы.
Сборщик мусора можно подтолкнуть предикатом
<vip>memory::garbageCollect()</vip> но обычно в этом нет никакой необходимости.

Следует иметь в виду, что момент, когда память будет фактически освобождена, и будет вызван предикат finalize (если он есть), не контролируется и определяется внутренней логикой сборщика мусора и его взаимодействием с операционной системой. Также нельзя делать никаких предположений о порядке освобождения объектов и, соответственно, о порядке вызова finalize для разных объектов. Рекомендуется предикат finalize использовать исключительно для освобождения ресурсов, при этом объектные факты освобождать нет никакой необходимости. Раз уж объект удаляется, то и все его факты постигнет аналогичная участь.
[[Категория:VipLanguage]]

Списки и рекурсия

2007-11-23T11:03:33Z

SergeMukhin: очепятки

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

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

==Что такое Список?==

В Прологе ''список (list)'' является объектом, содержащим внутри произвольное число других объектов. Списки соответствуют, грубо говоря, массивам в других языках, но, в отличие от массивов, список не трубует декларирования его размера до начала его использования.

Список, содержащий числа 1, 2 и 3 записывается как
<vip>[ 1, 2, 3 ]</vip>

Порядок элементов в этом списке значим:
*Число "1" является первым элементом,
*"2" - второй,
*"3" - третий.

Список [ 1, 2, 3 ] и список [ 1, 3, 2 ] различны.

Каждый компонент списка называется элемент (element). Для того, чтобы сформировать списковую структуру данных, следует разделять элементы запятыми и заключать их всех в квадратные скобки. Посмотрим на некоторые примеры:
<vip>["dog", "cat", "canary"]
["valerie ann", "jennifer caitlin", "benjamin thomas"]</vip>
Один и тот же элемент может быть представлен в списке несколько раз, например:
<vip>[ 1, 2, 1, 3, 1 ]</vip>

===Объявление Списков===
Для объявления домена - списка целых используется декларация домена, как показано ниже:
<vip>domains
integer_list = integer*.</vip>

Звездочка означает "список этого"; то есть, integer* означает "список целых".

Обратите внимание на то, что слово ''"list"'' не имеет специального значения в Visual Prolog. Вы равным образом могли бы назвать Ваш списковый домен как ''zanzibar''. Именно звездочка, а не имя, предписывает этому домену быть списком.

Элементами в списке может быть что угодно, включая другие списки. Но все элементы в списке должны принадлежать одному домену, и дополнительно к декларации спискового домена должна быть декларация '''domains''' для элементов:
<vip>domains
element_list = elements*.
elements = ....</vip>

Здесь ''elements'' должны быть приравнены к простым доменным типам (например, integer, real или symbol) или к набору возможных альтернатив, обозначенных различными функторами. Visual Prolog не допускает смешивание стандартных типов в списке. Например, следующие декларации ошибочно представляют списки, созданные из integers, reals и symbols:

<vip>element_list = elements*.
elements =
integer;
real;
symbol.
/* Неправильно */</vip>

Выходом для объявления списков из integer, real и symbols является объявление домена общего для всех типов, где функтор показывает какому типу принадлежит тот или иной элемент. Например:

<vip>element_list = elements*.
elements =
i(integer);
r(real);
s(symbol).
/* функторами являются i, r и s */</vip>

(Подробнее об этом - в этом же руководстве в разделе "Составные списки").

====Головы и Хвосты====

Список на самом деле является рекурсивным составным объетом. Он состоит из двух частей - головы списка, которым является первый элемент, и хвоста - списка, который включает все следующие элементы.

'''''Хвост списка всегда есть список; голова списка есть элемент.'''''

Например,

<vip>голова списка [a, b, c] есть a
хвост списка [a, b, c] есть [b, c]</vip>

Что происходит, когда мы имеем дело со списком, содержащим один элемент? Ответом является:

<vip>головой списка [c] является c
хвостом списка [c] является []</vip>

'''''Если многократно отнимать первый элемент от хвоста списка, мы получим в конечном итоге пустой список ('''[ ]''').'''''

'''''Пустой список не может быть разбит на голову и хвост.'''''

Это означает, что, концептуально говоря, списки имеют древовидную структуру подобно другим составным объектам. Древовидная структура списка [a, b, c, d] есть:

<pre> list
/ \
a list
/ \
b list
/ \
c list
/ \
d []</pre>
Более того, одноэлементный список, такой как [a] - это не тот же самый элемент, который этот список содержит, поскольку [a] является действительно составной структурой данных, как это видно здесь:

<pre> list
/ \
a []</pre>

==Представления Списков==

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

[a, b, c] эквивалентно [a|[b, c]]

и, продолжая процесс,

[a|[b,c]] эквивалентно [a|[b|[c]]],

что эквивалентно [a|[b|[c|[]]]]

Можно даже использовать оба способа разделения в одном и том же списке, рассматривая вертикальную черту как разделитель самого низкого уровня. Следовательно, можно записать [a, b, c, d] как [a, b|[c, d]]. Таблица 1 дает дополнительные примеры.

{|cellpadding="5" cellspacing="0" border="1"
|+'''Таблица 1: Головы и Хвосты списков'''
!Список
!Голова
!Хвост
|-
|['a', 'b', 'c']
|'a'
|['b', 'c']
|-
|[ 'a' ]
|'a'
|[]
|-
|/*пустой список*/ [ ]
|неопределен
|неопределен
|-
|[[1, 2, 3], [2, 3, 4], []]
|[1, 2, 3]
|[[2, 3, 4], []]

|}

В Таблице 2 приведены некоторые примеры унификации списков.

{|cellpadding="5" cellspacing="0" border="1"
|+'''Таблица 2: Унификация Списков'''
!Список 1
!Список 2
!Связывание Переменных
|-
|[X, Y, Z]
|[эгберт, ест, мороженое]
|X=эгберт, Y=ест, Z=мороженое
|-
|[7]
|[X <nowiki>|</nowiki> Y]
|X=7, Y=[]
|-
|[1, 2, 3, 4]
|[X, Y <nowiki>|</nowiki> Z]
|X=1, Y=2, Z=[3,4]
|-
|[1, 2]
|[3 <nowiki>|</nowiki> X]
|fail
|}

==Использование Списков==

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

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

===Вывод Списков на печать===

Например, если Вы хотите только вывести на печать элементы списка, то вот что Вы делаете:

<vip>class my
predicates
write_a_list : (integer*).
end class

implement my
clauses
write_a_list([]). /* Если список пустой, ничего не делаем. */
write_a_list([H|T]):- /* Сопоставляем голову с H и хвост с T, и... */
stdio::write(H),stdio::nl, /*выводим H и переводим строку*/
write_a_list(T).
end implement

goal
console::init(),
my::write_a_list([1, 2, 3]).</vip>

Здесь мы видим два клауза write_a_list, которые можно выразить но обычном языке:

*Для вывода на печать пустого списка ничего не надо делать.
*Иначе, для вывода на печать списка, вывести на печать его голову (она есть просто элемент), и потом вывести на печать хвост списка (он, как известно, есть список).

Первый раз, когда вызывается:

<vip>my::write_a_list([1, 2, 3]).</vip>

такой вызов сопоставляется со вторым клаузом, с головой H=1 и T=[2, 3]. Это приводит к выводу на печать 1, затем рекурсивно вызывается write_a_list с аргументом в виде хвоста списка:

<vip>my::write_a_list([2, 3]).
/* Это вызов write_a_list(T). */</vip>

Этот второй вызов опять сопоставляется со вторым клаузом, где, на этот раз H=2 и T=[3], поэтому выводится 2 и опять рекурсивно вызывается write_a_list:

<vip>my::write_a_list([3]).</vip>

С каким клаузом теперь такой вызов сопоставлятся? Напомним, что, хотя список [3] имеет всего один элемент, у него есть голова и хвост - голова есть 3, а хвост есть []. Таким образом, этот вызов опять сопоставляется со вторым клаузом с H=3 и T=[]. Теперь выводится 3 и вызывается рекурсивно write_a_list:

<vip>my::write_a_list([]).</vip>

Теперь становится понятно для чего нужен первый клауз. Второй клауз не может быть сопоставлен с таким вызовом, поскольку [] не может быть разделен на голову и хвост. Если бы первого клазуа здесь не было бы, то выполнение goal оказалось бы неуспешным. Но, поскольку он есть, то первый клауз сопоставляется с вызовом и выполнение goal успешно завершается и нечего более не делается.

===Подсчет элементов в Списке===

Рассмотрим теперь, как подсчитать число элементов в списке, или какова длина списка? Логично определить:

*Длина пустого списка [] есть 0.<br />
*Длина любого другого списка есть 1 плюс длина его хвоста.

Можно ли это запрограммировать? На Прологе это очень просто. Всего два клауза:

<vip>class my
predicates
length_of : (A*, integer) procedure(i,o).
end class

implement my
clauses
length_of([], 0).
length_of([_|T], L):-
length_of(T, TailLength),
L = TailLength + 1.
end implement

goal
console::init(),
my::length_of([1, 2, 3], L),
stdio::write(L).</vip>

Посмотрите прежде всего на второй клауз. Строго говоря, [_|T] сопоставляется с любым непустым списком, связывая T с хвостом списка. Значение головы неважно, если она есть, она может быть учтена как один элемент.

Тогда вызов:

<vip>my::length_of([1, 2, 3], L)</vip>

сопоставляется со вторым клаузом, с T=[2, 3]. Следующим шагом является вычисление длины хвоста T. Когда это сделано (не имеет значение, как), TailLength получит значение 2, и компьютер теперь может добавить 1 к ней и связать L со значением 3. Как выполняется этот промежуточный шаг? Надо найти длину списка [2, 3], путем удовлетворения цели

<vip>my::length_of([2, 3], TailLength)</vip>

Другими словами, length_of вызывает себя рекурсивно. Этот вызов сопоставляется со вторым клаузом, связывая

*[3] и T в вызове клаузы и
*TailLength с L в клаузе.

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

Итак, теперь задача - найти длину списка [3], которая есть 1, и мы добавляем 1 к этому значению, чтобы получить длину списка [2, 3], что будет 2. Ну и хорошо!.

Аналогично, length_of вызывает себя рекурсивно опять для получения длины списка [3]. Хвост [3] есть [], поэтому T связывается с [], и задача теперь - получение длины списка [] и добавление к ней 1, что дает длину списка [3].

Теперь все просто. Цель:

<vip>my::length_of([], TailLength)</vip>

сопоставляется с ''первым'' клаузом, связывая TailLength с 0. Поэтому теперь компьютер может добавить 1 к нему, получая длину списка [3], и возвращаясь теперь в вызывавший клауз. Это, в свою очередь, опять добавляет 1, давая длину списка [2, 3], и возвращается в клауз, который его вызывал; этот первоначальный клауз добавит снова 1, давая длину списка [1, 2, 3].

Не растерялись? Мы надеемся, нет. В следующей короткой иллюстрации мы сводим воедино все вызовы. Мы использовали здесь прием подстрочника для того, чтобы показать, что аналогично называемые переменные в разных клаузах или различные вызовы того же самого клауза - одно и то же.
<vip>my::length_of([1, 2, 3], L1).
my::length_of([2, 3], L2).
my::length_of([3], L3).
my::length_of([], 0).
L3 = 0+1 = 1.
L2 = L3+1 = 2.
L1 = L2+1 = 3.</vip>

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

===Хвостовая рекурсия===

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

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

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

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

<vip>class my
predicates
length_of : (A*, integer, integer) procedure(i,o,i).
end class

implement my
clauses
length_of([], Result, Result).
length_of([_|T], Result, Counter):-
NewCounter = Counter + 1,
length_of(T, Result, NewCounter).
end implement

goal
console::init(),
my::length_of([1, 2, 3], L, 0), /* Начинаем со счетчиком Counter = 0 */
stdio::write(" L = ", L).</vip>

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

===Модификация Списка===

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

<vip>class my
predicates
add1 : (integer*, integer*) procedure(i,o).
end class

implement my
clauses
add1([], [])./* граничное условие */
add1([Head|Tail],[Head1|Tail1]):- /* отделяем голову от остального списка*/
Head1 = Head+1, /* добавляем 1 к элементу-голове */
add1(Tail, Tail1)./* далаем это с остальной частью списка*/
end implement

goal
console::init(),
my::add1([1,2,3,4], NewList),
stdio::write(NewList)).</vip>

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

Загрузим программу и выполним такую цель
<vip>add1([1,2,3,4], NewList).</vip>

Цель вернет
<vip>NewList=[2,3,4,5]
1 Solution</vip>

===Опять о хвостовой рекурсии===

Является ли предикат add1 проедикатом с хвостовой рекурсией?
Если у Вас есть опыт использования Lisp или Pascal, Вы могли бы подумать, что нет, поскольку Вы бы рассуждали так:

*Делим список на ''Head'' и ''Tail''.
*Добавляем 1 к ''Head'', получаем ''Head1''.
*Рекурсивно добавляя 1 ко всем элементам списка ''Tail'', получаем ''Tail1''.
*Соединяем ''Head1'' и ''Tail1'', что дает результирующий список.

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

Однако, и это важно, – '''''Это не то, что делает Пролог'''''. В Visual Prolog add1 является предикатом с хвостовой рекурсией, поскольку выполняется в действительности следующим образом:

*Связать голову и хвост исходного списка с ''Head'' и ''Tail'', соответственно.
*Связать голову и хвост результирующего списка с ''Head1'' и ''Tail1'', соответственно. (''Head1'' и ''Tail1'' пока не получили значений.)
*Добавить 1 к ''Head'', что дает ''Head1''.
*Рекурсивно добавить 1 ко всем элементам списка ''Tail'', что дает ''Tail1''.

Когда это сделано, ''Head1'' и ''Tail1'' '''уже являются''' головой и списком результата и отдельной операции по их соединению нет. Поэтому рекурсивный вызов и является последним шагом.

<h6>Снова Модификация Списков</h6>

Конечно, не всегда модификации подлежит каждый элемент. Посмотрим на программу, которая сканирует список чисел и копирует его, удаляя отрицательные числа:

<vip>class my
predicates
discard_negatives : (integer*, integer*) procedure(i,o). /*удалить отрицательные*/
end class

implement my
clauses
discard_negatives([], []).
discard_negatives([H|T], ProcessedTail):-
H < 0,
!, /* Если H отрицательно, пропускаем его */
discard_negatives(T, ProcessedTail).
discard_negatives([H|T], [H|ProcessedTail]):-
discard_negatives(T, ProcessedTail).
end implement

goal
console::init(),
my::discard_negatives ([2, -45, 3, 468], X),
stdio::write(X).</vip>

Напрмер, цель
<vip>my::discard_negatives([2, -45, 3, 468], X)</vip>
дает
<vip>X=[2, 3, 468].</vip>

А вот - предикат который копирует элементы списка, добавляя для каждого элемента его дубликат:
<vip>doubletalk([], []).
doubletalk([H|T], [H, H|DoubledTail]) :-
doubletalk(T, DoubledTail).</vip>

===Принадлежнось списку===

Допустим, имеется список с именами ''John'', ''Leonard'', ''Eric'' и ''Frank'' и требуется, используя Visual Prolog, выяснить, принадлежит ли заданное имя этому списку. Другими словами, надо определить "отношение" между двумя аргументами: именем и списком имен. Это соответствует предикату

<vip>isMember : (name, name*).
/* "name" принадлежит списку "name*" */</vip>

В программе e01.pro первый клауз исследует голову списка. Если голова списка совпадает с искомым именем, то можно сделать заключение, что Name принадлежит списку. Поскольку хвост списка нас не интересует, то это мы представляем анонимной переменной. Благодаря первому клаузу, цель

<vip>my::isMember("john", ["john", "leonard", "eric", "frank"])</vip>

удовлетворена.

<vip>/* Программа e01.pro */
class my
predicates
isMember : (A, A*) determ.
end class

implement my
clauses
isMember(Name, [Name|_]) :-
!.
isMember(Name, [_|Tail]):-
isMember(Name,Tail).
end implement

goal
console::init(),
my::isMember("john", ["john", "leonard", "eric", "frank"]),
!,
stdio::write("Success")
;
stdio::write("No solution").
</vip>

Если голова списка не есть Name, то надо исследовать, не содержится ли Name в хвосте списка.

На обычном языке:

Name принадлежит списку, если Name является первым элементом списка, или<br />
Name принадлежит списку, если Name принадлежит хвосту.

Второй клауз предиката isMember относится к этому отношению. Таким образом на Visual Prolog:

<vip>isMember(Name, [_|Tail]) :-
isMember(Name, Tail).</vip>

===Добавление списка к другому списку: декларативное и рекурсивное решения===

Рассмотренный предикат member программы e01.pro работает в двух направлениях. Вернемся к его клаузам:

<vip>
member(Name, [Name|_]).
member(Name, [_|Tail]) :-
member(Name, Tail).
</vip>

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

*С декларативной точки зрения, клаузы выражают:
**Name (Имя) принадлежит списку, если голова списка есть Name
**иначе Name принадлежит списку, если оно (Имя) принадлежит хвосту.
*С процедурной точки зрения, эти же два клауза могут быть интерпретированы так:<br/>Чтобы найти элемент списка
**Найдите его голову
**иначе найдите элемент хвоста списка.

Эти две точки зрения соответствуют целям
<vip>member(2, [1, 2, 3, 4]).</vip>
и
<vip>member(X, [1, 2, 3, 4]).</vip>

В результате первый вызов поручает Visual Prolog(у) проверить, истино ли нечто (принадлежность числа 2 списку [1,2,3,4]). Второй вызов поручает Visual Prolog(у) найти все члены списка [1,2,3,4]. Не смущайтесь этим. Предикат member является одним и тем же, но на его поведение можно смотреть под разными углами.

====Рекурсия с процедуральной точки зрения====

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

<vip>append(List1, List2, List3).</vip>

Этот предикат интегрирует списки List1 и List2 в форму списка List3 так, что список List2 дописывается в конце списка List1. То есть содержательно - осуществляется добавление списка List2 к списку LIst1. Опять мы используем рекурсию (на этот раз с процедуральной точки зрения).

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

<vip>append([], List2, List2).</vip>

Если список List1 не пустой, то можно преобразовать списки List1 и List2 к форме списка ''List3'', сделав голову списка List1 головой списка List3. В приведенном коде переменная H используется в качестве головы как списка List1, так и списка List3. хвост списка List3 есть список L3, который составлен из остатка списка List1 (а именно, L1) и всего списка List2. Опять выразим это на Прологе:

<vip>append([H|L1], List2, [H|L3]) :-
append(L1, List2, L3).</vip>

Предикат append работает следующим образом: пока список List1 не пустой, рекурсивное правило дописывает один элемент каждый раз к списку List3. Когда список List1 становится пустым, первый клауз clause обеспечивает дописывание списка List2 в конец списка List3.

====Варианты использования одного предиката====

Подходя к предикату append с декларативной точки зрения, мы определили его как отношение между тремя списками. Это отношение справедливо также, если списки List1 и List3 известны, а List2 - нет. Более того, это также работает, если только List3 известен. Например, для того, чтобы выяснить, какие два списка могли бы быть соединены для получения известного списка, можно использовать вызов в форме
<vip>append(L1, L2, [1, 2, 4]).</vip>

С таким целевым вызовом, Visual Prolog найдет следующие решения:

<vip>
L1=[], L2=[1,2,4]
L1=[1], L2=[2,4]
L1=[1,2], L2=[4]
L1=[1,2,4], L2=[]
4 Solutions
</vip>

Можно использовать предикат append для нахождения списка, который следовало бы добавить к списку [3,4] для получения списка[1,2,3,4]. Попробуем такой вызов
<vip>append(L1, [3,4], [1,2,3,4]).</vip>
Visual Prolog находит решение
<vip>L1=[1,2].</vip>

Предикат append определяет отношение между ''входным набором (input set)'' и ''выходным набором (output set)'' таким образом, что отношение применимо в обе стороны. При таком отношении возникает вопрос

''Что является выходным набором для заданного входного?'' или ''Какой входной набор соответствует заданному выходному?''

Статус аргументов данного вызова предиката известен как ''поток (или шаблон) ввода-вывода''. Аргумент, который связан или наследуется в момент вызова является входным аргументом и обозначается как (i). Свободный аргумент является выходным аргументом и обозначается как (o).

Предикат append обладает свойством поддерживать любой шаблон ввода-вывода, какой требуется. Однако не все предикаты имеют возможность вызова с различными шаблонами ввода-вывода. Когда клауз Пролога способен поддерживать множество шаблонов ввода-вывода, он называется инверсным клаузом. Целый набор предикатов для обработки списков содержится в классе '''list'''.

==Все Решения Сразу==

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

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

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

*Первый аргумент, VarName, определяет аргумент в вызываемом целевом предикате, значения которого будут собираться в список.
*Второй - mypredicate - определяет предикат, который будет получать значения.
*Выходной параметр ListParam, является переменной, которая содержит список значений, полученных в ходе отката.

Программа e02.pro использует обработку списка для вывода среднего возраста группы людей.
<vip> /* Программа e02.pro */
class my
domains
name = string.
address = string.
age = integer.

predicates
person : (name, address, age) nondeterm anyflow.
sumlist : (age*, age, integer)procedure(i,o,o).
end class my

implement my
clauses
sumlist([],0,0).
sumlist([H|T], Sum, N):-
sumlist(T, S1, N1),
Sum=H+S1, N=1+N1.

person("Sherlock Holmes","22B Baker Street", 42).
person("Pete Spiers","Apt. 22, 21st Street", 36).
person("Mary Darrow","Suite 2, Omega Home", 51).
end implement my

goal
console::init(),
L = [ Age || my::person(_, _, Age)],
my::sumlist(L, Sum, N),
Ave = Sum/N,
stdio::write("Average=", Ave, ". ").</vip>

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

<vip>List = [ Who || my::person(Who, _, 42) ]</vip>

Следующий код порождает список всех положительных чисел исходного списка:

<vip>List = [ X || X = list::getMember_nd([2,-8,-3,6]), X > 0]</vip>

==Смешанные списки==

Список целых объявляется просто
<vip>integer*</vip>

То же верно и для списков вещественных чисел (integer), символьных (symbol) списков или списков строк (string).

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

<vip>[2, 3, 5.12, ["food", "goo"], "new"].
/* Не корректно для Visual Prolog*/</vip>

''Смешанные списки'' - списки, содержащие элементы более чем одного типа. Для работы со списками разнотипных элементов должны использоваться специальные объявления, поскольку Visual Prolog требует, чтобы все элементы списка принадлежали бы '''''одному и тому же''''' домену. Способом создания списка, который хранит такие различные типы элементов является использование функторов, поскольку домен может представляться '''''более, чем одним''''' функтором, каждый со своими т'''и'''повыми аргументами.

Пример объаявления списка, который может хранить целые, символы, строки или списки таких даных:

<vip>domains
/* функторами являются l, i, c, and s */
llist = l(list); i(integer); c(char); s(string).</vip>
Список
<vip>[ 2, 9, ["food", "goo"], "new" ]
/* Не корректно для Visual Prolog */</vip>
на Visual Prolog следовало бы записать так:

<vip>[i(2), i(9), l([s("food"), s("goo")]), s("new")]
/* Корректно для Visual Prolog */</vip>

Следующий пример предиката append показывает как использовать такого рода декларации в стандартных программах манипулирования списками.

<vip>class my
domains
llist = l(list); i(integer); c(char); s(string).

predicates
append : (A*,A*,A*) procedure (i,i,o).
end class

implement my
clauses
append([], L, L).
append([X|L1], L2, [X|L3]):-
append(L1, L2, L3).
end implement

goal
console::init(),
my::append
(
[my::s("likes"),my::l([my::s("bill"), my::s("mary")])],
[my::s("bill"), my::s("sue")],
Ans
),
stdio::write("Первый список: ", Ans,"\n\n"),
my::append
(
[my::l([my::s("This"),my::s("is"),my::s("a"),my::s("list")]),my::s("bee")],
[my::c('c')],
Ans2
),
stdio::write("Второй списко: ", Ans2, "\n\n&quot).</vip>

==Разбор с использованием списков==

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

Этот разборщик предназначен для примитивного формального языка. Хотя этот пример достаточно сложен с точки зрения этого руководства, мы решили поместит его здесь, поскольку разбор является одной из областей, где Visual Prolog очень эффективен. Если Вы чувствуете себя не вполне готовым для этого раздела, Вы можете этот пример пропустить и продолжить чтение руководства без потери содержательности.

<vip>#include @"pfc\exception\exception.ph"
#include @"pfc\string\string.ph"
#include @"pfc\console\console.ph"

class my_t
predicates
tokl : (string, string*) procedure (i,o).
end class

implement my_t
clauses
tokl(Str, [H|T]) :-
string::fronttoken(Str, H, Str1),
!,
tokl(Str1, T).
tokl(_, []).
end implement

/* * * * * * * * * * * * * * * * * * * * *
* Вторая часть этой программы - разборщик *
* * * * * * * * * * * * * * * * * * * * * */
class my_p
domains
program = program(statement*).
/* * * * * * * * * * * * * * * * * * * * * *
* Определение что есть языковая конструкция *
* (предложение языка) *
* * * * * * * * * * * * * * * * * * * * * * */
statement =
if_Then_Else(exp, statement, statement);
if_Then(exp, statement);
while(exp, statement);
assign(id, exp).
/* * * * * * * * * * * *
* Определение выражения *
* * * * * * * * * * * */
exp =
plus(exp, exp);
minus(exp, exp);
var(id);
int(integer).
id = string.

predicates
s_program : (string*, program) procedure (i,o).
s_statement : (string*, string*, statement) determ (i,o,o).
s_statement_list : (string*, string*, statement*) determ (i,o,o).
s_exp : (string*, string*, exp) determ (i,o,o).
s_exp1 : (string*, string*, exp, exp) determ (i,o,i,o).
s_exp2 : (string*, string*, exp) determ (i,o,o).
end class

implement my_p
clauses
s_program(TokenList, program(StatementList)):-
s_statement_list(TokenList, _, StatementList),
!.
s_program(_, program([])).

clauses
s_statement_list([], [], []) :- !.
s_statement_list(List1, List4, [Statement|Program]) :-
s_statement(List1, List2, Statement),
List2=[";"|List3],
s_statement_list(List3, List4, Program).

clauses
s_statement(["if"|List1], List7,if_then_else(Exp,Statement1, Statement2)):-
s_exp(List1, List2, Exp),
List2=["then"|List3],
s_statement(List3, List4, Statement1),
List4=["else"|List5],!,
s_statement(List5, List6, Statement2),
List6=["fi"|List7].
s_statement(["if"|List1], List5,if_then(Exp, Statement)) :- !,
s_exp(List1, List2, Exp),
List2=["then"|List3],
s_statement(List3, List4, Statement),
List4=["fi"|List5].
s_statement(["do"|List1], List4,while(Exp, Statement)) :- !,
s_statement(List1, List2, Statement),
List2=["while"|List3],
s_exp(List3, List4, Exp).
s_statement([ID|List1], List3,assign(Id,Exp)) :-
string::isname(ID),
List1=["="|List2],
s_exp(List2, List3, Exp).

clauses
s_exp(List1, List3, Exp):-
s_exp2(List1, List2, Exp1),
s_exp1(List2, List3, Exp1, Exp).

clauses
s_exp1(["+"|List1], List3, Exp1, Exp) :- !,
s_exp2(List1, List2, Exp2),
s_exp1(List2, List3, plus(Exp1, Exp2), Exp).
s_exp1(["-"|List1], List3, Exp1, Exp) :- !,
s_exp2(List1, List2, Exp2),
s_exp1(List2, List3, minus(Exp1, Exp2), Exp).
s_exp1(List, List, Exp, Exp).

clauses
s_exp2([Int|Rest], Rest, int(I)) :-
trap(I = toTerm(Int),Error,exception::clear_fail(Error)),
!.
s_exp2([Id|Rest], Rest, var(Id)) :-
string::isname(Id).
end implement

goal
console::init(),
my_t::tokl("b=2; if b then a=1 else a=2 fi; do a=a-1 while a;", Ans),
stdio::write(Ans),
my_p::s_program(Ans, Res),
stdio::write(Res).
</vip>

Загрузите программу и выполните целевой вызов:

<vip>goal
my_t::tokl("b=2; if b then a=1 else a=2 fi; do a=a-1 while a;", Ans),
my_p::s_program(Ans, Res).</vip>

Visual Prolog вернет структуру программы:

<vip>Ans = ["b","=","2",";","if","b","then","a","=","1",
"else","a","=","2","fi",";","do","a","=","a",
"-","1","while","a",";"],
Res=program
(
[assign("b",int(2)),
if_then_else
(
var("b"),
assign("a",int(1)),
assign("a",int(2))
),
while
(
var("a"),
assign
(
"a",
minus
(
var("a"),
int(1)
)
)
)
])
</vip>

Преобразование в этом примере представлено двумя шагами: сканирование и разбор. Предикат tokl - это сканер. Он принимает строку и преобразует ее в список токенов. Все предикаты с именами, начинающимися с s_ являются предикатами парсера. В этом примере входный текст представляет программу на языке, подобном языку Паскаль, и состоящей из Паскале-подобных предложений. Этот язык программирования позволяет только предложения вида: IF THEN ELSE, IF THEN, DO WHILE и присваивание (ASSIGNMENT). Предложения состоят из выражений и вложенных предложений. Выражения - сложение, вычитание, переменные и целые.

Далее, как это работает:

*Первый клауз парсера, s_program, принимает список токенов и пытается преобразовать его в список предложений.
*Предикат s_statement_list принимает тот же самый список токенов и проверяет возможность деления токенов на предложения, завершающиеся точкой с запятой.
*Предикат s_statement проверяет могут ли начальные токены списка (токенов) представлять собой правильное предложение. Если да, то такое предложение возвращается в виде структуры, а остаток токенов передается рекурсивно вызываемому предикату s_statement_list.
*Четыре клауза предиката s_statement соответствуют четырем типам, которые парсер понимает.<br\> Если первый клауз предиката s_statement не может преобразовать список токенов в предложение вида IF THEN ELSE, то клауз завершается неуспешно и в порядке отката переходит к следующему клаузу предиката s_statement. Теперь делается попытка преобразовать список токенов в конструкцию вида IF THEN. Если эта попытка неуспешна, то в следующем клаузе делается попытка преобразования к предложению вида DO WHILE.
*Если первые три клауза предиката s_statement завершаются неуспешно, то последний клауз этого предиката провереяет представлена ли в списке токенов операция присваивания. Этот клауз проверяет "на присваивание" является ли первый терм символом, второй - знаком равно ("="), а следующие термы представляют простое математическое выражение.
*Предикаты s_exp, s_exp1 и s_exp2 работают аналогично, путем проверки являются ли начальные термы выражениями и, если это так, то предикату s_statement предикат s_exp возвращает остаток термов и математическое выражение в виде структуры.

==Заключение==

В этом руководстве раскрыта следующие важные моменты:

*''Списки'' могут содержать произвольное число элементов; Вы объявляете их простым добавление звездочки ('''*''') в конце ранее определённого домена.
*Список является рекурсивным составным объектом, состоящим из головы и хвоста. Голова есть первый элемент, а хвост - остальная часть списка (без первого элемента). Хвост списка - всегда список; голова списка - всегда элемента. Список может содержать ноль или более элементов; Пустой список обозначается [].
*Элементами списка может быть что угодно, включая другие списки; все элементы списка должны принадлежать одному домену. В этом случае объявление домена элементов должно выглядеть так:

<vip>domains
element_list = elements*.
elements = ....</vip>

где elements = один из стандартных доменов (integer, real, etc.) или набор альтернатив обозначенных различными функторами (int(integer); rl(real); smb(symbol); и т.д.). Смешение типов в списках языка системы Visual Prolog допускается только включением их в составные объекты или функторы.
*Можно использовать разделители (запятые, [ и |) для явного отделения головы списка от хвоста. Так, список
<vip>[a, b, c, d]</vip>
может быть записан как:
<vip>
[a|[b, c, d]]
или
[a, b|[c, d]]
или
[a, b, c|[d]]
или
[a|[b|[c, d]]]
или
[a|[b|[c|[d]]]]
или даже
[a|[b|[c|[d|[]]]]]</vip>
*Обработка списков заключается в рекурсивном отщеплении головы списка (и выполнении действий над ней) до опустошения списка.
*Предикаты для работы со списками содержаться в классе '''list'''.
*Visual Prolog поддерживает встроенную конструкцию обработки списков, которая принимает целевой предикат в качестве одного из аргументов и собирает все решения этого целевого предиката в едином списке. Синтаксис такой конструкции
<vip>Result = [ Argument || myPredicate(Argument) ]</vip>
*Поскольку Visual Prolog требует, чтобы все элементы списка принадлежали бы одному и тому же домену, следует использовать функторы для создания списков, хранящих элементы различного типа.
*процесс ''разбора с использованием разностных списков (parsing by difference lists)'' работает путем сокращения задачи; пример в этом руководстве преобразует строку входных данных в структуру, которая может обрабатываться позже.

==References==
[[en:Lists and Recursion]]
[[Категория:VipРуководства]]
[[Категория:VipLanguage]]

Списки и рекурсия

2007-11-23T11:01:40Z

SergeMukhin: очепятки

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

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

==Что такое Список?==

В Прологе ''список (list)'' является объектом, содержащим внутри произвольное число других объектов. Списки соответствуют, грубо говоря, массивам в других языках, но, в отличие от массивов, список не трубует декларирования его размера до начала его использования.

Список, содержащий числа 1, 2 и 3 записывается как
<vip>[ 1, 2, 3 ]</vip>

Порядок элементов в этом списке значим:
*Число "1" является первым элементом,
*"2" - второй,
*"3" - третий.

Список [ 1, 2, 3 ] и список [ 1, 3, 2 ] различны.

Каждый компонент списка называется элемент (element). Для того, чтобы сформировать списковую структуру данных, следует разделять элементы запятыми и заключать их всех в квадратные скобки. Посмотрим на некоторые примеры:
<vip>["dog", "cat", "canary"]
["valerie ann", "jennifer caitlin", "benjamin thomas"]</vip>
Один и тот же элемент может быть представлен в списке несколько раз, например:
<vip>[ 1, 2, 1, 3, 1 ]</vip>

===Объявление Списков===
Для объявления домена - списка целых используется декларация домена, как показано ниже:
<vip>domains
integer_list = integer*.</vip>

Звездочка означает "список этого"; то есть, integer* означает "список целых".

Обратите внимание на то, что слово ''"list"'' не имеет специального значения в Visual Prolog. Вы равным образом могли бы назвать Ваш списковый домен как ''zanzibar''. Именно звездочка, а не имя, предписывает этому домену быть списком.

Элементами в списке может быть что угодно, включая другие списки. Но все элементы в списке должны принадлежать одному домену, и дополнительно к декларации спискового домена должна быть декларация '''domains''' для элементов:
<vip>domains
element_list = elements*.
elements = ....</vip>

Здесь ''elements'' должны быть приравнены к простым доменным типам (например, integer, real или symbol) или к набору возможных альтернатив, обозначенных различными функторами. Visual Prolog не допускает смешивание стандартных типов в списке. Например, следующие декларации ошибочно представляют списки, созданные из integers, reals и symbols:

<vip>element_list = elements*.
elements =
integer;
real;
symbol.
/* Неправильно */</vip>

Выходом для объявления списков из integer, real и symbols является объявление домена общего для всех типов, где функтор показывает какому типу принадлежит тот или иной элемент. Например:

<vip>element_list = elements*.
elements =
i(integer);
r(real);
s(symbol).
/* функторами являются i, r и s */</vip>

(Подробнее об этом - в этом же руководстве в разделе "Составные списки").

====Головы и Хвосты====

Список на самом деле является рекурсивным составным объетом. Он состоит из двух частей - головы списка, которым является первый элемент, и хвоста - списка, который включает все следующие элементы.

'''''Хвост списка всегда есть список; голова списка есть элемент.'''''

Например,

<vip>голова списка [a, b, c] есть a
хвост списка [a, b, c] есть [b, c]</vip>

Что происходит, когда мы имеем дело со списком, содержащим один элемент? Ответом является:

<vip>головой списка [c] является c
хвостом списка [c] является []</vip>

'''''Если многократно отнимать первый элемент от хвоста списка, мы получим в конечном итоге пустой список ('''[ ]''').'''''

'''''Пустой список не может быть разбит на голову и хвост.'''''

Это означает, что, концептуально говоря, списки имеют древовидную структуру подобно другим составным объектам. Древовидная структура списка [a, b, c, d] есть:

<pre> list
/ \
a list
/ \
b list
/ \
c list
/ \
d []</pre>
Более того, одноэлементный список, такой как [a] - это не тот же самый элемент, который этот список содержит, поскольку [a] является действительно составной структурой данных, как это видно здесь:

<pre> list
/ \
a []</pre>

==Представления Списков==

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

[a, b, c] эквивалентно [a|[b, c]]

и, продолжая процесс,

[a|[b,c]] эквивалентно [a|[b|[c]]],

что эквивалентно [a|[b|[c|[]]]]

Можно даже использовать оба способа разделения в одном и том же списке, рассматривая вертикальную черту как разделитель самого низкого уровня. Следовательно, можно записать [a, b, c, d] как [a, b|[c, d]]. Таблица 1 дает дополнительные примеры.

{|cellpadding="5" cellspacing="0" border="1"
|+'''Таблица 1: Головы и Хвосты списков'''
!Список
!Голова
!Хвост
|-
|['a', 'b', 'c']
|'a'
|['b', 'c']
|-
|[ 'a' ]
|'a'
|[]
|-
|/*пустой список*/ [ ]
|неопределен
|неопределен
|-
|[[1, 2, 3], [2, 3, 4], []]
|[1, 2, 3]
|[[2, 3, 4], []]

|}

В Таблице 2 приведены некоторые примеры унификации списков.

{|cellpadding="5" cellspacing="0" border="1"
|+'''Таблица 2: Унификация Списков'''
!Список 1
!Список 2
!Связывание Переменных
|-
|[X, Y, Z]
|[эгберт, ест, мороженое]
|X=эгберт, Y=ест, Z=мороженое
|-
|[7]
|[X <nowiki>|</nowiki> Y]
|X=7, Y=[]
|-
|[1, 2, 3, 4]
|[X, Y <nowiki>|</nowiki> Z]
|X=1, Y=2, Z=[3,4]
|-
|[1, 2]
|[3 <nowiki>|</nowiki> X]
|fail
|}

==Использование Списков==

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

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

===Вывод Списков на печать===

Например, если Вы хотите только вывести на печать элементы списка, то вот что Вы делаете:

<vip>class my
predicates
write_a_list : (integer*).
end class

implement my
clauses
write_a_list([]). /* Если список пустой, ничего не делаем. */
write_a_list([H|T]):- /* Сопоставляем голову с H и хвост с T, и... */
stdio::write(H),stdio::nl, /*выводим H и переводим строку*/
write_a_list(T).
end implement

goal
console::init(),
my::write_a_list([1, 2, 3]).</vip>

Здесь мы видим два клауза write_a_list, которые можно выразить но обычном языке:

*Для вывода на печать пустого списка ничего не надо делать.
*Иначе, для вывода на печать списка, вывести на печать его голову (она есть просто элемент), и потом вывести на печать хвост списка (он, как известно, есть список).

Первый раз, когда вызывается:

<vip>my::write_a_list([1, 2, 3]).</vip>

такой вызов сопоставляется со вторым клаузом, с головой H=1 и T=[2, 3]. Это приводит к выводу на печать 1, затем рекурсивно вызывается write_a_list с аргументом в виде хвоста списка:

<vip>my::write_a_list([2, 3]).
/* Это вызов write_a_list(T). */</vip>

Этот второй вызов опять сопоставляется со вторым клаузом, где, на этот раз H=2 и T=[3], поэтому выводится 2 и опять рекурсивно вызывается write_a_list:

<vip>my::write_a_list([3]).</vip>

С каким клаузом теперь такой вызов сопоставлятся? Напомним, что, хотя список [3] имеет всего один элемент, у него есть голова и хвост - голова есть 3, а хвост есть []. Таким образом, этот вызов опять сопоставляется со вторым клаузом с H=3 и T=[]. Теперь выводится 3 и вызывается рекурсивно write_a_list:

<vip>my::write_a_list([]).</vip>

Теперь становится понятно для чего нужен первый клауз. Второй клауз не может быть сопоставлен с таким вызовом, поскольку [] не может быть разделен на голову и хвост. Если бы первого клазуа здесь не было бы, то выполнение goal оказалось бы неуспешным. Но, поскольку он есть, то первый клауз сопоставляется с вызовом и выполнение goal успешно завершается и нечего более не делается.

===Подсчет элементов в Списке===

Рассмотрим теперь, как подсчитать число элементов в списке, или какова длина списка? Логично определить:

*Длина пустого списка [] есть 0.<br />
*Длина любого другого списка есть 1 плюс длина его хвоста.

Можно ли это запрограммировать? На Прологе это очень просто. Всего два клауза:

<vip>class my
predicates
length_of : (A*, integer) procedure(i,o).
end class

implement my
clauses
length_of([], 0).
length_of([_|T], L):-
length_of(T, TailLength),
L = TailLength + 1.
end implement

goal
console::init(),
my::length_of([1, 2, 3], L),
stdio::write(L).</vip>

Посмотрите прежде всего на второй клауз. Строго говоря, [_|T] сопоставляется с любым непустым списком, связывая T с хвостом списка. Значение головы неважно, если она есть, она может быть учтена как один элемент.

Тогда вызов:

<vip>my::length_of([1, 2, 3], L)</vip>

сопоставляется со вторым клаузом, с T=[2, 3]. Следующим шагом является вычисление длины хвоста T. Когда это сделано (не имеет значение, как), TailLength получит значение 2, и компьютер теперь может добавить 1 к ней и связать L со значением 3. Как выполняется этот промежуточный шаг? Надо найти длину списка [2, 3], путем удовлетворения цели

<vip>my::length_of([2, 3], TailLength)</vip>

Другими словами, length_of вызывает себя рекурсивно. Этот вызов сопоставляется со вторым клаузом, связывая

*[3] и T в вызове клаузы и
*TailLength с L в клаузе.

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

Итак, теперь задача - найти длину списка [3], которая есть 1, и мы добавляем 1 к этому значению, чтобы получить длину списка [2, 3], что будет 2. Ну и хорошо!.

Аналогично, length_of вызывает себя рекурсивно опять для получения длины списка [3]. Хвост [3] есть [], поэтому T связвается с [], и задача теперь - получение длины списка [] и добавление к ней 1, что дает длину списка [3].

Теперь все просто. Цель:

<vip>my::length_of([], TailLength)</vip>

сопоставляется с ''первым'' клаузом, связывая TailLength с 0. Поэтому теперь компьютер может добавить 1 к нему, получая длину списка [3], и возвращаясь теперь в вызывавший клауз. Это, в свою очередь, опять добавляет 1, давая длину списка [2, 3], и возвращается в клауз, который его вызывал; этот первоначальный клауз добавит снова 1, давая длину списка [1, 2, 3].

Не растерялись? Мы надеемся, нет. В следующей короткой иллюстрации мы сводим воедино все вызовы. Мы использовали здесь прием подстрочника для того, чтобы показать, что аналогично называемые переменные в разных клаузах или различные вызовы того же самого клауза - одно и то же.
<vip>my::length_of([1, 2, 3], L1).
my::length_of([2, 3], L2).
my::length_of([3], L3).
my::length_of([], 0).
L3 = 0+1 = 1.
L2 = L3+1 = 2.
L1 = L2+1 = 3.</vip>

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

===Хвостовая рекурсия===

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

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

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

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

<vip>class my
predicates
length_of : (A*, integer, integer) procedure(i,o,i).
end class

implement my
clauses
length_of([], Result, Result).
length_of([_|T], Result, Counter):-
NewCounter = Counter + 1,
length_of(T, Result, NewCounter).
end implement

goal
console::init(),
my::length_of([1, 2, 3], L, 0), /* Начинаем со счетчиком Counter = 0 */
stdio::write(" L = ", L).</vip>

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

===Модификация Списка===

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

<vip>class my
predicates
add1 : (integer*, integer*) procedure(i,o).
end class

implement my
clauses
add1([], [])./* граничное условие */
add1([Head|Tail],[Head1|Tail1]):- /* отделяем голову от остального списка*/
Head1 = Head+1, /* добавляем 1 к элементу-голове */
add1(Tail, Tail1)./* далаем это с остальной частью списка*/
end implement

goal
console::init(),
my::add1([1,2,3,4], NewList),
stdio::write(NewList)).</vip>

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

Загрузим программу и выполним такую цель
<vip>add1([1,2,3,4], NewList).</vip>

Цель вернет
<vip>NewList=[2,3,4,5]
1 Solution</vip>

===Опять о хвостовой рекурсии===

Является ли предикат add1 проедикатом с хвостовой рекурсией?
Если у Вас есть опыт использования Lisp или Pascal, Вы могли бы подумать, что нет, поскольку Вы бы рассуждали так:

*Делим список на ''Head'' и ''Tail''.
*Добавляем 1 к ''Head'', получаем ''Head1''.
*Рекурсивно добавляя 1 ко всем элементам списка ''Tail'', получаем ''Tail1''.
*Соединяем ''Head1'' и ''Tail1'', что дает результирующий список.

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

Однако, и это важно, – '''''Это не то, что делает Пролог'''''. В Visual Prolog add1 является предикатом с хвостовой рекурсией, поскольку выполняется в действительности следующим образом:

*Связать голову и хвост исходного списка с ''Head'' и ''Tail'', соответственно.
*Связать голову и хвост результирующего списка с ''Head1'' и ''Tail1'', соответственно. (''Head1'' и ''Tail1'' пока не получили значений.)
*Добавить 1 к ''Head'', что дает ''Head1''.
*Рекурсивно добавить 1 ко всем элементам списка ''Tail'', что дает ''Tail1''.

Когда это сделано, ''Head1'' и ''Tail1'' '''уже являются''' головой и списком результата и отдельной операции по их соединению нет. Поэтому рекурсивный вызов и является последним шагом.

<h6>Снова Модификация Списков</h6>

Конечно, не всегда модификации подлежит каждый элемент. Посмотрим на программу, которая сканирует список чисел и копирует его, удаляя отрицательные числа:

<vip>class my
predicates
discard_negatives : (integer*, integer*) procedure(i,o). /*удалить отрицательные*/
end class

implement my
clauses
discard_negatives([], []).
discard_negatives([H|T], ProcessedTail):-
H < 0,
!, /* Если H отрицательно, пропускаем его */
discard_negatives(T, ProcessedTail).
discard_negatives([H|T], [H|ProcessedTail]):-
discard_negatives(T, ProcessedTail).
end implement

goal
console::init(),
my::discard_negatives ([2, -45, 3, 468], X),
stdio::write(X).</vip>

Напрмер, цель
<vip>my::discard_negatives([2, -45, 3, 468], X)</vip>
дает
<vip>X=[2, 3, 468].</vip>

А вот - предикат который копирует элементы списка, добавляя для каждого элемента его дубликат:
<vip>doubletalk([], []).
doubletalk([H|T], [H, H|DoubledTail]) :-
doubletalk(T, DoubledTail).</vip>

===Принадлежнось списку===

Допустим, имеется список с именами ''John'', ''Leonard'', ''Eric'' и ''Frank'' и требуется, используя Visual Prolog, выяснить, принадлежит ли заданное имя этому списку. Другими словами, надо определить "отношение" между двумя аргументами: именем и списком имен. Это соответствует предикату

<vip>isMember : (name, name*).
/* "name" принадлежит списку "name*" */</vip>

В программе e01.pro первый клауз исследует голову списка. Если голова списка совпадает с искомым именем, то можно сделать заключение, что Name принадлежит списку. Поскольку хвост списка нас не интересует, то это мы представляем анонимной переменной. Благодаря первому клаузу, цель

<vip>my::isMember("john", ["john", "leonard", "eric", "frank"])</vip>

удовлетворена.

<vip>/* Программа e01.pro */
class my
predicates
isMember : (A, A*) determ.
end class

implement my
clauses
isMember(Name, [Name|_]) :-
!.
isMember(Name, [_|Tail]):-
isMember(Name,Tail).
end implement

goal
console::init(),
my::isMember("john", ["john", "leonard", "eric", "frank"]),
!,
stdio::write("Success")
;
stdio::write("No solution").
</vip>

Если голова списка не есть Name, то надо исследовать, не содержится ли Name в хвосте списка.

На обычном языке:

Name принадлежит списку, если Name является первым элементом списка, или<br />
Name принадлежит списку, если Name принадлежит хвосту.

Второй клауз предиката isMember относится к этому отношению. Таким образом на Visual Prolog:

<vip>isMember(Name, [_|Tail]) :-
isMember(Name, Tail).</vip>

===Добавление списка к другому списку: декларативное и рекурсивное решения===

Рассмотренный предикат member программы e01.pro работает в двух направлениях. Вернемся к его клаузам:

<vip>
member(Name, [Name|_]).
member(Name, [_|Tail]) :-
member(Name, Tail).
</vip>

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

*С декларативной точки зрения, клаузы выражают:
**Name (Имя) принадлежит списку, если голова списка есть Name
**иначе Name принадлежит списку, если оно (Имя) принадлежит хвосту.
*С процедурной точки зрения, эти же два клауза могут быть интерпретированы так:<br/>Чтобы найти элемент списка
**Найдите его голову
**иначе найдите элемент хвоста списка.

Эти две точки зрения соответствуют целям
<vip>member(2, [1, 2, 3, 4]).</vip>
и
<vip>member(X, [1, 2, 3, 4]).</vip>

В результате первый вызов поручает Visual Prolog(у) проверить, истино ли нечто (принадлежность числа 2 списку [1,2,3,4]). Второй вызов поручает Visual Prolog(у) найти все члены списка [1,2,3,4]. Не смущайтесь этим. Предикат member является одним и тем же, но на его поведение можно смотреть под разными углами.

====Рекурсия с процедуральной точки зрения====

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

<vip>append(List1, List2, List3).</vip>

Этот предикат интегрирует списки List1 и List2 в форму списка List3 так, что список List2 дописывается в конце списка List1. То есть содержательно - осуществляется добавление списка List2 к списку LIst1. Опять мы используем рекурсию (на этот раз с процедуральной точки зрения).

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

<vip>append([], List2, List2).</vip>

Если список List1 не пустой, то можно преобразовать списки List1 и List2 к форме списка ''List3'', сделав голову списка List1 головой списка List3. В приведенном коде переменная H используется в качестве головы как списка List1, так и списка List3. хвост списка List3 есть список L3, который составлен из остатка списка List1 (а именно, L1) и всего списка List2. Опять выразим это на Прологе:

<vip>append([H|L1], List2, [H|L3]) :-
append(L1, List2, L3).</vip>

Предикат append работает следующим образом: пока список List1 не пустой, рекурсивное правило дописывает один элемент каждый раз к списку List3. Когда список List1 становится пустым, первый клауз clause обеспечивает дописывание списка List2 в конец списка List3.

====Варианты использования одного предиката====

Подходя к предикату append с декларативной точки зрения, мы определили его как отношение между тремя списками. Это отношение справедливо также, если списки List1 и List3 известны, а List2 - нет. Более того, это также работает, если только List3 известен. Например, для того, чтобы выяснить, какие два списка могли бы быть соединены для получения известного списка, можно использовать вызов в форме
<vip>append(L1, L2, [1, 2, 4]).</vip>

С таким целевым вызовом, Visual Prolog найдет следующие решения:

<vip>
L1=[], L2=[1,2,4]
L1=[1], L2=[2,4]
L1=[1,2], L2=[4]
L1=[1,2,4], L2=[]
4 Solutions
</vip>

Можно использовать предикат append для нахождения списка, который следовало бы добавить к списку [3,4] для получения списка[1,2,3,4]. Попробуем такой вызов
<vip>append(L1, [3,4], [1,2,3,4]).</vip>
Visual Prolog находит решение
<vip>L1=[1,2].</vip>

Предикат append определяет отношение между ''входным набором (input set)'' и ''выходным набором (output set)'' таким образом, что отношение применимо в обе стороны. При таком отношении возникает вопрос

''Что является выходным набором для заданного входного?'' или ''Какой входной набор соответствует заданному выходному?''

Статус аргументов данного вызова предиката известен как ''поток (или шаблон) ввода-вывода''. Аргумент, который связан или наследуется в момент вызова является входным аргументом и обозначается как (i). Свободный аргумент является выходным аргументом и обозначается как (o).

Предикат append обладает свойством поддерживать любой шаблон ввода-вывода, какой требуется. Однако не все предикаты имеют возможность вызова с различными шаблонами ввода-вывода. Когда клауз Пролога способен поддерживать множество шаблонов ввода-вывода, он называется инверсным клаузом. Целый набор предикатов для обработки списков содержится в классе '''list'''.

==Все Решения Сразу==

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

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

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

*Первый аргумент, VarName, определяет аргумент в вызываемом целевом предикате, значения которого будут собираться в список.
*Второй - mypredicate - определяет предикат, который будет получать значения.
*Выходной параметр ListParam, является переменной, которая содержит список значений, полученных в ходе отката.

Программа e02.pro использует обработку списка для вывода среднего возраста группы людей.
<vip> /* Программа e02.pro */
class my
domains
name = string.
address = string.
age = integer.

predicates
person : (name, address, age) nondeterm anyflow.
sumlist : (age*, age, integer)procedure(i,o,o).
end class my

implement my
clauses
sumlist([],0,0).
sumlist([H|T], Sum, N):-
sumlist(T, S1, N1),
Sum=H+S1, N=1+N1.

person("Sherlock Holmes","22B Baker Street", 42).
person("Pete Spiers","Apt. 22, 21st Street", 36).
person("Mary Darrow","Suite 2, Omega Home", 51).
end implement my

goal
console::init(),
L = [ Age || my::person(_, _, Age)],
my::sumlist(L, Sum, N),
Ave = Sum/N,
stdio::write("Average=", Ave, ". ").</vip>

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

<vip>List = [ Who || my::person(Who, _, 42) ]</vip>

Следующий код порождает список всех положительных чисел исходного списка:

<vip>List = [ X || X = list::getMember_nd([2,-8,-3,6]), X > 0]</vip>

==Смешанные списки==

Список целых объявляется просто
<vip>integer*</vip>

То же верно и для списков вещественных чисел (integer), символьных (symbol) списков или списков строк (string).

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

<vip>[2, 3, 5.12, ["food", "goo"], "new"].
/* Не корректно для Visual Prolog*/</vip>

''Смешанные списки'' - списки, содержащие элементы более чем одного типа. Для работы со списками разнотипных элементов должны использоваться специальные объявления, поскольку Visual Prolog требует, чтобы все элементы списка принадлежали бы '''''одному и тому же''''' домену. Способом создания списка, который хранит такие различные типы элементов является использование функторов, поскольку домен может представляться '''''более, чем одним''''' функтором, каждый со своими т'''и'''повыми аргументами.

Пример объаявления списка, который может хранить целые, символы, строки или списки таких даных:

<vip>domains
/* функторами являются l, i, c, and s */
llist = l(list); i(integer); c(char); s(string).</vip>
Список
<vip>[ 2, 9, ["food", "goo"], "new" ]
/* Не корректно для Visual Prolog */</vip>
на Visual Prolog следовало бы записать так:

<vip>[i(2), i(9), l([s("food"), s("goo")]), s("new")]
/* Корректно для Visual Prolog */</vip>

Следующий пример предиката append показывает как использовать такого рода декларации в стандартных программах манипулирования списками.

<vip>class my
domains
llist = l(list); i(integer); c(char); s(string).

predicates
append : (A*,A*,A*) procedure (i,i,o).
end class

implement my
clauses
append([], L, L).
append([X|L1], L2, [X|L3]):-
append(L1, L2, L3).
end implement

goal
console::init(),
my::append
(
[my::s("likes"),my::l([my::s("bill"), my::s("mary")])],
[my::s("bill"), my::s("sue")],
Ans
),
stdio::write("Первый список: ", Ans,"\n\n"),
my::append
(
[my::l([my::s("This"),my::s("is"),my::s("a"),my::s("list")]),my::s("bee")],
[my::c('c')],
Ans2
),
stdio::write("Второй списко: ", Ans2, "\n\n&quot).</vip>

==Разбор с использованием списков==

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

Этот разборщик предназначен для примитивного формального языка. Хотя этот пример достаточно сложен с точки зрения этого руководства, мы решили поместит его здесь, поскольку разбор является одной из областей, где Visual Prolog очень эффективен. Если Вы чувствуете себя не вполне готовым для этого раздела, Вы можете этот пример пропустить и продолжить чтение руководства без потери содержательности.

<vip>#include @"pfc\exception\exception.ph"
#include @"pfc\string\string.ph"
#include @"pfc\console\console.ph"

class my_t
predicates
tokl : (string, string*) procedure (i,o).
end class

implement my_t
clauses
tokl(Str, [H|T]) :-
string::fronttoken(Str, H, Str1),
!,
tokl(Str1, T).
tokl(_, []).
end implement

/* * * * * * * * * * * * * * * * * * * * *
* Вторая часть этой программы - разборщик *
* * * * * * * * * * * * * * * * * * * * * */
class my_p
domains
program = program(statement*).
/* * * * * * * * * * * * * * * * * * * * * *
* Определение что есть языковая конструкция *
* (предложение языка) *
* * * * * * * * * * * * * * * * * * * * * * */
statement =
if_Then_Else(exp, statement, statement);
if_Then(exp, statement);
while(exp, statement);
assign(id, exp).
/* * * * * * * * * * * *
* Определение выражения *
* * * * * * * * * * * */
exp =
plus(exp, exp);
minus(exp, exp);
var(id);
int(integer).
id = string.

predicates
s_program : (string*, program) procedure (i,o).
s_statement : (string*, string*, statement) determ (i,o,o).
s_statement_list : (string*, string*, statement*) determ (i,o,o).
s_exp : (string*, string*, exp) determ (i,o,o).
s_exp1 : (string*, string*, exp, exp) determ (i,o,i,o).
s_exp2 : (string*, string*, exp) determ (i,o,o).
end class

implement my_p
clauses
s_program(TokenList, program(StatementList)):-
s_statement_list(TokenList, _, StatementList),
!.
s_program(_, program([])).

clauses
s_statement_list([], [], []) :- !.
s_statement_list(List1, List4, [Statement|Program]) :-
s_statement(List1, List2, Statement),
List2=[";"|List3],
s_statement_list(List3, List4, Program).

clauses
s_statement(["if"|List1], List7,if_then_else(Exp,Statement1, Statement2)):-
s_exp(List1, List2, Exp),
List2=["then"|List3],
s_statement(List3, List4, Statement1),
List4=["else"|List5],!,
s_statement(List5, List6, Statement2),
List6=["fi"|List7].
s_statement(["if"|List1], List5,if_then(Exp, Statement)) :- !,
s_exp(List1, List2, Exp),
List2=["then"|List3],
s_statement(List3, List4, Statement),
List4=["fi"|List5].
s_statement(["do"|List1], List4,while(Exp, Statement)) :- !,
s_statement(List1, List2, Statement),
List2=["while"|List3],
s_exp(List3, List4, Exp).
s_statement([ID|List1], List3,assign(Id,Exp)) :-
string::isname(ID),
List1=["="|List2],
s_exp(List2, List3, Exp).

clauses
s_exp(List1, List3, Exp):-
s_exp2(List1, List2, Exp1),
s_exp1(List2, List3, Exp1, Exp).

clauses
s_exp1(["+"|List1], List3, Exp1, Exp) :- !,
s_exp2(List1, List2, Exp2),
s_exp1(List2, List3, plus(Exp1, Exp2), Exp).
s_exp1(["-"|List1], List3, Exp1, Exp) :- !,
s_exp2(List1, List2, Exp2),
s_exp1(List2, List3, minus(Exp1, Exp2), Exp).
s_exp1(List, List, Exp, Exp).

clauses
s_exp2([Int|Rest], Rest, int(I)) :-
trap(I = toTerm(Int),Error,exception::clear_fail(Error)),
!.
s_exp2([Id|Rest], Rest, var(Id)) :-
string::isname(Id).
end implement

goal
console::init(),
my_t::tokl("b=2; if b then a=1 else a=2 fi; do a=a-1 while a;", Ans),
stdio::write(Ans),
my_p::s_program(Ans, Res),
stdio::write(Res).
</vip>

Загрузите программу и выполните целевой вызов:

<vip>goal
my_t::tokl("b=2; if b then a=1 else a=2 fi; do a=a-1 while a;", Ans),
my_p::s_program(Ans, Res).</vip>

Visual Prolog вернет структуру программы:

<vip>Ans = ["b","=","2",";","if","b","then","a","=","1",
"else","a","=","2","fi",";","do","a","=","a",
"-","1","while","a",";"],
Res=program
(
[assign("b",int(2)),
if_then_else
(
var("b"),
assign("a",int(1)),
assign("a",int(2))
),
while
(
var("a"),
assign
(
"a",
minus
(
var("a"),
int(1)
)
)
)
])
</vip>

Преобразование в этом примере представлено двумя шагами: сканирование и разбор. Предикат tokl - это сканер. Он принимает строку и преобразует ее в список токенов. Все предикаты с именами, начинающимися с s_ являются предикатами парсера. В этом примере входный текст представляет программу на языке, подобном языку Паскаль, и состоящей из Паскале-подобных предложений. Этот язык программирования позволяет только предложения вида: IF THEN ELSE, IF THEN, DO WHILE и присваивание (ASSIGNMENT). Предложения состоят из выражений и вложенных предложений. Выражения - сложение, вычитание, переменные и целые.

Далее, как это работает:

*Первый клауз парсера, s_program, принимает список токенов и пытается преобразовать его в список предложений.
*Предикат s_statement_list принимает тот же самый список токенов и проверяет возможность деления токенов на предложения, завершающиеся точкой с запятой.
*Предикат s_statement проверяет могут ли начальные токены списка (токенов) представлять собой правильное предложение. Если да, то такое предложение возвращается в виде структуры, а остаток токенов передается рекурсивно вызываемому предикату s_statement_list.
*Четыре клауза предиката s_statement соответствуют четырем типам, которые парсер понимает.<br\> Если первый клауз предиката s_statement не может преобразовать список токенов в предложение вида IF THEN ELSE, то клауз завершается неуспешно и в порядке отката переходит к следующему клаузу предиката s_statement. Теперь делается попытка преобразовать список токенов в конструкцию вида IF THEN. Если эта попытка неуспешна, то в следующем клаузе делается попытка преобразования к предложению вида DO WHILE.
*Если первые три клауза предиката s_statement завершаются неуспешно, то последний клауз этого предиката провереяет представлена ли в списке токенов операция присваивания. Этот клауз проверяет "на присваивание" является ли первый терм символом, второй - знаком равно ("="), а следующие термы представляют простое математическое выражение.
*Предикаты s_exp, s_exp1 и s_exp2 работают аналогично, путем проверки являются ли начальные термы выражениями и, если это так, то предикату s_statement предикат s_exp возвращает остаток термов и математическое выражение в виде структуры.

==Заключение==

В этом руководстве раскрыта следующие важные моменты:

*''Списки'' могут содержать произвольное число элементов; Вы объявляете их простым добавление звездочки ('''*''') в конце ранее определённого домена.
*Список является рекурсивным составным объектом, состоящим из головы и хвоста. Голова есть первый элемент, а хвост - остальная часть списка (без первого элемента). Хвост списка - всегда список; голова списка - всегда элемента. Список может содержать ноль или более элементов; Пустой список обозначается [].
*Элементами списка может быть что угодно, включая другие списки; все элементы списка должны принадлежать одному домену. В этом случае объявление домена элементов должно выглядеть так:

<vip>domains
element_list = elements*.
elements = ....</vip>

где elements = один из стандартных доменов (integer, real, etc.) или набор альтернатив обозначенных различными функторами (int(integer); rl(real); smb(symbol); и т.д.). Смешение типов в списках языка системы Visual Prolog допускается только включением их в составные объекты или функторы.
*Можно использовать разделители (запятые, [ и |) для явного отделения головы списка от хвоста. Так, список
<vip>[a, b, c, d]</vip>
может быть записан как:
<vip>
[a|[b, c, d]]
или
[a, b|[c, d]]
или
[a, b, c|[d]]
или
[a|[b|[c, d]]]
или
[a|[b|[c|[d]]]]
или даже
[a|[b|[c|[d|[]]]]]</vip>
*Обработка списков заключается в рекурсивном отщеплении головы списка (и выполнении действий над ней) до опустошения списка.
*Предикаты для работы со списками содержаться в классе '''list'''.
*Visual Prolog поддерживает встроенную конструкцию обработки списков, которая принимает целевой предикат в качестве одного из аргументов и собирает все решения этого целевого предиката в едином списке. Синтаксис такой конструкции
<vip>Result = [ Argument || myPredicate(Argument) ]</vip>
*Поскольку Visual Prolog требует, чтобы все элементы списка принадлежали бы одному и тому же домену, следует использовать функторы для создания списков, хранящих элементы различного типа.
*процесс ''разбора с использованием разностных списков (parsing by difference lists)'' работает путем сокращения задачи; пример в этом руководстве преобразует строку входных данных в структуру, которая может обрабатываться позже.

==References==
[[en:Lists and Recursion]]
[[Категория:VipРуководства]]
[[Категория:VipLanguage]]

Списки и рекурсия

2007-11-23T10:59:53Z

SergeMukhin: очепятки

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

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

==Что такое Список?==

В Прологе ''список (list)'' является объектом, содержащим внутри произвольное число других объектов. Списки соответствуют, грубо говоря, массивам в других языках, но, в отличие от массивов, список не трубует декларирования его размера до начала его использования.

Список, содержащий числа 1, 2 и 3 записывается как
<vip>[ 1, 2, 3 ]</vip>

Порядок элементов в этом списке значим:
*Число "1" является первым элементом,
*"2" - второй,
*"3" - третий.

Список [ 1, 2, 3 ] и список [ 1, 3, 2 ] различны.

Каждый компонент списка называется элемент (element). Для того, чтобы сформировать списковую структуру данных, следует разделять элементы запятыми и заключать их всех в квадратные скобки. Посмотрим на некоторые примеры:
<vip>["dog", "cat", "canary"]
["valerie ann", "jennifer caitlin", "benjamin thomas"]</vip>
Один и тот же элемент может быть представлен в списке несколько раз, например:
<vip>[ 1, 2, 1, 3, 1 ]</vip>

===Объявление Списков===
Для объявления домена - списка целых используется декларация домена, как показано ниже:
<vip>domains
integer_list = integer*.</vip>

Звездочка означает "список этого"; то есть, integer* означает "список целых".

Обратите внимание на то, что слово ''"list"'' не имеет специального значения в Visual Prolog. Вы равным образом могли бы назвать Ваш списковый домен как ''zanzibar''. Именно звездочка, а не имя, предписывает этому домену быть списком.

Элементами в списке может быть что угодно, включая другие списки. Но все элементы в списке должны принадлежать одному домену, и дополнительно к декларации спискового домена должна быть декларация '''domains''' для элементов:
<vip>domains
element_list = elements*.
elements = ....</vip>

Здесь ''elements'' должны быть приравнены к простым доменным типам (например, integer, real или symbol) или к набору возможных альтернатив, обозначенных различными функторами. Visual Prolog не допускает смешивание стандартных типов в списке. Например, следующие декларации ошибочно представляют списки, созданные из integers, reals и symbols:

<vip>element_list = elements*.
elements =
integer;
real;
symbol.
/* Неправильно */</vip>

Выходом для объявления списков из integer, real и symbols является объявление домена общего для всех типов, где функтор показывает какому типу принадлежит тот или иной элемент. Например:

<vip>element_list = elements*.
elements =
i(integer);
r(real);
s(symbol).
/* функторами являются i, r и s */</vip>

(Подробнее об этом - в этом же руководстве в разделе "Составные списки").

====Головы и Хвосты====

Список на самом деле является рекурсивным составным объетом. Он состоит из двух частей - головы списка, которым является первый элемент, и хвоста - списка, который включает все следующие элементы.

'''''Хвост списка всегда есть список; голова списка есть элемент.'''''

Например,

<vip>голова списка [a, b, c] есть a
хвост списка [a, b, c] есть [b, c]</vip>

Что происходит, когда мы имеем дело со списком, содержащим один элемент? Ответом является:

<vip>головой списка [c] является c
хвостом списка [c] является []</vip>

'''''Если многократно отнимать первый элемент от хвоста списка, мы получим в конечном итоге пустой список ('''[ ]''').'''''

'''''Пустой список не может быть разбит на голову и хвост.'''''

Это означает, что, концептуально говоря, списки имеют древовидную структуру подобно другим составным объектам. Древовидная структура списка [a, b, c, d] есть:

<pre> list
/ \
a list
/ \
b list
/ \
c list
/ \
d []</pre>
Более того, одноэлементный список, такой как [a] - это не тот же самый элемент, который этот список содержит, поскольку [a] является действительно составной структурой данных, как это видно здесь:

<pre> list
/ \
a []</pre>

==Представления Списков==

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

[a, b, c] эквивалентно [a|[b, c]]

и, продолжая процесс,

[a|[b,c]] эквивалентно [a|[b|[c]]],

что эквивалентно [a|[b|[c|[]]]]

Можно даже использовать оба способа разделения в одном и том же списке, рассматривая вертикальную черту как разделитель самого низкого уровня. Следовательно, можно записать [a, b, c, d] как [a, b|[c, d]]. Таблица 1 дает дополнительные примеры.

{|cellpadding="5" cellspacing="0" border="1"
|+'''Таблица 1: Головы и Хвосты списков'''
!Список
!Голова
!Хвост
|-
|['a', 'b', 'c']
|'a'
|['b', 'c']
|-
|[ 'a' ]
|'a'
|[]
|-
|/*пустой список*/ [ ]
|неопределен
|неопределен
|-
|[[1, 2, 3], [2, 3, 4], []]
|[1, 2, 3]
|[[2, 3, 4], []]

|}

В Таблице 2 приведены некоторые примеры унификации списков.

{|cellpadding="5" cellspacing="0" border="1"
|+'''Таблица 2: Унификация Списков'''
!Список 1
!Список 2
!Связывание Переменных
|-
|[X, Y, Z]
|[эгберт, ест, мороженое]
|X=эгберт, Y=ест, Z=мороженое
|-
|[7]
|[X <nowiki>|</nowiki> Y]
|X=7, Y=[]
|-
|[1, 2, 3, 4]
|[X, Y <nowiki>|</nowiki> Z]
|X=1, Y=2, Z=[3,4]
|-
|[1, 2]
|[3 <nowiki>|</nowiki> X]
|fail
|}

==Использование Списков==

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

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

===Вывод Списков на печать===

Например, если Вы хотите только вывести на печать элементы списка, то вот что Вы делаете:

<vip>class my
predicates
write_a_list : (integer*).
end class

implement my
clauses
write_a_list([]). /* Если список пустой, ничего не делаем. */
write_a_list([H|T]):- /* Сопоставляем голову с H и хвост с T, и... */
stdio::write(H),stdio::nl, /*выводим H и переводим строку*/
write_a_list(T).
end implement

goal
console::init(),
my::write_a_list([1, 2, 3]).</vip>

Здесь мы видим два клауза write_a_list, которые можно выразить но обычном языке:

*Для вывода на печать пустого списка ничего не надо делать.
*Иначе, для вывода на печать списка, вывести на печать его голову (она есть просто элемент), и потом вывести на печать хвост списка (он, как известно, есть список).

Первый раз, когда вызывается:

<vip>my::write_a_list([1, 2, 3]).</vip>

такой вызов сопоставляется со вторым клаузом, с головой H=1 и T=[2, 3]. Это приводит к выводу на печать 1, затем рекурсивно вызывается write_a_list с аргументом в виде хвоста списка:

<vip>my::write_a_list([2, 3]).
/* Это вызов write_a_list(T). */</vip>

Этот второй вызов опять сопоставляется со вторым клаузом, где, на этот раз H=2 и T=[3], поэтому выводится 2 и опять рекурсивно вызывается write_a_list:

<vip>my::write_a_list([3]).</vip>

С каким клаузом теперь такой вызов сопоставлятся? Напомним, что, хотя список [3] имеет всего один элемент, у него есть голова и хвост - голова есть 3, а хвост есть []. Таким образом, этот вызов опять сопоставляется со вторым клаузом с H=3 и T=[]. Теперь выводится 3 и вызывается рекурсивно write_a_list:

<vip>my::write_a_list([]).</vip>

Теперь становится понятно для чего нужен первый клауз. Второй клауз не может быть сопоставлен с таким вызовом, поскольку [] не может быть разделен на голову и хвост. Если бы первого клазуа здесь не было бы, то выполнение goal оказалось бы неуспешным. Но, поскольку он есть, то первый клауз сопоставляется с вызовом и выполнение goal успешно завершается и нечего более не делается.

===Подсчет элементов в Списке===

Рассмотрим теперь, как подсчитать число элементов в списке, или какова длина списка? Логично определить:

*Длина пустого списка [] есть 0.<br />
*Длина любого другого списка есть 1 плюс длина его хвоста.

Можно ли это запрограммировать? На Прологе это очень просто. Всего два клауза:

<vip>class my
predicates
length_of : (A*, integer) procedure(i,o).
end class

implement my
clauses
length_of([], 0).
length_of([_|T], L):-
length_of(T, TailLength),
L = TailLength + 1.
end implement

goal
console::init(),
my::length_of([1, 2, 3], L),
stdio::write(L).</vip>

Посмотрите прежде всего на второй клауз. Строго говоря, [_|T] сопоставляется с любым непустым списком, связывая T с хвостом списка. Значение головы неважно, если она есть, она может быть учтена как один элемент.

Тогда вызов:

<vip>my::length_of([1, 2, 3], L)</vip>

сопоставляется со вторым клаузом, с T=[2, 3]. Следующим шагом является вычисление длины хвоста T. Когда это сделано (не имеет значение, как), TailLength получит значение 2, и компьютер теперь может добавить 1 к ней и связать L со значением 3. Как выполняется этот промежуточный шаг? Надо найти длину списка [2, 3], путем удовлетворения цели

<vip>my::length_of([2, 3], TailLength)</vip>

Другими словами, length_of вызывает себя рекурсивно. Этот вызов сопоставляется со вторым клаузом, связывая

*[3] и T в вызове клаузы и
*TailLength с L в клаузе.

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

Итак, теперь задача - найти длину списка [3], которая есть 1, и мы добавляем 1 к этому значению, чтобы получить длину списка [2, 3], что будет 2. Ну и хорошо!.

Аналогично, length_of вызывает себя рекурсивно опять для получения длины списка [3]. Хвост [3] есть [], поэтому T связвается с [], и задача теперь - получение длины списка [] и добавление к ней 1, что дает длину списка [3].

Теперь все просто. Цель:

<vip>my::length_of([], TailLength)</vip>

сопоставляется с ''первым'' клаузом, связывая TailLength с 0. Поэтому теперь компьютер может добавить 1 к нему, получая длину списка [3], и возвращаясь теперь в вызывавший клауз. Это, в свою очередь, опять добавляет 1, давая длину списка [2, 3], и возвращается в клауз, который его вызывал; этот первоначальный клауз добавит снова 1, давая длину списка [1, 2, 3].

Не растерялись? Мы надеемся, нет. В следующей короткой иллюстрации мы сводим воедино все вызовы. Мы использовали здесь прием подстрочника для того, чтобы показать, что аналогично называемые переменные в разных клаузах или различные вызовы того же самого клауза - одно и то же.
<vip>my::length_of([1, 2, 3], L1).
my::length_of([2, 3], L2).
my::length_of([3], L3).
my::length_of([], 0).
L3 = 0+1 = 1.
L2 = L3+1 = 2.
L1 = L2+1 = 3.</vip>

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

===Хвостовая рекурсия===

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

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

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

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

<vip>class my
predicates
length_of : (A*, integer, integer) procedure(i,o,i).
end class

implement my
clauses
length_of([], Result, Result).
length_of([_|T], Result, Counter):-
NewCounter = Counter + 1,
length_of(T, Result, NewCounter).
end implement

goal
console::init(),
my::length_of([1, 2, 3], L, 0), /* Начинаем со счетчиком Counter = 0 */
stdio::write(" L = ", L).</vip>

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

===Модификация Списка===

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

<vip>class my
predicates
add1 : (integer*, integer*) procedure(i,o).
end class

implement my
clauses
add1([], [])./* граничное условие */
add1([Head|Tail],[Head1|Tail1]):- /* отделяем голову от остального списка*/
Head1 = Head+1, /* добавляем 1 к элементу-голове */
add1(Tail, Tail1)./* далаем это с остальной частью списка*/
end implement

goal
console::init(),
my::add1([1,2,3,4], NewList),
stdio::write(NewList)).</vip>

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

Загрузим программу и выполним такую цель
<vip>add1([1,2,3,4], NewList).</vip>

Цель вернет
<vip>NewList=[2,3,4,5]
1 Solution</vip>

===Опять о хвостовой рекурсии===

Является ли предикат add1 проедикатом с хвостовой рекурсией?
Если у Вас есть опыт использования Lisp или Pascal, Вы могли бы подумать, что нет, поскольку Вы бы рассуждали так:

*Делим список на ''Head'' и ''Tail''.
*Добавляем 1 к ''Head'', получаем ''Head1''.
*Рекурсивно добавляя 1 ко всем элементам списка ''Tail'', получаем ''Tail1''.
*Соединяем ''Head1'' и ''Tail1'', что дает результирующий список.

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

Однако, и это важно, – '''''Это не то, что делает Пролог'''''. В Visual Prolog add1 является предикатом с хвостовой рекурсией, поскольку выполняется в действительности следующим образом:

*Связать голову и хвост исходного списка с ''Head'' и ''Tail'', соответственно.
*Связать голову и хвост результирующего списка с ''Head1'' и ''Tail1'', соответственно. (''Head1'' и ''Tail1'' пока не получили значений.)
*Добавить 1 к ''Head'', что дает ''Head1''.
*Рекурсивно добавить 1 ко всем элементам списка ''Tail'', что дает ''Tail1''.

Когда это сделано, ''Head1'' и ''Tail1'' '''уже являются''' головой и списком результата и отдельной операции по их соединению нет. Поэтому рекурсивный вызов и является последним шагом.

<h6>Снова Модификация Списков</h6>

Конечно, не всегда модификации подлежит каждый элемент. Посмотрим на программу, которая сканирует список чисел и копирует его, удаляя отрицательные числа:

<vip>class my
predicates
discard_negatives : (integer*, integer*) procedure(i,o). /*удалить отрицательные*/
end class

implement my
clauses
discard_negatives([], []).
discard_negatives([H|T], ProcessedTail):-
H < 0,
!, /* Если H отрицательно, пропускаем его */
discard_negatives(T, ProcessedTail).
discard_negatives([H|T], [H|ProcessedTail]):-
discard_negatives(T, ProcessedTail).
end implement

goal
console::init(),
my::discard_negatives ([2, -45, 3, 468], X),
stdio::write(X).</vip>

Напрмер, цель
<vip>my::discard_negatives([2, -45, 3, 468], X)</vip>
дает
<vip>X=[2, 3, 468].</vip>

А вот - предикат который копирует элементы списка, добавляя для каждого элемента его дубликат:
<vip>doubletalk([], []).
doubletalk([H|T], [H, H|DoubledTail]) :-
doubletalk(T, DoubledTail).</vip>

===Принадлежнось списку===

Допустим, имеется список с именами ''John'', ''Leonard'', ''Eric'' и ''Frank'' и требуется, используя Visual Prolog, выяснить, принадлежит ли заданное имя этому списку. Другими словами, надо определить "отношение" между двумя аргументами: именем и списком имен. Это соответствует предикату

<vip>isMember : (name, name*).
/* "name" принадлежит списку "name*" */</vip>

В программе e01.pro первый клауз исследует голову списка. Если голова списка совпадает с искомым именем, то можно сделать заключение, что Name принадлежит списку. Поскольку хвост списка нас не интересует, то это мы представляем анонимной переменной. Благодаря первому клаузу, цель

<vip>my::isMember("john", ["john", "leonard", "eric", "frank"])</vip>

удовлетворена.

<vip>/* Программа e01.pro */
class my
predicates
isMember : (A, A*) determ.
end class

implement my
clauses
isMember(Name, [Name|_]) :-
!.
isMember(Name, [_|Tail]):-
isMember(Name,Tail).
end implement

goal
console::init(),
my::isMember("john", ["john", "leonard", "eric", "frank"]),
!,
stdio::write("Success")
;
stdio::write("No solution").
</vip>

Если голова списка не есть Name, то надо исследовать, не содержится ли Name в хвосте списка.

На обычном языке:

Name принадлежит списку, если Name является первым элементом списка, или<br />
Name принадлежит списку, если Name принадлежит хвосту.

Второй клауз предиката isMember относится к этому отношению. Таким образом на Visual Prolog:

<vip>isMember(Name, [_|Tail]) :-
isMember(Name, Tail).</vip>

===Добавление списка к другому списку: декларативное и рекурсивное решения===

Рассмотренный предикат member программы e01.pro работает в двух направлениях. Вернемся к его клаузам:

<vip>
member(Name, [Name|_]).
member(Name, [_|Tail]) :-
member(Name, Tail).
</vip>

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

*С декларативной точки зрения, клаузы выражают:
**Name (Имя) принадлежит списку, если голова списка есть Name
**иначе Name принадлежит списку, если оно (Имя) принадлежит хвосту.
*С процедурной точки зрения, эти же два клауза могут быть интерпретированы так:<br/>Чтобы найти элемент списка
**Найдите его голову
**иначе найдите элемент хвоста списка.

Эти две точки зрения соответствуют целям
<vip>member(2, [1, 2, 3, 4]).</vip>
и
<vip>member(X, [1, 2, 3, 4]).</vip>

В результате первый вызов поручает Visual Prolog(у) проверить, истино ли нечто (принадлежность числа 2 списку [1,2,3,4]). Второй вызов поручает Visual Prolog(у) найти все члены списка [1,2,3,4]. Не смущайтесь этим. Предикат member является одним и тем же, но на его поведение можно смотреть под разными углами.

====Рекурсия с процедуральной точки зрения====

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

<vip>append(List1, List2, List3).</vip>

Этот предикат интегрирует списки List1 и List2 в форму списка List3 так, что список List2 дописывается в конце списка List1. То есть содержательно - осуществляется добавление списка List2 к списку LIst1. Опять мы используем рекурсию (на этот раз с процедуральной точки зрения).

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

<vip>append([], List2, List2).</vip>

Если список List1 не пустой, то можно преобразовать списки List1 и List2 к форме списка ''List3'', сделав голову списка List1 головой списка List3. В приведенном коде переменная H используется в качестве головы как списка List1, так и списка List3. хвост списка List3 есть список L3, который составлен из остатка списка List1 (а именно, L1) и всего списка List2. Опять выразим это на Прологе:

<vip>append([H|L1], List2, [H|L3]) :-
append(L1, List2, L3).</vip>

Предикат append работает следующим образом: пока список List1 не пустой, рекурсивное правило дописывает один элемент каждый раз к списку List3. Когда список List1 становится пустым, первый клауз clause обеспечивает дописывание списка List2 в конец списка List3.

====Варианты использования одного предиката====

Подходя к предикату append с декларативной точки зрения, мы определили его как отношение между тремя списками. Это отношение справедливо также, если списки List1 и List3 известны, а List2 - нет. Более того, это также работает, если только List3 известен. Например, для того, чтобы выяснить, какие два списка могли бы быть соединены для получения известного списка, можно использовать вызов в форме
<vip>append(L1, L2, [1, 2, 4]).</vip>

С таким целевым вызовом, Visual Prolog найдет следующие решения:

<vip>
L1=[], L2=[1,2,4]
L1=[1], L2=[2,4]
L1=[1,2], L2=[4]
L1=[1,2,4], L2=[]
4 Solutions
</vip>

Можно использовать предикат append для нахождения списка, который следовало бы добавить к списку [3,4] для получения списка[1,2,3,4]. Попробуем такой вызов
<vip>append(L1, [3,4], [1,2,3,4]).</vip>
Visual Prolog находит решение
<vip>L1=[1,2].</vip>

Предикат append определяет отношение между ''входным набором (input set)'' и ''выходным набором (output set)'' таким образом, что отношение применимо в обе стороны. При таком отношении возникает вопрос

''Что является выходным набором для заданного входного?'' или ''Какой входной набор соответствует заданному выходному?''

Статус аргументов данного вызова предиката известен как ''поток (или шаблон) ввода-вывода''. Аргумент, который связан или наследуется в момент вызова является входным аргументом и обозначается как (i). Свободный аргумент является выходным аргументом и обозначается как (o).

Предикат append обладает свойством поддерживать любой шаблон ввода-вывода, какой требуется. Однако не все предикаты имеют возможность вызова с различными шаблонами ввода-вывода. Когда клауз Пролога способен поддерживать множество шаблонов ввода-вывода, он называется инверсным клаузом. Целый набор предикатов для обработки списков содержится в классе '''list'''.

==Все Решения Сразу==

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

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

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

*Первый аргумент, VarName, определяет аргумент в вызываемом целевом предикате, значения которого будут собираться в список.
*Второй - mypredicate - определяет предикат, который будет получать значения.
*Выходной параметр ListParam, является переменной, которая содержит список значений, полученных в ходе отката.

Программа e02.pro использует обработку списка для вывода среднего возраста группы людей.
<vip> /* Программа e02.pro */
class my
domains
name = string.
address = string.
age = integer.

predicates
person : (name, address, age) nondeterm anyflow.
sumlist : (age*, age, integer)procedure(i,o,o).
end class my

implement my
clauses
sumlist([],0,0).
sumlist([H|T], Sum, N):-
sumlist(T, S1, N1),
Sum=H+S1, N=1+N1.

person("Sherlock Holmes","22B Baker Street", 42).
person("Pete Spiers","Apt. 22, 21st Street", 36).
person("Mary Darrow","Suite 2, Omega Home", 51).
end implement my

goal
console::init(),
L = [ Age || my::person(_, _, Age)],
my::sumlist(L, Sum, N),
Ave = Sum/N,
stdio::write("Average=", Ave, ". ").</vip>

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

<vip>List = [ Who || my::person(Who, _, 42) ]</vip>

Следующий код порождает список всех положительных чисел исходного списка:

<vip>List = [ X || X = list::getMember_nd([2,-8,-3,6]), X > 0]</vip>

==Смешанные списки==

Список целых объявляется просто
<vip>integer*</vip>

То же верно и для списков вещественных чисел (integer), символьных (symbol) списков или списков строк (string).

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

<vip>[2, 3, 5.12, ["food", "goo"], "new"].
/* Не корректно для Visual Prolog*/</vip>

''Смешанные списки'' - списки, содержащие элементы более чем одного типа. Для работы со списками разнотипных элементов должны использоваться специальные объявления, поскольку Visual Prolog требует, чтобы все элементы списка принадлежали бы '''''одному и тому же''''' домену. Способом создания списка, который хранит такие различные типы элементов является использование функторов, поскольку домен может представляться '''''более, чем одним''''' функтором, каждый со своими т'''и'''повыми аргументами.

Пример объаявления списка, который может хранить целые, символы, строки или списки таких даных:

<vip>domains
/* функторами являются l, i, c, and s */
llist = l(list); i(integer); c(char); s(string).</vip>
Список
<vip>[ 2, 9, ["food", "goo"], "new" ]
/* Не корректно для Visual Prolog */</vip>
на Visual Prolog следовало бы записать так:

<vip>[i(2), i(9), l([s("food"), s("goo")]), s("new")]
/* Корректно для Visual Prolog */</vip>

Следующий пример предиката append показывает как использовать такого рода декларации в стандартных программах манипулирования списками.

<vip>class my
domains
llist = l(list); i(integer); c(char); s(string).

predicates
append : (A*,A*,A*) procedure (i,i,o).
end class

implement my
clauses
append([], L, L).
append([X|L1], L2, [X|L3]):-
append(L1, L2, L3).
end implement

goal
console::init(),
my::append
(
[my::s("likes"),my::l([my::s("bill"), my::s("mary")])],
[my::s("bill"), my::s("sue")],
Ans
),
stdio::write("Первый список: ", Ans,"\n\n"),
my::append
(
[my::l([my::s("This"),my::s("is"),my::s("a"),my::s("list")]),my::s("bee")],
[my::c('c')],
Ans2
),
stdio::write("Второй списко: ", Ans2, "\n\n&quot).</vip>

==Разбор с использованием списков==

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

Этот разборщик предназначен для примитивного формального языка. Хотя этот пример достаточно сложен с точки зрения этого руководства, мы решили поместит его здесь, поскольку разбор является одной из областей, где Visual Prolog очень эффективен. Если Вы чувствуете себя не вполне готовым для этого раздела, Вы можете этот пример пропустить и продолжить чтение руководства без потери содержательности.

<vip>#include @"pfc\exception\exception.ph"
#include @"pfc\string\string.ph"
#include @"pfc\console\console.ph"

class my_t
predicates
tokl : (string, string*) procedure (i,o).
end class

implement my_t
clauses
tokl(Str, [H|T]) :-
string::fronttoken(Str, H, Str1),
!,
tokl(Str1, T).
tokl(_, []).
end implement

/* * * * * * * * * * * * * * * * * * * * *
* Вторая часть этой программы - разборщик *
* * * * * * * * * * * * * * * * * * * * * */
class my_p
domains
program = program(statement*).
/* * * * * * * * * * * * * * * * * * * * * *
* Определение что есть языковая конструкция *
* (предложение языка) *
* * * * * * * * * * * * * * * * * * * * * * */
statement =
if_Then_Else(exp, statement, statement);
if_Then(exp, statement);
while(exp, statement);
assign(id, exp).
/* * * * * * * * * * * *
* Определение выражения *
* * * * * * * * * * * */
exp =
plus(exp, exp);
minus(exp, exp);
var(id);
int(integer).
id = string.

predicates
s_program : (string*, program) procedure (i,o).
s_statement : (string*, string*, statement) determ (i,o,o).
s_statement_list : (string*, string*, statement*) determ (i,o,o).
s_exp : (string*, string*, exp) determ (i,o,o).
s_exp1 : (string*, string*, exp, exp) determ (i,o,i,o).
s_exp2 : (string*, string*, exp) determ (i,o,o).
end class

implement my_p
clauses
s_program(TokenList, program(StatementList)):-
s_statement_list(TokenList, _, StatementList),
!.
s_program(_, program([])).

clauses
s_statement_list([], [], []) :- !.
s_statement_list(List1, List4, [Statement|Program]) :-
s_statement(List1, List2, Statement),
List2=[";"|List3],
s_statement_list(List3, List4, Program).

clauses
s_statement(["if"|List1], List7,if_then_else(Exp,Statement1, Statement2)):-
s_exp(List1, List2, Exp),
List2=["then"|List3],
s_statement(List3, List4, Statement1),
List4=["else"|List5],!,
s_statement(List5, List6, Statement2),
List6=["fi"|List7].
s_statement(["if"|List1], List5,if_then(Exp, Statement)) :- !,
s_exp(List1, List2, Exp),
List2=["then"|List3],
s_statement(List3, List4, Statement),
List4=["fi"|List5].
s_statement(["do"|List1], List4,while(Exp, Statement)) :- !,
s_statement(List1, List2, Statement),
List2=["while"|List3],
s_exp(List3, List4, Exp).
s_statement([ID|List1], List3,assign(Id,Exp)) :-
string::isname(ID),
List1=["="|List2],
s_exp(List2, List3, Exp).

clauses
s_exp(List1, List3, Exp):-
s_exp2(List1, List2, Exp1),
s_exp1(List2, List3, Exp1, Exp).

clauses
s_exp1(["+"|List1], List3, Exp1, Exp) :- !,
s_exp2(List1, List2, Exp2),
s_exp1(List2, List3, plus(Exp1, Exp2), Exp).
s_exp1(["-"|List1], List3, Exp1, Exp) :- !,
s_exp2(List1, List2, Exp2),
s_exp1(List2, List3, minus(Exp1, Exp2), Exp).
s_exp1(List, List, Exp, Exp).

clauses
s_exp2([Int|Rest], Rest, int(I)) :-
trap(I = toTerm(Int),Error,exception::clear_fail(Error)),
!.
s_exp2([Id|Rest], Rest, var(Id)) :-
string::isname(Id).
end implement

goal
console::init(),
my_t::tokl("b=2; if b then a=1 else a=2 fi; do a=a-1 while a;", Ans),
stdio::write(Ans),
my_p::s_program(Ans, Res),
stdio::write(Res).
</vip>

Загрузите программу и выполните целевой вызов:

<vip>goal
my_t::tokl("b=2; if b then a=1 else a=2 fi; do a=a-1 while a;", Ans),
my_p::s_program(Ans, Res).</vip>

Visual Prolog вернет структуру программы:

<vip>Ans = ["b","=","2",";","if","b","then","a","=","1",
"else","a","=","2","fi",";","do","a","=","a",
"-","1","while","a",";"],
Res=program
(
[assign("b",int(2)),
if_then_else
(
var("b"),
assign("a",int(1)),
assign("a",int(2))
),
while
(
var("a"),
assign
(
"a",
minus
(
var("a"),
int(1)
)
)
)
])
</vip>

Преобразование в этом примере представлено двумя шагами: сканирование и разбор. Предикат tokl - это сканер. Он принимает строку и преобразует ее в список токенов. Все предикаты с именами, начинающимися с s_ являются предикатами парсера. В этом примере входный текст представляет программу на языке, подобном языку Паскаль, и состоящей из Паскале-подобных предложений. Этот язык программирования позволяет только предложения вида: IF THEN ELSE, IF THEN, DO WHILE и присваивание (ASSIGNMENT). Предложения состоят из выражений и вложенных предложений. Выражения - сложение, вычитание, переменные и целые.

Далее, как это работает:

*Первый клауз парсера, s_program, принимает список токенов и пытается преобразовать его в список предложений.
*Предикат s_statement_list принимает тот же самый список токенов и проверяет возможность деления токенов на предложения, завершающиеся точкой с запятой.
*Предикат s_statement проверяет могут ли начальные токены списка (токенов) представлять собой правильное предложение. Если да, то такое предложение возвращается в виде структуры, а остаток токенов передается рекурсивно вызываемому предикату s_statement_list.
*Четыре клауза предиката s_statement соответствуют четырем типам, которые парсер понимает.<br\> Если первый клауз предиката s_statement не может преобразовать список токенов в предложение вида IF THEN ELSE, то клауз завершается неуспешно и в порядке отката переходит к следующему клаузу предиката s_statement. Теперь делается попытка преобразовать список токенов в конструкцию вида IF THEN. Если эта попытка неуспешна, то в следующем клаузе делается попытка преобразования к предложению вида DO WHILE.
*Если первые три клауза предиката s_statement завершаются неуспешно, то последний клауз этого предиката провереяет представлена ли в списке токенов операция присваивания. Этот клауз проверяет "на присваивание" является ли первый терм символом, второй - знаком равно ("="), а следующие термы представляют простое математическое выражение.
*Предикаты s_exp, s_exp1 и s_exp2 работают аналогично, путем проверки являются ли начальные термы выражениями и, если это так, то предикату s_statement предикат s_exp возвращает остаток термов и математическое выражение в виде структуры.

==Заключение==

В этом руководстве раскрыта следующие важные моменты:

*''Списки'' могут содержать произвольное число элементов; Вы объявляете их простым добавление звездочки ('''*''') в конце ранее определенного домена.
*Список является рекурсивным составным объектом, состоящим из головы и хвоста. Голова есть первый элемент, а хвост - остальная часть списка (без первого элемента). Хвост списка - всегда список; голова списка - всегда элемента. Список может содержать ноль или более элементов; Пустой список обозначается [].
*Элементами списка можже быть что угодно, включая другиме списки; все элементы списка должны принадлежать одному домену. В этом случае объявление домена элементов должно выглядеть так:

<vip>domains
element_list = elements*.
elements = ....</vip>

где elements = один из стандартных доменов (integer, real, etc.) или набор альтернатив обозначенных различными функторами (int(integer); rl(real); smb(symbol); и т.д.). Смешение типов в списках языка системы Visual Prolog допускается только включением их в составные объекты или функторы.
*Можно использовать разделители (запятые, [ и |) для явного отделения головы списка от хвоста. Так, список
<vip>[a, b, c, d]</vip>
может быть записан как:
<vip>
[a|[b, c, d]]
или
[a, b|[c, d]]
или
[a, b, c|[d]]
или
[a|[b|[c, d]]]
или
[a|[b|[c|[d]]]]
или даже
[a|[b|[c|[d|[]]]]]</vip>
*Обработка списков заключается в рекурсивном отщеплении головы списка (и выполнении действий над ней) до опустошения списка.
*Предикаты для работы со списками содержаться в классе '''list'''.
*Visual Prolog поддерживает встроенную конструкцию обработки списков, которая принимает целевой предикат в качестве одного из аргументов и собирает все решения этого целевого предиката в едином списке. Синтаксис такой конструкции
<vip>Result = [ Argument || myPredicate(Argument) ]</vip>
*Поскольку Visual Prolog требует, чтобы все элементы списка принадлежали бы одному и тому же домену, следует использовать функторы для создания списков, хранящих элементы различного типа.
*процесс ''разбора с использованием разностных списков (parsing by difference lists)'' работает путем сокращения задачи; пример в этом руководстве преобрахует строку входных данных в структуру, которая может обрабатываться позже.

==References==
[[en:Lists and Recursion]]
[[Категория:VipРуководства]]
[[Категория:VipLanguage]]

Списки и рекурсия

2007-11-23T10:57:49Z

SergeMukhin: очепятки

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

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

==Что такое Список?==

В Прологе ''список (list)'' является объектом, содержащим внутри произвольное число других объектов. Списки соответствуют, грубо говоря, массивам в других языках, но, в отличие от массивов, список не трубует декларирования его размера до начала его использования.

Список, содержащий числа 1, 2 и 3 записывается как
<vip>[ 1, 2, 3 ]</vip>

Порядок элементов в этом списке значим:
*Число "1" является первым элементом,
*"2" - второй,
*"3" - третий.

Список [ 1, 2, 3 ] и список [ 1, 3, 2 ] различны.

Каждый компонент списка называется элемент (element). Для того, чтобы сформировать списковую структуру данных, следует разделять элементы запятыми и заключать их всех в квадратные скобки. Посмотрим на некоторые примеры:
<vip>["dog", "cat", "canary"]
["valerie ann", "jennifer caitlin", "benjamin thomas"]</vip>
Один и тот же элемент может быть представлен в списке несколько раз, например:
<vip>[ 1, 2, 1, 3, 1 ]</vip>

===Объявление Списков===
Для объявления домена - списка целых используется декларация домена, как показано ниже:
<vip>domains
integer_list = integer*.</vip>

Звездочка означает "список этого"; то есть, integer* означает "список целых".

Обратите внимание на то, что слово ''"list"'' не имеет специального значения в Visual Prolog. Вы равным образом могли бы назвать Ваш списковый домен как ''zanzibar''. Именно звездочка, а не имя, предписывает этому домену быть списком.

Элементами в списке может быть что угодно, включая другие списки. Но все элементы в списке должны принадлежать одному домену, и дополнительно к декларации спискового домена должна быть декларация '''domains''' для элементов:
<vip>domains
element_list = elements*.
elements = ....</vip>

Здесь ''elements'' должны быть приравнены к простым доменным типам (например, integer, real или symbol) или к набору возможных альтернатив, обозначенных различными функторами. Visual Prolog не допускает смешивание стандартных типов в списке. Например, следующие декларации ошибочно представляют списки, созданные из integers, reals и symbols:

<vip>element_list = elements*.
elements =
integer;
real;
symbol.
/* Неправильно */</vip>

Выходом для объявления списков из integer, real и symbols является объявление домена общего для всех типов, где функтор показывает какому типу принадлежит тот или иной элемент. Например:

<vip>element_list = elements*.
elements =
i(integer);
r(real);
s(symbol).
/* функторами являются i, r и s */</vip>

(Подробнее об этом - в этом же руководстве в разделе "Составные списки").

====Головы и Хвосты====

Список на самом деле является рекурсивным составным объетом. Он состоит из двух частей - головы списка, которым является первый элемент, и хвоста - списка, который включает все следующие элементы.

'''''Хвост списка всегда есть список; голова списка есть элемент.'''''

Например,

<vip>голова списка [a, b, c] есть a
хвост списка [a, b, c] есть [b, c]</vip>

Что происходит, когда мы имеем дело со списком, содержащим один элемент? Ответом является:

<vip>головой списка [c] является c
хвостом списка [c] является []</vip>

'''''Если многократно отнимать первый элемент от хвоста списка, мы получим в конечном итоге пустой список ('''[ ]''').'''''

'''''Пустой список не может быть разбит на голову и хвост.'''''

Это означает, что, концептуально говоря, списки имеют древовидную структуру подобно другим составным объектам. Древовидная структура списка [a, b, c, d] есть:

<pre> list
/ \
a list
/ \
b list
/ \
c list
/ \
d []</pre>
Более того, одноэлементный список, такой как [a] - это не тот же самый элемент, который этот список содержит, поскольку [a] является действительно составной структурой данных, как это видно здесь:

<pre> list
/ \
a []</pre>

==Представления Списков==

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

[a, b, c] эквивалентно [a|[b, c]]

и, продолжая процесс,

[a|[b,c]] эквивалентно [a|[b|[c]]],

что эквивалентно [a|[b|[c|[]]]]

Можно даже использовать оба способа разделения в одном и том же списке, рассматривая вертикальную черту как разделитель самого низкого уровня. Следовательно, можно записать [a, b, c, d] как [a, b|[c, d]]. Таблица 1 дает дополнительные примеры.

{|cellpadding="5" cellspacing="0" border="1"
|+'''Таблица 1: Головы и Хвосты списков'''
!Список
!Голова
!Хвост
|-
|['a', 'b', 'c']
|'a'
|['b', 'c']
|-
|[ 'a' ]
|'a'
|[]
|-
|/*пустой список*/ [ ]
|неопределен
|неопределен
|-
|[[1, 2, 3], [2, 3, 4], []]
|[1, 2, 3]
|[[2, 3, 4], []]

|}

В Таблице 2 приведены некоторые примеры унификации списков.

{|cellpadding="5" cellspacing="0" border="1"
|+'''Таблица 2: Унификация Списков'''
!Список 1
!Список 2
!Связывание Переменных
|-
|[X, Y, Z]
|[эгберт, ест, мороженое]
|X=эгберт, Y=ест, Z=мороженое
|-
|[7]
|[X <nowiki>|</nowiki> Y]
|X=7, Y=[]
|-
|[1, 2, 3, 4]
|[X, Y <nowiki>|</nowiki> Z]
|X=1, Y=2, Z=[3,4]
|-
|[1, 2]
|[3 <nowiki>|</nowiki> X]
|fail
|}

==Использование Списков==

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

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

===Вывод Списков на печать===

Например, если Вы хотите только вывести на печать элементы списка, то вот что Вы делаете:

<vip>class my
predicates
write_a_list : (integer*).
end class

implement my
clauses
write_a_list([]). /* Если список пустой, ничего не делаем. */
write_a_list([H|T]):- /* Сопоставляем голову с H и хвост с T, и... */
stdio::write(H),stdio::nl, /*выводим H и переводим строку*/
write_a_list(T).
end implement

goal
console::init(),
my::write_a_list([1, 2, 3]).</vip>

Здесь мы видим два клауза write_a_list, которые можно выразить но обычном языке:

*Для вывода на печать пустого списка ничего не надо делать.
*Иначе, для вывода на печать списка, вывести на печать его голову (она есть просто элемент), и потом вывести на печать хвост списка (он, как известно, есть список).

Первый раз, когда вызывается:

<vip>my::write_a_list([1, 2, 3]).</vip>

такой вызов сопоставляется со вторым клаузом, с головой H=1 и T=[2, 3]. Это приводит к выводу на печать 1, затем рекурсивно вызывается write_a_list с аргументом в виде хвоста списка:

<vip>my::write_a_list([2, 3]).
/* Это вызов write_a_list(T). */</vip>

Этот второй вызов опять сопоставляется со вторым клаузом, где, на этот раз H=2 и T=[3], поэтому выводится 2 и опять рекурсивно вызывается write_a_list:

<vip>my::write_a_list([3]).</vip>

С каким клаузом теперь такой вызов сопоставлятся? Напомним, что, хотя список [3] имеет всего один элемент, у него есть голова и хвост - голова есть 3, а хвост есть []. Таким образом, этот вызов опять сопоставляется со вторым клаузом с H=3 и T=[]. Теперь выводится 3 и вызывается рекурсивно write_a_list:

<vip>my::write_a_list([]).</vip>

Теперь становится понятно для чего нужен первый клауз. Второй клауз не может быть сопоставлен с таким вызовом, поскольку [] не может быть разделен на голову и хвост. Если бы первого клазуа здесь не было бы, то выполнение goal оказалось бы неуспешным. Но, поскольку он есть, то первый клауз сопоставляется с вызовом и выполнение goal успешно завершается и нечего более не делается.

===Подсчет элементов в Списке===

Рассмотрим теперь, как подсчитать число элементов в списке, или какова длина списка? Логично определить:

*Длина пустого списка [] есть 0.<br />
*Длина любого другого списка есть 1 плюс длина его хвоста.

Можно ли это запрограммировать? На Прологе это очень просто. Всего два клауза:

<vip>class my
predicates
length_of : (A*, integer) procedure(i,o).
end class

implement my
clauses
length_of([], 0).
length_of([_|T], L):-
length_of(T, TailLength),
L = TailLength + 1.
end implement

goal
console::init(),
my::length_of([1, 2, 3], L),
stdio::write(L).</vip>

Посмотрите прежде всего на второй клауз. Строго говоря, [_|T] сопоставляется с любым непустым списком, связывая T с хвостом списка. Значение головы неважно, если она есть, она может быть учтена как один элемент.

Тогда вызов:

<vip>my::length_of([1, 2, 3], L)</vip>

сопоставляется со вторым клаузом, с T=[2, 3]. Следующим шагом является вычисление длины хвоста T. Когда это сделано (не имеет значение, как), TailLength получит значение 2, и компьютер теперь может добавить 1 к ней и связать L со значением 3. Как выполняется этот промежуточный шаг? Надо найти длину списка [2, 3], путем удовлетворения цели

<vip>my::length_of([2, 3], TailLength)</vip>

Другими словами, length_of вызывает себя рекурсивно. Этот вызов сопоставляется со вторым клаузом, связывая

*[3] и T в вызове клаузы и
*TailLength с L в клаузе.

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

Итак, теперь задача - найти длину списка [3], которая есть 1, и мы добавляем 1 к этому значению, чтобы получить длину списка [2, 3], что будет 2. Ну и хорошо!.

Аналогично, length_of вызывает себя рекурсивно опять для получения длины списка [3]. Хвост [3] есть [], поэтому T связвается с [], и задача теперь - получение длины списка [] и добавление к ней 1, что дает длину списка [3].

Теперь все просто. Цель:

<vip>my::length_of([], TailLength)</vip>

сопоставляется с ''первым'' клаузом, связывая TailLength с 0. Поэтому теперь компьютер может добавить 1 к нему, получая длину списка [3], и возвращаясь теперь в вызывавший клауз. Это, в свою очередь, опять добавляет 1, давая длину списка [2, 3], и возвращается в клауз, который его вызывал; этот первоначальный клауз добавит снова 1, давая длину списка [1, 2, 3].

Не растерялись? Мы надеемся, нет. В следующей короткой иллюстрации мы сводим воедино все вызовы. Мы использовали здесь прием подстрочника для того, чтобы показать, что аналогично называемые переменные в разных клаузах или различные вызовы того же самого клауза - одно и то же.
<vip>my::length_of([1, 2, 3], L1).
my::length_of([2, 3], L2).
my::length_of([3], L3).
my::length_of([], 0).
L3 = 0+1 = 1.
L2 = L3+1 = 2.
L1 = L2+1 = 3.</vip>

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

===Хвостовая рекурсия===

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

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

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

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

<vip>class my
predicates
length_of : (A*, integer, integer) procedure(i,o,i).
end class

implement my
clauses
length_of([], Result, Result).
length_of([_|T], Result, Counter):-
NewCounter = Counter + 1,
length_of(T, Result, NewCounter).
end implement

goal
console::init(),
my::length_of([1, 2, 3], L, 0), /* Начинаем со счетчиком Counter = 0 */
stdio::write(" L = ", L).</vip>

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

===Модификация Списка===

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

<vip>class my
predicates
add1 : (integer*, integer*) procedure(i,o).
end class

implement my
clauses
add1([], [])./* граничное условие */
add1([Head|Tail],[Head1|Tail1]):- /* отделяем голову от остального списка*/
Head1 = Head+1, /* добавляем 1 к элементу-голове */
add1(Tail, Tail1)./* далаем это с остальной частью списка*/
end implement

goal
console::init(),
my::add1([1,2,3,4], NewList),
stdio::write(NewList)).</vip>

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

Загрузим программу и выполним такую цель
<vip>add1([1,2,3,4], NewList).</vip>

Цель вернет
<vip>NewList=[2,3,4,5]
1 Solution</vip>

===Опять о хвостовой рекурсии===

Является ли предикат add1 проедикатом с хвостовой рекурсией?
Если у Вас есть опыт использования Lisp или Pascal, Вы могли бы подумать, что нет, поскольку Вы бы рассуждали так:

*Делим список на ''Head'' и ''Tail''.
*Добавляем 1 к ''Head'', получаем ''Head1''.
*Рекурсивно добавляя 1 ко всем элементам списка ''Tail'', получаем ''Tail1''.
*Соединяем ''Head1'' и ''Tail1'', что дает результирующий список.

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

Однако, и это важно, – '''''Это не то, что делает Пролог'''''. В Visual Prolog add1 является предикатом с хвостовой рекурсией, поскольку выполняется в действительности следующим образом:

*Связать голову и хвост исходного списка с ''Head'' и ''Tail'', соответственно.
*Связать голову и хвост результирующего списка с ''Head1'' и ''Tail1'', соответственно. (''Head1'' и ''Tail1'' пока не получили значений.)
*Добавить 1 к ''Head'', что дает ''Head1''.
*Рекурсивно добавить 1 ко всем элементам списка ''Tail'', что дает ''Tail1''.

Когда это сделано, ''Head1'' и ''Tail1'' '''уже являются''' головой и списком результата и отдельной операции по их соединению нет. Поэтому рекурсивный вызов и является последним шагом.

<h6>Снова Модификация Списков</h6>

Конечно, не всегда модификации подлежит каждый элемент. Посмотрим на программу, которая сканирует список чисел и копирует его, удаляя отрицательные числа:

<vip>class my
predicates
discard_negatives : (integer*, integer*) procedure(i,o). /*удалить отрицательные*/
end class

implement my
clauses
discard_negatives([], []).
discard_negatives([H|T], ProcessedTail):-
H < 0,
!, /* Если H отрицательно, пропускаем его */
discard_negatives(T, ProcessedTail).
discard_negatives([H|T], [H|ProcessedTail]):-
discard_negatives(T, ProcessedTail).
end implement

goal
console::init(),
my::discard_negatives ([2, -45, 3, 468], X),
stdio::write(X).</vip>

Напрмер, цель
<vip>my::discard_negatives([2, -45, 3, 468], X)</vip>
дает
<vip>X=[2, 3, 468].</vip>

А вот - предикат который копирует элементы списка, добавляя для каждого элемента его дубликат:
<vip>doubletalk([], []).
doubletalk([H|T], [H, H|DoubledTail]) :-
doubletalk(T, DoubledTail).</vip>

===Принадлежнось списку===

Допустим, имеется список с именами ''John'', ''Leonard'', ''Eric'' и ''Frank'' и требуется, используя Visual Prolog, выяснить, принадлежит ли заданное имя этому списку. Другими словами, надо определить "отношение" между двумя аргументами: именем и списком имен. Это соответствует предикату

<vip>isMember : (name, name*).
/* "name" принадлежит списку "name*" */</vip>

В программе e01.pro первый клауз исследует голову списка. Если голова списка совпадает с искомым именем, то можно сделать заключение, что Name принадлежит списку. Поскольку хвост списка нас не интересует, то это мы представляем анонимной переменной. Благодаря первому клаузу, цель

<vip>my::isMember("john", ["john", "leonard", "eric", "frank"])</vip>

удовлетворена.

<vip>/* Программа e01.pro */
class my
predicates
isMember : (A, A*) determ.
end class

implement my
clauses
isMember(Name, [Name|_]) :-
!.
isMember(Name, [_|Tail]):-
isMember(Name,Tail).
end implement

goal
console::init(),
my::isMember("john", ["john", "leonard", "eric", "frank"]),
!,
stdio::write("Success")
;
stdio::write("No solution").
</vip>

Если голова списка не есть Name, то надо исследовать, не содержится ли Name в хвосте списка.

На обычном языке:

Name принадлежит списку, если Name является первым элементом списка, или<br />
Name принадлежит списку, если Name принадлежит хвосту.

Второй клауз предиката isMember относится к этому отношению. Таким образом на Visual Prolog:

<vip>isMember(Name, [_|Tail]) :-
isMember(Name, Tail).</vip>

===Добавление списка к другому списку: декларативное и рекурсивное решения===

Рассмотренный предикат member программы e01.pro работает в двух направлениях. Вернемся к его клаузам:

<vip>
member(Name, [Name|_]).
member(Name, [_|Tail]) :-
member(Name, Tail).
</vip>

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

*С декларативной точки зрения, клаузы выражают:
**Name (Имя) принадлежит списку, если голова списка есть Name
**иначе Name принадлежит списку, если оно (Имя) принадлежит хвосту.
*С процедурной точки зрения, эти же два клауза могут быть интерпретированы так:<br/>Чтобы найти элемент списка
**Найдите его голову
**иначе найдите элемент хвоста списка.

Эти две точки зрения соответствуют целям
<vip>member(2, [1, 2, 3, 4]).</vip>
и
<vip>member(X, [1, 2, 3, 4]).</vip>

В результате первый вызов поручает Visual Prolog(у) проверить, истино ли нечто (принадлежность числа 2 списку [1,2,3,4]). Второй вызов поручает Visual Prolog(у) найти все члены списка [1,2,3,4]. Не смущайтесь этим. Предикат member является одним и тем же, но на его поведение можно смотреть под разными углами.

====Рекурсия с процедуральной точки зрения====

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

<vip>append(List1, List2, List3).</vip>

Этот предикат интегрирует списки List1 и List2 в форму списка List3 так, что список List2 дописывается в конце списка List1. То есть содержательно - осуществляется добавление списка List2 к списку LIst1. Опять мы используем рекурсию (на этот раз с процедуральной точки зрения).

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

<vip>append([], List2, List2).</vip>

Если список List1 не пустой, то можно преобразовать списки List1 и List2 к форме списка ''List3'', сделав голову списка List1 головой списка List3. В приведенном коде переменная H используется в качестве головы как списка List1, так и списка List3. хвост списка List3 есть список L3, который составлен из остатка списка List1 (а именно, L1) и всего списка List2. Опять выразим это на Прологе:

<vip>append([H|L1], List2, [H|L3]) :-
append(L1, List2, L3).</vip>

Предикат append работает следующим образом: пока список List1 не пустой, рекурсивное правило дописывает один элемент каждый раз к списку List3. Когда список List1 становится пустым, первый клауз clause обеспечивает дописывание списка List2 в конец списка List3.

====Варианты использования одного предиката====

Подходя к предикату append с декларативной точки зрения, мы определили его как отношение между тремя списками. Это отношение справедливо также, если списки List1 и List3 известны, а List2 - нет. Более того, это также работает, если только List3 известен. Например, для того, чтобы выяснить, какие два списка могли бы быть соединены для получения известного списка, можно использовать вызов в форме
<vip>append(L1, L2, [1, 2, 4]).</vip>

С таким целевым вызовом, Visual Prolog найдет следующие решения:

<vip>
L1=[], L2=[1,2,4]
L1=[1], L2=[2,4]
L1=[1,2], L2=[4]
L1=[1,2,4], L2=[]
4 Solutions
</vip>

Можно использовать предикат append для нахождения списка, который следовало бы добавить к списку [3,4] для получения списка[1,2,3,4]. Попробуем такой вызов
<vip>append(L1, [3,4], [1,2,3,4]).</vip>
Visual Prolog находит решение
<vip>L1=[1,2].</vip>

Предикат append определяет отношение между ''входным набором (input set)'' и ''выходным набором (output set)'' таким образом, что отношение применимо в обе стороны. При таком отношении возникает вопрос

''Что является выходным набором для заданного входного?'' или ''Какой входной набор соответствует заданному выходному?''

Статус аргументов данного вызова предиката известен как ''поток (или шаблон) ввода-вывода''. Аргумент, который связан или наследуется в момент вызова является входным аргументом и обозначается как (i). Свободный аргумент является выходным аргументом и обозначается как (o).

Предикат append обладает свойством поддерживать любой шаблон ввода-вывода, какой требуется. Однако не все предикаты имеют возможность вызова с различными шаблонами ввода-вывода. Когда клауз Пролога способен поддерживать множество шаблонов ввода-вывода, он называется инверсным клаузом. Целый набор предикатов для обработки списков содержится в классе '''list'''.

==Все Решения Сразу==

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

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

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

*Первый аргумент, VarName, определяет аргумент в вызываемом целевом предикате, значения которого будут собираться в список.
*Второй - mypredicate - определяет предикат, который будет получать значения.
*Выходной параметр ListParam, является переменной, которая содержит список значений, полученных в ходе отката.

Программа e02.pro использует обработку списка для вывода среднего возраста группы людей.
<vip> /* Программа e02.pro */
class my
domains
name = string.
address = string.
age = integer.

predicates
person : (name, address, age) nondeterm anyflow.
sumlist : (age*, age, integer)procedure(i,o,o).
end class my

implement my
clauses
sumlist([],0,0).
sumlist([H|T], Sum, N):-
sumlist(T, S1, N1),
Sum=H+S1, N=1+N1.

person("Sherlock Holmes","22B Baker Street", 42).
person("Pete Spiers","Apt. 22, 21st Street", 36).
person("Mary Darrow","Suite 2, Omega Home", 51).
end implement my

goal
console::init(),
L = [ Age || my::person(_, _, Age)],
my::sumlist(L, Sum, N),
Ave = Sum/N,
stdio::write("Average=", Ave, ". ").</vip>

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

<vip>List = [ Who || my::person(Who, _, 42) ]</vip>

Следующий код порождает список всех положительных чисел исходного списка:

<vip>List = [ X || X = list::getMember_nd([2,-8,-3,6]), X > 0]</vip>

==Смешанные списки==

Список целых объявляется просто
<vip>integer*</vip>

То же верно и для списков вещественных чисел (integer), символьных (symbol) списков или списков строк (string).

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

<vip>[2, 3, 5.12, ["food", "goo"], "new"].
/* Не корректно для Visual Prolog*/</vip>

''Смешанные списки'' - списки, содержащие элементы более чем одного типа. Для работы со списками разнотипных элементов должны использоваться специальные объявления, поскольку Visual Prolog требует, чтобы все элементы списка принадлежали бы '''''одному и тому же''''' домену. Способом создания списка, который хранит такие различные типы элементов является использование функторов, поскольку домен может представляться '''''более, чем одним''''' функтором, каждый со своими т'''и'''повыми аргументами.

Пример объаявления списка, который может хранить целые, символы, строки или списки таких даных:

<vip>domains
/* функторами являются l, i, c, and s */
llist = l(list); i(integer); c(char); s(string).</vip>
Список
<vip>[ 2, 9, ["food", "goo"], "new" ]
/* Не корректно для Visual Prolog */</vip>
на Visual Prolog следовало бы записать так:

<vip>[i(2), i(9), l([s("food"), s("goo")]), s("new")]
/* Корректно для Visual Prolog */</vip>

Следующий пример предиката append показывает как использовать такого рода декларации в стандартных программах манипулирования списками.

<vip>class my
domains
llist = l(list); i(integer); c(char); s(string).

predicates
append : (A*,A*,A*) procedure (i,i,o).
end class

implement my
clauses
append([], L, L).
append([X|L1], L2, [X|L3]):-
append(L1, L2, L3).
end implement

goal
console::init(),
my::append
(
[my::s("likes"),my::l([my::s("bill"), my::s("mary")])],
[my::s("bill"), my::s("sue")],
Ans
),
stdio::write("Первый список: ", Ans,"\n\n"),
my::append
(
[my::l([my::s("This"),my::s("is"),my::s("a"),my::s("list")]),my::s("bee")],
[my::c('c')],
Ans2
),
stdio::write("Второй списко: ", Ans2, "\n\n&quot).</vip>

==Разбор с использованием списков==

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

Этот разборщик предназначен для примитивного формального языка. Хотя этот пример достаточно сложен с точки зрения этого руководства, мы решили поместит его здесь, поскольку разбор является одной из областей, где Visual Prolog очень эффективен. Если Вы чувствуете себя не вполне готовым для этого раздела, Вы можете этот пример пропустить и продолжить чтение руководства без потери содержательности.

<vip>#include @"pfc\exception\exception.ph"
#include @"pfc\string\string.ph"
#include @"pfc\console\console.ph"

class my_t
predicates
tokl : (string, string*) procedure (i,o).
end class

implement my_t
clauses
tokl(Str, [H|T]) :-
string::fronttoken(Str, H, Str1),
!,
tokl(Str1, T).
tokl(_, []).
end implement

/* * * * * * * * * * * * * * * * * * * * *
* Вторая часть этой программы - разборщик *
* * * * * * * * * * * * * * * * * * * * * */
class my_p
domains
program = program(statement*).
/* * * * * * * * * * * * * * * * * * * * * *
* Определение что есть языковая конструкция *
* (предложение языка) *
* * * * * * * * * * * * * * * * * * * * * * */
statement =
if_Then_Else(exp, statement, statement);
if_Then(exp, statement);
while(exp, statement);
assign(id, exp).
/* * * * * * * * * * * *
* Определение выражения *
* * * * * * * * * * * */
exp =
plus(exp, exp);
minus(exp, exp);
var(id);
int(integer).
id = string.

predicates
s_program : (string*, program) procedure (i,o).
s_statement : (string*, string*, statement) determ (i,o,o).
s_statement_list : (string*, string*, statement*) determ (i,o,o).
s_exp : (string*, string*, exp) determ (i,o,o).
s_exp1 : (string*, string*, exp, exp) determ (i,o,i,o).
s_exp2 : (string*, string*, exp) determ (i,o,o).
end class

implement my_p
clauses
s_program(TokenList, program(StatementList)):-
s_statement_list(TokenList, _, StatementList),
!.
s_program(_, program([])).

clauses
s_statement_list([], [], []) :- !.
s_statement_list(List1, List4, [Statement|Program]) :-
s_statement(List1, List2, Statement),
List2=[";"|List3],
s_statement_list(List3, List4, Program).

clauses
s_statement(["if"|List1], List7,if_then_else(Exp,Statement1, Statement2)):-
s_exp(List1, List2, Exp),
List2=["then"|List3],
s_statement(List3, List4, Statement1),
List4=["else"|List5],!,
s_statement(List5, List6, Statement2),
List6=["fi"|List7].
s_statement(["if"|List1], List5,if_then(Exp, Statement)) :- !,
s_exp(List1, List2, Exp),
List2=["then"|List3],
s_statement(List3, List4, Statement),
List4=["fi"|List5].
s_statement(["do"|List1], List4,while(Exp, Statement)) :- !,
s_statement(List1, List2, Statement),
List2=["while"|List3],
s_exp(List3, List4, Exp).
s_statement([ID|List1], List3,assign(Id,Exp)) :-
string::isname(ID),
List1=["="|List2],
s_exp(List2, List3, Exp).

clauses
s_exp(List1, List3, Exp):-
s_exp2(List1, List2, Exp1),
s_exp1(List2, List3, Exp1, Exp).

clauses
s_exp1(["+"|List1], List3, Exp1, Exp) :- !,
s_exp2(List1, List2, Exp2),
s_exp1(List2, List3, plus(Exp1, Exp2), Exp).
s_exp1(["-"|List1], List3, Exp1, Exp) :- !,
s_exp2(List1, List2, Exp2),
s_exp1(List2, List3, minus(Exp1, Exp2), Exp).
s_exp1(List, List, Exp, Exp).

clauses
s_exp2([Int|Rest], Rest, int(I)) :-
trap(I = toTerm(Int),Error,exception::clear_fail(Error)),
!.
s_exp2([Id|Rest], Rest, var(Id)) :-
string::isname(Id).
end implement

goal
console::init(),
my_t::tokl("b=2; if b then a=1 else a=2 fi; do a=a-1 while a;", Ans),
stdio::write(Ans),
my_p::s_program(Ans, Res),
stdio::write(Res).
</vip>

Загрузите программу и выполните целевой вызов:

<vip>goal
my_t::tokl("b=2; if b then a=1 else a=2 fi; do a=a-1 while a;", Ans),
my_p::s_program(Ans, Res).</vip>

Visual Prolog вернет структуру программы:

<vip>Ans = ["b","=","2",";","if","b","then","a","=","1",
"else","a","=","2","fi",";","do","a","=","a",
"-","1","while","a",";"],
Res=program
(
[assign("b",int(2)),
if_then_else
(
var("b"),
assign("a",int(1)),
assign("a",int(2))
),
while
(
var("a"),
assign
(
"a",
minus
(
var("a"),
int(1)
)
)
)
])
</vip>

Преобразование в этом примере представлено двумя шагами: сканирование и разбор. Предикат tokl - это сканер. Он принимает строку и преобразует ее в список токенов. Все предикаты с именами, начинающимися с s_ являются предикатами парсера. В этом примере входный текст представляет программу на языке, подобном языку Паскаль, и состоящей из Паскале-подобных предложений. Этот язык программирования позволяет только предложения вида: IF THEN ELSE, IF THEN, DO WHILE и присваивание (ASSIGNMENT). Предложения состоят из выражений и вложенных предложений. Выражения - сложение, вычитание, переменные и целые.

Далее, как это работает:

*Первый клауз парсера, s_program, принимает список токенов и пытается преобразовать его в список предложений.
*Предикат s_statement_list принимает тот же самый список токенов и проверяет возможность деления токенов на предложения, завершающиеся точкой с запятой.
*Предикат s_statement проверяет могут ли начальные токены списка (токенов) представлять собой правильное предложение. Если да, то такое предложение возвращается в виде структуры, а остаток токенов передается рекурсивно вызываемому предикату s_statement_list.
*Четыре клауза предиката s_statement соответствуют четырем типам, которые парсер понимает.<br\> Если первый клауз предиката s_statement не может преобразовать список токенов в предложение вида IF THEN ELSE, то клауз завершается неуспешно и в порядке отката переходит к следующему клаузу предиката s_statement. Теперь делается попытка преобразовать список токенов в конструкцию вида IF THEN. Если эта попытка неуспешна, то в следующем клаузе делается попытка преобразования к предложению вида DO WHILE.
*Если первые три клауза предиката s_statement завершаются неуспешно, то последний клауз этого предиката провереяет представлена ли в списке токенов операция присваивания. Этот клауз проверяет "на присваивание" является ли первый терм символом, второй - знаком равно ("="), а следующие термы представляют простое математическое выражение.
*Предикаты s_exp, s_exp1 и s_exp2 работают аналогично, путем проверки являются ли начальные термы выражениями и, если это так, то предикату s_statement предикат s_exp возвращает остаток термов и математическое выражение в виде структуры.

==Заключение==

В этом руководстве раскрыта следующие важные моменты:

*''Списки'' могут содержать произвольное число элементов; Вы объявляете их простым добавление звездочки ('''*''') в конце ранее определенного домена.
*Список является рекурсивным составным объектом, состоящим из головы и хвоста. Голова есть первый элемент, а хвост - остальная часть списка (без первого элемента). Хвост списка - всегда список; голова списка - всегда элемента. Список может содержать ноль или более элементов; Пустой список обозначается [].
*Элементами списка можже быть что угодно, включая другиме списки; все элементы списка должны принадлежать одному домену. В этом случае объявление домена элементов должно выглядеть так:

<vip>domains
element_list = elements*.
elements = ....</vip>

где elements = один из стандартных доменов (integer, real, etc.) или набор альтернатив обозначенных различными функторами (int(integer); rl(real); smb(symbol); и т.д.). Смешение типов в списках языка системы Visual Prolog допускается только включением их в составные объекты или функторы.
*Можно использовать разделители (запятые, [ и |) для явного отделения головы списка от хвоста. Так, список
<vip>[a, b, c, d]</vip>
может быть записан как:
<vip>
[a|[b, c, d]]
или
[a, b|[c, d]]
или
[a, b, c|[d]]
или
[a|[b|[c, d]]]
или
[a|[b|[c|[d]]]]
или даже
[a|[b|[c|[d|[]]]]]</vip>
*Обработка списков заключается в рекурсивном отщеплении головы списка (и выполнении действий над ней) до опустошения списка.
*Предикаты для работы со списками содержаться в классе '''list'''.
*Visual Prolog поддерживает встроенную конструкцию обработки списков, которая принимает целевой предикат в качестве одного из аргументов и собирает все решения этого целевого предиката в едином списке. Синтаксис такой конструкции
<vip>Result = [ Argument || myPredicate(Argument) ]</vip>
*Поскольку Visual Prolog требует, чтобы все элементы списка принадлежали бы одному и тому же домену, следует использовать функторы для создания списков, хранящих элементы различного типа.
*процесс ''разбора с использованием разностных списков (parsing by difference lists)'' работает путем сокращения задачи; пример в этом руководстве преобрахует строку входных данных в структуру, которая может обрабатываться позже.

==References==
[[en:Lists and Recursion]]
[[Категория:VipРуководства]]
[[Категория:VipLanguage]]

Списки и рекурсия

2007-11-23T10:56:09Z

SergeMukhin: очепятки

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

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

==Что такое Список?==

В Прологе ''список (list)'' является объектом, содержащим внутри произвольное число других объектов. Списки соответствуют, грубо говоря, массивам в других языках, но, в отличие от массивов, список не трубует декларирования его размера до начала его использования.

Список, содержащий числа 1, 2 и 3 записывается как
<vip>[ 1, 2, 3 ]</vip>

Порядок элементов в этом списке значим:
*Число "1" является первым элементом,
*"2" - второй,
*"3" - третий.

Список [ 1, 2, 3 ] и список [ 1, 3, 2 ] различны.

Каждый компонент списка называется элемент (element). Для того, чтобы сформировать списковую структуру данных, следует разделять элементы запятыми и заключать их всех в квадратные скобки. Посмотрим на некоторые примеры:
<vip>["dog", "cat", "canary"]
["valerie ann", "jennifer caitlin", "benjamin thomas"]</vip>
Один и тот же элемент может быть представлен в списке несколько раз, например:
<vip>[ 1, 2, 1, 3, 1 ]</vip>

===Объявление Списков===
Для объявления домена - списка целых используется декларация домена, как показано ниже:
<vip>domains
integer_list = integer*.</vip>

Звездочка означает "список этого"; то есть, integer* означает "список целых".

Обратите внимание на то, что слово ''"list"'' не имеет специального значения в Visual Prolog. Вы равным образом могли бы назвать Ваш списковый домен как ''zanzibar''. Именно звездочка, а не имя, предписывает этому домену быть списком.

Элементами в списке может быть что угодно, включая другие списки. Но все элементы в списке должны принадлежать одному домену, и дополнительно к декларации спискового домена должна быть декларация '''domains''' для элементов:
<vip>domains
element_list = elements*.
elements = ....</vip>

Здесь ''elements'' должны быть приравнены к простым доменным типам (например, integer, real или symbol) или к набору возможных альтернатив, обозначенных различными функторами. Visual Prolog не допускает смешивание стандартных типов в списке. Например, следующие декларации ошибочно представляют списки, созданные из integers, reals и symbols:

<vip>element_list = elements*.
elements =
integer;
real;
symbol.
/* Неправильно */</vip>

Выходом для объявления списков из integer, real и symbols является объявление домена общего для всех типов, где функтор показывает какому типу принадлежит тот или иной элемент. Например:

<vip>element_list = elements*.
elements =
i(integer);
r(real);
s(symbol).
/* функторами являются i, r и s */</vip>

(Подробнее об этом - в этом же руководстве в разделе "Составные списки").

====Головы и Хвосты====

Список на самом деле является рекурсивным составным объетом. Он состоит из двух частей - головы списка, которым является первый элемент, и хвоста - списка, который включает все следующие элементы.

'''''Хвост списка всегда есть список; голова списка есть элемент.'''''

Например,

<vip>голова списка [a, b, c] есть a
хвост списка [a, b, c] есть [b, c]</vip>

Что происходит, когда мы имеем дело со списком, содержащим один элемент? Ответом является:

<vip>головой списка [c] является c
хвостом списка [c] является []</vip>

'''''Если многократно отнимать первый элемент от хвоста списка, мы получим в конечном итоге пустой список ('''[ ]''').'''''

'''''Пустой список не может быть разбит на голову и хвост.'''''

Это означает, что, концептуально говоря, списки имеют древовидную структуру подобно другим составным объектам. Древовидная структура списка [a, b, c, d] есть:

<pre> list
/ \
a list
/ \
b list
/ \
c list
/ \
d []</pre>
Более того, одноэлементный список, такой как [a] - это не тот же самый элемент, который этот список содержит, поскольку [a] является действительно составной структурой данных, как это видно здесь:

<pre> list
/ \
a []</pre>

==Представления Списков==

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

[a, b, c] эквивалентно [a|[b, c]]

и, продолжая процесс,

[a|[b,c]] эквивалентно [a|[b|[c]]],

что эквивалентно [a|[b|[c|[]]]]

Можно даже использовать оба способа разделения в одном и том же списке, рассматривая вертикальную черту как разделитель самого низкого уровня. Следовательно, можно записать [a, b, c, d] как [a, b|[c, d]]. Таблица 1 дает дополнительные примеры.

{|cellpadding="5" cellspacing="0" border="1"
|+'''Таблица 1: Головы и Хвосты списков'''
!Список
!Голова
!Хвост
|-
|['a', 'b', 'c']
|'a'
|['b', 'c']
|-
|[ 'a' ]
|'a'
|[]
|-
|/*пустой список*/ [ ]
|неопределен
|неопределен
|-
|[[1, 2, 3], [2, 3, 4], []]
|[1, 2, 3]
|[[2, 3, 4], []]

|}

В Таблице 2 приведены некоторые примеры унификации списков.

{|cellpadding="5" cellspacing="0" border="1"
|+'''Таблица 2: Унификация Списков'''
!Список 1
!Список 2
!Связывание Переменных
|-
|[X, Y, Z]
|[эгберт, ест, мороженое]
|X=эгберт, Y=ест, Z=мороженое
|-
|[7]
|[X <nowiki>|</nowiki> Y]
|X=7, Y=[]
|-
|[1, 2, 3, 4]
|[X, Y <nowiki>|</nowiki> Z]
|X=1, Y=2, Z=[3,4]
|-
|[1, 2]
|[3 <nowiki>|</nowiki> X]
|fail
|}

==Использование Списков==

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

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

===Вывод Списков на печать===

Например, если Вы хотите только вывести на печать элементы списка, то вот что Вы делаете:

<vip>class my
predicates
write_a_list : (integer*).
end class

implement my
clauses
write_a_list([]). /* Если список пустой, ничего не делаем. */
write_a_list([H|T]):- /* Сопоставляем голову с H и хвост с T, и... */
stdio::write(H),stdio::nl, /*выводим H и переводим строку*/
write_a_list(T).
end implement

goal
console::init(),
my::write_a_list([1, 2, 3]).</vip>

Здесь мы видим два клауза write_a_list, которые можно выразить но обычном языке:

*Для вывода на печать пустого списка ничего не надо делать.
*Иначе, для вывода на печать списка, вывести на печать его голову (она есть просто элемент), и потом вывести на печать хвост списка (он, как известно, есть список).

Первый раз, когда вызывается:

<vip>my::write_a_list([1, 2, 3]).</vip>

такой вызов сопоставляется со вторым клаузом, с головой H=1 и T=[2, 3]. Это приводит к выводу на печать 1, затем рекурсивно вызывается write_a_list с аргументом в виде хвоста списка:

<vip>my::write_a_list([2, 3]).
/* Это вызов write_a_list(T). */</vip>

Этот второй вызов опять сопоставляется со вторым клаузом, где, на этот раз H=2 и T=[3], поэтому выводится 2 и опять рекурсивно вызывается write_a_list:

<vip>my::write_a_list([3]).</vip>

С каким клаузом теперь такой вызов сопоставлятся? Напомним, что, хотя список [3] имеет всего один элемент, у него есть голова и хвост - голова есть 3, а хвост есть []. Таким образом, этот вызов опять сопоставляется со вторым клаузом с H=3 и T=[]. Теперь выводится 3 и вызывается рекурсивно write_a_list:

<vip>my::write_a_list([]).</vip>

Теперь становится понятно для чего нужен первый клауз. Второй клауз не может быть сопоставлен с таким вызовом, поскольку [] не может быть разделен на голову и хвост. Если бы первого клазуа здесь не было бы, то выполнение goal оказалось бы неуспешным. Но, поскольку он есть, то первый клауз сопоставляется с вызовом и выполнение goal успешно завершается и нечего более не делается.

===Подсчет элементов в Списке===

Рассмотрим теперь, как подсчитать число элементов в списке, или какова длина списка? Логично определить:

*Длина пустого списка [] есть 0.<br />
*Длина любого другого списка есть 1 плюс длина его хвоста.

Можно ли это запрограммировать? На Прологе это очень просто. Всего два клауза:

<vip>class my
predicates
length_of : (A*, integer) procedure(i,o).
end class

implement my
clauses
length_of([], 0).
length_of([_|T], L):-
length_of(T, TailLength),
L = TailLength + 1.
end implement

goal
console::init(),
my::length_of([1, 2, 3], L),
stdio::write(L).</vip>

Посмотрите прежде всего на второй клауз. Строго говоря, [_|T] сопоставляется с любым непустым списком, связывая T с хвостом списка. Значение головы неважно, если она есть, она может быть учтена как один элемент.

Тогда вызов:

<vip>my::length_of([1, 2, 3], L)</vip>

сопоставляется со вторым клаузом, с T=[2, 3]. Следующим шагом является вычисление длины хвоста T. Когда это сделано (не имеет значение, как), TailLength получит значение 2, и компьютер теперь может добавить 1 к ней и связать L со значением 3. Как выполняется этот промежуточный шаг? Надо найти длину списка [2, 3], путем удовлетворения цели

<vip>my::length_of([2, 3], TailLength)</vip>

Другими словами, length_of вызывает себя рекурсивно. Этот вызов сопоставляется со вторым клаузом, связывая

*[3] и T в вызове клаузы и
*TailLength с L в клаузе.

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

Итак, теперь задача - найти длину списка [3], которая есть 1, и мы добавляем 1 к этому значению, чтобы получить длину списка [2, 3], что будет 2. Ну и хорошо!.

Аналогично, length_of вызывает себя рекурсивно опять для получения длины списка [3]. Хвост [3] есть [], поэтому T связвается с [], и задача теперь - получение длины списка [] и добавление к ней 1, что дает длину списка [3].

Теперь все просто. Цель:

<vip>my::length_of([], TailLength)</vip>

сопоставляется с ''первым'' клаузом, связывая TailLength с 0. Поэтому теперь компьютер может добавить 1 к нему, получая длину списка [3], и возвращаясь теперь в вызывавший клауз. Это, в свою очередь, опять добавляет 1, давая длину списка [2, 3], и возвращается в клауз, который его вызывал; этот первоначальный клауз добавит снова 1, давая длину списка [1, 2, 3].

Не растерялись? Мы надеемся, нет. В следующей короткой иллюстрации мы сводим воедино все вызовы. Мы использовали здесь прием подстрочника для того, чтобы показать, что аналогично называемые переменные в разных клаузах или различные вызовы того же самого клауза - одно и то же.
<vip>my::length_of([1, 2, 3], L1).
my::length_of([2, 3], L2).
my::length_of([3], L3).
my::length_of([], 0).
L3 = 0+1 = 1.
L2 = L3+1 = 2.
L1 = L2+1 = 3.</vip>

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

===Хвостовая рекурсия===

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

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

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

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

<vip>class my
predicates
length_of : (A*, integer, integer) procedure(i,o,i).
end class

implement my
clauses
length_of([], Result, Result).
length_of([_|T], Result, Counter):-
NewCounter = Counter + 1,
length_of(T, Result, NewCounter).
end implement

goal
console::init(),
my::length_of([1, 2, 3], L, 0), /* Начинаем со счетчиком Counter = 0 */
stdio::write(" L = ", L).</vip>

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

===Модификация Списка===

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

<vip>class my
predicates
add1 : (integer*, integer*) procedure(i,o).
end class

implement my
clauses
add1([], [])./* граничное условие */
add1([Head|Tail],[Head1|Tail1]):- /* отделяем голову от остального списка*/
Head1 = Head+1, /* добавляем 1 к элементу-голове */
add1(Tail, Tail1)./* далаем это с остальной частью списка*/
end implement

goal
console::init(),
my::add1([1,2,3,4], NewList),
stdio::write(NewList)).</vip>

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

Загрузим программу и выполним такую цель
<vip>add1([1,2,3,4], NewList).</vip>

Цель вернет
<vip>NewList=[2,3,4,5]
1 Solution</vip>

===Опять о хвостовой рекурсии===

Является ли предикат add1 проедикатом с хвостовой рекурсией?
Если у Вас есть опыт использования Lisp или Pascal, Вы могли бы подумать, что нет, поскольку Вы бы рассуждали так:

*Делим список на ''Head'' и ''Tail''.
*Добавляем 1 к ''Head'', получаем ''Head1''.
*Рекурсивно добавляя 1 ко всем элементам списка ''Tail'', получаем ''Tail1''.
*Соединяем ''Head1'' и ''Tail1'', что дает результирующий список.

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

Однако, и это важно, – '''''Это не то, что делает Пролог'''''. В Visual Prolog add1 является предикатом с хвостовой рекурсией, поскольку выполняется в действительности следующим образом:

*Связать голову и хвост исходного списка с ''Head'' и ''Tail'', соответственно.
*Связать голову и хвост результирующего списка с ''Head1'' и ''Tail1'', соответственно. (''Head1'' и ''Tail1'' пока не получили значений.)
*Добавить 1 к ''Head'', что дает ''Head1''.
*Рекурсивно добавить 1 ко всем элементам списка ''Tail'', что дает ''Tail1''.

Когда это сделано, ''Head1'' и ''Tail1'' '''уже являются''' головой и списком результата и отдельной операции по их соединению нет. Поэтому рекурсивный вызов и является последним шагом.

<h6>Снова Модификация Списков</h6>

Конечно, не всегда модификации подлежит каждый элемент. Посмотрим на программу, которая сканирует список чисел и копирует его, удаляя отрицательные числа:

<vip>class my
predicates
discard_negatives : (integer*, integer*) procedure(i,o). /*удалить отрицательные*/
end class

implement my
clauses
discard_negatives([], []).
discard_negatives([H|T], ProcessedTail):-
H < 0,
!, /* Если H отрицательно, пропускаем его */
discard_negatives(T, ProcessedTail).
discard_negatives([H|T], [H|ProcessedTail]):-
discard_negatives(T, ProcessedTail).
end implement

goal
console::init(),
my::discard_negatives ([2, -45, 3, 468], X),
stdio::write(X).</vip>

Напрмер, цель
<vip>my::discard_negatives([2, -45, 3, 468], X)</vip>
дает
<vip>X=[2, 3, 468].</vip>

А вот - предикат который копирует элементы списка, добавляя для каждого элемента его дубликат:
<vip>doubletalk([], []).
doubletalk([H|T], [H, H|DoubledTail]) :-
doubletalk(T, DoubledTail).</vip>

===Принадлежнось списку===

Допустим, имеется список с именами ''John'', ''Leonard'', ''Eric'' и ''Frank'' и требуется, используя Visual Prolog, выяснить, принадлежит ли заданное имя этому списку. Другими словами, надо определить "отношение" между двумя аргументами: именем и списком имен. Это соответствует предикату

<vip>isMember : (name, name*).
/* "name" принадлежит списку "name*" */</vip>

В программе e01.pro первый клауз исследует голову списка. Если голова списка совпадает с искомым именем, то можно сделать заключение, что Name принадлежит списку. Поскольку хвост списка нас не интересует, то это мы представляем анонимной переменной. Благодаря первому клаузу, цель

<vip>my::isMember("john", ["john", "leonard", "eric", "frank"])</vip>

удовлетворена.

<vip>/* Программа e01.pro */
class my
predicates
isMember : (A, A*) determ.
end class

implement my
clauses
isMember(Name, [Name|_]) :-
!.
isMember(Name, [_|Tail]):-
isMember(Name,Tail).
end implement

goal
console::init(),
my::isMember("john", ["john", "leonard", "eric", "frank"]),
!,
stdio::write("Success")
;
stdio::write("No solution").
</vip>

Если голова списка не есть Name, то надо исследовать, не содержится ли Name в хвосте списка.

На обычном языке:

Name принадлежит списку, если Name является первым элементом списка, или<br />
Name принадлежит списку, если Name принадлежит хвосту.

Второй клауз предиката isMember относится к этому отношению. Таким образом на Visual Prolog:

<vip>isMember(Name, [_|Tail]) :-
isMember(Name, Tail).</vip>

===Добавление списка к другому списку: декларативное и рекурсоивное решения===

Рассмотренный предикат member программы e01.pro работает в двух направлениях. Вернемся к его клаузам:

<vip>
member(Name, [Name|_]).
member(Name, [_|Tail]) :-
member(Name, Tail).
</vip>

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

*С декларативной точки зрения, клаузы выражают:
**Name (Имя) принадлежит списку, если голова списка есть Name
**иначе Name принадлежит списку, если оно (Имя) принадлежит хвосту.
*С процедурной точки зрения, эти же два клауза могут быть интерепретированы так:<br/>Чтобы найти элемент списка
**Найдите его голову
**иначе найдите элемент хвоста списка.

Эти две точки зрения соответствуют целям
<vip>member(2, [1, 2, 3, 4]).</vip>
и
<vip>member(X, [1, 2, 3, 4]).</vip>

В результате первый вызов поручает Visual Prolog(у) проверить, истино ли нечто (принадлежность числа 2 списку [1,2,3,4]). Второй вызов поручает Visual Prolog(у) найти все члены списка [1,2,3,4]. Не смущайтесь этим. Предикат member является одним и тем же, но на его поведение можно смотреть под разными углами.

====Рекурсия с процедуральной точки зрения====

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

<vip>append(List1, List2, List3).</vip>

Этот предикат интегрирует списки List1 и List2 в форму списка List3 так, что список List2 дописывается в конце списка List1. То есть содержательно - осуществляется добавление списка List2 к списку LIst1. Опять мы используем рекурсию (на этот раз с процедуральной точки зрения).

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

<vip>append([], List2, List2).</vip>

Если список List1 не пустой, то можно преобразовать списки List1 и List2 к форме списка ''List3'', сделав голову списка List1 головой списка List3. В приведенном коде переменная H используется в качестве головы как списка List1, так и списка List3. Хвось списка List3 есть список L3, который составлен из остатка списка List1 (а именно, L1) и всего списка List2. Опять выразим это на Прологе:

<vip>append([H|L1], List2, [H|L3]) :-
append(L1, List2, L3).</vip>

Предикат append работает следующим образом: пока список List1 не пустой, рекурсивное правило дописывает один элемент каждый раз к списку List3. Когда список List1 становится пустым, первый клауз clause обеспечивает дописыванеие списка List2 в конец списка List3.

====Варианты использования одного предиката====

Подходя к предикату append с декларативной точки зрения, мы определили его как отношение между тремя списками. Это отношение справедливо также, если списки List1 и List3 известны, а List2 - нет. Более того, это также работает, если только List3 известен. Например, для того, чтобы выяснить, какие два списка могли бы быть соединены для получения известного списка, можно использовать вызов в форме
<vip>append(L1, L2, [1, 2, 4]).</vip>

С таким целевым вызовом, Visual Prolog найдет следующие решения:

<vip>
L1=[], L2=[1,2,4]
L1=[1], L2=[2,4]
L1=[1,2], L2=[4]
L1=[1,2,4], L2=[]
4 Solutions
</vip>

Можно использовать предикат append для нахождения списка, который следовало бы добавить к списку [3,4] для получения списка[1,2,3,4]. Попробуем такой вызов
<vip>append(L1, [3,4], [1,2,3,4]).</vip>
Visual Prolog находит решение
<vip>L1=[1,2].</vip>

Предикат append определяет отношение между ''входным набором (input set)'' и ''выходным набором (output set)'' таким образом, что отношение применимо в обе стороны. При таком отношении возникает вопрос

''Что является выходным набором для заданного входного?'' или ''Какой входной набор соответствует заданному выходному?''

Статус аргументов данного вызова предиката известен как ''поток (или шаблон) ввода-вывода''. Аргумент, который связан или наследуется в момент вызова является входным аргументом и обозначается как (i). Свободный аргумент является выходным аргументом и обозначается как (o).

Предикат append обладает свойством поддерживать любой шаблон ввода-вывода, какой требуется. Однако не все предикаты имеют возможность вызова с различными шаблонами ввода-вывода. Когда клауз Пролога способен поддерживать множество шаблонов ввода-вывода, он назвается инверсным клаузом. Целый набор предикатов для обработки списков содержится в классе '''list'''.

==Все Решения Сразу==

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

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

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

*Первый аргумент, VarName, определяет аргумент в вызываемом целевом предикате, значения которого будут собираться в список.
*Второй - mypredicate - определяет предикат, который будет получать значения.
*Выходной параметр ListParam, является переменной, которая содержит список значений, полученных в ходе отката.

Программа e02.pro использует обработку списка для вывода среднего возраста группы людей.
<vip> /* Программа e02.pro */
class my
domains
name = string.
address = string.
age = integer.

predicates
person : (name, address, age) nondeterm anyflow.
sumlist : (age*, age, integer)procedure(i,o,o).
end class my

implement my
clauses
sumlist([],0,0).
sumlist([H|T], Sum, N):-
sumlist(T, S1, N1),
Sum=H+S1, N=1+N1.

person("Sherlock Holmes","22B Baker Street", 42).
person("Pete Spiers","Apt. 22, 21st Street", 36).
person("Mary Darrow","Suite 2, Omega Home", 51).
end implement my

goal
console::init(),
L = [ Age || my::person(_, _, Age)],
my::sumlist(L, Sum, N),
Ave = Sum/N,
stdio::write("Average=", Ave, ". ").</vip>

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

<vip>List = [ Who || my::person(Who, _, 42) ]</vip>

Следующий код порождает список всех положительных чисел исходного списка:

<vip>List = [ X || X = list::getMember_nd([2,-8,-3,6]), X > 0]</vip>

==Смешанные списки==

Список целых объявляется просто
<vip>integer*</vip>

То же верно и для списков вещественных чисел (integer), символьных (symbol) списков или списков строк (string).

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

<vip>[2, 3, 5.12, ["food", "goo"], "new"].
/* Не корректно для Visual Prolog*/</vip>

''Смешанные списки'' - списки, содержащие элементы более чем одного типа. Для работы со списками разнотипных элементов должны использоваться специальные объявления, поскольку Visual Prolog требует, чтобы все элементы списка принадлежали бы '''''одному и тому же''''' домену. Способом создания списка, который хранит такие различные типы элементов является использование функторов, поскольку домен может представляться '''''более, чем одним''''' функтором, каждый со своими т'''и'''повыми аргументами.

Пример объаявления списка, который может хранить целые, символы, строки или списки таких даных:

<vip>domains
/* функторами являются l, i, c, and s */
llist = l(list); i(integer); c(char); s(string).</vip>
Список
<vip>[ 2, 9, ["food", "goo"], "new" ]
/* Не корректно для Visual Prolog */</vip>
на Visual Prolog следовало бы записать так:

<vip>[i(2), i(9), l([s("food"), s("goo")]), s("new")]
/* Корректно для Visual Prolog */</vip>

Следующий пример предиката append показывает как использовать такого рода декларации в стандартных программах манипулирования списками.

<vip>class my
domains
llist = l(list); i(integer); c(char); s(string).

predicates
append : (A*,A*,A*) procedure (i,i,o).
end class

implement my
clauses
append([], L, L).
append([X|L1], L2, [X|L3]):-
append(L1, L2, L3).
end implement

goal
console::init(),
my::append
(
[my::s("likes"),my::l([my::s("bill"), my::s("mary")])],
[my::s("bill"), my::s("sue")],
Ans
),
stdio::write("Первый список: ", Ans,"\n\n"),
my::append
(
[my::l([my::s("This"),my::s("is"),my::s("a"),my::s("list")]),my::s("bee")],
[my::c('c')],
Ans2
),
stdio::write("Второй списко: ", Ans2, "\n\n&quot).</vip>

==Разбор с использованием списков==

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

Этот разборщик предназначен для примитивного формального языка. Хотя этот пример достаточно сложен с точки зрения этого руководства, мы решили поместит его здесь, поскольку разбор является одной из областей, где Visual Prolog очень эффективен. Если Вы чувствуете себя не вполне готовым для этого раздела, Вы можете этот пример пропустить и продолжить чтение руководства без потери содержательности.

<vip>#include @"pfc\exception\exception.ph"
#include @"pfc\string\string.ph"
#include @"pfc\console\console.ph"

class my_t
predicates
tokl : (string, string*) procedure (i,o).
end class

implement my_t
clauses
tokl(Str, [H|T]) :-
string::fronttoken(Str, H, Str1),
!,
tokl(Str1, T).
tokl(_, []).
end implement

/* * * * * * * * * * * * * * * * * * * * *
* Вторая часть этой программы - разборщик *
* * * * * * * * * * * * * * * * * * * * * */
class my_p
domains
program = program(statement*).
/* * * * * * * * * * * * * * * * * * * * * *
* Определение что есть языковая конструкция *
* (предложение языка) *
* * * * * * * * * * * * * * * * * * * * * * */
statement =
if_Then_Else(exp, statement, statement);
if_Then(exp, statement);
while(exp, statement);
assign(id, exp).
/* * * * * * * * * * * *
* Определение выражения *
* * * * * * * * * * * */
exp =
plus(exp, exp);
minus(exp, exp);
var(id);
int(integer).
id = string.

predicates
s_program : (string*, program) procedure (i,o).
s_statement : (string*, string*, statement) determ (i,o,o).
s_statement_list : (string*, string*, statement*) determ (i,o,o).
s_exp : (string*, string*, exp) determ (i,o,o).
s_exp1 : (string*, string*, exp, exp) determ (i,o,i,o).
s_exp2 : (string*, string*, exp) determ (i,o,o).
end class

implement my_p
clauses
s_program(TokenList, program(StatementList)):-
s_statement_list(TokenList, _, StatementList),
!.
s_program(_, program([])).

clauses
s_statement_list([], [], []) :- !.
s_statement_list(List1, List4, [Statement|Program]) :-
s_statement(List1, List2, Statement),
List2=[";"|List3],
s_statement_list(List3, List4, Program).

clauses
s_statement(["if"|List1], List7,if_then_else(Exp,Statement1, Statement2)):-
s_exp(List1, List2, Exp),
List2=["then"|List3],
s_statement(List3, List4, Statement1),
List4=["else"|List5],!,
s_statement(List5, List6, Statement2),
List6=["fi"|List7].
s_statement(["if"|List1], List5,if_then(Exp, Statement)) :- !,
s_exp(List1, List2, Exp),
List2=["then"|List3],
s_statement(List3, List4, Statement),
List4=["fi"|List5].
s_statement(["do"|List1], List4,while(Exp, Statement)) :- !,
s_statement(List1, List2, Statement),
List2=["while"|List3],
s_exp(List3, List4, Exp).
s_statement([ID|List1], List3,assign(Id,Exp)) :-
string::isname(ID),
List1=["="|List2],
s_exp(List2, List3, Exp).

clauses
s_exp(List1, List3, Exp):-
s_exp2(List1, List2, Exp1),
s_exp1(List2, List3, Exp1, Exp).

clauses
s_exp1(["+"|List1], List3, Exp1, Exp) :- !,
s_exp2(List1, List2, Exp2),
s_exp1(List2, List3, plus(Exp1, Exp2), Exp).
s_exp1(["-"|List1], List3, Exp1, Exp) :- !,
s_exp2(List1, List2, Exp2),
s_exp1(List2, List3, minus(Exp1, Exp2), Exp).
s_exp1(List, List, Exp, Exp).

clauses
s_exp2([Int|Rest], Rest, int(I)) :-
trap(I = toTerm(Int),Error,exception::clear_fail(Error)),
!.
s_exp2([Id|Rest], Rest, var(Id)) :-
string::isname(Id).
end implement

goal
console::init(),
my_t::tokl("b=2; if b then a=1 else a=2 fi; do a=a-1 while a;", Ans),
stdio::write(Ans),
my_p::s_program(Ans, Res),
stdio::write(Res).
</vip>

Загрузите программу и выполните целевой вызов:

<vip>goal
my_t::tokl("b=2; if b then a=1 else a=2 fi; do a=a-1 while a;", Ans),
my_p::s_program(Ans, Res).</vip>

Visual Prolog вернет структуру программы:

<vip>Ans = ["b","=","2",";","if","b","then","a","=","1",
"else","a","=","2","fi",";","do","a","=","a",
"-","1","while","a",";"],
Res=program
(
[assign("b",int(2)),
if_then_else
(
var("b"),
assign("a",int(1)),
assign("a",int(2))
),
while
(
var("a"),
assign
(
"a",
minus
(
var("a"),
int(1)
)
)
)
])
</vip>

Преобразование в этом примере представлено двумя шагами: сканирование и разбор. Предикат tokl - это сканер. Он принимает строку и преобразует ее в список токенов. Все предикаты с именами, начинающимися с s_ являются предикатами парсера. В этом примере входный текст представляет программу на языке, подобном языку Паскаль, и состоящей из Паскале-подобных предложений. Этот язык программирования позволяет только предложения вида: IF THEN ELSE, IF THEN, DO WHILE и присваивание (ASSIGNMENT). Предложения состоят из выражений и вложенных предложений. Выражения - сложение, вычитание, переменные и целые.

Далее, как это работает:

*Первый клауз парсера, s_program, принимает список токенов и пытается преобразовать его в список предложений.
*Предикат s_statement_list принимает тот же самый список токенов и проверяет возможность деления токенов на предложения, завершающиеся точкой с запятой.
*Предикат s_statement проверяет могут ли начальные токены списка (токенов) представлять собой правильное предложение. Если да, то такое предложение возвращается в виде структуры, а остаток токенов передается рекурсивно вызываемому предикату s_statement_list.
*Четыре клауза предиката s_statement соответствуют четырем типам, которые парсер понимает.<br\> Если первый клауз предиката s_statement не может преобразовать список токенов в предложение вида IF THEN ELSE, то клауз завершается неуспешно и в порядке отката переходит к следующему клаузу предиката s_statement. Теперь делается попытка преобразовать список токенов в конструкцию вида IF THEN. Если эта попытка неуспешна, то в следующем клаузе делается попытка преобразования к предложению вида DO WHILE.
*Если первые три клауза предиката s_statement завершаются неуспешно, то последний клауз этого предиката провереяет представлена ли в списке токенов операция присваивания. Этот клауз проверяет "на присваивание" является ли первый терм символом, второй - знаком равно ("="), а следующие термы представляют простое математическое выражение.
*Предикаты s_exp, s_exp1 и s_exp2 работают аналогично, путем проверки являются ли начальные термы выражениями и, если это так, то предикату s_statement предикат s_exp возвращает остаток термов и математическое выражение в виде структуры.

==Заключение==

В этом руководстве раскрыта следующие важные моменты:

*''Списки'' могут содержать произвольное число элементов; Вы объявляете их простым добавление звездочки ('''*''') в конце ранее определенного домена.
*Список является рекурсивным составным объектом, состоящим из головы и хвоста. Голова есть первый элемент, а хвост - остальная часть списка (без первого элемента). Хвост списка - всегда список; голова списка - всегда элемента. Список может содержать ноль или более элементов; Пустой список обозначается [].
*Элементами списка можже быть что угодно, включая другиме списки; все элементы списка должны принадлежать одному домену. В этом случае объявление домена элементов должно выглядеть так:

<vip>domains
element_list = elements*.
elements = ....</vip>

где elements = один из стандартных доменов (integer, real, etc.) или набор альтернатив обозначенных различными функторами (int(integer); rl(real); smb(symbol); и т.д.). Смешение типов в списках языка системы Visual Prolog допускается только включением их в составные объекты или функторы.
*Можно использовать разделители (запятые, [ и |) для явного отделения головы списка от хвоста. Так, список
<vip>[a, b, c, d]</vip>
может быть записан как:
<vip>
[a|[b, c, d]]
или
[a, b|[c, d]]
или
[a, b, c|[d]]
или
[a|[b|[c, d]]]
или
[a|[b|[c|[d]]]]
или даже
[a|[b|[c|[d|[]]]]]</vip>
*Обработка списков заключается в рекурсивном отщеплении головы списка (и выполнении действий над ней) до опустошения списка.
*Предикаты для работы со списками содержаться в классе '''list'''.
*Visual Prolog поддерживает встроенную конструкцию обработки списков, которая принимает целевой предикат в качестве одного из аргументов и собирает все решения этого целевого предиката в едином списке. Синтаксис такой конструкции
<vip>Result = [ Argument || myPredicate(Argument) ]</vip>
*Поскольку Visual Prolog требует, чтобы все элементы списка принадлежали бы одному и тому же домену, следует использовать функторы для создания списков, хранящих элементы различного типа.
*процесс ''разбора с использованием разностных списков (parsing by difference lists)'' работает путем сокращения задачи; пример в этом руководстве преобрахует строку входных данных в структуру, которая может обрабатываться позже.

==References==
[[en:Lists and Recursion]]
[[Категория:VipРуководства]]
[[Категория:VipLanguage]]

ProfileCount

2007-11-20T19:47:43Z

SergeMukhin:

Для измерения времени выполнения предикатов можно использовать класс '''profileCount''' из пакета '''pfc\profile'''. Перед его использованием необходимо добавить опцию компилятора '''/PROFILE''' и перестроить проект. Также необходимо вставить вызовы запускающие профилирование '''start''', обычно при инициализации приложения, останова '''stop''' и вывода результатов '''print''' (обычно в конце приложения).

Вот типичный пример использования в консольном приложении:

<vip>
clauses
run():-
console::init(),
profileCount::start(),
try
главныйПредикат()
finally
profileCount::stop(),
Out = console::getConsoleOutputStream(),
profileCount::print(Out)
end try.
</vip>

Для всех предикатов выводится количество их вызовов, а для некоторых и суммарное время выполнения. Следует учесть, что данный инструмент (как впрочем и все) влияет на выполняемую программу (даже если предикат '''start''' не был выполнен). Программа становится больше и выполняется медленней. Это надо учитывать при анализе полученных результатов. {{note|picsize=30|content=И, самое главное, не забыть убрать опцию '''/PROFILE''' после, того, как все замеры будут произведены.}} Если модуль построен без опции '''/PROFILE''', то предикат '''start''' не имеет никакого эффекта.

Пример результат работы:

Predicate invocations count information:
1. outputStream::write/0... 1 0.00017656
2. bufferSupport::getBuffer/2 2 0.00014974
3. outputStream::write/0... 1 0.00009526
4. outputStream_console::writeToStdDevice/4 2 0.00007683
5. outputStream::flush/0 1 0.00007599
6. outputStream_console::bufferFullCB/2 2 0.00006397
7. list::filter/2-> 1 0.00003436
8. авто::new/1-> 3 0.00003241
9. list::getMember_nd/1-> 6 0.00002123
10. fileSystem_api::lf_crlf/4 2 0.00002039
11. outputStream_console::convertLF2CRLF_ifNeeded/4 2 0.00001062
12. main::run$1/0 3 0.00000726
13. fileSystem_api::searchLineFeeds/6 2 0.00000698
14. авто::цена/0-> 4 0.00000670
15. stream::getMode/0-> 4 0.00000615
16. console::write/0... 1 0.00000615
17. авто::new/1 3 0.00000475
18. fileSystem_api::convertToCRLF_IfNeeded/4-> 2 0.00000419
19. console_api::getStdHandle/1-> 2 0.00000391
20. fileSystem_api::getSize/2-> 2 0.00000363
21. outputSupport::doNotFlush/0 1 0.00000307
22. console::getConsoleOutputStream/0-> 1 0.00000251

[[Категория:Profile]]

Где декларируются предикаты?

2007-11-18T07:45:52Z

SergeMukhin: добавил ссылки

Обычно, говоря о Visual Prolog, подчеркивают, что это - типизированный язык. Это подразумевает, что существует объявление (или декларация):
*типов данных, используемых в предикатах в качестве входных или выходных параметров
*других характеристик предикатов
Это объявление используется затем в клаузе - исполняемой части предиката, где и интерпретируется как программистом, так и компилятором.

Например, в следущем коде
<vip>
predicates
выделитьИзФайлаОтрезокТекстаСЗаданнойДлиной:(string ИмяФайла, unsigned ЧислоСимоволов) ->string.
clauses
выделитьИзФайлаОтрезокТекстаСЗаданнойДлиной(ИмяФайла,ЧислоСимоволов)=ОтрезокТекста:-
ПолныйТекстФайла=прочитатьФайл(ИмяФайла),
...
</vip>
декларация предиката (раздел '''[[predicates]]''') и клауза (раздел '''[[clauses]]''') помещаются рядом по тексту. Но это лишь частный случай возможного их взаимного размещения.

Местом размещения исполняемой части '''всегда''' является имплементация класса ('''implement ... end implement''').

Местами помещения декларации могут быть:
*та же имплементация класса ('''implement ... end implement''')
*декларация одноименного класса ('''class ... end class''')
*декларация интерфейса, который квалифицирует одноименный класс ('''interface ... end interface''')
'''''В первом случае''''' декларация может размещаться как выше, так и ниже по тексту.

Хорошим стилем считается, когда декларация помещена непосредственно над клаузой, как в примере выше. При этом имена разделов по-прежнему пишутся во множественном числе ('''predicates''', '''clauses''').

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

<vip>
class обработкаФайла
predicates
выделитьИзФайлаОтрезокТекстаСЗаданнойДлиной:(string ИмяФайла, unsigned ЧислоСимоволов) ->string.
end class обработкаФайла

implement обработкаФайла
выделитьИзФайлаОтрезокТекстаСЗаданнойДлиной(ИмяФайла,ЧислоСимоволов)=ОтрезокТекста:-
ПолныйТекстФайла=прочитатьФайл(ИмяФайла),
...
end implement обработкаФайла
</vip>
Следует подчеркнуть, что декларация класса - это сущность, неотделимая от имплементации класса с тем же именем. То есть нельзя в какую-либо произвольную декларацию класса поместить декларацию предиката, а в какую-то имплементацию класса с другим именем поместить клаузу и попытаться их связать какими-то ссылками, использующими эти имена. Имя класса однозначно определяет его декларацию и его имплементацию. Именно в них можно поместить декларацию предиката и его клаузу.

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

Наш фрагмент кода будет выглядеть в этом случае иначе.
<vip>
interface обработкаФайла
predicates
выделитьИзФайлаОтрезокТекстаСЗаданнойДлиной:(string ИмяФайла, unsigned ЧислоСимоволов) ->string.
end interface обработкаФайла

class обработкаФайла : обработкаФайла
end class обработкаФайла

implement обработкаФайла
выделитьИзФайлаОтрезокТекстаСЗаданнойДлиной(ИмяФайла,ЧислоСимоволов)=ОтрезокТекста:-
ПолныйТекстФайла=прочитатьФайл(ИмяФайла),
...
end implement обработкаФайла
</vip>
Обратите внимание, декларация класса ('''class... end class''') не содержит ничего, кроме указателя на используемый интерфейс. Несмотря на это, ее нельзя исключить из кода и связать клаузу предиката с его декларацией каким-либо другим способом.

Приведенный фрагмент кода мог бы выглядеть и по-другому (использование другого имени интерфейса)
<vip>
interface fileHandling
predicates
выделитьИзФайлаОтрезокТекстаСЗаданнойДлиной:(string ИмяФайла, unsigned ЧислоСимоволов) ->string.
end interface fileHandling

class обработкаФайла : fileHandling
end class обработкаФайла

implement обработкаФайла
выделитьИзФайлаОтрезокТекстаСЗаданнойДлиной(ИмяФайла,ЧислоСимоволов)=ОтрезокТекста:-
ПолныйТекстФайла=прочитатьФайл(ИмяФайла),
...
end implement обработкаФайла
</vip>

Все три приведенные способа декларирования предикатов определяют различные свойства и приемы их использования в классах и объектах и поэтому не являются равнозначными альтернативами.

Проперти (секция [[properties]]) так же могут реализовываться через клаузы, и тогда они водят неявное описание предиката(ов). Если есть (i) проперти, то клауза должна соответствовать предикату ''properyName : (propertyValue)'', а для (o) - ''properyName : () -> propertyValue''.
<vip>interface обработкаФайла
properties
размерФайла : unsigned(0).
end interface обработкаФайла

implement обработкаФайла
clauses
размерФайла() = Размер :-
Размер64 = fileSystem_api::getFileSize(handle_fv),
unsigned64(Размер, _).

end implement обработкаФайла</vip>
[[Категория:VipLanguage]]

Где декларируются предикаты?

2007-11-18T07:39:33Z

SergeMukhin: добавил проперти секцию

Обычно, говоря о Visual Prolog, подчеркивают, что это - типизированный язык. Это подразумевает, что существует объявление (или декларация):
*типов данных, используемых в предикатах в качестве входных или выходных параметров
*других характеристик предикатов
Это объявление используется затем в клаузе - исполняемой части предиката, где и интерпретируется как программистом, так и компилятором.

Например, в следущем коде
<vip>
predicates
выделитьИзФайлаОтрезокТекстаСЗаданнойДлиной:(string ИмяФайла, unsigned ЧислоСимоволов) ->string.
clauses
выделитьИзФайлаОтрезокТекстаСЗаданнойДлиной(ИмяФайла,ЧислоСимоволов)=ОтрезокТекста:-
ПолныйТекстФайла=прочитатьФайл(ИмяФайла),
...
</vip>
декларация предиката (раздел '''predicates''') и клауза (раздел '''clauses''') помещаются рядом по тексту. Но это лишь частный случай возможного их взаимного размещения.

Местом размещения исполняемой части '''всегда''' является имплементация класса ('''implement ... end implement''').

Местами помещения декларации могут быть:
*та же имплементация класса ('''implement ... end implement''')
*декларация одноименного класса ('''class ... end class''')
*декларация интерфейса, который квалифицирует одноименный класс ('''interface ... end interface''')
'''''В первом случае''''' декларация может размещаться как выше, так и ниже по тексту.

Хорошим стилем считается, когда декларация помещена непосредственно над клаузой, как в примере выше. При этом имена разделов по-прежнему пишутся во множественном числе ('''predicates''', '''clauses''').

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

<vip>
class обработкаФайла
predicates
выделитьИзФайлаОтрезокТекстаСЗаданнойДлиной:(string ИмяФайла, unsigned ЧислоСимоволов) ->string.
end class обработкаФайла

implement обработкаФайла
выделитьИзФайлаОтрезокТекстаСЗаданнойДлиной(ИмяФайла,ЧислоСимоволов)=ОтрезокТекста:-
ПолныйТекстФайла=прочитатьФайл(ИмяФайла),
...
end implement обработкаФайла
</vip>
Следует подчеркнуть, что декларация класса - это сущность, неотделимая от имплементации класса с тем же именем. То есть нельзя в какую-либо произвольную декларацию класса поместить декларацию предиката, а в какую-то имплементацию класса с другим именем поместить клаузу и попытаться их связать какими-то ссылками, использующими эти имена. Имя класса однозначно определяет его декларацию и его имплементацию. Именно в них можно поместить декларацию предиката и его клаузу.

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

Наш фрагмент кода будет выглядеть в этом случае иначе.
<vip>
interface обработкаФайла
predicates
выделитьИзФайлаОтрезокТекстаСЗаданнойДлиной:(string ИмяФайла, unsigned ЧислоСимоволов) ->string.
end interface обработкаФайла

class обработкаФайла : обработкаФайла
end class обработкаФайла

implement обработкаФайла
выделитьИзФайлаОтрезокТекстаСЗаданнойДлиной(ИмяФайла,ЧислоСимоволов)=ОтрезокТекста:-
ПолныйТекстФайла=прочитатьФайл(ИмяФайла),
...
end implement обработкаФайла
</vip>
Обратите внимание, декларация класса ('''class... end class''') не содержит ничего, кроме указателя на используемый интерфейс. Несмотря на это, ее нельзя исключить из кода и связать клаузу предиката с его декларацией каким-либо другим способом.

Приведенный фрагмент кода мог бы выглядеть и по-другому (использование другого имени интерфейса)
<vip>
interface fileHandling
predicates
выделитьИзФайлаОтрезокТекстаСЗаданнойДлиной:(string ИмяФайла, unsigned ЧислоСимоволов) ->string.
end interface fileHandling

class обработкаФайла : fileHandling
end class обработкаФайла

implement обработкаФайла
выделитьИзФайлаОтрезокТекстаСЗаданнойДлиной(ИмяФайла,ЧислоСимоволов)=ОтрезокТекста:-
ПолныйТекстФайла=прочитатьФайл(ИмяФайла),
...
end implement обработкаФайла
</vip>

Все три приведенные способа декларирования предикатов определяют различные свойства и приемы их использования в классах и объектах и поэтому не являются равнозначными альтернативами.

Проперти (секция properties) так же могут реализовываться через клаузы, и тогда они водят неявное описание предиката(ов). Если есть (i) проперти, то клауза должна соответствовать предикату ''properyName : (propertyValue)'', а для (o) - ''properyName : () -> propertyValue''.
<vip>interface обработкаФайла
properties
размерФайла : unsigned(0).
end interface обработкаФайла

implement обработкаФайла
clauses
размерФайла() = Размер :-
Размер64 = fileSystem_api::getFileSize(handle_fv),
unsigned64(Размер, _).

end implement обработкаФайла</vip>
[[Категория:VipLanguage]]

Обсуждение:Где декларируются предикаты?

2007-11-17T23:34:51Z

SergeMukhin: Новая: не совсем понятно, что такое декларация интерфейса, который квалифицирет одноименный класс (interface ... en...

не совсем понятно, что такое
декларация интерфейса, который квалифицирет одноименный класс (interface ... end interface)

Анонимные предикаты

2007-11-16T06:35:07Z

SergeMukhin: /* Погружение */

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

===Вступление===
Пример использования:

<Vip>
interface авто
properties
цена : unsigned(o).
end interface авто

class выборАвтомобиля
predicates
неДорогие : () -> авто* Результат.
...
implement выборАвтомобиля
clauses
неДорогие() = list::filter({(Авто) :- Авто:цена <= 10000, !}, списокАвтомобилей).
...
</Vip>

Казалось бы ничего нового, ведь то же самое можно записать при помощи дополнительного предиката. Например так
<Vip>predicates
фильтрДляНедорогих : (авто Авто).
clauses
фильтрДляНедорогих(Авто) :- Авто:цена <= 10000, !.
clauses
неДорогие() = list::filter(фильтрДляНедорогих, списокАвтомобилей).</Vip>

Но сегодня для нас сумма 10000 является пределом мечтаний, а завтра 12000, как быть? Есть два решения, или менять константу, или добавить факт-переменную. Анонимный предикат позволит сделать это изящней.
<Vip>predicates
неДорогие2 : (unsigned НашиВозможности).
clauses
неДорогие2(НашиВозможности) = list::filter({(Авто) :- Авто:цена <= НашиВозможности, !}, списокАвтомобилей).</Vip>

Если внимательно присмотреться, то тут мы наблюдаем картину, ранее недоступную невооружённым глазом. Переменная ''НашиВозможности'' из предиката ''''неДорогие2'''' перекочевала во внутрь другого предиката - фильтра! Вот это уже нельзя сделать использую дополнительный предикат, как раньше.

===Погружение===
Давайте еще усложним наш пример, не сильно отрываясь от реальности. Представим, что у нас есть следующий интерфейс:
<Vip>interface покупатель
properties
зарплата : unsigned(o).
фильтрМашин : () -> list::filter.
end interface покупатель</Vip>
Попробуем написать реализацию
<Vip>implement покупатель
facts
зарплата : unsigned.
clauses
фильтрМашин() =

{(Авто) :- Авто:цена <= НашиВозможности, !}, списокАвтомобилей)
implement покупатель</Vip>

===Детали реализации===
===Где использовать===

Это не оконченная статья

[[Категория:VipLanguage]]

Анонимные предикаты

2007-11-16T05:30:11Z

SergeMukhin:

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

===Вступление===
Пример использования:

<Vip>
interface авто
properties
цена : unsigned(o).
end interface авто

class выборАвтомобиля
predicates
неДорогие : () -> авто* Результат.
...
implement выборАвтомобиля
clauses
неДорогие() = list::filter({(Авто) :- Авто:цена <= 10000, !}, списокАвтомобилей).
...
</Vip>

Казалось бы ничего нового, ведь то же самое можно записать при помощи дополнительного предиката. Например так
<Vip>predicates
фильтрДляНедорогих : (авто Авто).
clauses
фильтрДляНедорогих(Авто) :- Авто:цена <= 10000, !.
clauses
неДорогие() = list::filter(фильтрДляНедорогих, списокАвтомобилей).</Vip>

Но сегодня для нас сумма 10000 является пределом мечтаний, а завтра 12000, как быть? Есть два решения, или менять константу, или добавить факт-переменную. Анонимный предикат позволит сделать это изящней.
<Vip>predicates
неДорогие2 : (unsigned НашиВозможности).
clauses
неДорогие2(НашиВозможности) = list::filter({(Авто) :- Авто:цена <= НашиВозможности, !}, списокАвтомобилей).</Vip>

Если внимательно присмотреться, то тут мы наблюдаем картину, ранее недоступную невооружённым глазом. Переменная ''НашиВозможности'' из предиката ''''неДорогие2'''' перекочевала во внутрь другого предиката - фильтра! Вот это уже нельзя сделать использую дополнительный предикат, как раньше.

===Погружение===
Давайте еще усложним наш пример, не сильно отрываясь от реальности. Представим, что у нас есть следующий интерфейс:
<Vip>interface покупатель
properties
зарплата : unsigned(o).
фильтрМашин : () -> list::filter.
end interface покупатель</Vip>
Попробуем написать реализацию
<Vip>implement покупатель
facts
зарплата : unsigned.
clauses
фильтрМашин() =
implement покупатель</Vip>
===Детали реализации===
===Где использовать===

Это не оконченная статья

[[Категория:VipLanguage]]

Анонимные предикаты

2007-11-16T05:29:18Z

SergeMukhin:

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

===Вступление===
Пример использования:

<Vip>
interface авто
properties
цена : unsigned(o).
end interface авто

class выборАвтомобиля
predicates
неДорогие : () -> авто* Результат.
...
implement выборАвтомобиля
clauses
неДорогие() = list::filter({(Авто) :- Авто:цена <= 10000, !}, списокАвтомобилей).
...
</Vip>

Казалось бы ничего нового, ведь то же самое можно записать при помощи дополнительного предиката. Например так
<Vip>predicates
фильтрДляНедорогих : (авто Авто).
clauses
фильтрДляНедорогих(Авто) :- Авто:цена <= 10000, !.
clauses
неДорогие() = list::filter(фильтрДляНедорогих, списокАвтомобилей).</Vip>

Но сегодня для нас сумма 10000 является пределом мечтаний, а завтра 12000, как быть? Есть два решения, или менять константу, или добавить факт-переменную. Анонимный предикат позволит сделать это изящней.
<Vip>predicates
неДорогие2 : (unsigned НашиВозможности).
clauses
неДорогие2(НашиВозможности) = list::filter({(Авто) :- Авто:цена <= НашиВозможности, !}, списокАвтомобилей).</Vip>

Если внимательно присмотреться, то тут мы наблюдаем картину, ранее недоступную невооружённым глазом. Переменная ''НашиВозможности'' из предиката ''''неДорогие2'''' перекочевала во внутрь другого предиката - фильтра! Вот это уже нельзя сделать использую дополнительный предикат, как раньше.

===Погружение===
Давайте еще усложним наш пример, не сильно отрываясь от реальности. Представим, что у нас есть следующий интерфейс:
<Vip>interface покупатель
properties
зарплата : unsigned(o).
фильтрМашин : () -> list::filter.
end interface покупатель</Vip>
Попробуем написать реализацию
<Vip>implement покупатель
facts
зарплата : unsigned.
clauses
фильтрМашин() =
implement покупатель</Vip>
===Детали реализации===
===Где использоватьь===

Это не оконченная статья

[[Категория:VipLanguage]]

Основы Системы Visual Prolog

2007-11-15T06:53:39Z

SergeMukhin:

{{FundamentalVisualPrologNavbar}}

В этом руководстве мы представляем программу, разработанную на платформе системы программирования Visual Prolog. Алгоритмы, используемые в руководстве , - те же, что и в руководстве "Fundamental Prolog" (Часть 2).

==Отличия между Visual Prolog и традиционным Прологом==

Различия между традиционным Прологом и Visual Prolog можно провести по следующим категориям:

*'''Различия в структуре программы''':<br/>Различия между Visual Prolog и традиционным Прологом имеются, но они не существенны. Они сводятся к пониманию того, как различаются декларации (declarations) от определений (definitions), а также к явному выделению цели ''Goal''. Все это поддержано специальными ключевыми словами.

*'''Файловая структура программы:''':<br/>Visual Prolog предоставляет возможности структуризации программ с использованием файлов различного типа.

*'''Границы видимости:'''<br/>Программа системы Visual Prolog может поддерживать функционирование, располагающееся в различных модулях с использованием концепции ''идентификация пространств''.

*'''Объектная ориентированность:'''<br/>Программа на языке Visual Prolog может быть написана как объектно ориентированная программа с использованием классических свойств объектно-ориентированной парадигмы.

===Program Structure Differences===

====Declarations and Definitions====

In Prolog, when we need to use a predicate we simply do so without any prior intimation to the Prolog engine about our intention. For example; in the earlier tutorial the grandFather predicate's clause was directly written down using the traditional Prolog's predicate head and body construction. We did not bother to inform the engine explicitly in the code that such a predicate construction is to be expected later.

Similarly, when a compound domain is to be used in traditional Prolog, we can use it without first forewarning the Prolog engine about our intention to use the domain. We simply use a domain, the moment we feel the need for it.

However, in Visual Prolog, before writing down the code for the clause body of a predicate, we would first need to declare the existence of such a predicate to the compiler. Similarly, before using any domains, they need to be declared and their presence is to be informed to the compiler.

The reason such forewarnings are required in Visual Prolog is essentially to ensure that runtime exceptions are converted into compile time errors as far as possible.

By ''"runtime exceptions"'', we mean the issues that turn up only at the time of running the program that were compiled with it. For example, if you had intended to use an integer as the argument of a functor, and instead of the integer you had erroneously used a real number, it would become a ''runtime'' error (in programs written using most other compilers, but not Visual Prolog) and the program would fail there.

When you also declare the predicates and domains that are defined, such kind of positional grammar (which argument belongs to which domain), etc. is made available to the compiler. Therefore, when Visual Prolog performs a compilation, it checks the program quite thoroughly to weed out such grammatical and other mistakes.

Because of this feature in Visual Prolog, the overall efficiency of a programmer improves. The programmer does not have to wait till the program is actually executed to detect a bug. In fact, those of you, who are experienced in programming, would understand what a life-saver this can be; for often, the particular sequence of events that is causing a ''runtime exception'' to happen at run-time may be so elusive that the bug may actually turn up after several years, or it may manifest itself in some crucially critical or other embarrassing situations!

All this automatically implies that the compiler '''has''' to be given explicit instructions regarding the predicates and domains that exist in the code using appropriate declarations before the same are defined.

====Keywords====

A Visual Prolog program consists of Prolog code which is punctuated into different '''sections''' by appropriate keywords that inform the compiler the code it has to generate. For example, there are keywords that differentiate the ''declarations'' from the ''definitions'' of predicates and domains. Usually, each section is preceded by a keyword. There is normally no keyword which signifies the ending of a particular section. The presence of another keyword indicates the ending of the previous section, and the starting of the next one.

The exception to this rule, are the keywords "implement" and "end implement" The code contained between these two keywords indicates the code to be used for a particular class. Those of you who do not understand the concept of a "class" can, for now (i.e. in this tutorial), think of it as a module or a section of the overall program code.

For the purpose of this tutorial, we'll introduce only the following keywords (given below). We are also giving the purpose behind these keywords, and the actual syntax can be easily learnt from the documentation. There are other keywords also in Visual Prolog, and those can easily be picked up in later tutorials and the documentation.

The list of the keywords that you need to know in this tutorial is the following:

implement and end implement

Among all the keywords discussed here, this is the only one, which exists as a pair. Visual Prolog treats the code written between these two keywords as the code that belongs to one class. The name of the class MUST be given after the implement keyword.

open

This keyword is used to extend the ''scope visibility'' of the class. It is to be used just after the implement keyword.

constants

This keyword is used to mark a section of the code that defines some commonly used values in the program code. For example, if the string literal "PDC Prolog" is to be used in multiple locations throughout the code, then you can define a mnemonic (a short-form, easily remembered word) for the same thus:

<vip>constants
pdc="PDC Prolog".</vip>

Note that the definition of a constant ends in a period (.). Unlike a Prolog variable, a constant should be a word starting with a lower case letter.

domains

This keyword is used to mark a section declaring the domains that would be used in the code. There are many variations for the syntax of such domain declarations, and they cater to the all the possible kinds of domains that would be used later on in the code. As this tutorial is a basic one, we shall not get into the finer details of the domain declarations that can be possible.

To summarize here, you would be declaring the functor that would be used for the domain and the kind of domains that would form its arguments. Functors and compound domains were explained in detail in the previous part of the Tutorial.

class facts

This keyword designates a section, which declares the facts that would be used later on in the code of the program. Each fact is declared with the name used to signify the fact and the arguments that are used for the respective facts along with the domains that those arguments belong to.

class predicates

This section contains the declarations of the predicates that would be later defined in the clauses section of the code. Once again, the names that would be used for these predicates along with the arguments and the domains, to which the arguments belong to, would be indicated in this section.

clauses

Of all the sections that are present in a Visual Prolog code, this section is the one that closely mimics a traditional Prolog program. It contains the actual ''definitions'' of the previously declared predicates. And you would find that the predicates used here would follow the syntax as declared in the ''class predicates'' section.

goal

This section defines the main entry point into a Visual Prolog program. A more detailed explanation is given below.

====Goal====

In traditional Prolog, whenever a predicate is defined in the code, the Prolog Engine can be instructed to start the code execution from that predicate onwards. However, that is not the case with Visual Prolog. Being a ''compiler'' it has the responsibility of producing efficiently executing code for the program you write. This code would not be actually executing at the same time the ''compiler'' is doing its work. Hence, the ''compiler'' needs to know beforehand the exact predicate from which the code execution would start, so that later on when the program is called to perform, it can do so from the correct starting point. As you may have guessed, the compiled program can run independently without the Visual Prolog compiler or the IDE itself.

In order to do that, there is a special section indicated by the keyword ''Goal''. Think of it as a special predicate that you would write without arguments. That predicate is the one from which the entire program execution will start.

===File Considerations===

Many times, it may become cumbersome to put all the parts of the program into one file itself. It may even make the program unreadable and sometimes incorrect. Visual Prolog has the capability of dividing the program code into separate files using the IDE (Integrated Development Environment) and it is possible to write neat pieces of code into separate files using that IDE. When it is done in that manner, things that are to be used commonly can be accessed across files. E.g. If you have a domain that is to be used in multiple files, then the declaration of that domain is done in a separate file, and that file is then accessed from other files.

However, for the purpose of simplifying this particular tutorial, we shall predominantly be using only one file to develop the program code. In the course of constructing the program, the IDE would automatically create some more files which we can ignore for the time being. We can learn about them in future tutorials.

===Scope Access Issues===

Visual Prolog divides the total program code into separate parts, each part defining one class. In object oriented languages, a class is a package of code and its associated data which is put together. This requires more explanation which would be available in later tutorials. As noted earlier, for those of you who are not familiar with object oriented programs, you can think of a ''class'' loosely as being synonymous to ''modules''. Normally, Visual Prolog defines each class in its own separate file.

During the program execution, it often so happens that the program may need to invoke a predicate that is actually defined in another class (file). Similarly, data (constants) or domains defined in a class may need to be accessed from a different file.

Visual Prolog allows such cross class code/data references using a concept called scope access. This can be understood by an example. Suppose there is a predicate called pred1 defined in a class called class1 (which is written down in another file using the IDE), and we need to call that predicate in the clause body of some other predicate, pred2 in a different file (say class2) then this is how pred1 would be called within the clause body of pred2 :

<vip>clauses
pred3:-
...
!.

pred2:-
class1::pred1, %pred1 is not known in this file. It is defined in some other file, hence a class qualifier is needed
pred3,
...</vip>

In the above example, you can see that the clause body of pred2 calls two predicates pred1 and pred3. As pred1 is defined in another file (which defines class1), the word class1 with the token '''::''' (two colons) precedes the word pred1. This can be called as a class qualifier.But the predicate pred3 is defined within the same file as pred2 itself. Hence there is no need to indicate class2:: prior to the predicate call for pred3.

This behavior is technically explained thus: The ''scope visibility'' of pred3 is within the same scope of pred2. Hence there is no need to clarify that pred3 is from the same class as pred2. The compiler would automatically look for the definition of pred3 within the same scope area as defined for class2.

The scope area of a particular class definition is restricted to the class that is implemented in a particular file (i.e. code that is written within the implement ''-'' end implement keywords). The predicates defined therein can call each other without the class qualifier and the double colon (::) token preceding it.

The scope area of a class can be extended by using the open keyword. This keyword informs the compiler to bring in names (of predicates / constants / domains) that were defined in other files. If a scope area is extended, then we need not write the class qualifier with the double colon.

<vip>open class1
...

clauses
pred3:-
...
!.

pred2:-
pred1, %Note: "class1::" qualifier is not needed anymore, as the scope area is extended using the 'open' keyword
pred3,
...</vip>

===Object Orientation===

The current version of Visual Prolog is a strongly object oriented language. The ENTIRE code which is developed for a program is put into appropriate classes, as needed. This happens by default, even if you are not interested in the object oriented features of the language. You would notice this feature in the example given in this tutorial also. The code is inserted into a class called "family1" even though we would eventually not use any objects created from that class. Instead, we would use publicly accessible predicates of the code within that class directly.

This tutorial will not handle the object oriented features of the language. Future tutorials would extend this concept, and even actually use the object oriented features.

==A Full Fledged Example: family1.prj6==

'''Download:''' Source files of the example project used in this tutorial.<img alt src="../tut11/images/tut11_dot.gif" border="0" width="1" height="1">

Let us now put all the knowledge we've gathered together to create our first Visual Prolog program. This will contain the same basic logic that was explored in the Tutorial "Fundamental Prolog. Part 2". All the code that is to be written for this tutorial is shown below. It has to be written into the file called ''family1.pro''. The actual code writing will be done using the Visual Prolog IDE (Integrated Development Environment). There are some more files that are needed for the tutorial, but those would automatically be generated and maintained by the IDE. The step by step instructions (using screenshots) for utilizing the IDE to develop the program will shortly follow.

But first of all, let us acquaint ourselves with the main code of the program:

<vip>implement family1
open core

constants
className = "family1".
classVersion = "$JustDate: $$Revision: $".

clauses
classInfo(className, classVersion).

domains
gender = female(); male().

class facts - familyDB
person : (string Name, gender Gender).
parent : (string Person, string Parent).

class predicates
father : (string Person, string Father) nondeterm anyflow.
clauses
father(Person, Father) :-
parent(Person, Father),
person(Father, male()).

class predicates
grandFather : (string Person, string GrandFather) nondeterm anyflow.
clauses
grandFather(Person, GrandFather) :-
parent(Person, Parent),
father(Parent, GrandFather).

class predicates
ancestor : (string Person, string Ancestor) nondeterm anyflow.
clauses
ancestor(Person, Ancestor) :-
parent(Person, Ancestor).
ancestor(Person, Ancestor) :-
parent(Person, P1),
ancestor(P1, Ancestor).

class predicates
reconsult : (string FileName).
clauses
reconsult(FileName) :-
retractFactDB( familyDB),
file::consult(FileName, familyDB).

clauses
run():-
console::init(),
stdIO::write("Load data\n"),
reconsult("fa.txt"),
stdIO::write("\nfather test\n"),
father(X, Y),
stdIO::writef("% is the father of %\n", Y, X),
fail.
run():-
stdIO::write("\ngrandFather test\n"),
grandFather(X, Y),
stdIO::writef("% is the grandfather of %\n", Y, X),
fail.
run():-
stdIO::write("\nancestor of Pam test\n"),
X = "Pam",
ancestor(X, Y),
stdIO::writef("% is the ancestor of %\n", Y, X),
fail.
run():-
stdIO::write("End of test\n").
end implement family1

goal
mainExe::run(family1::run).</vip>

===Step 1: Create a New Console Project in the IDE===

'''Step 1a.''' After starting the Visual Prolog IDE, click on the New menu item from the Project menu.

[[Image:FundamentalVisualProlog1.jpg]]

'''Step 1b.''' A dialog would be presented to you. Enter all the relevant information. Ensure that the UI Strategy is ''Console'' and NOT ''GUI''.

[[Image:FundamentalVisualProlog2.jpg]]

===Step 2: Build an Empty Project===

'''Step 2a.''' When the project is just created, the IDE would display the following project window. At this point in time, it does not have any clue about what files the project is dependent on. It does, however create the basic source code files for the project.

'''Step 2b.''' Use the Build menu item of the Build menu, to compile and link the empty project to create an executable file which basically does not do anything. (At this point it time, it would not generate any errors either)

While building the project, take a look at the messages that are dynamically displayed in the '''Messages''' window of the IDE. (In the case the '''Messages''' window is not visible, you can turn it on using the Window menu of the IDE) You will notice that the IDE intelligently pulls in ALL the necessary PFC (Prolog Foundation Classes) modules into your project. PFC classes are those classes which contains the basic functionality on which your programs would be built.

===Step 3: Populate the family1.pro with the Actual Code===

'''Step 3a.''' The default code inserted by the IDE is very basic and does not do anything useful. You would need to delete the entire code and copy and paste the actual code of family1.pro (given in this tutorial) into that window.

[[Image:FundamentalVisualProlog5.jpg]]

'''Step 3b.''' After you perform the copy-paste operation, the family1.pro window would now look as shown below:

[[Image:FundamentalVisualProlog6.jpg]]

===Step 4: Rebuild the Code===

Re-invoke the Build menu command, and the IDE will notice that the source code has changed, and will take measures to appropriately recompile the correct sections. If you use the Build All menu command, then ''ALL'' the modules would be recompiled. For large programs this can consume some time. Build All is often used ONLY at the end of a series of smaller compilations; just to ensure that everything is in ship-shape order.

During the ''Build'' process, the IDE not only does the compilation; but it also determines whether the project may need any other missing PFC modules, and inserts those and re-starts the compilation process if required. This can be seen in the messages appearing in the Messages window, where you'll notice the IDE was forced to build the project ''twice'' because of some additional include statements.

[[Image:FundamentalVisualProlog7.jpg]]

===Step 5: Execute the Program===

We now have our first true application complied using Visual Prolog. In order to test the application we've just compiled, you can run the program using the Build | Run ''in'' Window menu command. However, in our case this would result in an error. The reason is that our little program is trying to read a text file (fa.txt) for its functioning. That text file contains the actual data regarding persons which our program will process. We'll come to the syntax of that file a bit later.

We need to now write that text file using some text editor and place it in the same directory where the executable is now residing. Normally, the executable would reside in the sub-folder called exe from the main project folder.

Let us create such a file using the IDE itself. Use the File | New menu command. The Create Project Item window will appear. Select Text file from the list on the left hand side. Then select the appropriate directory where the file is to reside (The same directory where the executable file family1.exe is present). Then, give the filename ''fa.txt'' and click on the Create button of the dialog. Till the filename is given, the Create button would be grayed (disabled). Make sure that the checkbox: Add to project as module is checked on. The advantage of adding it to the project is that it would be available for any subsequent debugging, etc.

The contents of the file would be as follows:

<vip>clauses
person("Judith",female()).
person("Bill",male()).
person("John",male()).
person("Pam",female()).
parent("John","Judith").
parent("Bill","John").
parent("Pam","Bill").</vip>

Though it is a data file, you would notice that the syntax of the file is VERY similar to regular Prolog code! Even though the program is now compiled and is now in a binary format; you can change the output by simply changing the crucial data the program is processing. And that data is written into this text file using the same syntax as Prolog. Thus Visual Prolog emulates the ''dynamic'' code writing capability of traditional Prolog. Albeit, not all features are available but at least complicated domains such as those in this example can definitely be given.

The syntax used in fa.txt MUST be compatible with the domain definitions of the program. E.g. The functor used for defining a person MUST be ''person'' and not anything else; else appropriate compound domain representing that functor would not get initialized. (We had covered the topic of functors and compound domains in an earlier tutorial).

Now, when you run the program using the Build | Run in the Window menu command, this is what you'll see:

[[Image:FundamentalVisualProlog8.jpg]]

The program processes the information in the file fa.txt and works out the logical sequence of the parentages of people given there.

===A Round up of the Program===

The logic of the program is very simple. We had discussed it in an earlier tutorial, where we explained how the correct representation of data can help yield the appropriate results in a Prolog program. Let us now discuss the manner in which this logic works.

At start up, the main predicate will be invoked directly. This in turns branches off to the run predicate. The first thing the run predicate will do is to read in the data which is written in the file fa.txt. Once the data is in place, the program systematically progresses from one test to another to process the data and write out the conclusions of that test onto the console.

The mechanisms for processing the data are standard mechanisms of backtracking and recursions. This tutorial is not the place for a detailed explanation of how Prolog works, but here is a short summary of the internal workings.

When the run predicate is calling the father predicate, it does not stop at the first satisfactory ending of the father predicate. The invoking of a fail at the end of the predicate, forces the Prolog engine to seek another pass through the father predicate. Such a behavior is called ''backtracking'', because the Prolog engine literally seems to backtrack over code which had earlier executed.

This happens recursively (i.e. as a repetitive process or cyclically), and at each cycle the father predicate yields the next result. Eventually all the possible definitions of "fathers" given in the data are exhausted, and the run predicate would have no choice but carry over to the next clause body of the run predicate.

The father predicate (as well as some other predicates) has been declared to be non-deterministic. The keyword nondeterm can be used to declare non-deterministic predicates; i.e. predicates that can yield multiple answers using backtracking.

If the no keyword is used in a predicate declaration, then the predicate has got the procedure mode, which can give only one solution, and the father predicate will stop after yielding the first result and cannot be re-entered into. Also, one must be careful in the usage of the cut (!) in the clause bodies of such non-deterministic predicates. If there is a cut at the end of the clause body of the father predicate, yet again; the predicate will yield only one solution (even if it has been declared to be non-deterministic).

The anyflow flow-pattern tells the compiler that the parameters that are given for the predicate could be either free or bound, with no restrictions whatsoever. That means, with the same definition of the father predicate, it would be possible to both yield the father's name (in case the name of the offspring was bound) OR the offspring's name (in case the name of the father was bound). It can also handle situations where both are bound; in which case the predicate will check if such a relationship exists in the data.

And; to state the obvious; the anyflow flow pattern can also accommodate a situation where both the parameters of the father predicate are free variables. In such a case, the father predicate will yield the various combinations of father+offspring present in the data the program has learnt (through consulting the fa.txt file) to the enquirer. The last usage is what is performed in the run predicate, as seen in the code snippet below. You would notice that the variables X and Y given to the father predicate are not bound when the father predicate is called.

<vip>clauses
run():-
console::init(),
stdIO::write("Load data\n"),
reconsult("fa.txt"),
stdIO::write("\nfather test\n"),
father(X,Y),
stdIO::writef("% is the father of %\n", Y, X),
fail.</vip>

==Conclusion==

In this lesson we learnt that programs written in Visual Prolog are often very similar to those written in traditional Prolog. There are several keywords that are used to differentiate the various parts of a Visual Prolog source code. Though Visual Prolog is an object-oriented language, it is possible to develop code which avoids the language's object-oriented features. A complete console-based application (family1) was developed in this tutorial, which explains, how to create such a program.

We also found that it is possible to emulate the dynamic working of a traditional Prolog program by keeping part of the code as a data file outside the main binary compiled application. The syntax of such a data file closely follows Prolog syntax.

==References==

[[Категория:VipРуководства]]

Turbo Prolog

2007-11-10T19:02:13Z

SergeMukhin:

Turbo Prolog распространялся на рынке в 80-е годы компанией Borland. Turbo Prolog был разработан учредителями PDC.

==Примеры кодов Turbo Prolog / программы, доступные в Интернете==

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

[http://perso.orange.fr/colin.barker/tpro1/tpro.htm Colin Barker*s Turbo Prolog Goodies]

Несколько примеров на Turbo Prolog разработал Frank Bergmann:
*[http://www.fraber.de/games/chess/index.html Chess]
*[http://www.fraber.de/games/queens/index.html Queens]
*[http://www.fraber.de/games/world/index.html Tarskies World]

Анонимные предикаты

2007-11-08T05:30:30Z

SergeMukhin:

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

Пример использования:

<Vip>
interface авто
properties
цена : unsigned(o).
end interface авто

class выборАвтомобиля
predicates
неДорогие : () -> авто* Результат.
...
implement выборАвтомобиля
clauses
неДорогие() = list::filter({(Авто) :- Авто:цена <= 10000, !}, списокАвтомобилей).
...
</Vip>

Казалось бы ничего нового, ведь то же самое можно записать при помощи дополнительного предиката. Например так
<Vip>predicates
фильтрДляНедорогих : (авто Авто).
clauses
фильтрДляНедорогих(Авто) :- Авто:цена <= 10000, !.
clauses
неДорогие() = list::filter(фильтрДляНедорогих, списокАвтомобилей).</Vip>

Но сегодня для нас сумма 10000 является пределом мечтаний, а завтра 12000, как быть? Есть два решения, или менять константу, или добавить факт-переменную. Анонимный предикат позволит сделать это изящней.
<Vip>predicates
неДорогие2 : (unsigned НашиВозможности).
clauses
неДорогие2(НашиВозможности) = list::filter({(Авто) :- Авто:цена <= НашиВозможности, !}, списокАвтомобилей).</Vip>

Если внимательно присмотреться, то тут мы наблюдаем картину, ранее недоступную невооружённым глазом. Переменная ''НашиВозможности'' из предиката ''''неДорогие2'''' перекочевала во внутрь другого предиката - фильтра! Вот это уже нельзя сделать использую дополнительный предикат, как раньше.

Это не оконченная статья

[[Категория:VipLanguage]]

Анонимные предикаты

2007-11-07T19:44:17Z

SergeMukhin:

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

Пример использования:

<Vip>
interface авто
properties
цена : unsigned(o).
end interface авто

class выборАвтомобиля
predicates
недорогие : () -> авто* Результат.
...
implement выборАвтомобиля
clauses
неДорогие() = list::filter({(Авто):-Авто:цена <= 10000, !}, списокАвтомобилей).
...
</Vip>

Казалось бы ничего нового, ведь то же самое можно записать при помощи дополнительного предиката. Например так
<Vip>predicates
фильтрДляНедорогих : (авто Авто).
clauses
фильтрДляНедорогих(Авто):- Авто:цена <= 10000, !.
clauses
неДорогие() = list::filter(фильтрДляНедорогих, списокАвтомобилей).</Vip>

Но сегодня для нас сумма 10000 является пределом мечтаний, а завтра 12000, как быть? Есть два решения, или менять константу, или добавить факт-переменную. Анонимный предикат позволит сделать это изящней.
<Vip>predicates
неДорогие2 : (unsigned НашиВозможности).
clauses
неДорогие2(НашиВозможности) = list::filter({(Авто):-Авто:цена <= НашиВозможности, !}, списокАвтомобилей).</Vip>

Если внимательно присмотреться, то тут мы наблюдаем картину, ранее недоступную невооружённым глазом. Переменная ''НашиВозможности'' из предиката ''''неДорогие2'''' перекочевала во внутрь другого предиката - фильтра! Вот это уже нельзя сделать использую дополнительный предикат, как раньше.

Это не оконченная статья

[[Категория:VipLanguage]]

Анонимные предикаты

2007-11-07T19:43:36Z

SergeMukhin:

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

Пример использования:

<Vip>
interface авто
properties
цена : unsigned(o).
end interface авто

class выборАвтомобиля
predicates
недорогие : () -> авто* Результат.
...
implement выборАвтомобиля
clauses
неДорогие() = list::filter({(Авто):-Авто:цена <= 10000, !}, списокАвтомобилей).
...
</Vip>

Казалось бы ничего нового, ведь то же самое можно записать при помощи дополнительного предиката. Например так
<Vip>predicates
фильтрДляНедорогих : (авто Авто).
clauses
фильтрДляНедорогих(Авто):- Авто:цена < 10000, !.
clauses
неДорогие() = list::filter(фильтрДляНедорогих, списокАвтомобилей).</Vip>

Но сегодня для нас сумма 10000 является пределом мечтаний, а завтра 12000, как быть? Есть два решения, или менять константу, или добавить факт-переменную. Анонимный предикат позволит сделать это изящней.
<Vip>predicates
неДорогие2 : (unsigned НашиВозможности).
clauses
неДорогие2(НашиВозможности) = list::filter({(Авто):-Авто:цена <= НашиВозможности, !}, списокАвтомобилей).</Vip>

Если внимательно присмотреться, то тут мы наблюдаем картину, ранее недоступную невооружённым глазом. Переменная ''НашиВозможности'' из предиката ''''неДорогие2'''' перекочевала во внутрь другого предиката - фильтра! Вот это уже нельзя сделать использую дополнительный предикат, как раньше.

Это не оконченная статья

[[Категория:VipLanguage]]

Visual Prolog для чайников

2007-11-07T16:21:31Z

SergeMukhin:

''Visual Prolog для Чайников'' (в оригинале Visual Prolog For Tyros) пока является наиболее подробной книгой по Visual Prolog, написанная Eduardo Costa.

Мы представляем здесь макет перевода, который вместе с форматированием выполнил Марк Сафронов.
Переводчиком учтён ряд замечаний, сделанных участниками русскоязычного [http://www.progz.ru/forum/index.php?showforum=10 Форума по Прологу]

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

===Содержание===

*I Savoir-faire
**Введение
**Формы
**События мыши
**Некоторые изображения
**Хороновские Клаузы
**Консольные приложения
**Грамматики
**Рисование
**Типы данных
**Как это решается на Прологе
**Факты
**Классы и Объекты
**Джузеппе Пеано (Giuseppe Peano)
**L-Системы
**Игры
**Анимация
**Текстовый редактор
**Печать
**Фомы с закладками и прочие прелести
**Ошибки
**Менеджер баз данных
**Книги и статьи
*II Искусственный интеллект
**Поиск
**Нейронные сети
**Alpha Beta Pruning

===Скачать===
*[http://www.visual-prolog.com/vip/tutorial/tut14/tyros71_8.pdf Visual Prolog for Tyros - оригинал] ( Язык:En. PDF формат, 252 страницы).
**[http://www.visual-prolog.com/vip/tutorial/tut14/tyros71_rus_pdf.zip Язык:Ru; Zip(PDF) формат, 4.05 Mb]
**[http://www.visual-prolog.com/vip/tutorial/tut14/tyros71_rus_docx.zip Язык:Ru; Zip(DOCX) формат 5.14 Mb]
**[http://www.visual-prolog.com/vip/tutorial/tut14/tyros71_rus_doc.zip Язык:Ru; Zip(DOC) формат, 10.5 Mb]


Примеры
*[http://www.visual-prolog.com/vip/tutorial/tut14/tyros71_8.zip Примеры к руководству] (ZIP формат)

==Ссылки==
[[en:Visual Prolog for Tyros]]
[[Category:VipРуководства]]

Анонимные предикаты

2007-11-06T09:43:57Z

SergeMukhin:

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

Пример использования:

<Vip>
interface авто
properties
цена : unsigned(o).
end interface авто

class выборАвтомобиля
predicates
недорогие : () -> авто* Результат.
...
implement выборАвтомобиля
clauses
неДорогие() = list::filter({(Авто):-Авто:цена <= 10000, !}, списокАвтомобилей).
...
</Vip>

Казалось бы ничего нового, ведь то же самое можно записать при помощи дополнительного предиката. Например так
<Vip>predicates
фильтерДляНедорогих : (авто Авто).
clauses
фильтерДляНедорогих(Авто):- Авто:цена < 10000, !.
clauses
неДорогие() = list::filter(фильтерДляНедорогих, списокАвтомобилей).</Vip>

Но сегодня для нас сумма 10000 является пределом мечтаний, а завтра 12000, как быть? Есть два решения, или менять константу, или добавить факт-переменную. Анонимный предикат позволит сделать это изящней.
<Vip>predicates
неДорогие2 : (unsigned НашиВозможности).
clauses
неДорогие2(НашиВозможности) = list::filter({(Авто):-Авто:цена <= НашиВозможности, !}, списокАвтомобилей).</Vip>

Если внимательно присмотреться, то тут мы наблюдаем картину, ранее недоступную невооружённым глазом. Переменная ''НашиВозможности'' из предиката ''''неДорогие2'''' перекочевала во внутрь другого предиката - фильтра! Вот это уже нельзя сделать использую дополнительный предикат, как раньше.

Это не оконченная статья

[[Категория:VipLanguage]]

Особенности применения append

2007-11-06T07:20:34Z

SergeMukhin:

'''автор: Thomas Linder Puls. PDC'''

Соединение списков в Прологе затратно по своей природе. Эта проблема связана с «персистентной» природой прологовских списков. Структура персистентных данных неизменяема и неуничтожима при манипулировании этими данными.

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

Используя предикат '''append''' нужно быть очень осторожным, очень легко изменить линейную сложность алгоритма (О(N)) на квадратичную (О(N*N)).
Рассмотрим пример. Имеем бинарное дерево:
<vip>
domains
binTree =
empty();
tree(binTree Left, integer Node, binTree Right).
</vip>
Мы хотим создать список всех элементов дерева. Вот очевидный способ решения этой задачи, используя предикат '''append''':
<vip>
clauses
elems(empty()) = [].
elems(tree(Left, Node, Right)) = Elems :-
LeftElems = elems(Left),
RightElems = elems(Right),
Elems = append(LeftElems, [Node|RightElems]).
</vip>
Т.е. мы находим элементы в левом поддереве, затем в правом поддереве и соединяем их, вставив узел перед элементами правого поддерева.

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

Если в дереве N узлов, то мы имеем одну вершину и N-1 элементов в левом поддереве и пустое правое поддерево. В этом уровне, '''append''' выполнит N-1 операцию. На следующем уровне, по аналогии, будут выполнены N-2 операций, т.д. По моим представлениям о высшей математике, всего получится N*N/2 операций. Поэтому, в наихудшем случае, этот алгоритм имеет квадратичную сложность. Правда, в лучшем случае, алгоритм линейный. Оставляю вам доказательство этого утверждения.

Лично я никогда не применяю '''append''' в рекурсивном алгоритме. Я использую его, например, для соединения содержимого двух списковых элементов управления. Вообще, я практически никогда не использую '''append'''. Когда я его вижу, это вызывает настороженность - нет ли проблемы с этим алгоритмом?

К счастью, в нашем случае легко избежать использования '''append'''. Имеется стандартная «хитрость», которая помогает решить проблему без '''append''' с линейной сложностью в худшем случае.
Введём вспомогательный предикат, который не только собирает узлы, но и объединяет их в список. Звучит это ещё более сложно, чем раньше, но в действительности это не так. Вот предлагаемый предикат:
<vip>
clauses
elems_append(empty(), L) = L.
elems_append(tree(Left, Node, Right), L) = M :-
RightL = elems_append(Right, L),
M = elems_append(Left, [Node|RightL]).
</vip>
Если дерево пусто, то просто возвращается исходный список. Если дерево не пусто, то сначала присоединяем элементы правого дерева к L, затем помещаем узел в начало и, наконец, присоединяем элементы левого дерева. В результате процесс идёт с конца в начало. Этот алгоритм не только не использует '''append''', но даже в худшем случае имеет сложность О(N). Оставляю вам доказательство этого.

Этот предикат не решает исходной проблемы, но следующий предикат делает это:
<vip>
clauses
elem(Tree) = elem_append(Tree, []).
</vip>
Т.е. присоединяет пустой список к элементам дерева.
[[Категория:VipLanguage]]
[[Категория:VipКомментарии]]

Составные Домены и Списки

2007-11-06T07:16:15Z

SergeMukhin:

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

Составные домены и списки создаются с использованием встроенных (built-in) и других составных или списковых доменов. Справочная система Visual Prolog (Help) объясняет встроенные домены:
*integer - целые
*real - вещественные
*string - строковые
*symbol -символьные
*char - знаковые
*sring8 - строковые 8-разрядные
*pointer - указатели
*binary - двоичные (бинарные)
*boolean - булевские
*object - объекты

==Составные домены и Функторы==
Составные домены позволяют рассматривать наборы данных как единое целое и при этом мы можете рассматривать их и раздельно. Рассмотрим, например, дату "October 15, 2003". Она состоит из трех единиц информации – месяца, дня и года – но было бы полезно рассматривать дату как единое целое в виде древовидной структуры:

<pre> DATE
/|\
/ | \
/ | \
/ | \
October 15 2003</pre>
Это можно сделать путем объявления домена '''date_cmp''', содержащего данные '''date''':
<vip>domains
date_cmp = date(string Month, unsigned Day, unsigned Year).</vip>
и затем писать просто, то есть
<vip>D = date("October", 15, 2003),</vip>
Это выглядит как факт Пролога, но это не так – это всего лишь значение, которое можно обрабатывать почти также, как строки или числа. Такая структура начинается с имени, обычно называемым функтор (functor) (в данном случае - date), за которым следуют три аргумента.

Обращаем Ваше внимание на то, что функтор в Visual Prolog не имеет ничего общего с функциями в языках программирования. '''''Функтор не вызывает никаких вычислений''''', это всего лишь имя, которое идентифицирует составную величину и объединяет свои аргументы.

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

<pre> birthday
/ \
/ \
/ \
/ \
/ \
person date
/ \ / | \
/ \ / | \
"Per" "Schultze" "Apr" 14 1960</pre>
На Прологе это может быть записано как:
<vip>birthday(person("Per", "Schultze"), date("Apr",14,1960)).</vip>
В этом примере видны две подчасти составного значения birthday: аргумент person("Per", "Schultze") и аргумент date("Apr", 14, 1960). Функторами этих величин являются person и date.

==Унификация Составных Доменов==
Значения составных доменов могут унифицироваться либо с одиночными переменными, либо с составными значениями, которые сопоставимы с ними (здесь возможны переменные, как части внутренней структуры). Это значин, что Вы можете использовать составные величины для передачи в виде целого набора данных, а затем разбирать их по частям путем операции унификации. К примеру,
<vip>date("April", 14, 1960)</vip>
сопоставляется с переменной X и связывает переменную X с date("April",14,1960). Кроме того,
<vip>date("April", 14, 1960)</vip>
сопоставляется с date(Mo,Da,Yr) и связывает Mo с "April", Da с 14 и Yr с 1960.
===Использование Знака Равенства для Унификации Составных Доменов===
Visual Prolog выполняет унификацию в двух случаях. Первый - это когда вызов сопоставляется с головой клаузы. Второй - это при использовании знака '''''равно''''' (=), который в действительности является инфиксной формой предиката (предикат, который находится '''между''' своими аргументами, вместо того, чтобы быть '''перед''' ними).

Visual Prolog осуществляет необходимые связывания для унификации значений по обе стороны от знака '''равно'''. Это полезно для выделения значений аргументов в составных величинах. Например, следующий код проверяет имеют ли два человека одинаковы фамилии, после чего второй человек получает тот же адрес, что и первый.
<vip>class my
domains
person = person(name, address).
name = name(string First, string Last).
address = addr(street, string City, string State).
street = street(integer Number, string Street_name).

predicates
run :().
end class

implement my
clauses
run():-
console::init(),
P1 = person(name("Jim", "Smith"),addr(street(5, "1st st"), "igo", "CA")),
P1 = person(name(_, "Smith"), Address),
P2 = person(name("Jane", "Smith"), Address),
!,
stdio::write("P1 = ", P1, "\n"),
stdio::write("P2 = ", P2, "\n")
;
stdio::write("No solution").
end implement

goal
my::run.</vip>

==Структура Данных Как Единое Целое==
Составные данные могут рассматриваться как одиночные значения в клаузах Пролога, что значительно упрощает программирование. Рассмотрим следующий факт
<vip>owns("John", book("From Here to Eternity", "James Jones")).</vip>
в котором утверждается, что John владеет книгой "From Here to Eternity", написанной автором "James Jones". В то же время можно написать
<vip>owns("John", horse("Blacky")).</vip>
что может интерпретироваться как
John владеет лошадью с именем Blacky.

Составными значениями в этих двух примерах являются
<vip>book("From Here to Eternity", "James Jones")).</vip>
и
<vip>horse("Blacky").</vip>
Если бы вместо этого было бы записаны два факта:
<vip>owns("John", "From Here to Eternity").
owns("John", "Blacky").</vip>
то нельзя было бы решить является ли Blacky названием книги или имнем лошади. С другой стороны, можно использовать первый компонент структуры – функтор, для обозначения различия между различными типами данных. В этом примере использовались, соответственно функторы book и horse для того, чтобы показать различие между данными.

'''Помните''': Составные данные состоят из функтора и аргументов, принадлежащих функтору, как показано ниже:
<vip>functor(argument1, argument2, ..., argumentN)</vip>

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

<vip>predicates
phone_list :(string First, string Last, string Phone, string Month, intege Day, integer Year) determ.

clauses
phone_list("Ed", "Willis", "422-0208", "aug", 3, 1955).
phone_list("Chris", "Grahm", "433-9906", "may", 12, 1962).</vip>

Анализируя данные, замечаем, что факт phone_list имеет шесть аргументов; пять из них могут разбиты на два составных домена:

<pre> person birthday
/ \ / | \
/ \ / | \
First Name Last Name Month Day Year</pre>
Было бы более полезно представить эти факты в виде составных доменов. Отступив на шаг, видим, что персона (person) является отношением, а имя (First Name) и фамилия (Last Name) являются его аргументами. Кроме того, день рождения является также отношением с тремя аргументами: месяц (month), день (day) и год (year). Представление этих отношений средствами Пролога аналогично уже упоминавшемуся
<vip>owns("John", "From Here to Eternity").
owns("John", "Blacky").</vip>
Теперь можно переписать нашу небольшую базу данных с использованием этих составных доменов в базе данных.

<vip>domains
name = person(string First, string Last).
birthday = b_date(string Month, integer Day, integer Year).

class predicates
phone_list :(name, string Ph_num, birthday) determ.
clauses
phone_list(person("Ed", "Willis"), "422-0208",b_date("aug", 3, 1955)).
phone_list(person("Chris", "Grahm"), "433-9906",b_date("may", 12, 1962)).</vip>

В этой программе появились объявления двух составных '''доменов (domains)'''. Мы детальнее рассмотрим эти составные структыры данных позднее в этой главе. Пока же мы обратим внимание на преимущества использования таких составных доменов.

Предикат phone_list теперь содержит три аргумента вместо прежних шести. Иногда разбиение данных на составные структуры упрощает программу и облегчает обработку данных.

Теперь добавим некоторые правила в программу. Предположим, нам надо получить список людей, чьи дни рождения выпадают на текущий месяц. Ниже приведена программа, решающая эту задачу; эта программа использует стандартный предикат date для получения текущей даты из внутренних часов компьютера. Предикат date возвращает текущий год (year), месяц (month) и день (day) часов компьютера.
<vip>class my
domains
name = person(string First, string Last).
birthday = b_date(string Month, integer Day, integer Year).
predicates
phone_list :(name, string Ph_num, birthday) multi(o,o,o).
get_months_birthdays :().
convert_month :(string Name, integer Num) determ(i,o).
check_birthday_month :(integer Month_num, birthday) determ.
write_person :(name).
end class

implement my

clauses
get_months_birthdays() :-
stdio::write("****** This Month's Birthday List *****\n"),
stdio::write(" First Name\t\t Last Name\n"),
stdio::write("***********************************\n"),
CurTime = time::new(),
CurTime:getDate(_, ThisMonth, _),
phone_list(Person, _, Date),
check_birthday_month(ThisMonth, Date),
write_person(Person),
fail.
get_months_birthdays() :-
stdio::write("\n Press any key to continue:\n"),
_ = console::readChar().

clauses
write_person(person(FirstName, LastName)) :-
stdio::write(" ", FirstName, "\t\t ", LastName, "\n").

clauses
check_birthday_month(Mon, b_date(Month, _, _)) :-
convert_month(Month, Month1),
Mon = Month1.

clauses
phone_list(person("Ed", "Willis"), "11-1111", b_date("Jan", 3, 1955)).
phone_list(person("Benjamin", "Thomas"), "222-2222", b_date("Feb", 5, 1965)).
phone_list(person("Ray", "William"), "333-3333", b_date("Mar", 3, 1955)).
phone_list(person("Tomas", "Alfred"), "444-4444", b_date("Apr", 29, 1975)).
phone_list(person("Chris", "Gralm"), "555-5555", b_date("May", 12, 1975)).
phone_list(person("Dastin", "Robert"), "666-6666", b_date("Jun", 17, 1975)).
phone_list(person("Anna", "Friend"), "777-7777", b_date("Jul", 2, 1975)).
phone_list(person("Naomi", "Friend"), "888-8888", b_date("Aug", 10, 1975)).
phone_list(person("Christina", "Lynn"), "999-9999", b_date("Sep", 25, 1975)).
phone_list(person("Kathy", "Ann"), "110-1010", b_date("Oct", 20, 1975)).
phone_list(person("Elizabeth", "Ann"), "110-1111", b_date("Nov", 9, 1975)).
phone_list(person("Aaron", "Friend"), "110-1212", b_date("Dec", 31, 1975)).
phone_list(person("Jenifer", "Faitlin"), "888-8888", b_date("Aug", 14, 1975)).

clauses
convert_month("Jan", 1).
convert_month("Feb", 2).
convert_month("Mar", 3).
convert_month("Apr", 4).
convert_month("May", 5).
convert_month("Jun", 6).
convert_month("Jul", 7).
convert_month("Aug", 8).
convert_month("Sep", 9).
convert_month("Oct", 10).
convert_month("Nov", 11).
convert_month("Dec", 12).
end implement

goal
console::init(),
my::get_months_birthdays().</vip>

Каким образом составные домены помогают в этой программе? Это несложно увидеть, просмотрев код. Основная часть обработки производится в предикате get_months_birthdays.

*Сначала создается окно предикатом console::init()
*После этого пишется заголовок в окне, помогающий интерпретировать результаты.
*В предикате get_months_birthdays программа использует встроенный (built-in) предикат date, чтобы получить значение текущего месяца.
*Далее все в программе направлено на поиск в базе данных и получения списка людей, родившихся в текущем месяце. Прежде всего надо найти первого человека в базе данных. Вызов phone_list(Person, _, Date) связывает имя и фамилию человка с переменной Person путем связывания целого функтора person с этой переменной Person. Одновремиенно связывается день рождения человека с переменной Date.<br/> Обратите внимание, что для этого требуется всего одна переменная для запоминания полного имени человека и всего одна переменная Date для запоминания дня рождения. В этом и заключается мощность составных доменов.
*Теперь программа передает день рождения человека в виде одной переменной Date. Это происходит в следующей подцели, где программа передает значение текущего месяца (month), представленного целым числом, и день рождения (обрабатываемого человека) в предикат check_birthday_month.
*Посмотрите внимательно, что происходит. Visual Prolog вызывает предикат check_birthday_month с двуми параметрами: первый параметр связан с целым числом, а второй - с термом birthday. В голове правила, определяющего предикат check_birthday_month, первый аргумент сопоставляется с переменной Mon. Второй аргумент, Date, сопоставляется с b_date(Month, _,_).<br/> Поскольку нас интересует только месяц рождения человека, то на месте как дня, так и года рождения мы используем анонимную переменную.
*Предикат check_birthday_month сначала преобразует строку с названием месяца в целочисленное значение. Как только это сделано, Visual Prolog может сравнивать значение текущего месяца со значением месяца рождения человека. Если такое сравнение положительно (успешно), то цель check_birthday_month считается успешной, и обработка продолжается. Если же сравнение неуспешно (fails) - обрабатываемый человек не родился в текущем месяце, то Visual Prolog начинает операцию отката для поиска другого возможного решения задачи.
*Следующая обрабатываемая подцель - write_person. У обрабатываемого человека день рождения выпадает на текущий месяц, следовательно можно печатать его имя в отчете. После печати информации, клауза завершается предикатом неуспешности (fail), что вызывает откат.
*'''''Откат всегда распространяется вверх до ближайшего недетерминированного вызова и пытается передоказать вызов.''''' В нашей программе последним недетерминированным вызовом является вызов phone_list. Именно здесь программа выбирает следующего человека для обработки. Если людей в списке (в базе данных) больше нет, то текущая клауза завершается неуспешно (fails); Visual Prolog теперь пытается доказать эту цель путем просмотра быза правил ниже. Поскольку есть еще одна клауза, определяющая get_months_birthdays, Visual Prolog пытается доказать обращение к get_months_birthdays путем доказательства подцелей этой другой части клаузы.

=Декларирование Составных Доменов=

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

<vip>owns("John", book("From Here to Eternity", "James Jones")).</vip>
и
<vip>owns("John", horse("Blacky")).</vip>
можно запрашивать систему с помощью следующей цели:
<vip>owns("John", X)</vip>
Переменная X может быть связана с различными типами данных - книгой, лошадью или возможно другим типом, который будет определен. Поскольку предикат owns теперь определён, больше его нельзя использовать в смысле старого определения:
<vip>owns :(string, string).</vip>
Второй аргумент больше не относится к домену string. Вместо этого необходимо сформулировать новое определение предиката, такое как, например
<vip>owns :(name, articles).</vip>
Вы можете теперь описать домен articles в секции domains как показано здесь:
<vip>domains
articles =
book(string Title, string Author);
horse(string Name).
/* Articles - это книги или лошади */</vip>
Точка с запятой здесь читаются как ''or (или)''. В нашем случае возможны две альтернативы: либо книга может быть определена своим названием и автором, либо лошадь определяется своим именем. Домены Title, Author и Name - все являются стандартными доменами string.

Дополнительные альтернативы могут быть легко добавлены в декларацию домена. К примеру, articles мог бы включать лодку, дом, или банковский счёт. Для лодки, можно было бы использовать функтор без аргументов. С другой стороны, может возникнуть желание представлять баланс счета в качестве банковской записи. Тогда объявления домена articles расширяются до:
<vip>domains
articles =
book(string Title, string Author);
horse(string Name);
boat;
bankbook(real Balance).</vip>
Далее приведена полная программа, которая показывает как составной домен articles может быть использован в определениях предиката owns.
<vip>class my
domains
articles =
book(string Title, string Author) ;
horse(string Name) ;
boat ;
bankbook(real Balance).
predicates
owns :(string Name, articles) nondeterm(i,o) determ(i,i).
end class

implement my
clauses
owns("John", book("A friend of the family", "Irwin Shaw")).
owns("John", horse("Blacky")).
owns("John", boat).
owns("John", bankbook(1000)).
end implement

goal
console::init(),
my::owns("John", Thing),
stdio::write("Thing: ", Thing, "\n"),
fail
;
stdio::write("The end.").
</vip>
Загрузим теперь эту программу в IDE и запустим её. Visual Prolog теперь ответит:
<vip>Thing: book("A friend of the family","Irwin Shaw")
Thing: horse("Blacky")
Thing: boat()
Thing: bankbook(1000)
The end.</vip>

==Итак: правила объявлений==

Дадим теперь общее представление способа записи объявлений составных доменов:
<vip>
domain =
alternative1(D, D, ...);
alternative2(D, D, ...);
...
</vip>
Здесь alternative1 и alternative2 являются равновозможными (но различными) функторами. Обозначение (D, D, ...) представляет список имен, которые объявлены в любом месте либо относятся к стандартным типам доменов(таким как string, integer, real и т.д.).

'''Примечания:'''
*Алтернативы разделяются точкой с запятой.
*Каждая альтернатива состоит из фуктора и, возможно, списка доменов для соответствующих аргументов.
*Если функтор не имеет аргументов, его можно записывать как alternativeN или alternativeN( ).

==Многоуровневые Составные Домены==
Visual Prolog позволяет организовывать многоуровневые составные домены. Например, в

<vip>book("The Ugly Duckling", "Andersen").</vip>

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

<vip>book("The Ugly Duckling", author("Hans Christian", "Andersen")).</vip>

В старом объявлении домена

<vip>book(string Title, string Author).</vip>

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

<vip>author = author(string First_name, string Last_name).</vip>

что приводит к следующим объявлениям:

<vip>domains
articles = book(string Title, author Author); ...
/* First level */
author = author(string First_name, string Last_name).
/* Second level */</vip>

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

<pre> book
/ \
/ \
title author
/ \
/ \
First_name Last_name</pre>

Одна декларация домена всегда описывает только один уровень дерева, а не все дерево. В частности, домен book не может быть объявлен такой декларацией:

<vip>/* Not allowed */
book = book(string Title, author(string First_name, string Last_name)).</vip>

=Объявления Составных Смешанных Доменов=

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

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

==Аргументы множественных типов==

Для того, чтобы предикат в Visual Prolog допускал использование аргументов различного типа, необходимо использовать функторные объявления. Следующий пример, клауза your_age clause будет воспринимать аргументы типа age, которые могут иметь тип string, real или integer.

<vip>domains
age = i(integer); r(real); s(string).

class predicates
your_age :(age).
clauses
your_age(i(Age)) :- stdio::write(Age).
your_age(r(Age)) :- stdio::write(Age).
your_age(s(Age)) :- stdio::write(Age).</vip>

При этом Visual Prolog не допускает декларации вида:

<vip>/* Не допустимо. */
domains
age = integer; real; string.</vip>

==Списки==

Предположим, мы обрабатываем данные о предметах, которые может преподавать учитель. Код может выглядеть так:

<vip>class predicates
teacher :(string First_name, string Last_name, string Class) determ.

clauses
teacher("Ed", "Willis", "english1").
teacher("Ed", "Willis", "math1").
teacher("Ed", "Willis", "history1").
teacher("Mary", "Maker", "history2").
teacher("Mary", "Maker", "math2").
teacher("Chris", "Grahm", "geometry").</vip>

Здесь необходимо повторять имя преподавателя для каждого предмета, который он (она) может преподавать. Для каждого предмета необходимо добавлять такой факт в базу данных. Хотя в данной ситуации это не вызывает трудности, можно найти школу, в которой сотни предметов, и тогда поддержка такой структур данных становится утомительной. Тогда было бы удобно создать такой аргумент для предиката, который мог бы воспринимать один или несколько значений.

В Прологе это делает '''список'''. В следующем коде аргумент class объявлен имеющим '''тип список'''. Покажем, как список представляется в Прологе.

<vip>domains
classes = string*. /* объявляет списковый домен*/

class predicates
teacher :(string First_name, string Last_name, classes Classes) determ.
clauses
teacher("Ed", "Willis", ["english1", "math1", "history1"]).
teacher("Mary", "Maker", ["history2", "math2"]).
teacher("Chris", "Grahm", ["geometry"]).</vip>

В этом примере код более лаконичен и проще читается, чем код предыдущего примера. Обратите внимание на объявление домена. Звездочка (*) означает, домен classes является списком строк. Так же легко можно объявить список целых:

<vip>domains
integer_list = integer*.</vip>

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

<vip>domains
integer_list = integer*.

class predicates
test_scores :
(string First_name,
string Last_name,
integer_list Test_Scores)
determ.
clauses
test_scores("Lisa", "Lavender", [86, 91, 75]).
test_scores("Libby", "Dazzner", [79, 75]).
test_scores("Jeff", "Zheutlin", []).</vip>

Обратите внимание, в случае ''Jeff Zheutlin'' список не содержит никаких элементов.

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

<vip>domains
tree_list = tree*.
tree = tree(string Text, tree_list TreeList).

class predicates
family :(tree) determ.
clauses
family(tree("Grandmother",
[tree("John",
[tree("Eric", []),
tree("Mark", []),
tree("Leonard", []) ] ),
tree("Ellen", [])
]
)).</vip>

=Заключение=

В этом руководстве были рассмотрены важные понятия:

*Программа на Visual Prolog может содержать множество типов значений: простых и составных, встроенных (стандартных) и определяемых в программе.
*Простые значения - это: числа, строки и т.д..
*''Составные домены'' позволяют рассматривать структуру информации как единую сущность. Составной домен состоит из имени (известного как функтор) и, возможно, аргументов. Можно определить домен с несколькими альтернативными функторами.
*Функтор в Visual Prolog не есть то же, что функция в других языках программирования. '''''Функтор не вызывает никаких вычислений.''''' Это просто имя которое обозначает составной домен и объединяет его аргументы.
*Составные значения могут обрабатываться и рассматриваться как одиночные переменные; функторы используются для создания различия между различными типами составных значений. Visual Prolog позволяет строить многоуровневые структурированные значения; Аргументами составных доменов могут быть опять-таки составные значения. Используя декларации составных смешанных доменов, можно использовать предикаты, которые:
**принимают аргументы нескольких различных типов (определяется объявлениями функторов).
**принимают переменное число аргументов, каждый определённого типа (объявления списков).
**принимают переменное число аргументов, часть из которых могут иметь более одного типа.

=Ссылки=
[[en:Compound and List Domains]]
[[Категория:VipРуководства]]
[[Категория:VipLanguage]]

Составные Домены и Списки

2007-11-06T07:14:16Z

SergeMukhin: /* Декларирование Составных Доменов */

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

Составные домены и списки создаются с использованием встроенных (built-in) и других составных или списковых доменов. Справочная система Visual Prolog (Help) объясняет встроенные домены:
*integer - целые
*real - вещественные
*string - строковые
*symbol -символьные
*char - знаковые
*sring8 - строковые 8-разрядные
*pointer - указатели
*binary - двоичные (бинарные)
*boolean - булевские
*object - объекты

==Составные домены и Функторы==
Составные домены позволяют рассматривать наборы данных как единое целое и при этом мы можете рассматривать их и раздельно. Рассмотрим, например, дату "October 15, 2003". Она состоит из трех единиц информации – месяца, дня и года – но было бы полезно рассматривать дату как единое целое в виде древовидной структуры:

<pre> DATE
/|\
/ | \
/ | \
/ | \
October 15 2003</pre>
Это можно сделать путем объявления домена '''date_cmp''', содержащего данные '''date''':
<vip>domains
date_cmp = date(string Month, unsigned Day, unsigned Year).</vip>
и затем писать просто, то есть
<vip>D = date("October", 15, 2003),</vip>
Это выглядит как факт Пролога, но это не так – это всего лишь значение, которое можно обрабатывать почти также, как строки или числа. Такая структура начинается с имени, обычно называемым функтор (functor) (в данном случае - date), за которым следуют три аргумента.

Обращаем Ваше внимание на то, что функтор в Visual Prolog не имеет ничего общего с функциями в языках программирования. '''''Функтор не вызывает никаких вычислений''''', это всего лишь имя, которое идентифицирует составную величину и объединяет свои аргументы.

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

<pre> birthday
/ \
/ \
/ \
/ \
/ \
person date
/ \ / | \
/ \ / | \
"Per" "Schultze" "Apr" 14 1960</pre>
На Прологе это может быть записано как:
<vip>birthday(person("Per", "Schultze"), date("Apr",14,1960)).</vip>
В этом примере видны две подчасти составного значения birthday: аргумент person("Per", "Schultze") и аргумент date("Apr", 14, 1960). Функторами этих величин являются person и date.

==Унификация Составных Доменов==
Значения составных доменов могут унифицироваться либо с одиночными переменными, либо с составными значениями, которые сопоставимы с ними (здесь возможны переменные, как части внутренней структуры). Это значин, что Вы можете использовать составные величины для передачи в виде целого набора данных, а затем разбирать их по частям путем операции унификации. К примеру,
<vip>date("April", 14, 1960)</vip>
сопоставляется с переменной X и связывает переменную X с date("April",14,1960). Кроме того,
<vip>date("April", 14, 1960)</vip>
сопоставляется с date(Mo,Da,Yr) и связывает Mo с "April", Da с 14 и Yr с 1960.
===Использование Знака Равенства для Унификации Составных Доменов===
Visual Prolog выполняет унификацию в двух случаях. Первый - это когда вызов сопоставляется с головой клаузы. Второй - это при использовании знака '''''равно''''' (=), который в действительности является инфиксной формой предиката (предикат, который находится '''между''' своими аргументами, вместо того, чтобы быть '''перед''' ними).

Visual Prolog осуществляет необходимые связывания для унификации значений по обе стороны от знака '''равно'''. Это полезно для выделения значений аргументов в составных величинах. Например, следующий код проверяет имеют ли два человека одинаковы фамилии, после чего второй человек получает тот же адрес, что и первый.
<vip>class my
domains
person = person(name, address).
name = name(string First, string Last).
address = addr(street, string City, string State).
street = street(integer Number, string Street_name).

predicates
run :().
end class

implement my
clauses
run():-
console::init(),
P1 = person(name("Jim", "Smith"),addr(street(5, "1st st"), "igo", "CA")),
P1 = person(name(_, "Smith"), Address),
P2 = person(name("Jane", "Smith"), Address),
!,
stdio::write("P1 = ", P1, "\n"),
stdio::write("P2 = ", P2, "\n")
;
stdio::write("No solution").
end implement

goal
my::run.</vip>

==Структура Данных Как Единое Целое==
Составные данные могут рассматриваться как одиночные значения в клаузах Пролога, что значительно упрощает программирование. Рассмотрим следующий факт
<vip>owns("John", book("From Here to Eternity", "James Jones")).</vip>
в котором утверждается, что John владеет книгой "From Here to Eternity", написанной автором "James Jones". В то же время можно написать
<vip>owns("John", horse("Blacky")).</vip>
что может интерпретироваться как
John владеет лошадью с именем Blacky.

Составными значениями в этих двух примерах являются
<vip>book("From Here to Eternity", "James Jones")).</vip>
и
<vip>horse("Blacky").</vip>
Если бы вместо этого было бы записаны два факта:
<vip>owns("John", "From Here to Eternity").
owns("John", "Blacky").</vip>
то нельзя было бы решить является ли Blacky названием книги или имнем лошади. С другой стороны, можно использовать первый компонент структуры – функтор, для обозначения различия между различными типами данных. В этом примере использовались, соответственно функторы book и horse для того, чтобы показать различие между данными.

'''Помните''': Составные данные состоят из функтора и аргументов, принадлежащих функтору, как показано ниже:
<vip>functor(argument1, argument2, ..., argumentN)</vip>

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

<vip>predicates
phone_list :(string First, string Last, string Phone, string Month, intege Day, integer Year) determ.

clauses
phone_list("Ed", "Willis", "422-0208", "aug", 3, 1955).
phone_list("Chris", "Grahm", "433-9906", "may", 12, 1962).</vip>

Анализируя данные, замечаем, что факт phone_list имеет шесть аргументов; пять из них могут разбиты на два составных домена:

<pre> person birthday
/ \ / | \
/ \ / | \
First Name Last Name Month Day Year</pre>
Было бы более полезно представить эти факты в виде составных доменов. Отступив на шаг, видим, что персона (person) является отношением, а имя (First Name) и фамилия (Last Name) являются его аргументами. Кроме того, день рождения является также отношением с тремя аргументами: месяц (month), день (day) и год (year). Представление этих отношений средствами Пролога аналогично уже упоминавшемуся
<vip>owns("John", "From Here to Eternity").
owns("John", "Blacky").</vip>
Теперь можно переписать нашу небольшую базу данных с использованием этих составных доменов в базе данных.

<vip>domains
name = person(string First, string Last).
birthday = b_date(string Month, integer Day, integer Year).

class predicates
phone_list :(name, string Ph_num, birthday) determ.
clauses
phone_list(person("Ed", "Willis"), "422-0208",b_date("aug", 3, 1955)).
phone_list(person("Chris", "Grahm"), "433-9906",b_date("may", 12, 1962)).</vip>

В этой программе появились объявления двух составных '''доменов (domains)'''. Мы детальнее рассмотрим эти составные структыры данных позднее в этой главе. Пока же мы обратим внимание на преимущества использования таких составных доменов.

Предикат phone_list теперь содержит три аргумента вместо прежних шести. Иногда разбиение данных на составные структуры упрощает программу и облегчает обработку данных.

Теперь добавим некоторые правила в программу. Предположим, нам надо получить список людей, чьи дни рождения выпадают на текущий месяц. Ниже приведена программа, решающая эту задачу; эта программа использует стандартный предикат date для получения текущей даты из внутренних часов компьютера. Предикат date возвращает текущий год (year), месяц (month) и день (day) часов компьютера.
<vip>class my
domains
name = person(string First, string Last).
birthday = b_date(string Month, integer Day, integer Year).
predicates
phone_list :(name, string Ph_num, birthday) multi(o,o,o).
get_months_birthdays :().
convert_month :(string Name, integer Num) determ(i,o).
check_birthday_month :(integer Month_num, birthday) determ.
write_person :(name).
end class

implement my

clauses
get_months_birthdays() :-
stdio::write("****** This Month's Birthday List *****\n"),
stdio::write(" First Name\t\t Last Name\n"),
stdio::write("***********************************\n"),
CurTime = time::new(),
CurTime:getDate(_, ThisMonth, _),
phone_list(Person, _, Date),
check_birthday_month(ThisMonth, Date),
write_person(Person),
fail.
get_months_birthdays() :-
stdio::write("\n Press any key to continue:\n"),
_ = console::readChar().

clauses
write_person(person(FirstName, LastName)) :-
stdio::write(" ", FirstName, "\t\t ", LastName, "\n").

clauses
check_birthday_month(Mon, b_date(Month, _, _)) :-
convert_month(Month, Month1),
Mon = Month1.

clauses
phone_list(person("Ed", "Willis"), "11-1111", b_date("Jan", 3, 1955)).
phone_list(person("Benjamin", "Thomas"), "222-2222", b_date("Feb", 5, 1965)).
phone_list(person("Ray", "William"), "333-3333", b_date("Mar", 3, 1955)).
phone_list(person("Tomas", "Alfred"), "444-4444", b_date("Apr", 29, 1975)).
phone_list(person("Chris", "Gralm"), "555-5555", b_date("May", 12, 1975)).
phone_list(person("Dastin", "Robert"), "666-6666", b_date("Jun", 17, 1975)).
phone_list(person("Anna", "Friend"), "777-7777", b_date("Jul", 2, 1975)).
phone_list(person("Naomi", "Friend"), "888-8888", b_date("Aug", 10, 1975)).
phone_list(person("Christina", "Lynn"), "999-9999", b_date("Sep", 25, 1975)).
phone_list(person("Kathy", "Ann"), "110-1010", b_date("Oct", 20, 1975)).
phone_list(person("Elizabeth", "Ann"), "110-1111", b_date("Nov", 9, 1975)).
phone_list(person("Aaron", "Friend"), "110-1212", b_date("Dec", 31, 1975)).
phone_list(person("Jenifer", "Faitlin"), "888-8888", b_date("Aug", 14, 1975)).

clauses
convert_month("Jan", 1).
convert_month("Feb", 2).
convert_month("Mar", 3).
convert_month("Apr", 4).
convert_month("May", 5).
convert_month("Jun", 6).
convert_month("Jul", 7).
convert_month("Aug", 8).
convert_month("Sep", 9).
convert_month("Oct", 10).
convert_month("Nov", 11).
convert_month("Dec", 12).
end implement

goal
console::init(),
my::get_months_birthdays().</vip>

Каким образом составные домены помогают в этой программе? Это несложно увидеть, просмотрев код. Основная часть обработки производится в предикате get_months_birthdays.

*Сначала создается окно предикатом console::init()
*После этого пишется заголовок в окне, помогающий интерпретировать результаты.
*В предикате get_months_birthdays программа использует встроенный (built-in) предикат date, чтобы получить значение текущего месяца.
*Далее все в программе направлено на поиск в базе данных и получения списка людей, родившихся в текущем месяце. Прежде всего надо найти первого человека в базе данных. Вызов phone_list(Person, _, Date) связывает имя и фамилию человка с переменной Person путем связывания целого функтора person с этой переменной Person. Одновремиенно связывается день рождения человека с переменной Date.<br/> Обратите внимание, что для этого требуется всего одна переменная для запоминания полного имени человека и всего одна переменная Date для запоминания дня рождения. В этом и заключается мощность составных доменов.
*Теперь программа передает день рождения человека в виде одной переменной Date. Это происходит в следующей подцели, где программа передает значение текущего месяца (month), представленного целым числом, и день рождения (обрабатываемого человека) в предикат check_birthday_month.
*Посмотрите внимательно, что происходит. Visual Prolog вызывает предикат check_birthday_month с двуми параметрами: первый параметр связан с целым числом, а второй - с термом birthday. В голове правила, определяющего предикат check_birthday_month, первый аргумент сопоставляется с переменной Mon. Второй аргумент, Date, сопоставляется с b_date(Month, _,_).<br/> Поскольку нас интересует только месяц рождения человека, то на месте как дня, так и года рождения мы используем анонимную переменную.
*Предикат check_birthday_month сначала преобразует строку с названием месяца в целочисленное значение. Как только это сделано, Visual Prolog может сравнивать значение текущего месяца со значением месяца рождения человека. Если такое сравнение положительно (успешно), то цель check_birthday_month считается успешной, и обработка продолжается. Если же сравнение неуспешно (fails) - обрабатываемый человек не родился в текущем месяце, то Visual Prolog начинает операцию отката для поиска другого возможного решения задачи.
*Следующая обрабатываемая подцель - write_person. У обрабатываемого человека день рождения выпадает на текущий месяц, следовательно можно печатать его имя в отчете. После печати информации, клауза завершается предикатом неуспешности (fail), что вызывает откат.
*'''''Откат всегда распространяется вверх до ближайшего недетерминированного вызова и пытается передоказать вызов.''''' В нашей программе последним недетерминированным вызовом является вызов phone_list. Именно здесь программа выбирает следующего человека для обработки. Если людей в списке (в базе данных) больше нет, то текущая клауза завершается неуспешно (fails); Visual Prolog теперь пытается доказать эту цель путем просмотра быза правил ниже. Поскольку есть еще одна клауза, определяющая get_months_birthdays, Visual Prolog пытается доказать обращение к get_months_birthdays путем доказательства подцелей этой другой части клаузы.

=Декларирование Составных Доменов=

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

<vip>owns("John", book("From Here to Eternity", "James Jones")).</vip>
и
<vip>owns("John", horse("Blacky")).</vip>
можно запрашивать систему с помощью следующей цели:
<vip>owns("John", X)</vip>
Переменная X может быть связана с различными типами данных - книгой, лошадью или возможно другим типом, который будет определен. Поскольку предикат owns теперь определён, больше его нельзя использовать в смысле старого определения:
<vip>owns :(string, string).</vip>
Второй аргумент больше не относится к домену string. Вместо этого необходимо сформулировать новое определение предиката, такое как, например
<vip>owns :(name, articles).</vip>
Вы можете теперь описать домен articles в секции domains как показано здесь:
<vip>domains
articles =
book(string Title, string Author);
horse(string Name).
/* Articles - это книги или лошади */</vip>
Точка с запятой здесь читаются как ''or (или)''. В нашем случае возможны две альтернативы: либо книга может быть определена своим названием и автором, либо лошадь определяется своим именем. Домены Title, Author и Name - все являются стандартными доменами string.

Дополнительные альтернативы могут быть легко добавлены в декларацию домена. К примеру, articles мог бы включать лодку, дом, или банковский счёт. Для лодки, можно было бы использовать функтор без аргументов. С другой стороны, может возникнуть желание представлять баланс счета в качестве банковской записи. Тогда объявления домена articles расширяются до:
<vip>domains
articles =
book(string Title, string Author);
horse(string Name);
boat;
bankbook(real Balance).</vip>
Далее приведена полная программа, которая показывает как составной домен articles может быть использован в определениях предиката owns.
<vip>class my
domains
articles =
book(string Title, string Author) ;
horse(string Name) ;
boat ;
bankbook(real Balance).
predicates
owns :(string Name, articles) nondeterm(i,o) determ(i,i).
end class

implement my
clauses
owns("John", book("A friend of the family", "Irwin Shaw")).
owns("John", horse("Blacky")).
owns("John", boat).
owns("John", bankbook(1000)).
end implement

goal
console::init(),
my::owns("John", Thing),
stdio::write("Thing: ", Thing, "\n"),
fail
;
stdio::write("The end.").
</vip>
Загрузим теперь эту программу в IDE и запустим её. Visual Prolog теперь ответит:
<vip>Thing: book("A friend of the family","Irwin Shaw")
Thing: horse("Blacky")
Thing: boat()
Thing: bankbook(1000)
The end.</vip>

==Итак: правила объявлений==

Дадим теперь общее представление способа записи объявлений составных доменов:
<vip>
domain =
alternative1(D, D, ...);
alternative2(D, D, ...);
...
</vip>
Здесь alternative1 и alternative2 являются равновозможными (но различными) функторами. Обозначение (D, D, ...) представляет список имен, которые объявлены в любом месте либо относятся к стандартным типам доменов(таким как string, integer, real и т.д.).

'''Примечания:'''
*Алтернативы разделяются точкой с запятой.
*Каждая альтернатива состоит из фуктора и, возможно, списка доменов для соответствующих аргументов.
*Если функтор не имеет аргументов, его можно записывать как alternativeN или alternativeN( ).

==Многоуровневые Составные Домены==
Visual Prolog позволяет организовывать многоуровневые составные домены. Например, в

<vip>book("The Ugly Duckling", "Andersen").</vip>

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

<vip>book("The Ugly Duckling", author("Hans Christian", "Andersen")).</vip>

В старом объявлении домена

<vip>book(string Title, string Author).</vip>

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

<vip>author = author(string First_name, string Last_name).</vip>

что приводит к следующим объявлениям:

<vip>domains
articles = book(string Title, author Author); ...
/* First level */
author = author(string First_name, string Last_name).
/* Second level */</vip>

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

<pre> book
/ \
/ \
title author
/ \
/ \
First_name Last_name</pre>

Одна декларация домена всегда описывает только один уровень дерева, а не все дерево. В частности, домен book не может быть объявлен такой декларацией:

<vip>/* Not allowed */
book = book(string Title, author(string First_name, string Last_name)).</vip>

=Объявления Составных Смешанных Доменов=

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

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

==Аргументы множественных типов==

Для того, чтобы предикат в Visual Prolog допускал использование аргументов различного типа, необходимо использовать функторные объявления. Следующий пример, клауза your_age clause будет воспринимать аргументы типа age, которые могут иметь тип string, real или integer.

<vip>domains
age = i(integer); r(real); s(string).

class predicates
your_age :(age).
clauses
your_age(i(Age)) :- stdio::write(Age).
your_age(r(Age)) :- stdio::write(Age).
your_age(s(Age)) :- stdio::write(Age).</vip>

При этом Visual Prolog не допускает декларации вида:

<vip>/* Не допустимо. */
domains
age = integer; real; string.</vip>

==Списки==

Предположим, мы обрабатываем данные о предметах, которые может преподавать учитель. Код может выглядеть так:

<vip>class predicates
teacher :(string First_name, string Last_name, string Class) determ.

clauses
teacher("Ed", "Willis", "english1").
teacher("Ed", "Willis", "math1").
teacher("Ed", "Willis", "history1").
teacher("Mary", "Maker", "history2").
teacher("Mary", "Maker", "math2").
teacher("Chris", "Grahm", "geometry").</vip>

Здесь необходимо повторять имя преподавателя для каждого предмета, который он (она) может преподавать. Для каждого предмета необходимо добавлять такой факт в базу данных. Хотя в данной ситуации это не вызывает трудности, можно найти школу, в которой сотни предметов, и тогда поддержка такой структур данных становится утомительной. Тогда было бы удобно создать такой аргумент для предиката, который мог бы воспринимать один или несколько значений.

В Прологе это делает '''список'''. В следующем коде аргумент class объявлен имеющим '''тип список'''. Покажем, как список представляется в Прологе.

<vip>domains
classes = string*. /* объявляет списковый домен*/

class predicates
teacher :(string First_name, string Last_name, classes Classes) determ.
clauses
teacher("Ed", "Willis", ["english1", "math1", "history1"]).
teacher("Mary", "Maker", ["history2", "math2"]).
teacher("Chris", "Grahm", ["geometry"]).</vip>

В этом примере код более лаконичен и проще читается, чем код предыдущего примера. Обратите внимание на объявление домена. Звездочка (*) означает, домен classes является списком строк. Так же легко можно объявить список целых:

<vip>domains
integer_list = integer*.</vip>

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

<vip>domains
integer_list = integer*.

class predicates
test_scores :
(string First_name,
string Last_name,
integer_list Test_Scores)
determ.
clauses
test_scores("Lisa", "Lavender", [86, 91, 75]).
test_scores("Libby", "Dazzner", [79, 75]).
test_scores("Jeff", "Zheutlin", []).</vip>

Обратите внимание, в случае ''Jeff Zheutlin'' список не содержит никаких элементов.

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

<vip>domains
tree_list = tree*.
tree = tree(string Text, tree_list TreeList).

class predicates
family :(tree) determ.
clauses
family(tree("Grandmother",
[tree("John",
[tree("Eric", []),
tree("Mark", []),
tree("Leonard", []) ] ),
tree("Ellen", [])
]
)).</vip>

=Заключение=

В этом руководстве были рассмотрены важные понятия:

*Программа на Visual Prolog может содержать множество типов значений: простых и составных, встроенных (стандартных) и определяемых в программе.
*Простые значения - это: числа, строки и т.д..
*''Составные домены'' позволяют рассматривать структуру информации как единую сущность. Составной домен состоит из имени (известного как функтор) и одного или более аргументов. Можно определить домен с несколькими альтернативными фукторами.
*Функтор в Visual Prolog не есть то же, что функция в других языках программирования. '''''Функтор не вызывает никаких вычислений.''''' Это просто имя которое обозначает составной домен и объединяет его аргументы.
*Составные значения могут обрабатываться и рассматриваться как одиночные переменные; функторы используются для создания различия между различными типами составных значений. Visual Prolog позволяет строить многоуровневые структурированные значения; Аргументами составных доменов могут быть опять-таки составные значения. Используя декларации составных смешанных доменов, можно использовать предикаты, которые:
**принимают аргументы нескольких различных типов (определяется объявлениями функторов).
**принимают переменное число аргументов, каждый определенного типа (объявления списков).
**принимают переменное число аргументов, часть из которых могут иметь более одного типа.

=Ссылки=
[[en:Compound and List Domains]]
[[Категория:VipРуководства]]
[[Категория:VipLanguage]]

Составные Домены и Списки

2007-11-06T07:13:04Z

SergeMukhin:

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

Составные домены и списки создаются с использованием встроенных (built-in) и других составных или списковых доменов. Справочная система Visual Prolog (Help) объясняет встроенные домены:
*integer - целые
*real - вещественные
*string - строковые
*symbol -символьные
*char - знаковые
*sring8 - строковые 8-разрядные
*pointer - указатели
*binary - двоичные (бинарные)
*boolean - булевские
*object - объекты

==Составные домены и Функторы==
Составные домены позволяют рассматривать наборы данных как единое целое и при этом мы можете рассматривать их и раздельно. Рассмотрим, например, дату "October 15, 2003". Она состоит из трех единиц информации – месяца, дня и года – но было бы полезно рассматривать дату как единое целое в виде древовидной структуры:

<pre> DATE
/|\
/ | \
/ | \
/ | \
October 15 2003</pre>
Это можно сделать путем объявления домена '''date_cmp''', содержащего данные '''date''':
<vip>domains
date_cmp = date(string Month, unsigned Day, unsigned Year).</vip>
и затем писать просто, то есть
<vip>D = date("October", 15, 2003),</vip>
Это выглядит как факт Пролога, но это не так – это всего лишь значение, которое можно обрабатывать почти также, как строки или числа. Такая структура начинается с имени, обычно называемым функтор (functor) (в данном случае - date), за которым следуют три аргумента.

Обращаем Ваше внимание на то, что функтор в Visual Prolog не имеет ничего общего с функциями в языках программирования. '''''Функтор не вызывает никаких вычислений''''', это всего лишь имя, которое идентифицирует составную величину и объединяет свои аргументы.

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

<pre> birthday
/ \
/ \
/ \
/ \
/ \
person date
/ \ / | \
/ \ / | \
"Per" "Schultze" "Apr" 14 1960</pre>
На Прологе это может быть записано как:
<vip>birthday(person("Per", "Schultze"), date("Apr",14,1960)).</vip>
В этом примере видны две подчасти составного значения birthday: аргумент person("Per", "Schultze") и аргумент date("Apr", 14, 1960). Функторами этих величин являются person и date.

==Унификация Составных Доменов==
Значения составных доменов могут унифицироваться либо с одиночными переменными, либо с составными значениями, которые сопоставимы с ними (здесь возможны переменные, как части внутренней структуры). Это значин, что Вы можете использовать составные величины для передачи в виде целого набора данных, а затем разбирать их по частям путем операции унификации. К примеру,
<vip>date("April", 14, 1960)</vip>
сопоставляется с переменной X и связывает переменную X с date("April",14,1960). Кроме того,
<vip>date("April", 14, 1960)</vip>
сопоставляется с date(Mo,Da,Yr) и связывает Mo с "April", Da с 14 и Yr с 1960.
===Использование Знака Равенства для Унификации Составных Доменов===
Visual Prolog выполняет унификацию в двух случаях. Первый - это когда вызов сопоставляется с головой клаузы. Второй - это при использовании знака '''''равно''''' (=), который в действительности является инфиксной формой предиката (предикат, который находится '''между''' своими аргументами, вместо того, чтобы быть '''перед''' ними).

Visual Prolog осуществляет необходимые связывания для унификации значений по обе стороны от знака '''равно'''. Это полезно для выделения значений аргументов в составных величинах. Например, следующий код проверяет имеют ли два человека одинаковы фамилии, после чего второй человек получает тот же адрес, что и первый.
<vip>class my
domains
person = person(name, address).
name = name(string First, string Last).
address = addr(street, string City, string State).
street = street(integer Number, string Street_name).

predicates
run :().
end class

implement my
clauses
run():-
console::init(),
P1 = person(name("Jim", "Smith"),addr(street(5, "1st st"), "igo", "CA")),
P1 = person(name(_, "Smith"), Address),
P2 = person(name("Jane", "Smith"), Address),
!,
stdio::write("P1 = ", P1, "\n"),
stdio::write("P2 = ", P2, "\n")
;
stdio::write("No solution").
end implement

goal
my::run.</vip>

==Структура Данных Как Единое Целое==
Составные данные могут рассматриваться как одиночные значения в клаузах Пролога, что значительно упрощает программирование. Рассмотрим следующий факт
<vip>owns("John", book("From Here to Eternity", "James Jones")).</vip>
в котором утверждается, что John владеет книгой "From Here to Eternity", написанной автором "James Jones". В то же время можно написать
<vip>owns("John", horse("Blacky")).</vip>
что может интерпретироваться как
John владеет лошадью с именем Blacky.

Составными значениями в этих двух примерах являются
<vip>book("From Here to Eternity", "James Jones")).</vip>
и
<vip>horse("Blacky").</vip>
Если бы вместо этого было бы записаны два факта:
<vip>owns("John", "From Here to Eternity").
owns("John", "Blacky").</vip>
то нельзя было бы решить является ли Blacky названием книги или имнем лошади. С другой стороны, можно использовать первый компонент структуры – функтор, для обозначения различия между различными типами данных. В этом примере использовались, соответственно функторы book и horse для того, чтобы показать различие между данными.

'''Помните''': Составные данные состоят из функтора и аргументов, принадлежащих функтору, как показано ниже:
<vip>functor(argument1, argument2, ..., argumentN)</vip>

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

<vip>predicates
phone_list :(string First, string Last, string Phone, string Month, intege Day, integer Year) determ.

clauses
phone_list("Ed", "Willis", "422-0208", "aug", 3, 1955).
phone_list("Chris", "Grahm", "433-9906", "may", 12, 1962).</vip>

Анализируя данные, замечаем, что факт phone_list имеет шесть аргументов; пять из них могут разбиты на два составных домена:

<pre> person birthday
/ \ / | \
/ \ / | \
First Name Last Name Month Day Year</pre>
Было бы более полезно представить эти факты в виде составных доменов. Отступив на шаг, видим, что персона (person) является отношением, а имя (First Name) и фамилия (Last Name) являются его аргументами. Кроме того, день рождения является также отношением с тремя аргументами: месяц (month), день (day) и год (year). Представление этих отношений средствами Пролога аналогично уже упоминавшемуся
<vip>owns("John", "From Here to Eternity").
owns("John", "Blacky").</vip>
Теперь можно переписать нашу небольшую базу данных с использованием этих составных доменов в базе данных.

<vip>domains
name = person(string First, string Last).
birthday = b_date(string Month, integer Day, integer Year).

class predicates
phone_list :(name, string Ph_num, birthday) determ.
clauses
phone_list(person("Ed", "Willis"), "422-0208",b_date("aug", 3, 1955)).
phone_list(person("Chris", "Grahm"), "433-9906",b_date("may", 12, 1962)).</vip>

В этой программе появились объявления двух составных '''доменов (domains)'''. Мы детальнее рассмотрим эти составные структыры данных позднее в этой главе. Пока же мы обратим внимание на преимущества использования таких составных доменов.

Предикат phone_list теперь содержит три аргумента вместо прежних шести. Иногда разбиение данных на составные структуры упрощает программу и облегчает обработку данных.

Теперь добавим некоторые правила в программу. Предположим, нам надо получить список людей, чьи дни рождения выпадают на текущий месяц. Ниже приведена программа, решающая эту задачу; эта программа использует стандартный предикат date для получения текущей даты из внутренних часов компьютера. Предикат date возвращает текущий год (year), месяц (month) и день (day) часов компьютера.
<vip>class my
domains
name = person(string First, string Last).
birthday = b_date(string Month, integer Day, integer Year).
predicates
phone_list :(name, string Ph_num, birthday) multi(o,o,o).
get_months_birthdays :().
convert_month :(string Name, integer Num) determ(i,o).
check_birthday_month :(integer Month_num, birthday) determ.
write_person :(name).
end class

implement my

clauses
get_months_birthdays() :-
stdio::write("****** This Month's Birthday List *****\n"),
stdio::write(" First Name\t\t Last Name\n"),
stdio::write("***********************************\n"),
CurTime = time::new(),
CurTime:getDate(_, ThisMonth, _),
phone_list(Person, _, Date),
check_birthday_month(ThisMonth, Date),
write_person(Person),
fail.
get_months_birthdays() :-
stdio::write("\n Press any key to continue:\n"),
_ = console::readChar().

clauses
write_person(person(FirstName, LastName)) :-
stdio::write(" ", FirstName, "\t\t ", LastName, "\n").

clauses
check_birthday_month(Mon, b_date(Month, _, _)) :-
convert_month(Month, Month1),
Mon = Month1.

clauses
phone_list(person("Ed", "Willis"), "11-1111", b_date("Jan", 3, 1955)).
phone_list(person("Benjamin", "Thomas"), "222-2222", b_date("Feb", 5, 1965)).
phone_list(person("Ray", "William"), "333-3333", b_date("Mar", 3, 1955)).
phone_list(person("Tomas", "Alfred"), "444-4444", b_date("Apr", 29, 1975)).
phone_list(person("Chris", "Gralm"), "555-5555", b_date("May", 12, 1975)).
phone_list(person("Dastin", "Robert"), "666-6666", b_date("Jun", 17, 1975)).
phone_list(person("Anna", "Friend"), "777-7777", b_date("Jul", 2, 1975)).
phone_list(person("Naomi", "Friend"), "888-8888", b_date("Aug", 10, 1975)).
phone_list(person("Christina", "Lynn"), "999-9999", b_date("Sep", 25, 1975)).
phone_list(person("Kathy", "Ann"), "110-1010", b_date("Oct", 20, 1975)).
phone_list(person("Elizabeth", "Ann"), "110-1111", b_date("Nov", 9, 1975)).
phone_list(person("Aaron", "Friend"), "110-1212", b_date("Dec", 31, 1975)).
phone_list(person("Jenifer", "Faitlin"), "888-8888", b_date("Aug", 14, 1975)).

clauses
convert_month("Jan", 1).
convert_month("Feb", 2).
convert_month("Mar", 3).
convert_month("Apr", 4).
convert_month("May", 5).
convert_month("Jun", 6).
convert_month("Jul", 7).
convert_month("Aug", 8).
convert_month("Sep", 9).
convert_month("Oct", 10).
convert_month("Nov", 11).
convert_month("Dec", 12).
end implement

goal
console::init(),
my::get_months_birthdays().</vip>

Каким образом составные домены помогают в этой программе? Это несложно увидеть, просмотрев код. Основная часть обработки производится в предикате get_months_birthdays.

*Сначала создается окно предикатом console::init()
*После этого пишется заголовок в окне, помогающий интерпретировать результаты.
*В предикате get_months_birthdays программа использует встроенный (built-in) предикат date, чтобы получить значение текущего месяца.
*Далее все в программе направлено на поиск в базе данных и получения списка людей, родившихся в текущем месяце. Прежде всего надо найти первого человека в базе данных. Вызов phone_list(Person, _, Date) связывает имя и фамилию человка с переменной Person путем связывания целого функтора person с этой переменной Person. Одновремиенно связывается день рождения человека с переменной Date.<br/> Обратите внимание, что для этого требуется всего одна переменная для запоминания полного имени человека и всего одна переменная Date для запоминания дня рождения. В этом и заключается мощность составных доменов.
*Теперь программа передает день рождения человека в виде одной переменной Date. Это происходит в следующей подцели, где программа передает значение текущего месяца (month), представленного целым числом, и день рождения (обрабатываемого человека) в предикат check_birthday_month.
*Посмотрите внимательно, что происходит. Visual Prolog вызывает предикат check_birthday_month с двуми параметрами: первый параметр связан с целым числом, а второй - с термом birthday. В голове правила, определяющего предикат check_birthday_month, первый аргумент сопоставляется с переменной Mon. Второй аргумент, Date, сопоставляется с b_date(Month, _,_).<br/> Поскольку нас интересует только месяц рождения человека, то на месте как дня, так и года рождения мы используем анонимную переменную.
*Предикат check_birthday_month сначала преобразует строку с названием месяца в целочисленное значение. Как только это сделано, Visual Prolog может сравнивать значение текущего месяца со значением месяца рождения человека. Если такое сравнение положительно (успешно), то цель check_birthday_month считается успешной, и обработка продолжается. Если же сравнение неуспешно (fails) - обрабатываемый человек не родился в текущем месяце, то Visual Prolog начинает операцию отката для поиска другого возможного решения задачи.
*Следующая обрабатываемая подцель - write_person. У обрабатываемого человека день рождения выпадает на текущий месяц, следовательно можно печатать его имя в отчете. После печати информации, клауза завершается предикатом неуспешности (fail), что вызывает откат.
*'''''Откат всегда распространяется вверх до ближайшего недетерминированного вызова и пытается передоказать вызов.''''' В нашей программе последним недетерминированным вызовом является вызов phone_list. Именно здесь программа выбирает следующего человека для обработки. Если людей в списке (в базе данных) больше нет, то текущая клауза завершается неуспешно (fails); Visual Prolog теперь пытается доказать эту цель путем просмотра быза правил ниже. Поскольку есть еще одна клауза, определяющая get_months_birthdays, Visual Prolog пытается доказать обращение к get_months_birthdays путем доказательства подцелей этой другой части клаузы.

=Декларирование Составных Доменов=

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

<vip>owns("John", book("From Here to Eternity", "James Jones")).</vip>
и
<vip>owns("John", horse("Blacky")).</vip>
можно запрашивать систему с помощью следующей цели:
<vip>owns("John", X)</vip>
Переменная X может быть связана с различными типами данных - книгой, лошадью или возможно другим типом, который будет определен. Поскольку предикат owns теперь определен, больше его нельзя использовать в смысле старого определения:
<vip>owns :(string, string).</vip>
Второй аргумент больше не относится к домену string. Вместо этого необходимо сформулировать новое определение предиката, такое как, например
<vip>owns :(name, articles).</vip>
Вы можете теперь описать домен articles в секции domains как показано здесь:
<vip>domains
articles =
book(string Title, string Author);
horse(string Name).
/* Articles - это книги или лошади */</vip>
Точка с запятой здесь читаются как ''or (или)''. В нашем случае возможны две альтернативы: либо книга может быть определена своим названием и автором, либо лошадь определяется своим именем. Домены Title, Author и Name - все являются стандартными доменами string.

Дополнительные альтернативы могут быть легко добавлены в декларацию домена. К примеру, articles мог бы включать лодку, дом, или банковский счет. Для лодки, можно было бы использовать функтор без аргументов. С другой стороны, может возникнуть желание представлять баланс счета в качестве банковской записи. Тогда объявления домена articles расширяются до:
<vip>domains
articles =
book(string Title, string Author);
horse(string Name);
boat;
bankbook(real Balance).</vip>
Далее приведена полная программа, которая показывает как составной домен articles может быть использован в определениях предиката owns.
<vip>class my
domains
articles =
book(string Title, string Author) ;
horse(string Name) ;
boat ;
bankbook(real Balance).
predicates
owns :(string Name, articles) nondeterm(i,o) determ(i,i).
end class

implement my
clauses
owns("John", book("A friend of the family", "Irwin Shaw")).
owns("John", horse("Blacky")).
owns("John", boat).
owns("John", bankbook(1000)).
end implement

goal
console::init(),
my::owns("John", Thing),
stdio::write("Thing: ", Thing, "\n"),
fail
;
stdio::write("The end.").
</vip>
Загрузим теперь эту программу в IDE и запустим ее. Visual Prolog теперь ответит:
<vip>Thing: book("A friend of the family","Irwin Shaw")
Thing: horse("Blacky")
Thing: boat()
Thing: bankbook(1000)
The end.</vip>

==Итак: правила объявлений==

Дадим теперь общее представление способа записи объявлений составных доменов:
<vip>
domain =
alternative1(D, D, ...);
alternative2(D, D, ...);
...
</vip>
Здесь alternative1 и alternative2 являются равновозможными (но различными) функторами. Обозначение (D, D, ...) представляет список имен, которые объявлены в любом месте либо относятся к стандартным типам доменов(таким как string, integer, real и т.д.).

'''Примечания:'''
*Алтернативы разделяются точкой с запятой.
*Каждая алттернатива состоит из фуктора и, возможно, списка доменов для соответствующих аргументов.
*Если функтор не имеет аргументов, его можно записывать как alternativeN или alternativeN( ).

==Многоуровневые Составные Домены==
Visual Prolog позволяет организовывать многоуровневые составные домены. Например, в

<vip>book("The Ugly Duckling", "Andersen").</vip>

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

<vip>book("The Ugly Duckling", author("Hans Christian", "Andersen")).</vip>

В старом объявлении домена

<vip>book(string Title, string Author).</vip>

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

<vip>author = author(string First_name, string Last_name).</vip>

что приводит к следующим объявлениям:

<vip>domains
articles = book(string Title, author Author); ...
/* First level */
author = author(string First_name, string Last_name).
/* Second level */</vip>

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

<pre> book
/ \
/ \
title author
/ \
/ \
First_name Last_name</pre>

Одна декларация домена всегда описывает только один уровень дерева, а не все дерево. В частности, домен book не может быть объявлен такой декларацией:

<vip>/* Not allowed */
book = book(string Title, author(string First_name, string Last_name)).</vip>

=Объявления Составных Смешанных Доменов=

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

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

==Аргументы множественных типов==

Для того, чтобы предикат в Visual Prolog допускал использование аргументов различного типа, необходимо использовать функторные объявления. Следующий пример, клауза your_age clause будет воспринимать аргументы типа age, которые могут иметь тип string, real или integer.

<vip>domains
age = i(integer); r(real); s(string).

class predicates
your_age :(age).
clauses
your_age(i(Age)) :- stdio::write(Age).
your_age(r(Age)) :- stdio::write(Age).
your_age(s(Age)) :- stdio::write(Age).</vip>

При этом Visual Prolog не допускает декларации вида:

<vip>/* Не допустимо. */
domains
age = integer; real; string.</vip>

==Списки==

Предположим, мы обрабатываем данные о предметах, которые может преподавать учитель. Код может выглядеть так:

<vip>class predicates
teacher :(string First_name, string Last_name, string Class) determ.

clauses
teacher("Ed", "Willis", "english1").
teacher("Ed", "Willis", "math1").
teacher("Ed", "Willis", "history1").
teacher("Mary", "Maker", "history2").
teacher("Mary", "Maker", "math2").
teacher("Chris", "Grahm", "geometry").</vip>

Здесь необходимо повторять имя преподавателя для каждого предмета, который он (она) может преподавать. Для каждого предмета необходимо добавлять такой факт в базу данных. Хотя в данной ситуации это не вызывает трудности, можно найти школу, в которой сотни предметов, и тогда поддержка такой структур данных становится утомительной. Тогда было бы удобно создать такой аргумент для предиката, который мог бы воспринимать один или несколько значений.

В Прологе это делает '''список'''. В следующем коде аргумент class объявлен имеющим '''тип список'''. Покажем, как список представляется в Прологе.

<vip>domains
classes = string*. /* объявляет списковый домен*/

class predicates
teacher :(string First_name, string Last_name, classes Classes) determ.
clauses
teacher("Ed", "Willis", ["english1", "math1", "history1"]).
teacher("Mary", "Maker", ["history2", "math2"]).
teacher("Chris", "Grahm", ["geometry"]).</vip>

В этом примере код более лаконичен и проще читается, чем код предыдущего примера. Обратите внимание на объявление домена. Звездочка (*) означает, домен classes является списком строк. Так же легко можно объявить список целых:

<vip>domains
integer_list = integer*.</vip>

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

<vip>domains
integer_list = integer*.

class predicates
test_scores :
(string First_name,
string Last_name,
integer_list Test_Scores)
determ.
clauses
test_scores("Lisa", "Lavender", [86, 91, 75]).
test_scores("Libby", "Dazzner", [79, 75]).
test_scores("Jeff", "Zheutlin", []).</vip>

Обратите внимание, в случае ''Jeff Zheutlin'' список не содержит никаких элементов.

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

<vip>domains
tree_list = tree*.
tree = tree(string Text, tree_list TreeList).

class predicates
family :(tree) determ.
clauses
family(tree("Grandmother",
[tree("John",
[tree("Eric", []),
tree("Mark", []),
tree("Leonard", []) ] ),
tree("Ellen", [])
]
)).</vip>

=Заключение=

В этом руководстве были рассмотрены важные понятия:

*Программа на Visual Prolog может содержать множество типов значений: простых и составных, встроенных (стандартных) и определяемых в программе.
*Простые значения - это: числа, строки и т.д..
*''Составные домены'' позволяют рассматривать структуру информации как единую сущность. Составной домен состоит из имени (известного как функтор) и одного или более аргументов. Можно определить домен с несколькими альтернативными фукторами.
*Функтор в Visual Prolog не есть то же, что функция в других языках программирования. '''''Функтор не вызывает никаких вычислений.''''' Это просто имя которое обозначает составной домен и объединяет его аргументы.
*Составные значения могут обрабатываться и рассматриваться как одиночные переменные; функторы используются для создания различия между различными типами составных значений. Visual Prolog позволяет строить многоуровневые структурированные значения; Аргументами составных доменов могут быть опять-таки составные значения. Используя декларации составных смешанных доменов, можно использовать предикаты, которые:
**принимают аргументы нескольких различных типов (определяется объявлениями функторов).
**принимают переменное число аргументов, каждый определенного типа (объявления списков).
**принимают переменное число аргументов, часть из которых могут иметь более одного типа.

=Ссылки=
[[en:Compound and List Domains]]
[[Категория:VipРуководства]]
[[Категория:VipLanguage]]

IDE: Переменные

2007-11-05T11:16:52Z

SergeMukhin:

В IDE Вы можете определить так называемые переменные среды IDE. Мы покажем здесь один из случаев их использования.

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

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

Скоро Вы обнаружите, что ссылки на эти пакеты по их абсолютным путям (как c:\sharedTools\tool1\tool1.pack) - плохая практика, поскольку это закрепляет местоположение на диске, а это, в свою очередь затрудняет реструктуризацию дискового пространства, а при работе в группе все члены группы вынуждены использовать одинаковую организационную структуру диска.

Вместо этого Вы можете использовать относительные маршруты (например ..\sharedTools\tool1\tool1.pack), это несколько лучше, поскольку теперь Вы можете установить по крайней мере свою собственную директорию верхнего уровня (и, следовательно, другой диск при необходимости).

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

Использование переменных среды IDE повышает гибкость. Давайте рассмотрим имя файла $(Tools)\tool1\tool1.pack. Чтобы его можно было использовать, Вы должны определить переменную среды $(Tools) и затем Вам необходимо включить переменную $(Tools) в качестве include-директории в установках проекта.

Когда include-маршруты используют переменные IDE, проектное дерево также показывает это.

Теперь, если Вы решите переместить sharedTools в другое место, Вы можете смело это сделать и только переопределить переменную $(Tools). Переменные IDE разделяются среди всех проектов, и такое изменение должно быть сделано лишь один раз для того, чтобы все проекты смогли бы использовать такие пакеты. Разные члены группы могут иметь директории с общими пакетами в различных местах, поскольку каждый член группы использует свою собственную переменную $(Tools).

Такая стратегия используется для $(ProDir), которая всегда ссылается на директорию установки системы программирования Visual Prolog на данном компьютере.

=Ссылки=
[[en:IDE Variables]]
[[Категория:VipIDE]]