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

Lessons/Succeed, fail and backtrack - part 1

2020-02-05T10:50:24Z

Jonas Sonn Jørgensen:

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 proejct 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 '''succed''', 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 succeds 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 pursuited.
* 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/Succeed, fail and backtrack - part 1

2020-02-05T10:44:32Z

Jonas Sonn Jørgensen:

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 proejct 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 '''succed''', 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 succeds 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 secon <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 pursuited.
* 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/Succeed, fail and backtrack - part 1

2020-02-05T10:42:26Z

Jonas Sonn Jørgensen:

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 proejct 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 '''succed''', 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 succeds 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 abcktrack 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 secon <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 pursuited.
* 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/Succeed, fail and backtrack - part 1

2020-02-05T10:26:26Z

Jonas Sonn Jørgensen:

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 proejct 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 '''succed''', 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 succeds 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 alterative 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 abcktrack 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 secon <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 pursuited.
* 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/Succeed, fail and backtrack - part 1

2020-02-05T10:11:55Z

Jonas Sonn Jørgensen:

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 proejct 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 '''succed''', 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 succeds 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 therfore 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 alterative 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 abcktrack 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 secon <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 pursuited.
* 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

2020-02-05T09:54:53Z

Jonas Sonn Jørgensen:

In the {{Lesson|Functions}} lesson we created a function, i.e. a predicate that retruned 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/Output arguments

2020-02-05T09:30:24Z

Jonas Sonn Jørgensen:

In the {{Lesson|Functions}} lesson we created a function, i.e. a predicate that retruned 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 "reqest" 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/Output arguments

2020-02-05T09:30:00Z

Jonas Sonn Jørgensen:

In the {{Lesson|Functions}} lesson we created a function, i.e. a predicate that retruned 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" correcponding 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 "reqest" 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/Functions

2020-02-04T15:23:42Z

Jonas Sonn Jørgensen:

In the {{Lesson|Hello World!}} lesson we created a predicate that took an argument and passed it on to another predicate. The data was flowing inwards. Here we will extend with data that float outwards.

Let us start by creating a function. A function is a predicate that returns a value to place where the function was called from.

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

<vip>
class predicates
makeGreeting : (string Name) -> string Greeting.
clauses
makeGreeting(Name) = Result :-
Result = string::format("Hello %!\n", Name).
</vip>

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

Let's start with the include statement. In our new clause we are calling the <vp>format</vp> predicate in the <vp>string</vp> class. However the <vp>string</vp> class is not visible in the '''main.pro''' file. At this point we will not concern ourselves with why this is so and what needs to be done, etc. We will simply accept that the Compiler and IDE in collaboration knows how to solve the problem by inserting a suitable include statement in a suitable place. Actually, this "automation" will deal with most "including" that you ever deal with. The back side to this magic (as to all such automation magic) is that, lazy as we are, we don't really get to know the "include stuff", and the day where the magic cannot figure out what to do we don't know it either (see [[Ide/Creating new Project Items#Creating a Package|Creating a Package]]).

Now let us return to the function itself. As mentioned a function is a predicate that returns a value. In the declaration of <vp>makeGreeting</vp> there is an arrow <vp>-></vp> between the arguments and the ''return type''. This arrow indicated that the predicate is a function and the type after the arrow say what type the returned value has. Again the name (i.e. <vp>Greeting</vp>) after the type mainly serves documentation purposes.

A function clause has the form <vp><head> = <result> :- <body>.</vp>. The execution flow is that we "enter" at the <vp><head></vp>, then the <vp><body></vp> is executed and then the <vp><result></vp> is evaluated/executed and returned.

In the clause above the returned value is in the variable <vp>Result</vp>, which receives it value in the second line (i.e. in the <vp><body></vp> of the clause). What happens in the second line is actually that we call another function, namely the function <vp>format</vp> in the <vp>string</vp> class.

The name <vp>Result</vp> is used just to illustrate that is does not have to be <vp>Greeting</vp> even though this is what is written in the declaration. (For a real program I would say: why use two quite unrelated words for the same thing.)

The function <vp>string::format</vp> is closely related to <vp>stdio::writef</vp>. The input is the same, but <vp>stdio::writef</vp> will write the result to the standard output stream, <vp>string::format</vp> returns the result as a string.

Let us call our new function:

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

<vip>
clauses
run() :-
DearGreeting = makeGreeting("Dear"),
stdio::write(DearGreeting),
WorldGreeting = makeGreeting("World"),
stdio::write(WorldGreeting).
</vip>

Run the project (in a window).}}

It is worth noticing that equal is a rather special thing in Visual Prolog. In the function clause <vp><head> = <result> :- <body>.</vp> it is just a token that separates the head from the result. But in the clause bodies it is an equal operator as you know it from mathematics and logic. Equal is very much '''''unlike''''' an assignement operator as you may know it from other programmig languages. Notice for example that equal is symetrical:

{{Lessons/Exercise|Update the <vp>makeGreeting</vp> clause to look like this:

<vip>
class predicates
makeGreeting : (string Name) -> string Greeting.
clauses
makeGreeting(Name) = Result :-
string::format("Hello %!\n", Name) = Result.
</vip>

And run the project.}}

Notice that the result of calling a function is a value, you do not have to bind that value to a variable, you can use it directly.

{{Lessons/Exercise|Update the <vp>makeGreeting</vp> clause to look like this:

<vip>
class predicates
makeGreeting : (string Name) -> string Greeting.
clauses
makeGreeting(Name) = string::format("Hello %!\n", Name).
</vip>

And run the project.}}

Here we have used the result of the <vp>string::format</vp> function directly as the result of <vp>makeGreeting</vp>. As a result we have nothing for the function <vp><body></vp>, but fortunately the function <vp><body></vp> is optional (if there is no <vp><body></vp> then the <vp>:-</vp> token must also be left out).

In the same way we can use the returned value from <vp>makeGreeting</vp> directly in a call to <vp>stdio::write</vp>:

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

<vip>
clauses
run() :-
stdio::write(makeGreeting("Dear")),
stdio::write(makeGreeting("World")).
</vip>

Run the project (in a window).}}

Summary:

* A function declaration contains an arrow <vp>-></vp> followed by the type of the value that the function returns.
* A function clause has the form <vp><head> = <result> :- <body>.</vp>
* Or the form <vp><head> = <result>.</vp> if there is no need for a body.
* The equal operator is not an assignment operator as known from some other programming lanugages (it is for example symetrical).

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

Lessons/Functions

2020-02-04T15:16:29Z

Jonas Sonn Jørgensen:

In the {{Lesson|Hello World!}} lesson we created a predicate that took an argument and passed it on to another predicate. The data was flowing inwards. Here we will extend with data that float outwards.

Let us start by creating a function. A function is a predicate that returns a value to place where the function was called from.

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

<vip>
class predicates
makeGreeting : (string Name) -> string Greeting.
clauses
makeGreeting(Name) = Result :-
Result = string::format("Hello %!\n", Name).
</vip>

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

Let's start with the include statement. In our new clause we are calling the <vp>format</vp> predicate in the <vp>string</vp> class. However the <vp>string</vp> class is not visible in the '''main.pro''' file. At this point we will not concern ourselves with why this is so and what needs to be done, etc. We will simply accept that the Compiler and IDE in collaboration knows how to solve the problem by inserting a suitable include statement in a suitable place. Actually, this "automation" will deal with most "including" that you ever deal with. The back side to this magic (as to all such automation magic) is that, lazy as we are, we don't really get to know the "include stuff", and the day where the magic cannot figure out what to do we don't know it either (see [[Ide/Creating new Project Items#Creating a Package|Creating a Package]]).

Now let us return to the function itself. As mentioned a function is a predicate that returns a value. In the declaration of <vp>makeGreeting</vp> there is an arrow <vp>-></vp> between the arguments and the ''return type''. This arrow indicated that the predicate is a function and the type after the arrow say what type the returned value has. Again the name (i.e. <vp>Greeting</vp>) after the type mainly serves documentation purposes.

A function clause has the form <vp><head> = <result> :- <body>.</vp>. The execution flow is that we "enter" at the <vp><head></vp>, then the <vp><body></vp> is executed and then the <vp><result></vp> is evaluated/executed and returned.

In the clause above the returned value is in the variable <vp>Result</vp>, which receives it value in the second line (i.e. in the <vp><body></vp> of the clause). What happens in the second line is actually that we call another function, namely the function <vp>format</vp> in the <vp>string</vp> class.

The name <vp>Result</vp> is used just to illustrate that is does not have to be <vp>Greeting</vp> even thoug this is what is written in the declaration. (For a real program I would say: why use two quite unrelated words for the same thing.)

The function <vp>string::format</vp> is closely related to <vp>stdio::writef</vp>. The input is the same, but <vp>stdio::writef</vp> will write the result to the standard output stream, <vp>string::format</vp> returns the result as a string.

Let us call our new function:

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

<vip>
clauses
run() :-
DearGreeting = makeGreeting("Dear"),
stdio::write(DearGreeting),
WorldGreeting = makeGreeting("World"),
stdio::write(WorldGreeting).
</vip>

Run the project (in a window).}}

It is worth noticing that equal is a rather special thing in Visual Prolog. In the function clause <vp><head> = <result> :- <body>.</vp> it is just a token that separates the head from the result. But in the clause bodies it is an equal operator as you know it from mathematics and logic. Equal is very much '''''unlike''''' an assignement operator as you may know it from other programmig languages. Notice for example that equal is symetrical:

{{Lessons/Exercise|Update the <vp>makeGreeting</vp> clause to look like this:

<vip>
class predicates
makeGreeting : (string Name) -> string Greeting.
clauses
makeGreeting(Name) = Result :-
string::format("Hello %!\n", Name) = Result.
</vip>

And run the project.}}

Notice that the result of calling a function is a value, you do not have to bind that value to a variable, you can use it directly.

{{Lessons/Exercise|Update the <vp>makeGreeting</vp> clause to look like this:

<vip>
class predicates
makeGreeting : (string Name) -> string Greeting.
clauses
makeGreeting(Name) = string::format("Hello %!\n", Name).
</vip>

And run the project.}}

Here we have used the result of the <vp>string::format</vp> function directly as the result of <vp>makeGreeting</vp>. As a result we have nothing for the function <vp><body></vp>, but fortunately the function <vp><body></vp> is optional (if there is no <vp><body></vp> then the <vp>:-</vp> token must also be left out).

In the same way we can use the returned value from <vp>makeGreeting</vp> directly in a call to <vp>stdio::write</vp>:

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

<vip>
clauses
run() :-
stdio::write(makeGreeting("Dear")),
stdio::write(makeGreeting("World")).
</vip>

Run the project (in a window).}}

Summary:

* A function declaration contains an arrow <vp>-></vp> followed by the type of the value that the function returns.
* A function clause has the form <vp><head> = <result> :- <body>.</vp>
* Or the form <vp><head> = <result>.</vp> if there is no need for a body.
* The equal operator is not an assignment operator as known from some other programming lanugages (it is for example symetrical).

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

Lessons/Hello World!

2020-02-04T12:21:10Z

Jonas Sonn Jørgensen:

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

2020-02-04T12:19:26Z

Jonas Sonn Jørgensen: Ord

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. 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 delcaration 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!

2020-02-04T11:58:35Z

Jonas Sonn Jørgensen: Har bare rettet et par ord

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 teh declaration and in the clauses can be different, or you can remove it completely. I reccoment that you always have names here and that you use 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 delcaration 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}}]]