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

Lessons/Succeed, fail and backtrack - part 3

2024-10-11T09:31:55Z

Adam Rose: spelling

Here we will consider more ways to use the knowledge in our little "knowledge base" (i.e. from {{lesson|Succeed, fail and backtrack - part 2}}).

{{Lessons/Exercise|Update the runGoal clauses like this:

<vip>
clauses
runGoal() :-
father(Person, Father),
stdio::writef("% is the father of %.\n", Father, Person).
</vip>

And run the program.}}

This clause will call <vp>father</vp> with two free variables, i.e. both arguments are output arguments. Therefore it will succeed for the first clause and have created a backtrack point to the second clause. And so forth.

Notice that the actual backtracking takes place from <vp>runGoal</vp> to <vp>father</vp>.

{{Lessons/Exercise|Try this instead:

<vip>
clauses
runGoal() :-
foreach father(Person, Father) do
stdio::writef("% is the father of %.\n", Father, Person)
end foreach,
stdio::write("That is all we know about fathers\n").
</vip>}}

<vp>foreach do <Q> end foreach</vp> is a construction that executes <vp></vp> and if it succeeds then it executes <vp><Q></vp> after <vp><Q></vp> has executed it will backtrack into <vp></vp> if that is possible and if <vp></vp> succeeds again then <vp><Q></vp> is also run again, this continues until <vp></vp> finally fails, at which point the execution will continue after <vp>end foreach</vp>.

<vp>fail</vp> is a built-in predicate that always fails, it can be used to achieve a similar behavior as the one <vp>foreach</vp> achieves:

{{Lessons/Exercise|Try this:

<vip>
clauses
runGoal() :-
father(Person, Father),
stdio::writef("% is the father of %.\n", Father, Person),
fail.
runGoal() :-
stdio::write("That is all we know about fathers\n").
</vip>}}

After we have found a <vp>Person</vp> and its <vp>Father</vp> and written it we call <vp>fail</vp>. And since <vp>fail</vp> fails we will backtrack:

* Into <vp>father</vp> if there is a backtrack point there.
* And otherwise to the second <vp>runGoal</vp> clause.

So besides the syntactic difference in using <vp>foreach</vp> and <vp>fail</vp> there is also the difference that after having found all fathers, the <vp>foreach</vp> construction will '''succeed''' and execution will therefore continue after <vp>end foreach</vp> in the '''same''' clause; <vp>fail</vp> on the other hand fails, so in after having found all fathers fail will fail, and we will therefore the entire clause containing <vp>fail</vp> will itself fail, and execution will therefore continue in the '''next''' clause.

Summary:

* We can use the "knowledge base" with different combinations of bound and free arguments.
* <vp>foreach</vp> can be used to exhaust backtracking of a certain "generator" and perform some action of each "generated thing".
* when the backtracking in a <vp>foreach</vp> construction is finally exhausted, the entire <vp>foreach</vp> construction succeeds.
* <vp>fail</vp> is a built-in predicate that fails when called.

{{Lessons/Exercise|Try this:

<vip>
clauses
runGoal() :-
Person = "Sue",
if father(Person, Father) then
stdio::writef("% is the father of %.\n", Father, Person)
else
stdio::writef("We don't kno who the father of % is.\n", Person)
end if,
stdio::write("<<end>>\n").
</vip>
Also try it with <vp>Person = "Pam"</vp>.}}

<vp>if <C> then else <Q> end if</vp> is a construction that will first execute <vp><C></vp> if that succeeds it will execute <vp></vp> if it fails it will execute <vp><Q></vp> instead. Backtrack points in <vp><C></vp> (if any) will be discarded, so there will be no backtracking into <vp><C></vp>. So <vp><C></vp> is used to choose between <vp></vp> and <vp><Q></vp>. If (let us say) <vp></vp> is chosen then the entire <vp>if</vp> construction functions as if <vp></vp> was called. So if <vp></vp> fails then the entire <vp>if</vp> construction fails, and it <vp></vp> succeeds then the entire <vp>if</vp> construction succeeds. Finally, if <vp></vp> created backtrack points then backtracking will return into <vp></vp>.

If you don't want anything to happen in the then-part you can use the built-in <vp>succeed</vp> predicate, which simply succeeds, or you can write nothing at all:

<vip>
if <C> then succeed else <Q> end if
if <C> then else <Q> end if
</vip>

If you don't want anything to take place in the <vp>else</vp> part you can also leave out the word <vp>else</vp>, so these three things have the same meaning:

<vip>
if <C> then else succeed end if
if <C> then else end if
if <C> then end if
</vip>

Summary

* <vp>succeed</vp> is a build-in predicate that succeeds
* <vp>if <C> then else <Q> end if</vp> runs <vp>C</vp> to choose between <vp></vp> and <vp><Q></vp>.

[[Category:Lessons|{{SUBPAGENAME}}]]

Lessons/Succeed, fail and backtrack - part 2

2024-10-11T09:14:26Z

Adam Rose: spelling and grammar

In {{Lesson|Succeed, fail and backtrack - part 1}} we described what it means that a predicate succeeds and fails and what backtracking means. By examining a very small program with an extremely little "knowledge base". Here we'll discuss how we can add more abstract rules to such a knowledge base.

In particular we will look at the mentioned grandfather rule:

* "C is the grandfather of A if C is the father of B and B is the father of A"

The rule as it is written here is actually more or less a Visual Prolog clause:

{{Lessons/Exercise|And an extra <vp>father</vp> clause:

<vip>
clauses
father("Bill", "John").
father("Pam", "Bill").
</vip>

And add a <vp>grandfather</vp> predicate:

<vip>
class predicates
grandfather : (string Person, string Grandfather) nondeterm anyflow.
clauses
grandfather(Person, Grandfather) :-
father(Father, Grandfather),
father(Person, Father).
</vip>

Build the project.}}

In consistence wih my <vp>father</vp> predicate, it is the second argument of the <vp>grandfather</vp> predicate that is the grandfather. In the clause I have chosen to use <vp>Person</vp>, <vp>Father</vp> and <vp>Grandfather</vp> as variable names instead of <vp>A</vp>, <vp>B</vp> and <vp>C</vp>, but otherwise the rule is a "direct" translation of the textual version.

Let us test the new predicate in a way similar to how we tested the <vp>father</vp> predicate:

{{Lessons/Exercise|Update the <vp>runGoal</vp> clauses like this:

<vip>
clauses
runGoal() :-
grandfather("Pam", "John"),
stdio::write("Yes, John is the grandfather of Pam\n").
runGoal() :-
not(grandfather("Bill", "John")),
stdio::write("No, John is not the grandfather of Bill\n").
</vip>

Run the project.}}

When <vp>run</vp> calls <vp>runGoal</vp> we first create a backtrack point to the second <vp>runGoal</vp> clause and then execute the first clause.

In the first <vp>runGoal</vp> clause we call <vp>grandfather("Pam", "John")</vp>, so when we enter the <vp>grandfather</vp> clause <vp>Person</vp> is <vp>"Pam"</vp> and Grandfather is <vp>"John"</vp>. We will say that <vp>Person</vp> is '''bound''' to <vp>"Pam"</vp> and <vp>Grandfather</vp> is '''bound''' to <vp>"John"</vp> and <vp>Father</vp> is unbound or '''free'''. If we substitute known values for the variables the clause looks like this:

<vip>
grandfather("Pam", "John") :- father(Father, "John"), father("Pam", Father).
</vip>

In this clause we will first call the <vp>father</vp> predicate with a '''free''' first argument and a '''bound''' second argument. So the data flow in that call is that the first argument is an '''output''' argument and the second argument is an '''input''' argument.

When we enter the <vp>father</vp> predicate we have two clauses, so the first thing that happens is that we create a backtrack point to the second clause and then execute the first clause. Since our first argument is free it can match "Bill" in the clause, i.e. if we bind it to <vp>"Bill"</vp>. The second argument is "John" and that also matches "John" clause. So the first clause succeeds and we return to the <vp>grandfather</vp> clause where the <vp>Father</vp> variable is now bound to <vp>"Bill"</vp>. If we substitute <vp>"Bill"</vp> for the <vp>Father</vp> variable the clause now looks like this:

<vip>
grandfather("Pam", "John") :- father("Bill", "John"), father("Pam", "Bill").
</vip>

So now we have to call <vp>father("Pam", "Bill")</vp>, which means that this time we call the <vp>father</vp> predicate with two '''input''' arguments.

In the <vp>father</vp> predicate we again first create a backtrack point to the second clause, and then execute the first clause. The first clause fails because the first argument in our call is <vp>"Pam"</vp> but the first argument in the clause is <vp>"Bill"</vp>. There is no need to consider the second arguments, we just immediately invoke the backtracking mechanism which will bring us to the second clause. The second clause succeeds and we return to the <vp>grandfather</vp> predicate and since this was the last call in that clause the grandfather predicate also succeeds.

So we return to <vp>runGoal</vp> where we will write <vp>"Yes, John is the grandfather of Pam\n"</vp>. And then the first clause of <vp>runGoal</vp> succeeds and we will return to the <vp>run</vp> predicate.

{{Lessons/Exercise|Recall that the <vp>run</vp> predicate will make sure that all backtracking takes place, so carefully consider what happens next. Do we have any backtrack points? If so where do we backtrack to?}}

Well if you considered correctly, you would recall that we have created three backtrack points in total and also used one of them, so we have two backtrack points left.

The first we created was to the second clause in <vp>runGoal</vp>, the second backtrack point we created was to the second clause of the <vp>father</vp> predicate which we had called from the first call in the <vp>grandfather</vp> predicate which we had called in the first clause in the <vp>runGoal</vp> predicate. Both these backtrack points still exists, and the one we created in the father predicate was the last one we created so this it the one we will backtrack to.

So at this point we will backtrack to place that is nested rather deeply in something that we have already returned from once.

Furthermore at that backtrack point in the <vp>father</vp> predicate the first argument was free, when we executed the first clause in that predicate the variable became bound, but when we backtrack to this place the variable is again free. So backtracking not only transfers the program control back to an earlier state, it also restores variables to the free/bound state they were in at that point. Notice that such restore of variables can only make variables free again, bound variables never receive new values, so bound variables already have the correct state.

So we are back at the second clause <vp>father("Pam", "Bill").</vp> of the <vp>father</vp> predicate with the first argument being free and the second argument being <vp>"John"</vp>. When we execute this clause we can bind the free first argument, but the <vp>"John"</vp> does not match <vp>"Bill"</vp>, so this clause fails.

Once more we backtrack this time to the second clause of <vp>runGoal</vp>.

So backtracking can jump quite a lot around in your program.

[[Category:Lessons|{{SUBPAGENAME}}]]

Lessons/Succeed, fail and backtrack - part 1

2024-10-11T07:44:53Z

Adam Rose: small spelling mistakes

So why is it a logical programming language? And why do we call it predicates and clauses?

Logic is a formalized approach to

* propositions like "John is the father of Bill"
* rules like "C is the grandfather of A if C is the father of B and B is the father of A"
* questions like "Who is the father of John"

Visual Prolog can formalize logical entities. The Visual Prolog compiler has a number of strict validation checks that will help you write the programs you intend. But to keep things simple we will "work around" those checks in this lesson. To do that work around you should update enter the following code in the console project:

{{Lessons/Exercise|In a console project update the <vp>run</vp> clause and add a <vp>runGoal</vp> predicate, like this:

<vip>
clauses
run() :-
foreach runGoal() do
end foreach.

class predicates
runGoal : () nondeterm.
clauses
runGoal().
</vip>

Build the project.}}

Compared to what we have see so far you will notice the token <vp>nondeterm</vp> in the declaration of <vp>run2</vp> and you will also get a warning about '<vp>nondeterm</vp>'. We have inserted <vp>nondeterm</vp> to get around some compiler errors that we would later get, and instead we now get some warnings. For now we will just ignore these warnings and in the sequel of this lesson you should just accept to write <vp>nondeterm</vp> and also <vp>anyflow</vp> where told.

Back to the main subject. Let us start with the proposition "John is the father of Bill".

Here we have two "things": John and Bill, and a "relation" between these, namely that one is the father of the other.
In Visual Prolog I can formalize this proposition in the following way:

<vip>father("Bill", "John").</vip>

father is a predicate/relation taking two arguments, where the second is the father of the first.

'''Notice''' that '''''I '''''have chosen that the '''second''' person should be the father of the '''first'''.
I might as well have chosen it the other way around: The order of the arguments is the choice of the "designer" of the formalization.
However, once you have chosen, you must be consistent.
So in '''my''' formalization the father must '''always''' be the second person.

{{Lessons/Exercise|Add this code to the project:

<vip>
class predicates
father : (string Person, string Father) nondeterm anyflow.
clauses
father("Bill", "John").
</vip>

Build the project.}}

Now that we have a (tiny) "knowledge base", we will try to find the answer to some questions. Let's first see the "magic":

{{Lessons/Exercise|Update the <vp>runGoal</vp> clause like this:

<vip>
clauses
runGoal() :-
father("Bill", "John"),
stdio::write("Yes, John is the father of Bill").
</vip>

Run the project.

Then add one more clause like this:

<vip>
clauses
runGoal() :-
father("Bill", "John"),
stdio::write("Yes, John is the father of Bill").

runGoal() :-
father("Sue", "John"),
stdio::write("Yes, John is the father of Sue").
</vip>

And run the project again.

Finally, modify add one more clauses like this:

<vip>
clauses
runGoal() :-
father("Bill", "John"),
stdio::write("Yes, John is the father of Bill").

runGoal() :-
father("Sue", "John"),
stdio::write("Yes, John is the father of Sue").

runGoal() :-
not(father("Sue", "John")),
stdio::write("No, John is the not the father of Sue").
</vip>

And run the project again.}}

To understand what is going on we need to understand the concept of '''succeed''' and '''fail'''. When we call <vp>father("Bill", "John")</vp> the call will '''succeed''', because there is a clause that matches this call. When we call <vp>father("Sue", "John")</vp> the call will '''fail''', because the clauses for the father predicate cannot match this call.
The call <vp>not(father("Sue", "John"))</vp> will '''succeed''' because <vp>not</vp> is special predicate that succeeds if its argument fails and fails if the argument succeeds.

Using the words ''succeed'' and ''fail' we can now explain the clauses.

Let us first consider each of the three clauses individually (as if they were the only one)

The first clause <vp>runGoal() :- father("Bill", "John"), stdio::write("Yes, ...").</vp> works like this: <vp>runGoal()</vp> succeeds '''if''' <vp>father("Bill", "John")</vp> '''and''' <vp>stdio::write("Yes, ...")</vp> succeeds, otherwise it fails.

So when we call <vp>runGoal()</vp> we will first run <vp>father("Bill", "John")</vp> and ''if'' that succeeds (which we know it will) we will call <vp>stdio::write("Yes, ...")</vp>.

The predicate <vp>stdio::write</vp> is a predicate that succeeds no matter which arguments it is called with and in addition it will also write the arguments to the standard output stream.

So all in all, the first clause will '''succeed''' and also write <vp>"Yes, ..."</vp> to the standard output stream.

In the second clause we will first run <vp>father("Sue", "John")</vp> and since that call fails, the entire clause fails, and therefore we will ''not'' call <vp>stdio::write</vp> in this clause.

In the third clause we first call <vp>not(father("Sue", "John"))</vp>. As mentioned above this call succeeds and therefore we will also call <vp>stdio::write</vp> in this clause.

Now that we know how each clause works individually, lets look at the effect of having them all three. This is actually the most unique feature of logical programming languages, but probably also the most tricky one to understand. The idea is based on the logical "or": to <vp>runGoal()</vp> will succeed if the first clause "or" the second clause "or" the third clause succeeds. It is true, but it is not sufficiently detailed when actually programming in Visual Prolog. Here I will provide a much more detailed and operative description of how it works.

When we invoke <vp>runGoal()</vp>, which has three clauses. We will first create a '''''backtrack''''' point to the two other clauses, and then excecute the first clause.

A backtrack point is a "thing" that describes a place in our program where we had two alternative ways to fulfill our goal. We do one thing but make a note about the other possibility. If we at some point fail, we backtrack to the place we noted in the most recent backtrack point we created and follow the alternative way we noted in the backtrack point. (That backtrack point is then used and thus discarded).

So with all three <vp>runGoal()</vp> clauses we will first create a backtrack point to the two last clauses and then execute the first clause. As discussed above the first clause will succeed, so we will return from <vp>runGoal()</vp> to the place in <vp>run()</vp> where <vp>runGoal()</vp> was called from, but we have also created a backtrack point to the two last clauses of <vp>runGoal()</vp>.

The code we wrote in the <vp>run</vp> clause will (without going into the datails) has the effect that we backtrack according to our backtrack point, so after returning from runGoal the first time we will backtrack to the last two <vp>runGoal</vp> clauses.

When we backtrack to the last two clauses there is a choice between the second and the third clause, so again a backtrack point is created, this time to the third clause, and then the second clause is executed.

As mentioned before the second clause will fail in the <vp>not(father("Sue", "John"))</vp> call, when this happens we will again backtrack to where the latest backtrack point says, i.e. to the third <vp>runGoal</vp> clause. The third clause is the last clause so here we don't have a choice point and therefore we do not have any more backtrack points left.

The third clause will execute as described above and <vp>runGoal</vp> will return to then <vp>run()</vp> clause, and with no more backtrack points <vp>run()</vp> will finish and eventually the entire program will finish.

Notice that we backtracked two times in this program:

* The first time we backtracked back into a predicate that had already returned one time, and therefore a single call to <vp>runGoal</vp> returned twice to <vp>run</vp>
* The second backtrack was from the nested call to father in the second <vp>runGoal</vp> clause to the third <vp>runGoal</vp> clause.

Summary

* Calls can succeed or fail.
* Whenever there is a choice point a backtrack point is created to the second choice and the first choice is pursued.
* When a predicate fails program control is backtracked to the latest backtrack point.
* Backtrack may "jump" out from nested calls
* Backtracking may also "jump" back into already succeeded calls
* So as a result of backtracking a certain predicate call may succeed/return '''several''' times.

[[Category:Lessons|{{SUBPAGENAME}}]]

Lessons/Output arguments

2024-10-11T07:41:55Z

Adam Rose: spelling mistake

In the {{Lesson|Functions}} lesson we created a function, i.e. a predicate that returned a value. Here we will look at output parameters, which is another way to let data flow outwards.

{{Lessons/Exercise|Add this code to a console project:

<vip>
class predicates
nowDateAndTime : (string Date [out], string Time [out]).
clauses
nowDateAndTime(Date, Time) :-
Now = time::now(),
Date = Now:formatShortDate(),
Time = Now:formatTime().
</vip>

Build the project, and answer "Yes" to adding the '''...time.ph''' include statement.}}

The first thing to notice here is the use of <vp>[out]</vp> in the predicate declaration, this "mark" indicates that the corresponding argument is an output argument rather than an input argument.

In the clause we still have a "position" corresponding to that argument, but this time we have to "calculate" and return a value. So in the clause above <vp>Date</vp> and <vp>Time</vp> does not have a value when the body starts to execute, it is our responsibility to create bind values to these variables.

In the clause body we call the function <vp>now</vp> on the class <vp>time</vp> this function returns a time ''object'' that represents the time the function was called. Here we will not go into details about objects, but the next two lines of code shows that objects have predicates associated with them and that these are referenced these using a single colon: <vp><object>:<predicate></vp>.

A <vp>time</vp> object represents a time and date, and in the last two lines we "request" the date using the short format and the time formatted as a string. What exactly these functions does depends on the users settings on the computer (i.e. the users locale settings).

{{Lessons/Exercise|Update the run clause like this:

<vip>
clauses
run() :-
nowDateAndTime(NowDate, NowTime),
stdio::writef("The time is now % and it is the %.\n", NowTime, NowDate).
</vip>

Run the project.}}

Sometimes you will accidentally use a single colon where you intended to use two and vice versa:

{{Lessons/Exercise|Try using a single colon instead of two and build the project and examine the error message. Revert the problem and try the the opposite error. End without errors.}}

Output arguments can also be used in functions, and together with input arguments.

{{Lessons/Exercise|Update <vp>nowDateAndTime</vp> to be a '''function''' that returns the date as an output argument and the time as the function return value.

Notice the error message you get if you don't update the call in the <vp>run</vp> clause.

Also update the <vp>run</vp> clause and run the program.}}

Summary:

* Output arguments are declared using the <vp>[out]</vp> attribute.
* An output argument is unbound when the clause <vp><body></vp> is entered and must be bound when the predicate returns.
* There is something called objects.
* Objects are values that can be passed around and held in variables.
* Objects have predicates associated and these are referenced with single colon: <vp><object>:<predicate></vp> (predicates in classes are referenced using a double-colon).

[[Category:Lessons|{{SUBPAGENAME}}]]

Lessons/Projects

2024-10-11T07:40:19Z

Adam Rose: small spelling mistakes

A Visual Prolog ''project'' represents an executable or DLL programmed in Visual Prolog. You can open a project in the [[IDE|IDE (Integrated Development Environment)]] and work on that project (i.e. executable/DLL).

The IDE will remember a list of the projects it has opened, so that you can easily reopen one of your projects. You can open several projects in each their IDE and work on them in parallel (should you want to).

When you have a project open in the IDE you can navigate to the source files that the target (i.e. executable/DLL) is built from, and you can edit them. In the IDE you can also build, execute and debug the target.

So your main interaction with the project will be through the IDE. The top-level information about the project is described in a project file (with extension '''vipprj'''). The IDE will maintain the project file, and you will not need to look into the file. But actually the project file is relatively easy to understand when you are familiar with the concepts of a project.

When you create a new project you give it a name and decide which directory that should contain the project. The project file and several other files will be created in this directory (and optionally sub-directories). You can choose among project templates for GUI programs, command line programs, etc.

{{Lessons/Exercise|
Create a '''console''' project in the IDE.}}

After the project has been created it is automatically built (compiled, linked, etc). This will produce an initial version of your target. Since the project is just created the target is not really interesting at this point, but a side effect of building a project is that the compiler will gather a lot of ''browse'' information about the entities in the program.

The browse information enables the IDE to provide a lot of ways to navigate around in your code. In the project tree there will be a lot of nodes corresponding to the entities in your program (including what is included from [[PFC| PFC (Prolog Foundation Classes]]). And in the '''Go to''' menu you will find lots of navigation means most of which are based on the browse information.

Browse information becomes inaccurate when you edit files, because editing changed the positions where things are located. But upon a successful build of the project the browse information will again be accurate. Unsuccessful builds may however make some useful browse information disappear until the build is again successful. Therefore it is advisable to try to keep code as compilable as possible and build regularly.

{{Lessons/Exercise|
Even though you currently does not know much about Visual Prolog examine the project tree in the project you created above, and try navigating around in it using the different entries in the '''Go to''' menu. Try to figure out what the different things do. And notice that many things have short-cut keys.}}

{{Lessons/Exercise|
Watch the [https://www.visual-prolog.com/video/HelloWorld/default.htm Hello World!] video tutorial, which demonstrates the basic IDE features. The IDE in the video is from the older Visual Prolog version 7.3, so there are deviations from the current IDE, but the basics is the same and most of the details are also the same.}}

{{Lessons/Exercise|
Read the tutorial [[Ide/Environment Overview]] which contains much more detailed information about the IDE. You may not get the full benefit from this tutorial now. So it may be a good idea to read it again at some later point.}}

[[Category:Lessons|{{SUBPAGENAME}}]]

Lessons/Hello World!

2024-10-11T07:37:33Z

Adam Rose: a few spelling mistakes

In this lesson we will just write some code disregarding the finer details.

{{Lessons/Exercise|Create a console project.

Double-click the '''main.pro''' file in the project tree to open it in an editor, and update the <vp>run clauses</vp> to look like this:

<vip>
clauses
run() :-
stdio::write("Hello World!\n").
</vip>

Run the program using '''Build -> Run in window Alt+F5'''.}}

The '''main.pro''' file contains other stuff, which we will currently disregard, and focus solely on the <vp>run clauses</vp> you just wrote.

First we have the keyword <vp>clauses</vp>, which simply indicates that what comes after are '''clauses'''. Clauses is where the actual running code is written.

In this text I will use words like "clause" and "predicate", which all have their origin in formal logic, but for the moment we will simply treat them as the names that happens to be chosen for things in a Prolog program.

<vp>clauses</vp> are used to define <vp>predicates</vp>, where a ''predicate'' is a Prolog routine/subroutine/function/procedure (dear child has many names)

This particular clause defines a predicate <vp>run</vp> which takes no arguments (indicated by the empty parentheses <vp>()</vp>).

After the <vp>:-</vp> token we have the code that will be executed when <vp>run</vp> is invoked/called.

In this case we call a predicate named <vp>write</vp> which is defined in the <vp>class</vp> named <vp>stdio</vp>. We will discuss classes later for now we will just consider <vp>stdio::write</vp> as "a long compound name".

We supply one argument, i.e. the string literal <vp>"Hello World!\n"</vp>, to the <vp>stdio::write</vp> predicate. Notice that \n in the string literal represents a line shift.

The clause is terminated by a period (i.e. <vp>.</vp>). Period is used as terminator for many kinds of entities in Visual Prolog.

The predicate <vp>run</vp> is called when the program is run, and acts as our entry point to the program. Actually, the real entry point is the <vp>goal</vp> a further down in the main.pro file, but that entry point is used to make varous initializations, corresponding clean-up, etc and will call the <vp>run</vp> predicate in the right spot, so run can act like your entry point.

So when the program is run the predicate <vp>run</vp> in '''main.pro''' will be called and this will (here) call
<vp>stdio::write</vp> with the argument <vp>"Hello World!\n"</vp>, as a result ''Hello World!'' and a line shift will be written to the console window.

Actually, <vp>stdio::write</vp> writes to the standard output stream, which in a console program is initialized to be the console window. In a default GUI program the standard output stream will write to a message window, but the standard output stream is under programmer control, so what happens when you call <vp>stdio::write</vp> will depend of what has taken place in the program.

To summarize:

* The actual running code is in <vp>clauses</vp>
* <vp>predicates</vp> is the Visual Prolog name for routines/subroutines/functions/procedures.
* Predicates are organized in classes, and predicates from other classes is referenced using <vp><class>::<predicate></vp>.
* The <vp>run</vp> predicate in <vp>main.pro</vp> is the (effective) entry to a program.
* <vp>stdio::write</vp> can write to the standard output stream

Now let us extend the program with an extra predicate.

{{Lessons/Exercise|Add this code below the <vp>run</vp> clauses:

<vip>
class predicates
advancedHello : (string Name).
clauses
advancedHello(Name) :-
stdio::writef("Hello %!\n", Name).
</vip>

Build the project using '''Build -> Build Ctrl+Shift+B'''}}

When you build the project you will get a warning stating that the predicate <vp>main::advancedHello</vp> is an unused local predicate. Which is completely correct; we haven't used it for anything. But let us "decipher" it before we go any further.

We notice that we again have a clause in a <vp>clauses</vp> section. The clause is for a predicate named <vp> advancedHello</vp> that takes one argument called <vp>Name</vp>. <vp>Name</vp> is a variable, a variable starts with an uppercase letter and will be green in the editor (variables can also start with an underscore, but we will discuss that later).

<vp>Name</vp> acts as a formal parameter representing the actual argument used in the call to <vp>advancedHello</vp>. In this clause we call <vp>stdio::writef</vp> which is a more advanced "writer" predicate. The first argument to <vp>writef</vp> is a format string, which contains a %-character, what happens when <vp>writef</vp> is called is that the actual value of <vp>Name</vp> is substituted into the format string in the place where the %-character is and then the resulting string is written to the standard output.

This time we also have a <vp>class predicates</vp> section containing a declaration of the <vp>advancedHello</vp> predicate. This particular declaration declares <vp>advancedHello</vp> as a class predicate which takes one argument which must be a string.

In the predicate declaration the argument also have the name <vp>Name</vp> but in the declaration the name is mainly intended for documentation purposes. The variable name in the declaration and in the clauses can be different, or you can remove it completely from the declaration. I recommend that you always have variable names here and that you use variable names that will make it clearer for the user of the predicate what the arguments represents.

What it means to be a ''class'' predicate and what else a predicate can be is discussed elsewhere/later. But before we leave the subject try this little experiment:

{{Lessons/Exercise|Remove the word <vp>class</vp> from <vp>class predicates</vp> in the declaration of advancedHello. And then build the project.

Notice the error message and remember that you get this message when you have forgotten to write <vp>class</vp> in front of <vp>predicates</vp>.

Then insert <vp>class</vp> again and build the project again.}}

Now that we have the advancedHello predicate we can use it in our <vp>run</vp> predicate.

{{Lessons/Exercise|Update the run clause to look like this:

<vip>
clauses
run() :-
advancedHello("Dear"),
advancedHello("World").
</vip>
Run the project in a window.}}

The clause should be understandable, I just want to highlight that we have used '''comma''' to separate the two invocations of <vp>advancedHello</vp>: '''comma''' to separate, '''period''' to terminate. I will give a little prediction: Later when you are familiar with Visual Prolog you will from time to time make syntax errors and (the prediction) 9 out of 10 times the syntax error will concern '''comma''' and/or '''period'''.

To summarize:

* Predicates must have a declaration (<vp>run</vp> is also declared we just havn't looked at its declaration).
* Arguments in predicates declarations can be given names that clarify the meaning if the arguments.
* <vp>stdio::writef</vp> writes text to the standard output stream using a format string.
* calls are separated by comma and clauses (and predicate declarations) are terminated by period.
* If I get a syntax error it is likely to be related to comma or period.
* A certain other error message (can you recall it) probably means that I have forgotten to write <vp>class</vp> in front of <vp>predicates</vp>.

[[Category:Lessons|{{SUBPAGENAME}}]]

Lessons/Hello World!

2024-10-10T14:06:12Z

Adam Rose: Fixed bold formatting

In this lesson we will just write some code disregarding the finer details.

{{Lessons/Exercise|Create a console project.

Double-click the '''main.pro''' file in the project tree to open it in an editor, and update the <vp>run clauses</vp> to look like this:

<vip>
clauses
run() :-
stdio::write("Hello World!\n").
</vip>

Run the program using '''Build -> Run in window Alt+F5'''.}}

The '''main.pro''' file contains other stuff, which we will currently disregard, and focus solely on the <vp>run clauses</vp> you just wrote.

First we have the keyword <vp>clauses</vp>, which simly indicates that what comes after are '''clauses'''. Clauses is where the actual running code is written.

In this text I will use words like "clause" and "predicate", which all have their origin in formal logic, but for the moment we will simply treat them as the names that happens to be chosen for things in a Prolog program.

<vp>clauses</vp> are used to define <vp>predicates</vp>, where a ''predicate'' is a Prolog routine/subroutine/function/procedure (dear child has many names)

This particular clause defines a predicate <vp>run</vp> which takes no arguments (indicated by the empty parentheses <vp>()</vp>).

After the <vp>:-</vp> token we have the code that will be executed when <vp>run</vp> is invoked/called.

In this case we call a predicate named <vp>write</vp> which is defined in the <vp>class</vp> named <vp>stdio</vp>. We will discuss classes later for now we will just consider <vp>stdio::write</vp> as "a long compound name".

We supply one argument, i.e. the string literal <vp>"Hello World!\n"</vp>, to the <vp>stdio::write</vp> predicate. Notice that \n in the string literal represents a line shift.

The clause is terminated by a period (i.e. <vp>.</vp>). Period is used as terminator for many kinds of entities in Visual Prolog.

The predicate <vp>run</vp> is called when the program is run, and acts as our entry point to the program. Actually, the real entry point is the <vp>goal</vp> a further down in the main.pro file, but that entry point is used to make varous initializations, corresponding clean-up, etc and will call the <vp>run</vp> predicate in the right spot, so run can act like your entry point.

So when the program is run the predicate <vp>run</vp> in '''main.pro''' will be called and this will (here) call
<vp>stdio::write</vp> with the argument <vp>"Hello World!\n"</vp>, as a result ''Hello World!'' and a line shift will be written to the console window.

Actually, <vp>stdio::write</vp> writes to the standard output stream, which in a console program is initialized to be the console window. In a default GUI program the standard output stream will write to a message window, but the standard output stream is under programmer control, so what happens when you call <vp>stdio::write</vp> will depend of what has taken place in the program.

To summarize:

* The actual running code is in <vp>clauses</vp>
* <vp>predicates</vp> is the Visual Prolog name for routines/subroutines/functions/procedures.
* Predicates are organized in classes, and predicates from other classes is referenced using <vp><class>::<predicate></vp>.
* The <vp>run</vp> predicate in <vp>main.pro</vp> is the (effective) entry to a program.
* <vp>stdio::write</vp> can write to the standard output stream

Now let us extend the program with an extra predicate.

{{Lessons/Exercise|Add this code below the <vp>run</vp> clauses:

<vip>
class predicates
advancedHello : (string Name).
clauses
advancedHello(Name) :-
stdio::writef("Hello %!\n", Name).
</vip>

Build the project using '''Build -> Build Ctrl+Shift+B'''}}

When you build the project you will get a warning stating that the predicate <vp>main::advancedHello</vp> is an unused local predicate. Which is completely correct; we haven't used it for anything. But let us "decipher" it before we go any further.

We notice that we again have a clause in a <vp>clauses</vp> section. The clause is for a predicate named <vp> advancedHello</vp> that takes one argument called <vp>Name</vp>. <vp>Name</vp> is a variable, a variable starts with an uppercase letter and will be green in the editor (variables can also start with an underscore, but we will discuss that later).

<vp>Name</vp> acts as a formal parameter representing the actual argument used in the call to <vp>advancedHello</vp>. In this clause we call <vp>stdio::writef</vp> which is a more advanced "writer" predicate. The first argument to <vp>writef</vp> is a format string, which contains a %-character, what happens when <vp>writef</vp> is called is that the actual value of <vp>Name</vp> is substituted into the format string in the place where the %-character is and then the resulting string is written to the standard output.

This time we also have a <vp>class predicates</vp> section containing a declaration of the <vp>advacedHello</vp> predicate. This perticular declaration declares <vp>advancedHello</vp> as a class predicate which takes one argument which must be a string.

In the predicate declaration the argument also have the name <vp>Name</vp> but in the declaration the name is mainly intended for documentation purposes. The variable name in the declaration and in the clauses can be different, or you can remove it completely from the declaration. I recommend that you always have variable names here and that you use variable names that will make it clearer for the user of the predicate what the arguments represents.

What it means to be a ''class'' predicate and what else a predicate can be is discussed elsewhere/later. But before we leave the subject try this little experiement:

{{Lessons/Exercise|Remove the word <vp>class</vp> from <vp>class predicates</vp> in the declaration of advancedHello. And then build the project.

Notice the error message and remember that you get this message when you have forgotten to write <vp>class</vp> in front of <vp>predicates</vp>.

Then insert <vp>class</vp> again and build the project again.}}

Now that we have the advancedHello predicate we can use it in our <vp>run</vp> predicate.

{{Lessons/Exercise|Update the run clause to look like this:

<vip>
clauses
run() :-
advancedHello("Dear"),
advancedHello("World").
</vip>
Run the project in a window.}}

The clause should be understandable, I just want to highlight that we have used '''comma''' to separate the two invocations of <vp>advancedHello</vp>: '''comma''' to separate, '''period''' to terminate. I will give a little prediction: Later when you are familiar with Visual Prolog you will from time to time make syntax errors and (the prediction) 9 out of 10 times the syntax error will concern '''comma''' and/or '''period'''.

To summarize:

* Predicates must have a declaration (<vp>run</vp> is also declared we just havn't looked at its declaration).
* Arguments in predicates declarations can be given names that clarify the meaning if the arguments.
* <vp>stdio::writef</vp> writes text to the standard output stream using a format string.
* calls are separated by comma and clauses (and predicate declarations) are terminated by period.
* If I get a syntax error it is likely to be related to comma or period.
* A certain other error message (can you recall it) probably means that I have forgotten to write <vp>class</vp> in front of <vp>predicates</vp>.

[[Category:Lessons|{{SUBPAGENAME}}]]

Lessons/Hello World!

2024-10-10T14:03:13Z

Adam Rose: Clarification

In this lesson we will just write some code disregarding the finer details.

{{Lessons/Exercise|Create a console project.

Double-click the '''main.pro''' file in the project tree to open it in an editor, and update the <vp>run clauses</vp> to look like this:

<vip>
clauses
run() :-
stdio::write("Hello World!\n").
</vip>

Run the program using '''Build -> Run in window Alt+F5'''.}}

The '''main.pro''' file contains other stuff, which we will currently disregard, and focus solely on the <vp>run clauses</vp> you just wrote.

First we have the keyword <vp>clauses</vp>, which simly indicates that what comes after are '''clauses'''. Clauses is where the actual running code is written.

In this text I will use words like "clause" and "predicate", which all have their origin in formal logic, but for the moment we will simply treat them as the names that happens to be chosen for things in a Prolog program.

<vp>clauses</vp> are used to define <vp>predicates</vp>, where a ''predicate'' is a Prolog routine/subroutine/function/procedure (dear child has many names)

This particular clause defines a predicate <vp>run</vp> which takes no arguments (indicated by the empty parentheses <vp>()</vp>).

After the <vp>:-</vp> token we have the code that will be executed when <vp>run</vp> is invoked/called.

In this case we call a predicate named <vp>write</vp> which is defined in the <vp>class</vp> named <vp>stdio</vp>. We will discuss classes later for now we will just consider <vp>stdio::write</vp> as "a long compound name".

We supply one argument, i.e. the string literal <vp>"Hello World!\n"</vp>, to the <vp>stdio::write</vp> predicate. Notice that \n in the string literal represents a line shift.

The clause is terminated by a period (i.e. <vp>.</vp>). Period is used as terminator for many kinds of entities in Visual Prolog.

The predicate <vp>run</vp> is called when the program is run, and acts as our entry point to the program. Actually, the real entry point is the <vp>goal</vp> a further down in the main.pro file, but that entry point is used to make varous initializations, corresponding clean-up, etc and will call the <vp>run</vp> predicate in the right spot, so run can act like your entry point.

So when the program is run the predicate <vp>run</vp> in '''main.pro''' will be called and this will (here) call
<vp>stdio::write</vp> with the argument <vp>"Hello World!\n"</vp>, as a result ''Hello World!'' and a line shift will be written to the console window.

Actually, <vp>stdio::write</vp> writes to the standard output stream, which in a console program is initialized to be the console window. In a default GUI program the standard output stream will write to a message window, but the standard output stream is under programmer control, so what happens when you call <vp>stdio::write</vp> will depend of what has taken place in the program.

To summarize:

* The actual running code is in <vp>clauses</vp>
* <vp>predicates</vp> is the Visual Prolog name for routines/subroutines/functions/procedures.
* Predicates are organized in classes, and predicates from other classes is referenced using <vp><class>::<predicate></vp>.
* The <vp>run</vp> predicate in <vp>main.pro</vp> is the (effective) entry to a program.
* <vp>stdio::write</vp> can write to the standard output stream

Now let us extend the program with an extra predicate.

{{Lessons/Exercise|Add this code below the <vp>run</vp> clauses:

<vip>
class predicates
advancedHello : (string Name).
clauses
advancedHello(Name) :-
stdio::writef("Hello %!\n", Name).
</vip>

Build the project using '''Build -> Build Ctrl+Shift+B'''}}

When you build the project you will get a warning stating that the predicate <vp>main::advancedHello</vp> is an unused local predicate. Which is completely correct; we haven't used it for anything. But let us "decipher" it before we go any further.

We notice that we again have a clause in a <vp>clauses</vp> section. The clause is for a predicate named <vp> advancedHello</vp> that takes one argument called <vp>Name</vp>. <vp>Name</vp> is a variable, a variable starts with an uppercase letter and will be green in the editor (variables can also start with an underscore, but we will discuss that later).

<vp>Name</vp> acts as a formal parameter representing the actual argument used in the call to <vp>advancedHello</vp>. In this clause we call <vp>stdio::writef</vp> which is a more advanced "writer" predicate. The first argument to <vp>writef</vp> is a format string, which contains a %-character, what happens when <vp>writef</vp> is called is that the actual value of <vp>Name</vp> is substituted into the format string in the place where the %-character is and then the resulting string is written to the standard output.

This time we also have a <vp>class predicates</vp> section containing a declaration of the <vp>advacedHello</vp> predicate. This perticular declaration declares <vp>advancedHello</vp> as a class predicate which takes one argument which must be a string.

In the predicate declaration the argument also have the name <vp>Name</vp> but in the declaration the name is mainly intended for documentation purposes. The variable name in the declaration and in the clauses can be different, or you can remove it completely from the declaration. I recommend that you always have variable names here and that you use variable names that will make it clearer for the user of the predicate what the arguments represents.

What it means to be a ''class'' predicate and what else a predicate can be is discussed elsewhere/later. But before we leave the subject try this little experiement:

{{Lessons/Exercise|Remove the word <vp>class</vp> from <vp>class predicates</vp> in the declaration of advancedHello. And then build the project.

Notice the error message and remember that you get this message when you have forgotten to write <vp>class</vp> in front of <vp>predicates</vp>.

Then insert <vp>class</vp> again and build the project again.}}

Now that we have the advancedHello predicate we can use it in our <vp>run</vp> predicate.

{{Lessons/Exercise|Update the run clause to look like this:

<vip>
clauses
run() :-
advancedHello("Dear"),
advancedHello("World").
</vip>
Run the project in a window.}}

The clause should be understandable, I just want to highlight that we have used '''comma''' to separate the two invocations of <vp>advancedHello</vp>: '''comma" to separate, '''period''' to terminate. I will give a little prediction: Later when you are familiar with Visual Prolog you will from time to time make syntax errors and (the prediction) 9 out of 10 times the syntax error will concern '''comma''' and/or '''period'''.

To summarize:

* Predicates must have a declaration (<vp>run</vp> is also declared we just havn't looked at its declaration).
* Arguments in predicates declarations can be given names that clarify the meaning if the arguments.
* <vp>stdio::writef</vp> writes text to the standard output stream using a format string.
* calls are separated by comma and clauses (and predicate declarations) are terminated by period.
* If I get a syntax error it is likely to be related to comma or period.
* A certain other error message (can you recall it) probably means that I have forgotten to write <vp>class</vp> in front of <vp>predicates</vp>.

[[Category:Lessons|{{SUBPAGENAME}}]]