wiki.visual-prolog.com - User contributions [en]

Fundamental Visual Prolog

2019-05-14T01:18:10Z

Mark Green:

{{FundamentalPrologNavbar}}

In this tutorial, we will introduce a program that is developed on the Visual Prolog platform. The essential algorithms of the tutorial are the same as those that were developed in [[Fundamental Prolog Part 2]].

==Differences between Visual Prolog and traditional Prolog==

The differences between traditional Prolog and Visual Prolog can be broadly divided into these categories:

*Program structure differences: There are distinct, yet easy to understand differences between the structure used in traditional Prolog and that used in Visual Prolog. It essentially comprises of understanding how to mark out the declarations from the definitions, and to indicate the main ''Goal'' that the program has to seek using specific keywords.

*File considerations: Visual Prolog provides various facilities to organize the structure of the program into different kinds of files.

*Scope access issues: A Visual Prolog program can pick up functionality developed in other modules using a concept called ''scope identification''.

*Object orientation: A Visual Prolog program can be written as an object-oriented program, using classic object oriented features.

===Program Structure Differences===

====Declarations and Definitions====

In Prolog, when we need to use a predicate we simply do so without any prior indication to the Prolog engine about our intention. For example, in the earlier tutorial the <code>grandFather</code> predicate's clause was directly written using the traditional Prolog predicate head and body construction. We did not bother to inform the engine in the code that such a predicate construction is to be expected later.

Similarly, when a compound domain is used in traditional Prolog, we can use it without first warning 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 the code for the clause body of a predicate we first need to declare the existence of such a predicate. Similarly, before using any domains, they need to be declared. The reason such forewarnings are required in Visual Prolog is to ensure that runtime exceptions are converted into compile time errors as far as possible.

By ''"runtime exceptions"'', we mean issues that turn up when a program is run. 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 Prolog compilers and the program would fail there. When you declare the predicates and domains in advance, this 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; often, the particular sequence of events that causes a ''runtime exception'' to happen may be so elusive that the bug may only turn up after several years, or it may manifest itself in some critical or other embarrassing situations!

All this implies that the compiler '''has''' to be given explicit instructions regarding the predicates and domains that exist in the code using appropriate declarations before they 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, 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:

<blockquote><vip>constants
pdc = "PDC Prolog".</vip></blockquote>

: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 class. It is defined in some other class, 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.vipprj ==

This project is available as an example in the Visual Prolog installation, use '''Help -> Install Examples...''' to install the examples. This particular example is then in the folder: '…\_tutorial\familyfamily1', where '…' is the folder in which you installed the examples.

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. 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 main

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 [out], string GrandFather [out]) nondeterm.
clauses
grandFather(Person, GrandFather) :-
parent(Person, Parent),
father(Parent, GrandFather).

class predicates
ancestor : (string Person, string Ancestor [out]) nondeterm.
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 main

goal
mainExe::run(main::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.

'''Step 1b.''' A dialog would be presented to you. Enter all the relevant information. Ensure that the Project Kind is ''Console'' and NOT ''GUI''.

:[[Image:FundamentalVisualProlog2.png]]

===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 main.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 main.pro (given in this tutorial) into that window.

:[[Image:FundamentalVisualProlog5.png]]

'''Step 3b.''' After you perform the copy-paste operation, the main.pro window would now look as shown below:

:[[Image:FundamentalVisualProlog6.png]]

===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.png]]

===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''' 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.

You cannot create such a file directly in the IDE itself, but you can save an existing files with a new name (using '''File -> Save as ...''') and then edit that file. Give the file the name ''fa.txt''. After you have saved the file you can add it to the project by selecting '''File -> Add...'''. The advantage of adding it to the project is that it will be available for any subsequent debugging, etc.

The contents of the file should 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 Window''' menu command, this is what you'll see:

:[[Image:FundamentalVisualProlog8.png]]

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==
[[ru:Основы Системы Visual Prolog]]
[[Category:Fundamental Visual Prolog Tutorial]]

Getting Started

2019-05-14T01:10:24Z

Mark Green:

How to get started with Visual Prolog? The answer depends on what you know already.

No matter what prerequisites you have, it is a good idea to read the [[:Category:Tutorials|tutorials]] and you may choose to start with [[Visual Prolog for Tyros]].

== Starting from scratch ==

The book [[A Beginners Guide to Visual Prolog]] is a good starting point.

Alternatively, you can start with the [[Fundamental Prolog Part 1|Fundamental Prolog tutorials]], which describes the basic ideas of "classical" Prolog programming. It uses Edinburgh/ISO Prolog syntax, which is simpler than Visual Prolog because it does not have any type declarations and no Object-Oriented overhead. The code from the examples can be run in '''PIE''' ('''P'''rolog '''I'''nference '''E'''ngine), which is a Edinburgh/ISO Prolog interpreter written in Visual Prolog. '''PIE''' is supplied as an example with Visual Prolog. To run it, click "Browse" on the Open Project menu in Visual Prolog, then look in your Documents directory for <code>Visual Prolog Examples</code> and the directory <code>pie</code> within it, and open the project there.

== Knowing ''traditional'' Prolog ==

The tutorials in the [[Fundamental Visual Prolog]] section describe differences between Visual Prolog and traditional Prolog, and introduce a program that is developed in Visual Prolog. You will be asked to download example projects devoted to family relations that are discussed in these tutorials.

Other tutorials discuss the [[Ide/Environment Overview|Visual Prolog Integrated Environment]] (IDE) and various Visual Prolog language features.

These books are also good starting points:

* [[A Beginners Guide to Visual Prolog]] by ''Thomas W. de Boer''
* [[Visual Prolog for Tyros]] by ''Eduardo Costas''

== Video Tutorials ==

* [http://www.visual-prolog.com/video/HelloWorld/default.htm Hello World! Video Tutorial] covers basic IDE functionality
* [http://www.visual-prolog.com/video/IntelliSpeed/default.htm IntelliSpeed Video Tutorial] demonstrates the context sensitive keyboard accelerator and browse system.

== Online Help System ==

Once you are familiar with the concepts and principles, you also can use reference material from the following sections of the Help system:

*The [[Language Reference]] that describes the syntax and semantics of the Visual Prolog language.
*Integrated Development Environment (IDE) Help.
*Prolog Foundation Classes (PFC) reference documentation.

This Help is reference material rather than tutorial, meaning that it is not a good place to learn Visual Prolog, but it is a very good place to seek answers to specific questions.

The Help system is available from the Integrated Development Environment.

== Community ==

You are also welcome to join Visual Prolog world-wide Community and seek assistance or share your knowledge in the [http://discuss.visual-prolog.com Visual Prolog Discussion forums] and this wiki.

You will find a lot of interesting information in the [http://discuss.visual-prolog.com/viewforum.php?f=3 Visual Prolog Tips, How To's, Code Samples, etc]. And, of course, you are also invited to contribute your own tips, etc.

== Examples ==

In the distribution there is a number of example programs. You can install these examples from the IDE, just press Help -> Install Examples.... You can install these examples again and again, so do not worry about experimenting with them. You can also use them as a starting point for your own programs. Finally, you can download even more examples on [http://www.visual-prolog.com/vip/example/default.htm Visual Prolog Examples and Demos].

== Knowledge Base ==

If you come over a problem, while creating your project, and think that there is a bug in Visual Prolog, you can check [http://kb.visual-prolog.com/ Visual Prolog Knowledge Base]. Here you will find descriptions of bugs and problems that the PDC knows about and is investigating for a possible future fix. Often we provide steps to work around the problem. The Knowledge Base is available from the IDE by
If a bug is fixed in a new release of the product, the "Bug" article includes information about the product version, where the Bug is fixed.

You will also find a lot valuable information in [http://www.visual-prolog.com Visual Prolog site].

Visual Prolog Tutorials, Visual Prolog Discussion forums, the Knowledge Base, and information about Visual Prolog updates are available directly from the Integrated Development Environment (IDE) via the WEB menu.

== Prolog Develpment Center Site ==

We invite you to visit the [http://www.pdc.dk Prolog Development Center site] to find descriptions of real-world commercial projects written entirely in Visual Prolog for:

* Staff Planning
* Hospital Booking
* Airport Decision Support
* Airline Decision Support
* Shop Floor Scheduling
* Speech Based Solutions

We hope, you will enjoy Visual Prolog!

[[Category:Basic Information]]

Library Reference

2019-05-13T22:33:56Z

Mark Green: Created page with "The reference to the standard Visual Prolog library, the Prolog Foundation Classes, is contained within Visual Prolog itself. This ensures that you will always be viewing the..."

The reference to the standard Visual Prolog library, the Prolog Foundation Classes, is contained within Visual Prolog itself. This ensures that you will always be viewing the correct documentation for the version of Visual Prolog you are using. PDC have requested that the PFC documentation is not placed on the wiki.

To view the Library Reference for your copy of Visual Prolog, follow the steps below:

=== From within Visual Prolog ===

* Create a project and open one of its source files (<code>.pro</code> files) in the text editor.
* Place the text cursor over the name of a PFC library or predicate and press F1.

If pressing F1 opens this Wiki on a page related to getting started or the text editor, then the text cursor was not over the name of a PFC library or predicate when you pressed F1. (Note that the '''text''' cursor must be over the name, not the '''mouse''' cursor.)

If you are writing a new program or learning Visual Prolog, you can place the cursor on the word <code>core</code> of the <code>open core</code> line at the top of the project template. Once the Library Reference is open you can view the documentation for any class.

=== Without Visual Prolog ===

If you wish to browsre the PFC reference without connecting to the Visual Prolog IDE, you can find it by opening the directory where you installed Visual Prolog (usually <code>\Program Files (x86)\Visual Prolog 9</code> or the appropriate version number) and looking in the subfolder <code>`appData\doc`</code>. Double clicking the file <code>vip.chm</code> will open the Library Reference.

== List of Packages ==

The list of PFC libraries is shown below. These give an overview of the functionality available in PFC and can be used in the editor to open the documentation on each one.

* <code>5xVip</code> contains predicates for compatibility with Visual Prolog v5.
* <code>action</code> provides standard classes for passing event messages between listeners.
* <code>application</code> provides support for calling external processes or foreign DLLs.
* <code>asynchronous</code> supports asynchronous networking via winSock.
* <code>basis</code> provides base classes for iterators, cancelable operations and disposable resources.
* <code>binary</code> provides support for raw binary data.
* <code>boolean</code> provides support for C-style int-booleans and logical operations.
* <code>chainDB</code> contains support for external databases.
* <code>codePageId</code> contains constants representing standard code pages.
* <code>collection</code> contains standard classes for maps, queues, trees and sets.
* <code>commandLineParser</code> contains support for parsing command line options.
* <code>communications</code> contains support for pipes and synchronous sockets.
* <code>console</code> provides console I/O.
* <code>cryptography</code> provides support for encryption and decryption, hashing, and also base64 encoding.
* <code>dataType</code> contains support for disjoint sets.
* <code>environment</code> provides support for manipulating environment variables.
* <code>event</code> provides fully general purpose event message passing with variable numbers of parameters.
* <code>exception</code> holds the basic exception classes.
* <code>fileSystem</code> contains file operations.
* <code>gui</code> contains GUI support.
* <code>guid</code> provides support for manipulating Globally Unique IDs (GUIDs)
* <code>hash</code> provides incremental hashing.
* <code>htmlHelp</code> provides an interface to the Microsoft HTML Help engine, as used to display the Library Reference.
* <code>InternetExplorer</code> contains classes for interfacing with web browsers.
* <code>list</code> contains standard list manipulation predicates.
* <code>log</code> provides support for logging to the console, databases, streams, or files.
* <code>math</code> contains standard math operations.
* <code>memory</code> allows direct C-style manipulation of system memory.
* <code>multiThread</code> provides support for multithreaded applications.
* <code>namedValue</code> contains support for lists of named values.
* <code>ODBC</code> provides connections to ODBC databases.
* <code>pie</code> contains the Prolog Inference Engine.
* <code>presenter</code> contains support for [[Presenters]].
* <code>printing</code> provides support for print jobs.
* <code>profile</code> provides support for execution profiling.
* <code>programControl</code> allows direct control over the program's execution flow.
* <code>reflection</code> provides support for reflection of defined predicates.
* <code>regEx</code> provides support for regular expression matching.
* <code>registry</code> provides support for manipulating the Windows registry.
* <code>service</code> and <code>serviceImplementation</code> provide support for remotely executed services.
* <code>shellDDEServer</code> provides connection with Windows Explorer (the file browser, distinct from Internet Explorer)
* <code>smapi</code> provides an interface to Windows' SMAPI interface.
* <code>std</code> provides predicates for looping, likely used together with <code>foreach</code>.
* <code>stream</code> provides generic stream support.
* <code>string</code> and <code>string8</code> provide support for Unicode and ASCII strings respectively.
* <code>syntax</code> contains predicates supporting the [[LALR Parser Generator]].
* <code>systemTray</code> provides support for the Windows System Tray.
* <code>templateExpander</code> provides support for defining output templates.
* <code>testSupport</code> provides support for automated testing.
* <code>time</code> contains date/time handling.
* <code>timingStatistics</code> provides code for timing sections of the program.
* <code>vpi</code> provides further GUI support.
* <code>watchDirectory</code> allows a file system directory to be watched for changes.
* <code>web</code> contains support for XHTML, XML, JSON and MIME, an HTTP client and an interface to CGI.
* <Code>windowsApi</code> contains predicates for directly calling the Windows API.

Main/3rd/frameBoxText

2019-05-13T21:40:42Z

Mark Green:

== 3rd party packages and add-ons ==

The wiki has a name space dedicated to [[3rd:Main Page|3rd party packages and add-on's]].
[[Category:Main Page]]

Main/help/frameBoxText

2019-05-13T21:40:31Z

Mark Green:

=== Wiki software and help ===

The wiki is based on [https://www.mediawiki.org/wiki/MediaWiki MediaWiki] software, which is also used for [https://www.wikipedia.org/ Wikipedia]. If you need help with the wiki itself and cannot find it here, you may search in:
*[https://www.mediawiki.org/wiki/Help:Contents MediaWiki help pages]
*[https://en.wikipedia.org/wiki/Help:Contents Wikipedea help pages].

[[Category:Main Page]]

Main/content/frameBoxText

2019-05-13T21:40:11Z

Mark Green:

== Content ==

If you are new to Visual Prolog you may start with [[Getting Started]].

Also check out the Visual Prolog [[:Category:Tutorials|Tutorials]] and the books:
* ''[[A Beginners Guide to Visual Prolog]]'' by ''Thomas W. de Boer''
* ''[[Visual Prolog for Tyros]]'' by ''Eduardo Costa''.

The [[Language Reference]] is also on the wiki, as are instructions for looking up the [[Library Reference]] within Visual Prolog itself.

[[Category:Main Page]]

Main/contribute/frameBoxText

2019-05-13T21:38:46Z

Mark Green:

== Contribution ==

To contribute to this wiki, send an e-mail to [mailto:support@visual.prolog.com support@visual.prolog.com] to get an account on the wiki.

Automatic account creation has been closed due to misuse.

[[Category:Main Page]]