Language Reference/Terms/in - Revision history

SergeMukhin: typo

2024-09-27T03:25:48Z

typo

← Older revision		Revision as of 05:25, 27 September 2024
Line 28:		Line 28:
	The <vp>in</vp> operator can be defined for any domain and interface using the <vp>in_test</vp> and <vp>in_iterate</vp> attributes.		The <vp>in</vp> operator can be defined for any domain and interface using the <vp>in_test</vp> and <vp>in_iterate</vp> attributes.

	The <vp>in_test(<predicate name>)</vp> attribute defines the predicate that is used as in-test for a certain domain or interface. Likewise the <vp>in_iterate</vp> attribute defines the predicate that is used as in-~~ieratorfor~~ the domain/interface.		The <vp>in_test(<predicate name>)</vp> attribute defines the predicate that is used as in-test for a certain domain or interface. Likewise the <vp>in_iterate</vp> attribute defines the predicate that is used as in-iterator for the domain/interface.

	{{Example\|		{{Example\|

Thomas Linder Puls: category

2016-04-28T17:10:17Z

Thomas Linder Puls: category

2016-04-28T17:08:38Z

Thomas Linder Puls: wrong dot

2015-03-28T14:33:45Z

wrong dot

← Older revision		Revision as of 16:33, 28 March 2015
Line 65:		Line 65:
	For an interface <vp><collection></vp> the <vp>in_test</vp> and <vp>in_iterate</vp> predicate must fulfill these schematic declarations:		For an interface <vp><collection></vp> the <vp>in_test</vp> and <vp>in_iterate</vp> predicate must fulfill these schematic declarations:

	<vip>interface <collection> [in_test(<in_test>), in_iterate(<in_iterate>)].		<vip>interface <collection> [in_test(<in_test>), in_iterate(<in_iterate>)]
	predicates		predicates
	<in_test> : (<some-type> Elem) determ.		<in_test> : (<some-type> Elem) determ.

Thomas Linder Puls: mixed words

2015-03-28T14:32:27Z

mixed words

← Older revision		Revision as of 16:32, 28 March 2015
Line 32:		Line 32:
	{{Example\|		{{Example\|
	<vip>domains		<vip>domains
	tree{E} = empty; node(tree{E} Left, E Value, tree{E} Right) [in_test(isMemberTree), in_iterate(getAll_nd)].</vip>		tree{E} = empty; node(tree{E} Left, E Value, tree{E} Right)
			[in_test(isMemberTree), in_iterate(getAll_nd)].</vip>
	When the program contains <vp>A in B</vp> where <vp>A</vp> is bound <vp>B</vp> is a <vp>tree{E}</vp> then <vp>isMemberTree</vp> is actually called.		When the program contains <vp>A in B</vp> where <vp>A</vp> is bound <vp>B</vp> is a <vp>tree{E}</vp> then <vp>isMemberTree</vp> is actually called.

Line 45:		Line 46:

	{{Example\|		{{Example\|
	<vip>interface collection [in_test(contains), ~~in_test~~(getAll_nd)]		<vip>interface collection [in_test(contains), in_iterate(getAll_nd)]
	...		...
	end interface collection</vip>		end interface collection</vip>
Line 82:		Line 83:
	end foreach.</vip>		end foreach.</vip>

	The first <vp>in</vp> is the predefined <vp>in_iterate</vp> for the list domain, and the second one is the predefined <vp>~~in_iterate~~</vp>.		The first <vp>in</vp> is the predefined <vp>in_iterate</vp> for the list domain, and the second one is the predefined <vp>in_test</vp>.

	<vip>clauses		<vip>clauses

Thomas Linder Puls: superfluous header

2015-03-14T20:16:16Z

superfluous header

← Older revision		Revision as of 22:16, 14 March 2015
Line 1:		Line 1:
	~~==== in ====~~

	<vipbnf><InOperator>:		<vipbnf><InOperator>:
	in</vipbnf>		in</vipbnf>

Thomas Linder Puls: /* in */ released

2014-07-23T20:37:14Z

in: released

← Older revision		Revision as of 22:37, 23 July 2014
Line 1:		Line 1:
	==== in ====		==== in ====

	~~{{Template:NonReleased}}~~

	<vipbnf><InOperator>:		<vipbnf><InOperator>:

SergeMukhin: misspelling

2014-06-23T11:08:19Z

misspelling

← Older revision		Revision as of 13:08, 23 June 2014
Line 26:		Line 26:
	q(L) :-		q(L) :-
	foreach X in L do		foreach X in L do
	~~write~~("% is in L\n", X)		writef("% is in L\n", X)
	end foreach.</vip>		end foreach.</vip>
	<vp>q</vp> is a procedure that takes a list <vp>L</vp> as argument. The "in" operator is used to nondeterministically return the members of L, so that they can be written.}}		<vp>q</vp> is a procedure that takes a list <vp>L</vp> as argument. The "in" operator is used to nondeterministically return the members of L, so that they can be written.}}
Line 49:		Line 49:

	{{Example\|		{{Example\|
	<vip>~~inteface~~ collection [in_test(contains), in_test(getAll_nd)]		<vip>interface collection [in_test(contains), in_test(getAll_nd)]
	...		...
	end interface collection</vip>		end interface collection</vip>
Line 60:		Line 60:
	For a domain <vp><collection></vp> the <vp>in_test</vp> and <vp>in_iterate</vp> predicate must fulfill these schematic declarations:		For a domain <vp><collection></vp> the <vp>in_test</vp> and <vp>in_iterate</vp> predicate must fulfill these schematic declarations:

	<vip>~~domain~~		<vip>domains
	<collection> = ... [in_test(<in_test>), in_iterate(<in_iterate>)].		<collection> = ... [in_test(<in_test>), in_iterate(<in_iterate>)].
	class predicates		class predicates

Thomas Linder Puls: spelling/style

2014-06-23T07:58:26Z

spelling/style

← Older revision		Revision as of 09:58, 23 June 2014
Line 1:		Line 1:
			==== in ====

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

Line 99:		Line 101:
	end foreach.</vip>		end foreach.</vip>

	For collections the <vp>in</vp> operators ~~resolves~~ to <~~vip~~>contains</~~vip~~> and <~~vip~~>getAll_nd</~~vip~~>:		For collections the <vp>in</vp> operators resolve to <vp>contains</vp> and <vp>getAll_nd</vp>:

	<vip>interface collection{@Type}		<vip>interface collection{@Type}
Line 117:		Line 119:

	end interface collection</vip>}}		end interface collection</vip>}}

	~~<noinclude>{{LanguageReferenceSubarticle\|Terms/in}}</noinclude>~~

Thomas Linder Puls: in operator

2014-06-20T15:28:23Z

in operator

New page

{{Template:NonReleased}}

<vipbnf><InOperator>:
in</vipbnf>

The <vp>in</vp> operator is used to test for member ship of a collection (e.g. a list) and to nondeterministically generate the members of a collection.

{{Example|
<vip>predicates
p : (Type X, Type* L).
clauses
p(X, L) :-
if X in L then
write("X is in L\n")
end if.</vip>
<vp>p</vp> is a procedure that takes a value <vp>X</vp> and a list <vp>L</vp> as arguments. If <vp>X</vp> is in the list <vp>L</vp> then it will write <vp>"X is in L"</vp>. In this case in is used as an in-test (membership test).
}}

{{Example|
<vip>predicates
q : (Type* L).
clauses
q(L) :-
foreach X in L do
write("% is in L\n", X)
end foreach.</vip>
<vp>q</vp> is a procedure that takes a list <vp>L</vp> as argument. The "in" operator is used to nondeterministically return the members of L, so that they can be written.}}

The <vp>in</vp> operator can be defined for any domain and interface using the <vp>in_test</vp> and <vp>in_iterate</vp> attributes.

The <vp>in_test(<predicate name>)</vp> attribute defines the predicate that is used as in-test for a certain domain or interface. Likewise the <vp>in_iterate</vp> attribute defines the predicate that is used as in-ieratorfor the domain/interface.

{{Example|
<vip>domains
tree{E} = empty; node(tree{E} Left, E Value, tree{E} Right) [in_test(isMemberTree), in_iterate(getAll_nd)].</vip>
When the program contains <vp>A in B</vp> where <vp>A</vp> is bound <vp>B</vp> is a <vp>tree{E}</vp> then <vp>isMemberTree</vp> is actually called.

In that case <vp>A in B</vp> corresponds to <vp>isMemberTree(A, B)</vp>.

If <vp>A</vp> is free the call corresponds to <vp>A = getAll_nd(B)</vp>.}}

For a domain <collection> the predicate must have the type:

<vip>predicates
<predicate> : (<some-type> Elem, <collection> Collection) determ.</vip>

{{Example|
<vip>inteface collection [in_test(contains), in_test(getAll_nd)]
...
end interface collection</vip>
When the program contains <vp>A in B</vp> where <vp>A</vp> is bound <vp>B</vp> is a <vp>collection</vp> then <vp>contains</vp> is actually called.

In that case <vp>A in B</vp> corresponds to <vp>B:contains(A)</vp>.

If <vp>A</vp> is free the call corresponds to <vp>A = B:getAll_nd()</vp>.}}

For a domain <vp><collection></vp> the <vp>in_test</vp> and <vp>in_iterate</vp> predicate must fulfill these schematic declarations:

<vip>domain
<collection> = ... [in_test(<in_test>), in_iterate(<in_iterate>)].
class predicates
<in_test> : (<some-type> Elem, <collection> Collection) determ.
<in_iterate : (<collection> Collection) -> <some-type> Elem nondeterm.</vip>

For an interface <vp><collection></vp> the <vp>in_test</vp> and <vp>in_iterate</vp> predicate must fulfill these schematic declarations:

<vip>interface <collection> [in_test(<in_test>), in_iterate(<in_iterate>)].
predicates
<in_test> : (<some-type> Elem) determ.
<in_iterate : () -> <some-type> Elem nondeterm.
...
end interface <collection></vip>

The <vp>in</vp> operator is predefined on list domains, and in PFC the collections have suitable attributes.

{{Example|
<vip>clauses
p() :-
foreach X in [1, 2, 3, 4] do % in_iterate
if X in [2, 4] then % in_test
...
end if
end foreach.</vip>

The first <vp>in</vp> is the predefined <vp>in_iterate</vp> for the list domain, and the second one is the predefined <vp>in_iterate</vp>.

<vip>clauses
q() :-
M1 = setM_redBlack::new(),
M1:inset("a"),
M1:inset("b"),
M2 = setM_redBlack::new(),
M2:inset("b"),
foreach X in M1 do % in_iterate
if X in M2 then % in_test
...
end if
end foreach.</vip>

For collections the <vp>in</vp> operators resolves to <vip>contains</vip> and <vip>getAll_nd</vip>:

<vip>interface collection{@Type}
[in_test(contains), in_iterate(getAll_nd)]

predicates
contains : (@Type Value) determ.
% @short Succeeds if the collection contains the value @Type
% @end

predicates
getAll_nd : () -> @Type Value nondeterm.
% @short @Type is nondeterministic iteration of the elements in the collection.
% @end

...

end interface collection</vip>}}

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

← Older revision		Revision as of 19:08, 28 April 2016
Line 116:		Line 116:

	end interface collection</vip>}}		end interface collection</vip>}}
			<noinclude>{{LanguageReferenceSubarticle\|Built-in entities/Operators}}</noinclude>

← Older revision		Revision as of 19:10, 28 April 2016
Line 116:		Line 116:

	end interface collection</vip>}}		end interface collection</vip>}}
	<noinclude>{{LanguageReferenceSubarticle\|~~Built-~~in ~~entities/Operators~~}}</noinclude>		<noinclude>{{LanguageReferenceSubarticle\|Terms/in}}</noinclude>