Language Reference/Terms/Arguments - Revision history

Thomas Linder Puls: Default parameters nonconstant

2021-04-14T09:31:27Z

Default parameters nonconstant

← Older revision		Revision as of 11:31, 14 April 2021
Line 43:		Line 43:
	==== Default parameters ====		==== Default parameters ====

	A default parameter is defined by adding <vp>= <value></vp> after a formal input parameter in a declaration (<vp><value></vp> ~~must~~ be a ~~compile time~~ constant expression).		A default parameter is defined by adding <vp>= <value></vp> after a formal input parameter in a declaration (<vp><value></vp> can be a constant expression, a property or predicate call).

	{{Example\|The predicate <vp>addPerson</vp> has three parameters <vp>Name</vp>, <vp>Height</vp> and <vp>Weight</vp>::		{{Example\|The predicate <vp>addPerson</vp> has three parameters <vp>Name</vp>, <vp>Height</vp> and <vp>Weight</vp>::

Thomas Linder Puls: release

2019-03-12T16:14:10Z

release

← Older revision		Revision as of 18:14, 12 March 2019
Line 1:		Line 1:

	~~{{Template:NonReleased}}~~

	This section describes named, default, optional parameters and functor originals. Even though these notions are individual they also have a significant impact on each other and therefore they are described together.		This section describes named, default, optional parameters and functor originals. Even though these notions are individual they also have a significant impact on each other and therefore they are described together.

Thomas Linder Puls: Optional parameters: mandatoryOut

2019-02-21T14:18:33Z

Optional parameters: mandatoryOut

@@ Line 91: / Line 91: @@
 ppp(:B = Out) % corresponding to ppp(B: = Out, :A = 17) --> ppp(17, Out)
 </vip>
 }}

Thomas Linder Puls: grammar consistency

2019-02-12T11:10:39Z

grammar consistency

← Older revision		Revision as of 13:10, 12 February 2019
Line 9:		Line 9:
	* '''Default parameters''': A default parameter value can be stated together with a formal argument in a predicate declaration. This value is used when no actual parameter is supplied.		* '''Default parameters''': A default parameter value can be stated together with a formal argument in a predicate declaration. This value is used when no actual parameter is supplied.
	* '''Optional parameters''': An actual parameter is optional and can therefore be skipped.		* '''Optional parameters''': An actual parameter is optional and can therefore be skipped.
	* '''Functor ~~original~~''': Functor term which is used as/bound to the original of another functor term (in a functor term expression).		* '''Functor originals''': Functor term which is used as/bound to the original of another functor term (in a functor term expression).

	==== Named parameters ====		==== Named parameters ====

Thomas Linder Puls: spelling

2019-02-12T11:07:58Z

spelling

← Older revision		Revision as of 13:07, 12 February 2019
Line 1:		Line 1:

	{{Template:NonReleased}}		{{Template:NonReleased}}

Line 6:		Line 7:

	* '''Named parameters''': In a call the actual arguments can be supplied by formal parameter name rather than position.		* '''Named parameters''': In a call the actual arguments can be supplied by formal parameter name rather than position.
	* '''Default parameters''': A default parameter value can be stated ~~toghether~~ with a formal argument in a predicate declaration. This value is used when no actual parameter is supplied.		* '''Default parameters''': A default parameter value can be stated together with a formal argument in a predicate declaration. This value is used when no actual parameter is supplied.
	* '''Optional parameters''': An actual parameter is optional and can therefore be skipped.		* '''Optional parameters''': An actual parameter is optional and can therefore be skipped.
	* '''Functor original''': Functor term which is used as/bound to the original of another functor term (in a functor term expression).		* '''Functor original''': Functor term which is used as/bound to the original of another functor term (in a functor term expression).
Line 45:		Line 46:
	==== Default parameters ====		==== Default parameters ====

	A default parameter is defined by adding <vp>= <value></vp> after a formal input parameter in a declaration (<vp><value></vp> must be a ~~compiletime~~ constant expression).		A default parameter is defined by adding <vp>= <value></vp> after a formal input parameter in a declaration (<vp><value></vp> must be a compile time constant expression).

	{{Example\|The predicate <vp>addPerson</vp> has three parameters <vp>Name</vp>, <vp>Height</vp> and <vp>Weight</vp>::		{{Example\|The predicate <vp>addPerson</vp> has three parameters <vp>Name</vp>, <vp>Height</vp> and <vp>Weight</vp>::
Line 59:		Line 60:
	==== Optional parameters ====		==== Optional parameters ====

	If a parameter is <vp>[out]</vp> or if it has a default value then the actual argument is optional and can be skipped provided that it is the last argument in the call. Skipping an <vp>[out]</vp> parameter corresponds to supplying an anonymous variable for that parameter. Skipping a parameter that has a default value corresponds to supplying the default value for the parameter.		If a parameter is <vp>[out]</vp> or if it has a default value, then the actual argument is optional and can be skipped provided that it is the last argument in the call. Skipping an <vp>[out]</vp> parameter corresponds to supplying an anonymous variable for that parameter. Skipping a parameter that has a default value corresponds to supplying the default value for the parameter.

	{{Example\|Given this predicate		{{Example\|Given this predicate
Line 100:		Line 101:
	</vip>		</vip>

	The functor original can either be a a functor value or a free variable. In both cases the construction ~~inticates~~ that the functor may have more arguments than those mentioned explicitly in front of the bar.		The functor original can either be a a functor value or a free variable. In both cases the construction indicates that the functor may have more arguments than those mentioned explicitly in front of the bar.

	If the functor original is a functor value then it will be used as original for constructing a new functor value.		If the functor original is a functor value then it will be used as original for constructing a new functor value.
Line 152:		Line 153:
	<vip>		<vip>
	A1 = aircraft("Cruiser 1", 25, 300),		A1 = aircraft("Cruiser 1", 25, 300),
	A2 = aircraft("Cruiser 2" \| A1) % legal A1 is an ~~aricraft~~		A2 = aircraft("Cruiser 2" \| A1) % legal A1 is an aircraft
	</vip>		</vip>
	Because <vp>A1</vp> is an <vp>aircraft</vp>, and it is an <vp>aircraft</vp> we are constructing (as <vp>A2</vp>).		Because <vp>A1</vp> is an <vp>aircraft</vp>, and it is an <vp>aircraft</vp> we are constructing (as <vp>A2</vp>).
Line 177:		Line 178:
	Here we have used an anonymous variable as functor original indicating that the functor term has/may have more arguments (which we are not interested in).		Here we have used an anonymous variable as functor original indicating that the functor term has/may have more arguments (which we are not interested in).

	In the <vp>car</vp> case the functor original only represents one additional argument, but using this form the code will be robust to adding ~~aditional~~ components to <vp>car</vp> later. For the same reason, it can make sense to provide a functor original that doesn't represent any ~~addiational~~ arguments (i.e. that represents zero extra arguments).		In the <vp>car</vp> case the functor original only represents one additional argument, but using this form the code will be robust to adding additional components to <vp>car</vp> later. For the same reason, it can make sense to provide a functor original that doesn't represent any additional arguments (i.e. that represents zero extra arguments).

	We could also have used named parameters:		We could also have used named parameters:

Thomas Linder Puls: formatting

2019-02-12T11:05:01Z

formatting

← Older revision		Revision as of 13:05, 12 February 2019
Line 8:		Line 8:
	* '''Default parameters''': A default parameter value can be stated toghether with a formal argument in a predicate declaration. This value is used when no actual parameter is supplied.		* '''Default parameters''': A default parameter value can be stated toghether with a formal argument in a predicate declaration. This value is used when no actual parameter is supplied.
	* '''Optional parameters''': An actual parameter is optional and can therefore be skipped.		* '''Optional parameters''': An actual parameter is optional and can therefore be skipped.
	* '''Functor original'': Functor term which is used as/bound to the original of another functor term (in a functor term expression).		* '''Functor original''': Functor term which is used as/bound to the original of another functor term (in a functor term expression).

	==== Named parameters ====		==== Named parameters ====

Thomas Linder Puls: Default parameters for out (illegal)

2019-02-07T14:47:39Z

Default parameters for out (illegal)

← Older revision		Revision as of 16:47, 7 February 2019
Line 45:		Line 45:
	==== Default parameters ====		==== Default parameters ====

	A default parameter is defined by adding <vp>= <value></vp> after a formal parameter in a declaration (<vp><value></vp> must be a compiletime constant expression).		A default parameter is defined by adding <vp>= <value></vp> after a formal input parameter in a declaration (<vp><value></vp> must be a compiletime constant expression).

	{{Example\|The predicate <vp>addPerson</vp> has three parameters <vp>Name</vp>, <vp>Height</vp> and <vp>Weight</vp>::		{{Example\|The predicate <vp>addPerson</vp> has three parameters <vp>Name</vp>, <vp>Height</vp> and <vp>Weight</vp>::
Line 54:		Line 54:
	<vp>Height</vp> has default value <vp>175</vp> and <vp>Weight</vp> has default value <vp>75</vp>.		<vp>Height</vp> has default value <vp>175</vp> and <vp>Weight</vp> has default value <vp>75</vp>.
	}}		}}

			Notice that it is illegal to provide default parameters for <vp>[out]</vp> parameters.

	==== Optional parameters ====		==== Optional parameters ====

Thomas Linder Puls: Named parameters version of getName

2019-02-07T14:45:52Z

Named parameters version of getName

← Older revision		Revision as of 16:45, 7 February 2019
Line 176:		Line 176:

	In the <vp>car</vp> case the functor original only represents one additional argument, but using this form the code will be robust to adding aditional components to <vp>car</vp> later. For the same reason, it can make sense to provide a functor original that doesn't represent any addiational arguments (i.e. that represents zero extra arguments).		In the <vp>car</vp> case the functor original only represents one additional argument, but using this form the code will be robust to adding aditional components to <vp>car</vp> later. For the same reason, it can make sense to provide a functor original that doesn't represent any addiational arguments (i.e. that represents zero extra arguments).

			We could also have used named parameters:
			<vip>
			class predicates
			getName : (transport Transport) -> string Name
			clauses
			getName(aircraft(:Name = Name \| _)) = Name.
			getName(car(:Name = Name \| _)) = Name.
			</vip>



	Here is a predicate that determines whether a <vp>transport</vp> is a <vp>car</vp>:		Here is a predicate that determines whether a <vp>transport</vp> is a <vp>car</vp>:

Thomas Linder Puls: closed example section

2019-02-07T14:42:27Z

closed example section

← Older revision		Revision as of 16:42, 7 February 2019
Line 219:		Line 219:
	Car = getCurrentCar(),		Car = getCurrentCar(),
	car(Name \| _) = Car		car(Name \| _) = Car
	</vip>		</vip>}}

	<noinclude>{{LanguageReferenceSubarticle\|Terms/Arguments}}</noinclude>		<noinclude>{{LanguageReferenceSubarticle\|Terms/Arguments}}</noinclude>

Thomas Linder Puls: initial

2019-02-06T13:44:37Z

initial

New page

{{Template:NonReleased}}

This section describes named, default, optional parameters and functor originals. Even though these notions are individual they also have a significant impact on each other and therefore they are described together.

In brief:

* '''Named parameters''': In a call the actual arguments can be supplied by formal parameter name rather than position.
* '''Default parameters''': A default parameter value can be stated toghether with a formal argument in a predicate declaration. This value is used when no actual parameter is supplied.
* '''Optional parameters''': An actual parameter is optional and can therefore be skipped.
* '''Functor original'': Functor term which is used as/bound to the original of another functor term (in a functor term expression).

==== Named parameters ====

The formal parameter names from a declaration can be used to specify the actual arguments in a call by using the syntax <vp>:<Formal> = <Actual></vp>.

{{Example|Given the predicate <vp>addPerson</vp>:
<vip>
class predicates
addPerson : (string Name, integer Height, integer Weight).
</vip>

You can call <vp>addPerson</vp> using positional arguments like this:
<vip>
addPerson("Hans", 175, 75)
</vip>

But you can also use named parameters like this
<vip>
addPerson(:Name = "Hans", :Height = 175, :Weight = 75)
</vip>
Where <vp>Name</vp>, <vp>Height</vp> and <vp>Weight</vp> are the names that is used in the declaration.

When using named parameters the order of the parameters are insignificant, so this call has the same meaning:
<vip>
addPerson(:Weight = 75, :Name = "Hans", :Height = 175)
</vip>

Poisitional and named parameters can be mixed such that the first arguments are given by position and the last by name. Here the <vp>Name</vp> is given by position and <vp>Weight</vp> and <vp>Height</vp> are given by name
<vip>
addPerson("Hans", :Weight = 75, :Height = 175)
</vip>
Notice that all positional arguments must be to the left of the first named argument.
}}

==== Default parameters ====

A default parameter is defined by adding <vp>= <value></vp> after a formal parameter in a declaration (<vp><value></vp> must be a compiletime constant expression).

{{Example|The predicate <vp>addPerson</vp> has three parameters <vp>Name</vp>, <vp>Height</vp> and <vp>Weight</vp>::
<vip>
class predicates
addPerson : (string Name, integer Height = 175, integer Weight = 75).
</vip>
<vp>Height</vp> has default value <vp>175</vp> and <vp>Weight</vp> has default value <vp>75</vp>.
}}

==== Optional parameters ====

If a parameter is <vp>[out]</vp> or if it has a default value then the actual argument is optional and can be skipped provided that it is the last argument in the call. Skipping an <vp>[out]</vp> parameter corresponds to supplying an anonymous variable for that parameter. Skipping a parameter that has a default value corresponds to supplying the default value for the parameter.

{{Example|Given this predicate
<vip>
class predicates
ppp : (integer A = 17, integer B [out]).
</vip>

We can skip <vp>B</vp> because it is the last parameter and <vp>[out]</vp>, so here we supply <vp>12</vp> for <vp>A</vp> and ignore the <vp>B</vp> output:

<vip>
ppp(12) % corresponding to ppp(12, _)
</vip>

In the call above <vp>12</vp> is the last argument, but there is a default value for that parameter so that argument can also be skipped:

<vip>
ppp() % corresponding to ppp(17, _)
</vip>

Using named arguments we can exchange the order of the parameters:

<vip>
ppp(:B = Out, :A = 17)
</vip>

In that call the last parameter has a default value so it can be skipped:

<vip>
ppp(:B = Out) % corresponding to ppp(B: = Out, :A = 17) --> ppp(17, Out)
</vip>
}}

==== Functor originals ====

A functor original is a syntactic construction that describes an ''original'' for a functor term expression. Syntactically it takes the following form:

<vip>
<functor>(<arguments> | <functor original> )
</vip>

The functor original can either be a a functor value or a free variable. In both cases the construction inticates that the functor may have more arguments than those mentioned explicitly in front of the bar.

If the functor original is a functor value then it will be used as original for constructing a new functor value.

{{Example|Consider this code:
<vip>
domains
person = person(string Name, integer Height, integer Weight).

class predicates
updateName : (person Person, string NewName) -> person Updated.
clauses
updateName(Person, NewName) = person(NewName | Person).
</vip>
Here we use <vp>Person</vp> as original in the functor term expression <vp>person(NewName | Person)</vp>. This expression will create a new <vp>person</vp> value which has <vp>NewName</vp> as the <vp>Name</vp>/first component. All the remaining functor components (i.e. <vp>Height</vp> and <vp>Weight</vp>) are taken from the original, i.e. <vp>Person</vp>.

The use of functor originals can be combined with named parameters:

<vip>
domains
person = person(string Name, integer Height, integer Weight).

class predicates
updateWeight : (person Person, Integer NewWeight) -> person Updated.
clauses
updateWeight(Person, NewWeight) = person(:Weight = NewWeight | Person).
</vip>
Here <vp>NewWeight</vp> is used as <vp>Weight</vp> component. And again the remaining functor components (i.e. <vp>Name</vp> and <vp>Height</vp>) are taken from the original, i.e. <vp>Person</vp>.
}}

The functor original can be any kind of term as long as it evaluates to an appropriate functor term.

{{Example|Here the functor original is the result of calling a function:
<vip>
clauses
mkPerson(Name) = person(Name | getCurrentPerson()).
</vip>
}}

If a functor domain has more than one alternative, then the functor original must be of same kind as the term that is constructed.

{{Example|Consider a functor domain with two alternatives:
<vip>
domains
transport =
aircraft(string Name, integer Seats, integer Range);
car(string Name, integer Doors).
</vip>

The following is legal:
<vip>
A1 = aircraft("Cruiser 1", 25, 300),
A2 = aircraft("Cruiser 2" | A1) % legal A1 is an aricraft
</vip>
Because <vp>A1</vp> is an <vp>aircraft</vp>, and it is an <vp>aircraft</vp> we are constructing (as <vp>A2</vp>).

This is illegal:
<vip>
C = car("Taxi 23", 4),
A = aircraft(:Seats = 25, :Range = 173 | C) % illegal C is a car
</vip>
Because <vp>C</vp> is a <vp>car</vp> but we are constructing an <vp>aircraft</vp>, it does '''''not''''' matter/help that a <vp>car</vp> has a <vp>Name</vp> component, which is what we need for the <vp>aircraft</vp> we are constructing.
}}

In a functor match the functor original can be an anonymous variable. And in that it simply indicates that the term can have more components which we don't care about.

{{Example|Given the transport domain above, we can write a predicate that extract the Name component like this:

<vip>
class predicates
getName : (transport Transport) -> string Name
clauses
getName(aircraft(Name | _)) = Name.
getName(car(Name | _)) = Name.
</vip>
Here we have used an anonymous variable as functor original indicating that the functor term has/may have more arguments (which we are not interested in).

In the <vp>car</vp> case the functor original only represents one additional argument, but using this form the code will be robust to adding aditional components to <vp>car</vp> later. For the same reason, it can make sense to provide a functor original that doesn't represent any addiational arguments (i.e. that represents zero extra arguments).

Here is a predicate that determines whether a <vp>transport</vp> is a <vp>car</vp>:
<vip>
class predicates
isCar : (transport Transport) determ.
clauses
isCar(car( | _)).
</vip>
This example also shows that it is not necessary to provide any regular arguments at all besides the functor original.
}}

In a functor match the functor original can be a '''named''' variable. If the variable is bound then it is used as an original for constructing a functor value and then that functor value is used in the match.

{{Example|Consider this code
<vip>
C = car("Taxi 23", 4),
car("Taxi 24" | C) = getCurrentCar()
</vip>
In the second line <vp>C</vp> is used as original creating the term <vp>car("Taxi 24", 4)</vp>. This term is then matched against the result of calling <vp>getCurrentCar</vp>.}}

If the functor original is a free variable (in a functor match) then that variable will be bound to the entire functor term:

{{Example|Consider this code where <vp>Free</vp> is a free variable
<vip>
car("Taxi 24" | Free) = getCurrentCar(),
</vip>
This code is equivalent to this code:
<vip>
Free = getCurrentCar(),
car("Taxi 24" | _) = Free,
</vip>
I.e. <vp>Free</vp> is bound to the result of calling <vp>getCurrentCar</vp> and then it is matched to this functor pattern <vp>car("Taxi 24" | _)</vp>.

Notice that the code will <vp>fail</vp> (and not raise an exception) if <vp>getCurrentCar</vp> returns an <vp>aircraft</vp>.

Also consider this code (where <vp>Name</vp> and <vp>Car</vp> are both free variables):
<vip>
car(Name | Car) = getCurrentCar(),
</vip>
it equivalent to this code
<vip>
Car = getCurrentCar(),
car(Name | _) = Car
</vip>

<noinclude>{{LanguageReferenceSubarticle|Terms/Arguments}}</noinclude>