Lessons/Output arguments - Revision history

Adam Rose: spelling mistake

2024-10-11T07:41:55Z

spelling mistake

← Older revision		Revision as of 09:41, 11 October 2024
Line 1:		Line 1:
	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.		In the {{Lesson\|Functions}} lesson we created a function, i.e. a predicate that returned a value. Here we will look at output parameters, which is another way to let data flow outwards.

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

Jonas Sonn Jørgensen at 09:54, 5 February 2020

2020-02-05T09:54:53Z

← Older revision		Revision as of 11:54, 5 February 2020
Line 21:		Line 21:
	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>.		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).		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:		{{Lessons/Exercise\|Update the run clause like this:

Jonas Sonn Jørgensen at 09:30, 5 February 2020

2020-02-05T09:30:24Z

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

Jonas Sonn Jørgensen at 09:30, 5 February 2020

2020-02-05T09:30:00Z

← Older revision		Revision as of 11:30, 5 February 2020
Line 17:		Line 17:
	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.		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 an "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 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>.		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>.

Thomas Linder Puls: Less backreference

2018-09-26T08:54:22Z

Less backreference

← Older revision		Revision as of 10:54, 26 September 2018
Line 1:		Line 1:
	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.		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 ~~your {{Lesson\|Functions}}~~ project:		{{Lessons/Exercise\|Add this code to a console project:

	<vip>		<vip>

Thomas Linder Puls: initial

2018-09-25T16:43:54Z

initial

New page

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 your {{Lesson|Functions}} 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 an "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}}]]