Lessons/Functions - Revision history

Jonas Sonn Jørgensen at 15:23, 4 February 2020

2020-02-04T15:23:42Z

← Older revision		Revision as of 17:23, 4 February 2020
Line 23:		Line 23:
	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.		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 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.		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.

Jonas Sonn Jørgensen at 15:16, 4 February 2020

2020-02-04T15:16:29Z

← Older revision		Revision as of 17:16, 4 February 2020
Line 15:		Line 15:
	Build the project, and answer "Yes" to adding the '''...string.ph''' include statement.}}		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>~~sting~~</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]]).		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.		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.

Thomas Linder Puls: Less backreference

2018-09-26T08:53:54Z

Less backreference

← Older revision		Revision as of 10:53, 26 September 2018
Line 3:		Line 3:
	Let us start by creating a function. A function is a predicate that returns a value to place where the function was called from.		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 your {{Lesson\|Hello World!}} project (or~~ to a ~~similar~~ console project):		{{Lessons/Exercise\|Add this code to a console project:

	<vip>		<vip>

Thomas Linder Puls: initial

2018-09-25T15:06:37Z

initial

New page

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 your {{Lesson|Hello World!}} project (or to a similar 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>sting</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}}]]