View source for Language Reference/Terms

From wiki.visual-prolog.com
You do not have permission to edit this page, for the following reasons:
The action you have requested is limited to users in the group: emailconfirmed.
You must confirm your email address before editing pages. Please set and validate your email address through your user preferences.
You can view and copy the source of this page.
{{languageReferenceNavbar|Terms}}

This section describes terms and how execution/evaluation of terms and clauses proceeds.

Semantically, there are two kinds of terms: '''''formulas''''' and '''''expressions'''''.

*Expressions represent values, like the number 7.
*Formulas represent logical statements, like "the number 7 is greater than the number 3".

Syntactically the two kinds have a huge overlap and therefore the syntax unites the two kinds into ''terms''.

The following definition of <vpbnf><Term></vpbnf> is simplified, in the sense that it includes syntactic constructions that are not legal. For example, one cannot legally write <vp>! + !</vp>. We do however believe that using this simple syntax description in combination with intuitive understanding of language concepts, the type system, and the operator hierarchy described below is better for most purposes.

<vipbnf><Term>:
    ( <Term> )
    <Literal>
    <Variable>
    <Identifier>
    <MemberAccess>
    <PredicateCall>
    <PredicateExpression>
    <UnaryOperator> <Term>
    <Term> <Operator> <Term>
    <Cut>
    <Ellipsis>
    <FactvariableAssignment></vipbnf>

=== Backtracking ===

The evaluation of a Prolog program is a search for a "solution" to the goal. Each step in the search for a solution can either '''''succeed''''' or '''''fail'''''. At certain points in the program execution there are more than one possible choices for finding a solution. When such a choice point is met a so called '''''backtrack point''''' is created. A backtrack point is a recording of the program state plus a pointer to the choice that was not executed. If it turn out that the original choice could not provide the solution (i.e. if it '''''fails'''''), then the program will '''''backtrack''''' to the recorded backtrack point. Thereby restoring the program state and pursuing the other choice. The mechanism will be described and exemplified in details in the following sections.

=== Literals ===

Literals have {{lang2|Domains|Universal_Types|universal type}}.

<vipbnf><Literal>:
   <IntegerLiteral>
   <RealLiteral>
   <CharacterLiteral>
   <StringLiteral>
   <BinaryLiteral>
   <ListLiteral>
   <CompoundDomainLiteral></vipbnf>

See also {{lang2|Lexical Elements|Literals|Literals (in Lexical Elements)}}

=== Variables ===

Variables in Visual Prolog are immutable: once they are bound to a value they retain that value, but backtracking can unbind the variable again during the process of restoring a previous program state.

A variable can thus be bound (during unification and matching), if it is already bound then it evaluates to the value that it is bound to.

Variables are names starting with an upper-case letter or with an underscore (_), followed by a sequence of letters (both uppercase and lowercase), digits, and underscore characters (all in all called an UppercaseIdentifier):

<vipbnf><Variable>:
    <UppercaseIdentifer></vipbnf>

The following are examples of valid variable names:

<vip>My_first_correct_variable_name
_
_Sales_10_11_86</vip>

while the next two are invalid:

<vip>1stattempt
second_attempt</vip>

The variable consisting of single underscore character (i.e. <vp>_</vp>) is known as the ''anonymous variable''. The anonymous variable is used in patterns and bindings where the corresponding value is of no interest and should be ignored.  Every occurrence of the anonymous variable is an independent anonymous variable, i.e. even though the anonymous variable is used several times in a single clause they have no relation to each other.

If variables that starts with an underscore are not anonymous, but they are still intended for values of no interest that should be ignored.  The compiler will issue a warning if the value of such a warning is actually not ignored.

Prolog variables are local to the clause in which it occurs. That is, if two clauses each contain a variable called <vp>X</vp>, these <vp>X</vp>-s are two distinct variables.

A variable is said to be ''free'' when it is not yet associated with a term and to be ''bound'' or instantiated when it is unified with a term.

The Visual Prolog compiler does not make a distinction between upper and lower case letters in names, except for the first letter. This means that the two variables <vp>SourceCode</vp> and <vp>SOURCECODE</vp> are the same.

=== Identifier ===

<vipbnf><Identifier>: one of
    <MemberName>
    <GlobalScopeMembername>
    <ScopeQualifiedMemberName>

<MemberName>:
    <LowerCaseIdentifier>
</vipbnf>

Identifiers are used to refer to named entities (i.e. classes, interfaces, constants, domains, predicates, facts, ...).

An identifier can just be a lower case identifier (i.e. a lowercase letter followed by a sequence of letters, numbers and underscore characters).

Many entities can have the same name.  So it may be necessary or desirable to qualify the lowercase identifier the name of the particular scope of interest, or to state that the name is in the global namespace.

{{Example| These are examples of unqualified identifiers:

<vip>integer
mainExe
myPredicate</vip>
}}

==== Global Entities Access ====

The only global entities, which exist in Visual Prolog, are built-in domains, predicates, and constants. Global names are directly accessible in any scope. There might however exist situations where a global name is shadowed by a local or imported name. In that case the global entity can be qualified with a double colon '<vp>::</vp>' (without a prefixed class/interface name). The double colon can be used everywhere, but the most important place is where an interface name is used as formal parameter type specifier.

<vipbnf><GlobalScopeMemberName>:
    :: <MemberName></vipbnf>

{{Example| The built-in domain <vp>integer</vp> is defined in the global scope, to avoid ambiguity or stress that it is this particular domains you can use the global scope member name:

<vip>::integer</vip>
}}

==== Class/Interface Member Access ====

Static members of classes and interfaces are accessed by means of qualification with the class name (and optionally a namespace prefix):

<vipbnf><ScopeQualifiedMemberName>
    <NamespacePrefix>-opt <ScopeName> :: <MemberName>

<NamespacePrefix>:
    <NamespaceIdentifier>-opt \

<ScopeName>:
    <LowercaseIdentifier></vipbnf>

The ScopeName is the name of the class or interface that defines/declares the name.

Namespace prefixing is explained in: {{lang2|Namespaces|Referencing names in namespaces|Referencing names in namespaces}}.

Some names can be accessed without qualification, see {{lang2|Basic_Concepts|Scoping_&_Visibility|scoping & visibility}}.

=== Predicate Call ===

A predicate call have the form

<vipbnf><PredicateCall>:
     <Term> ( <Term>-comma-sep-list-opt )</vipbnf>

The first term must be an expression that evaluates to a value with predicate type.  Typically, it is either the name of a predicate in a class, or an expression that evaluates to a predicate member of an object.

Notice that some predicates return values, whereas other predicates do not. A predicate that returns a value is an expression, and the predicate call is often referred to as a '''function''' call.  A predicate that does return a value is a formula.

A predicate is invoked by applying arguments to the predicate. The predicate must have a flow-pattern that matches the free/bound state of the arguments.

Most predicates are defined by a set of clauses, but some predicates are built into the language and some are defined externally in a DLL (perhaps in a foreign programming language).

When a predicate is invoked by a predicate call, each clause is executed in turn until one of them '''''succeeds''''', or there are no more clauses left to execute. If no clause succeeds the predicate '''''fails'''''.

If a clause succeeds and there are more relevant clauses left, a '''backtrackpoint''' is created to the next relevant clause.

Thus, a predicate can '''''fail''''', '''''succeed''''', and even '''''succeed''''' multiple times.

Each clause has a head and optionally a body.

When a predicate is called the clauses are tried in turn (from top to bottom). For each clause the arguments in the head is unified with the arguments from the call. If this unification succeeds then the body of the clause (if present) is executed. The clause '''''succeeds,''''' if the match of the head '''''succeeds''''' and the body '''''succeeds'''''. Otherwise it '''''fails'''''.

{{Example|
<vip>clauses
   ppp() :- qqq(X), write(X), fail.

   qqq(1).
   qqq(2).
   qqq(3).</vip>

When <vp>ppp</vp> is called it in turn calls <vp>qqq</vp>. When <vp>qqq</vp> is called, it first creates a backtrack point pointing to the second clause. Then the first clause is executed. Hereby the free variable <vp>X</vp> from <vp>ppp</vp> is matched against the number <vp>1</vp>, whereby <vp>X</vp> is bound to <vp>1</vp>.

In <vp>ppp</vp> <vp>X</vp> (i.e. <vp>1</vp>) is written and then <vp>fail</vp> cause backtracking to the backtrackpoint. Hereby program control is set to the second clause in <vp>qqq</vp> and the program state is set back to the state it was in when <vp>qqq</vp> was first entered, i.e. <vp>X</vp> in <vp>ppp</vp> is unbound again.

Before the actual execution of the second clause in <vp>qqq</vp> begins a backtrack point to the third clause is created.  The execution then proceeds as it did for <vp>1</vp>
}}

=== Unification ===

When a predicate is called the arguments from the call is '''''unified''''' with the terms in the head of each clause.

Unification is the process of binding variables in such a way that two terms become equal, making as few bindings as possible (i.e. leaving as much as possible open for further binding).

Variables can be bound to any kind of terms, including variables or terms containing variables.

Unification is either possible or impossible, i.e. it can '''''succeed''''' or '''''fail'''''.

Variables and terms to which they are unified have types, a variable can only be bound to a term of the same type as the variable, or a subtype. When two variables are bound to each other they must therefore have exactly the same type.

Unification takes place (as mentioned) between a predicate call and the clause head. It also takes place when two terms are compared for equality.

{{Example| Consider two terms (of the same type):

<vip>T1 = f1(g(), X, 17, Y, 17)
T2 = f1(Z, Z, V, U, 43)</vip>

We will attempt to unify these two terms from left to right (i.e. a left-to-right pre-traversal).

Both <vp>T1</vp> and <vp>T2</vp> are <vp>f1/5</vp> terms, this match. Therefore we attempt to unify each of the arguments from <vp>T1</vp> with each correspondent argument of <vp>T2</vp>. First we must unify <vp>Z</vp> and <vp>g()</vp>, this can be unified if we bind <vp>Z</vp> to <vp>g()</vp>. So far everything is fine and we have the first binding in our unifier:

<vip>Z = g()</vip>

The next two arguments are <vp>X</vp> and <vp>Z</vp>, which already has been bound to <vp>g()</vp>. These two arguments can also be unified if we also bind <vp>X</vp> to <vp>g()</vp>. So we now have the following contributions to our unifier:

<vip>X = Z = g()</vip>

Next we must bind <vp>V</vp> to <vp>17</vp> and then we must bind <vp>Y</vp> to <vp>U</vp>. So far everything unifies with the following unifier:

<vip>X = Z = g()
V = 17
Y = U</vip>

The two unified terms are now equivalent to these terms:

<vip>T1 = f1(g(), g(), 17, Y, 17)
T2 = f1(g(), g(), 17, Y, 43)</vip>

But we have not yet unified the two last arguments, which are <vp>17</vp> and <vp>43</vp>. No variable binding can make these terms equal, so all in all the unification '''''fails'''''.

<vp>T1</vp> and <vp>T2</vp> cannot be unified.
}}

In the example above <vp>T1</vp> could have been a predicate call and <vp>T2</vp> a clause head. But they could also have been two terms that were compared with equal "<vp>=</vp>".

=== Matching ===

'''''Matching''''' is the same as unification except that variables can only be bound to grounded terms. A '''''grounded''''' term is a term that does not contain any unbound variables.

It is the flow-patterns that are stated for predicates, that make it possible to use matching rather than full-blown unification.

{{Example|
<vip>clauses
   ppp(Z, Z, 17).
   qqq() :-
      ppp(g(), X, 17).</vip>

Unification of the <vp>ppp</vp>-call with the <vp>ppp</vp>-clause is possible with the following unifier:

<vip>Z = X = g()</vip>

If <vp>ppp</vp> have the flow <vp>(i,o,i)</vp> then the unification is just a match:

*<vp>g()</vp> is input as the first argument, this is bound to <vp>Z</vp>
*The second argument in the clause is therefore bound and can thus be output to <vp>X</vp>, which therefore becomes bound to ''<vp>g()</vp>''.
*finally the third argument is <vp>17</vp> used as input this number is simply compared to the third argument in the clause.

It is the flow-pattern that makes it possible to predict that the clause does not need real unification.
}}

=== Nested Function Calls ===

Terms that have to be unified or matched with each other are allowed to contain sub-terms that are actually expressions or function calls that have to be evaluated before the unification/matching can be completed.

The evaluation of such sub-terms is done on a by-need basis.

In a predicate call all input arguments are evaluated before the predicate is called, all output arguments are variables, which does not need evaluation.

Clause heads can also contain terms that have to be evaluated, before matching/unification can be determined.

*all matching/unification that does not require any evaluation is performed before any evaluation is performed;
*then evaluation corresponding to input arguments is performed one by one left-to-right. Comparing each value to the corresponding input after each evaluation;
*then the clause body is evaluated;
*then the output arguments are evaluated (left-to-right);
*then the return value (if the predicate is a function) is evaluated.

If any of these '''''fail''''' then the rest of the evaluation is not carried out.

All in all the base principles are:

*input after other match, before body evaluation
*output after body evaluation
*left-to-right

=== Arguments ===
{{:Language Reference/Terms/Arguments}}
=== Fact Variable Assignment ===

Assign operator <vp>:=</vp> is used to assign a new value for a {{lang2|Facts|Fact_Variable_Declarations|fact variable}} <vpbnf><FactVariable></vpbnf>. The <vpbnf><Term></vpbnf> must be evaluated to a value of suitable type (i.e. the same type as the fact variable, or a subtype).

<vipbnf><FactVariableAssignment>:
    <FactVariable> := <Term></vipbnf>

=== Facts ===

A fact database contains a number of fully instantiated (grounded) predicate heads corresponding to the facts from the facts section declaration. The facts can be accessed by a predicate call, using the fact name as the predicate name. The predicate call is matched against each fact in turn; succeeding with a possible backtrack point to the next fact each time the predicate call match the fact. When there are no more facts in the fact database then the predicate call fails.

New facts can be '''''asserted''''' using the predicates {{lang2|Built-in_entities|assert|assert/1}}, {{lang2|Built-in_entities|asserta|asserta/1}}, and {{lang2|Built-in_entities|assertz|assertz/1}}. {{lang2|Built-in_entities|assert|assert/1}} is the same as {{lang2|Built-in_entities|assertz|assertz/1}} and it asserts a new fact to the end of the list of facts, whereas {{lang2|Built-in_entities|asserta|asserta/1}} asserts a new fact to the start of the list.

Existing facts can be '''''retracted''''' with the predicate {{lang2|Built-in_entities|retract|retract/1}} and {{lang2|Built-in_entities|retractall|retractAll/1}}. {{lang2|Built-in_entities|retract|retract/1}} retracts the first fact that match the argument binding variables in the argument and leaving a backtrack point so that more facts will potentially be retracted when backtracking.

{{lang2|Built-in_entities|retractall|retractAll/1}} retracts all facts that matches the arguments and succeeds without any binding.

=== Operators ===

Operators are organized in a precedence hierarchy. In the rule below operators in each group have same precedence, which is higher than those below. I.e. the power operator has higher precedence than unary minus and plus, which in turn has higher precedence than the multiplication operators, etc. Parenthesis can be used to circumvent the precedence (and for clarification).

<vipbnf><Operator>: one of
    <PowerOperator>
    <UnaryOperator>
    <MultiplicationOperator>
    <AdditionOperator>
    <OtherwiseOperator>
    <RelationOperator>
    <MustUnifyOperator>
    <InOperator>
    <AndOperator>
    <OrOperator></vipbnf>

<vipbnf><UnaryOperator>: one of
    - +</vipbnf>

All operators except the <vpbnf><UnaryOperator></vpbnf>'s are binary.  The power operator is right associative, all other operators are left associative.

<vpbnf><RelationOperator></vpbnf>, <vpbnf><MustUnifyOperator></vpbnf> and <vpbnf><InOperator></vpbnf> have same precedence.

'''Notice''' that the placement <vpbnf><UnaryOperator></vpbnf> is not consistent with mathematics, where these operators are at the same level as the <vpbnf><AdditionalOperator></vpbnf>'s.  The difference has no influence of the calculated value, but it allows writing <vp>2*-2</vp>, where mathematics would require a parenthesis around the second operator <vp>2*(-2)</vp>.  It also means that <vp>-2*2</vp> is mmeans (-2)*2 where it would be <vp>-(2*2)</vp> in mathematics (the resulting value is the same).

{{Example|
<vp>-2^2</vp> is the same as <vp>-(2^2)</vp> because ^ has higher precedence than unary minus.
}}

{{Example|
<vp>3^2^2</vp> is the same as <vp>3^(2^2)</vp> because ^ is right associative.
}}

{{Example|
<vp>-2*-3^-4+5</vp> is the same as <vp>((-2) * (-(3 ^ (-4)))) + 5</vp>.
}}

{{Example| The following term:

<vip>7 + 3 * 5 * 13 + 4 + 3 = X / 6 ; A < 7,  p(X)</vip>

has the same meaning as this term:

<vip>((((7 + ((3 * 5) * 13)) + 4) + 3) = (X / 6)) ; ((A < 7) , p(X))</vip>

I.e. at outermost level the term is an "<vp>or</vp>" of two terms, the first of these is a relational (<vp>=</vp>) term, the second is an "<vp>and</vp>" term, etc.
}}

=== Arithmetic Operators ===

The arithmetic operators are used for arithmetic operations on numbers. They are expressions, which takes expressions as arguments. They have root types as arguments and return universal types as result. (See {{lang2|Domains|Universal_and_Root_Types|Universal and Root types}}.)

<vipbnf><PowerOperator>:
    ^</vipbnf>

<vipbnf><MultiplicationOperator>: one of
    * / div mod quot rem</vipbnf>

<vipbnf><AdditionOperator>: one of
    +  -</vipbnf>

=== Relational Operators ===

The relational operators are formulas, which takes expressions as arguments. Given this nature they are non-associative.

<vipbnf><RelationOperator>: one of
  =   >   <   >=   <=   <>   ><</vipbnf>

First the left term is evaluated, then the right term is evaluated and then the results are compared.

'''Notice''' that <vp><></vp> (different) is not the dual operation of = (equal). <vp><></vp> compares two values, whereas <vp>=</vp> tries to unify two terms (in the general case at least).

The dual to expression <vp>A = B</vp> is <vp>not (A = B)</vp>.

==== Must Unify Operator ====

The must unify operator is a procedure, which takes expressions as arguments. It is non-associative.

<vipbnf><MustUnifyOperator>:
  ==</vipbnf>

<vpbnf>A == B</vpbnf> unifies <vpbnf>A</vpbnf> and <vpbnf>B</vpbnf>; if the unification fails an exception is raised, otherwise the predicate succeeds.  Therefore <vpbnf>A == B</vpbnf> always succeeds.

{{Example|
<vip>clauses
    p(L) :-
        [H|T] == L,
        ...</vip>
<vp>p</vp> is a procedure. An exception will be raised if it is called with an empty list, because <vp>[H|T]</vp> and <vp>L</vp> cannot unify.}}

=== Bitwise and boolean operators ===

The following operators for bitwise operations on <vp>unsigned</vp>, <vp>unsigned64</vp> and <vp>unsignedNative</vp>.

<vip>
A ** B % A and B
A ++ B % A or B
A -- B % A and not B
A ^^ B % A exclusive or B
~~ A % not A
A << N % Shifts the bits in A N times to the left.
A >> N % Shifts the bits in A N times to the right.
</vip>

The logical operations (<vp>**</vp>, <vp>++</vp>, <vp>^^</vp> and <vp>~~</vp>) can also be used on <vp>boolean</vp> values.

The shift operations discard bits that is shifted out of the number, and shift-in zero bits in the opposite end.

=== Logical Operators ===

The <vpbnf><AndOperator></vpbnf>(s) and <vpbnf><OrOperator></vpbnf>(s) are formulas, which takes formulas as arguments. They are all left associative. The <vp>,</vp> and <vp>and </vp> are synonyms and so are <vp>; </vp> and <vp>or</vp>.

<vipbnf><AndOperator>: one of
 ,   and</vipbnf>

<vipbnf><OrOperator>: one of
  ;  or orelse</vipbnf>

==== and (,) ====

The evaluation of an <vp>and</vp> term <vp>A, B</vp> proceeds as follows. First the left sub-term <vp>A</vp> is evaluated. If this evaluation fails, the whole <vp>and</vp> term fails. If <vp>A</vp> succeeds then the right sub-term <vp>B</vp> is evaluated. If this evaluation fails, the whole <vp>and</vp> term fails, otherwise the <vp>and</vp> term succeeds.

Thus the second sub-term <vp>B</vp> is only evaluated, if the first sub-term <vp>A</vp> succeeds.

{{Example|
<vip>clauses
   ppp() :-
       qqq(), rrr().</vip>

When <vp>ppp</vp> is called it will first call <vp>qqq</vp> and if <vp>qqq</vp> succeeds, then it will call <vp>rrr</vp>. If <vp>rrr</vp> succeeds, then the <vp>and</vp> term and subsequently the whole clause succeeds.
}}

==== or (;) ====

The evaluation of an <vp>or</vp> term <vp>A</vp>; <vp>B</vp> proceeds as follows. First a backtrack point to the second term <vp>B</vp> is created and then the first term <vp>A</vp> is evaluated. If the evaluation of the first term succeeds, then the whole <vp>or</vp> term succeeds and is left with a backtrack to the second term <vp>B</vp>. If the evaluation of the first term fails, the backtrack point to the second term is activated.

If the backtrack point to the second term <vp>B</vp> is activated (either because the first term fails, or because something later in the execution invokes the backtrack point), then the second term <vp>B</vp> is evaluated and the whole <vp>or</vp> term will succeed if <vp>B</vp> succeeds.

Thus an <vp>or</vp> term can succeed with a backtrack point and the second sub-term <vp>B</vp> is only evaluated on backtrack.

{{Example|
<vip>clauses
   ppp() :-
       (V = 3 or V = 7), write(V), fail.</vip>

Here we have used the keyword <vp>or</vp>, but you can also use semi-colon <vp>;</vp>.

When <vp>ppp</vp> is called we first create a backtrack point to the term <vp>V = 7</vp> and then we evaluate <vp>V = 3</vp>. Thereby <vp>V</vp> will be bound to <vp>3</vp> we then continue to the <vp>write(V)</vp> after <vp>3</vp> has been written <vp>fail</vp> is met. <vp>fail</vp> always fails so we effectuate the backtrack point leading us to the term <vp>V = 7</vp>.

Backtracking also undo all bindings made since the backtrack point was created. In this case it means that <vp>V</vp> is unbound.

Then <vp>V = 7</vp> is evaluated and <vp>V</vp> becomes bound to <vp>7</vp> and er continue to the term <vp>write(V)</vp>, and then <vp>fail</vp> is met again, this time there are no more backtrack points <vp>ppp</vp> fails.
}}

Using parentheses <vp>or</vp> can be nested deeply in clauses.

<vip>clauses
   p(X) = Y :-
       (X = 1, !, Z = 3 or Z = 7), Y = 2*Z.</vip>

We recommend careful usage of <vp>or</vp>. It is mainly intended for usage in test-conditions:

<vip>clauses
   isOutside(X) :-
       (X < 10 or X > 90), !.</vip>

<vp>or</vp> is a nondeterministic construction, but <vp>orelse</vp> can be used as a deterministic pendant:

<vip>clauses
   isOutside(X) :-
       X < 10 orelse X > 90.</vip>

==== orelse ====


<vp>orelse</vp> is a deterministic pendant to the nondeterministic <vp>or</vp>.  <vp>A orelse B</vp> will succeed if <vp>A</vp> succeeds or if <vp>B</vp> succeeds, but it will '''''not''''' leave a backtrack point to <vp>B</vp> if <vp>A</vp> succeeds.

The evaluation of an <vp>orelse</vp> term <vp>A orelse B</vp> proceeds as follows: First a backtrack point to the second term <vp>B</vp> is created and then the first term <vp>A</vp> is evaluated. If the evaluation of the first term succeeds then the backtrack to the second term (and any backtrack point within it) <vp>B</vp> are removed again and the whole <vp>orelse</vp> term succeeds. If the evaluation of the first term <vp>A</vp> fails, the backtrack point to the second term <vp>B</vp> is evaluated.

So an <vp>orelse</vp> term does not leave a backtrack point.

{{Example|
<vip>clauses
   ppp(V) :-
       (V = 3 orelse V = 7), write(V).</vip>

Whenever <vp>ppp</vp> is called we first create a backtrack point to the term <vp>V = 7</vp> and then we evaluate the term <vp>V = 3</vp>, if <vp>V = 3</vp> succeeds we remove the backtrack point to <vp>V = 7</vp> again and then continue to <vp>write(V)</vp>.  If <vp>V = 3</vp> fails the backtrack point to <vp>V = 7</vp> is effectuated.  If <vp>V = 7</vp> succeeds we continue to <vp>write(V)</vp>, if <vp>V = 7</vp> fails the entire <vp>ppp</vp> predicate will fail.
}}

==== otherwise ====

<vp>otherwise</vp> is an expression operator; though it has control flow that makes it resemble the logical operators. 

<vip>A otherwise B</vip>

is an expression (<vp>A</vp> and <vp>B</vp> must be expressions).  If the evaluation of <vp>A</vp> succeeds by evaluating to the value VA then <vp>A otherwise B</vp> evaluates to VA, otherwise (i.e. if the evaluation of <vp>A</vp> fails) then <vp>A otherwise B</vp> will be the result of evaluating <vp>B</vp>.

<vp>otherwise</vp> is right associative:

<vip>A otherwise B otherwise C
=>
A otherwise (B otherwise C)</vip>

It has lower precedence than all other expression operators, but higher than relational operators:

<vip>V < A + tryGet() otherwise 9
=>
V < ((A + tryGet()) otherwise 9)</vip>

<vp>core</vp> have been enriched with a predicate <vp>isSome</vp> for providing default values for <vp>core::optional</vp> matching:

{{Example|
<vip>V = isSome(Optional) otherwise 0</vip>
If <vp>Optional</vp> have the form <vp>some(X)</vp> then <vp>V</vp> will get the value <vp>X</vp> otherwise <vp>V</vp> will get the value <vp>0</vp>.}}

==== not ====

The {{lang2|Built-in_entities|not|not/1}} takes a term as the argument. The evaluation of <vp>not(A)</vp> first evaluates <vp>A</vp>. If <vp>A</vp> succeeds, then <vp>not(A)</vp> fails, if <vp>A</vp> fails, then <vp>not(A)</vp> succeeds.

Notice that <vp>not(A)</vp> will never bind any variables, because if <vp>not(A)</vp> succeeds then <vp>A</vp> has failed, and a failed term does not bind anything. If <vp>not(A)</vp> on the other hand fails, it cannot bind any variables either, because then the term itself failed.

Also notice that <vp>not(A)</vp> can never succeed with backtrack points, because if <vp>not(A)</vp> succeeds then <vp>A</vp> have failed, and a failed term cannot contain any backtrack points. This in turn means that all possibilities of success in <vp>A</vp> have been exhausted.

==== cut (!) ====

Cut "<vp>!</vp>" removes all backtrack points created since the entrance to the current predicate, this means all backtrack points to subsequent clauses, plus backtrack points in predicate calls made in the current clause before the "<vp>!</vp>".

<vipbnf><Cut>:
    !</vipbnf>

{{Example|
<vip>clauses
   ppp(X) :-
       X > 7,
       !,
       write("Greater than seven").
   ppp(_X) :-
       write("Not greater than seven").</vip>

When <vp>ppp</vp> is executed, there is first created a backtrack point to the second clause, and then the first clause is executed. If the test "<vp>X > 7</vp>" succeeds then the cut "<vp>!</vp>" is reached. This cut "<vp>!</vp>" will remove the backtrack point to the second clause.
}}

{{Example|

<vip>clauses
   ppp() :-
       qqq(X),
       X > 7,
       !,
       write("Found one").
   ppp() :-
       write("Did not find one").
clauses
   qqq(3).
   qqq(12).
   qqq(13).</vip>

When <vp>ppp</vp> is executed it first creates a backtrack point to the second <vp>ppp</vp> clause and then <vp>qqq</vp> is called. The <vp>qqq</vp> will create a backtrack point to the second <vp>qqq</vp> clause and execute the first clause, thereby returning the value <vp>3</vp>. In <vp>ppp</vp> variable <vp>X</vp> is bound to this value and then compared to <vp>7</vp>. This test fails and, therefore, the control backtracks to the second clause of <vp>qqq</vp>.

Before executing the second clause a new backtrack point to the third clause of <vp>qqq</vp> is created and then the second clause returns <vp>12</vp>.

This time the test against <vp>7</vp> succeeds and, therefore, the cut is executed. This cut will remove both the backtrack point left in <vp>qqq</vp> as well as the backtrack point to the second clause of <vp>ppp</vp>.
}}

===== cut Scopes =====

A cut scope is a scope to which the effect of a <vp>cut</vp> is limited. Meaning that if a <vp>cut</vp> is met within a cut scope then only backtrack points within that scope are discarded, while backtrack points outside (i.e. prior to) the cut scope remains.

The clauses of a predicate is a cut scope. Meeting a <vp>cut</vp> will (at most) discard the backtrack points that was created after entrance to the predicate.  Backtrack points created before entrance to the predicate will remain.

{{Example|
<vip>clauses
   aaa() :- p1_nd(), qqq().
   qqq() :- p2_nd(), !.</vip>

<vp>aaa</vp> calls <vp>p1_nd</vp>, which leaves a backtrack point, and then it calls <vp>qqq</vp>. <vp>qqq</vp> calls <vp>p2_nd</vp>, which also leaves a backtrack point. Then we meet a <vp>cut</vp>. This <vp>cut</vp> is in the <vp>cut</vp>-scope of the <vp>qqq</vp> predicate, so it is only the backtrack point in <vp>p2_nd</vp> which is discarded, the one in <vp>p1_nd</vp> remains.
}}

Several terms introduce cut scopes (see the respective terms: {{lang2|Terms|List_Comprehension|list comprehension}}, {{lang2|Terms|if-then-else|if-then-else}}, {{lang2|Terms|foreach|foreach}}). Here we will use <vp>if-then-else</vp> to illustrate the effect of cut scopes.  Consider the schematic <vp>if-then-else</vp> term:

<vip>if Cond then T1 else T2 end if</vip>

The condition <vp>Cond</vp> is a cut-scope, meaning that a <vp>cut</vp> inside <vp>Cond</vp> will only have effect inside <vp>Cond</vp>. <vp>Cut</vp>s inside <vp>T1</vp> and <vp>T2</vp>, on the other hand, have effect outside the <vp>if-then-else</vp> statement.

Consider this code fragment:

<vip>X = getMember_nd([3,1,2]),
if X = getMember_nd([3,3]), ! then
   write(X)
else
   !
end if,
fail</vip>

<vp>getMember_nd</vp> is a nondeterministic predicate. The evaluation of this code will go as follows. First <vp>X</vp> is bound to <vp>3</vp> and <vp>getMember_nd</vp> leaves a backtrack point (so that <vp>X</vp> can later become <vp>1</vp> and then even <vp>2</vp>).

Then we evaluate the condition in the <vp>if-then-else</vp> term. The first part of this condition succeeds as <vp>3</vp> is a member of <vp>[3,3]</vp>. The first part also leaves a backtrack point, so that it can be examined whether <vp>X</vp> is a member several times.

Now we meet a <vp>cut</vp>. This <vp>cut</vp> is inside the condition part of an <vp>if-then-else</vp> statement, so it only has local effect, meaning that it only discards the backtrack point in the second <vp>getMember_nd</vp>, but leaves the backtrack point in the first <vp>getMember_nd</vp> predicate.

The whole condition succeeds and we enter the then-part and write out "<vp>3</vp>".

After the <vp>if-then-else</vp> we meet <vp>fail</vp>, which backtracks us to the first <vp>getMember_nd</vp>.

<vp>getMember_nd</vp> then binds <vp>X</vp> to <vp>1</vp>, and leaves a backtrack point (so that <vp>X</vp> can later become <vp>2</vp>).

Then we evaluate the condition in the <vp>if-then-else</vp> term. The first part of this condition fails as <vp>1</vp> is not a member of <vp>[3,3]</vp>. So we enter the <vp>else</vp>-part.

Here we meet a <vp>cut</vp>. This <vp>cut</vp> is in the <vp>else</vp>-part of a conditional term so it has effect outside the <vp>if-then-else</vp> term and subsequently it discards the backtrack point in the first <vp>getMember_nd</vp>.

When we meet the <vp>fail</vp> after the <vp>if-then-else</vp> term there are no more backtrack points in the code and it will fail. So all in all <vp>X</vp> never becomes <vp>2</vp>.

==== fail/0 and succeed/0 ====

{{lang2|Built-in_entities|fail|fail/0}} and {{lang2|Built-in_entities|succeed|succeed/0}} are two built-in nullary predicates. {{lang2|Built-in_entities|fail|fail/0}} always fails and {{lang2|Built-in_entities|succeed|succeed/0}} always succeeds, besides this the predicates have no effect.

=== in ===
{{:Language Reference/Terms/in}}
=== List Comprehension ===

<vipbnf><ListComprehensionTerm> :
    [ <Term> || <Term> ]</vipbnf>

The list comprehension term is a list expression. Consider this schematic term:

<vip>[ Exp || Gen ]</vip>

<vp>Gen</vp> is (typically) a <vp>nondeterm</vp> term. <vp>Exp</vp> is evaluated for each solution of <vp>Gen</vp>, and the resulting <vp>Exp</vp>'s are collected in a list. The <vp>Exp</vp> corresponding to the first solution of <vp>Gen</vp> is the first element in the list, etc. This list is the result of the list comprehension term. <vp>Exp</vp> must be procedure (or erroneous). Both <vp>Exp</vp> and <vp>Gen</vp> are {{lang2|Terms|Cut_Scopes|cut scopes}}.

The list comprehension (normally) reads: The list of <vp>Exp</vp>'s such that <vp>Gen</vp>.

{{Example|
<vip>[ X || X = getMember_nd(L), X mod 2 = 0 ]</vip>

This reads the list of <vp>X</vp>'s such that <vp>X</vp> is in <vp>L</vp> and <vp>X</vp> is even. So this expression is the even numbers of <vp>L</vp>.
}}

{{Example|
<vip>[ X + 1 || X = getMember_nd(L), X mod 2 = 0 ]</vip>

Here the collected expression is more complex. This makes say the term more awkward:

:"the list of (X+1)'s such that ..."

This expression again finds the even elements in <vp>L</vp>, but the resulting list contains all these values incremented.

This term is completely equivalent to this term:

<vip>[ Y || X = getMember_nd(L), X mod 2 = 0 , Y = X+1 ]</vip>

This term is easier to say:

:"The list of Y's such that (there exists an) X which is member of L, and which is even, and Y is X+1."
}}

=== Anonymous Predicates ===
{{:Language Reference/Terms/Anonymous Predicates}}
=== Object Member Access ===
Whenever we have a reference to an object, we can access the object member predicates of that object.
<vipbnf><MemberAccess>:
    <Term> : <Identifier></vipbnf>

(Currently, the {{lang|Terms|term}} must be a variable or a fact variable).

The {{lang2|Lexical_Elements|Identifiers|identifier}} must have the type of the {{lang|Terms|term}}.

Inside an implementation object member predicates can be invoked without reference to an object, because "<vp>This</vp>" is subsumed, see {{lang2|Basic_Concepts|Scoping_&_Visibility|Scoping}}.

=== Object Expressions ===

An object expressions is an expressions that evaluates to an object.  Like anonymous predicates it can capture values from and access facts in the context it appears in.

The syntax is like a regular class implementation without a name, but with a construction interface:

{{Example|<vip>Object = 
    implement : observer
      clauses
        onNext(A) :- F(toString(A)).
        onCompletion() :- F("\n").
    end implement</vip>
}}

the <vp>implement ... end implement</vp> part is an object expression.
To make object expressions a lightweight construction the keyword <vp>clauses</vp> is implicit/optional at the beginning of the scope (unless the scope has <vp>open</vp>, <vp>supports</vp> or <vp>inherits</vp> qualifications).

<vipbnf><ObjectExpression>: one of
    <FullObjectExpression>
    <SimpleObjectExpression>

<FullObjectExpression>:
    implement : <ConstructionType>
        <ScopeQualifications>
        <Sections>
    end implement

<SimpleObjectExpression>:
    implement : <ConstructionType>
        <Clause>-dot-term-list-opt
        <Sections>
    end implement</vipbnf>

There will be exactly one constructor <vp>new\0</vp>. Like for other objects you don't need to supply an implementation if the constructor is 'trivial'.

<vp>inherits</vp>, <vp>supports</vp>, <vp>open</vp>, <vp>delegate</vp> and <vp>resolve</vp> works in the same way as in regular implementations.

=== Scoping ===

The predicates can refer to the context like anonymous predicates but can also refer to facts and inherited classes inside the object.

Object expressions are nested within other scopes, these scopes are all visible from the object expression.  If a name is defined in more than one surrounding scope then the reference is to the closest level.  Names from named scopes can be resolved with the scope name, but names from surrounding object expressions must be resolved by means of a variable as described in the "This" section.

=== This ===

In a predicate in an object expression the variable <vp>This</vp> represent the object of the object expression.  There are no predefined names for surrounding <vp>This</vp> variables.  So if you want to refer to an outer <vp>This</vp> you will have to put it in another variable e.g. <vp>Outer = This</vp> and then use that variable inside the object expression.

<vip>...
    Outer = This,
    Object = 
        implement : observer
            onNext(A) :- F(Outer, toString(A))).
            onCompletion() :- F(Outer, "\n")).
        end implement</vip>

=== Polymorphism (limitation) ===

Occasionally there will be situations where we will need a type variable.  An example would be a predicate <vp>p : () -> observer{A}</vp> implemented using an object expression. Unfortunately, this is not possible until we get access to the type variables of polymorphic constructions.

<vip>
clauses
    p(Value) = 
        implement : observer{A} % A is unknown/unbound
        facts
            v : A = Value. % A is unknown/unbound
        clauses
            onNext(V) :- v := V.
            onCompleted():- write(v).
        end implement.
</vip>

=== Examples ===


The examples below will be based on <vp>iterator</vp> objets.

<vip>interface iterator
predicates
   hasNext : () determ.
   next : () -> integer.
end interface iterator</vip>

Which we will write using this predicate:

<vip>class predicates
    writeAll : (iterator It).
clauses
    writeAll(It) :-
        if It:hasNext() then
            writef("%\n", It:next()),
            writeAll(It)
        else
            write("<<<end>>>\n")
        end if.</vip>


==== Simple  object ====

{{Example|We can write a simple "null" <vp>iterator</vp> that is finished immediately.

<vip>class predicates
    test1 : ().
clauses
    test1() :-
        It =
            implement : iterator
                hasNext() :-
                    fail.
                next() = _ :-
                    exception::raise_error().
            end implement,
        writeAll(It).</vip>

Calling <vp>test1</vp> will produce
 <<<end>>>
 }}

==== Own state====

{{Example|In this example we create an iterator object that har its own fact <vp>n</vp> which is used to count down from <vp>3</vp>

<vip>class predicates
    test2 : ().
clauses
    test2() :-
        It =
            implement : iterator
                hasNext() :-
                    n > 0.
                next() = N :-
                    N = n,
                    n := n - 1.
            facts
                n : integer := 3.
            end implement,
        writeAll(It).</vip>

Calling <vp>test2</vp> will produce
  3
  2
  1
 <<<end>>>
 }}

==== Capturing values ====

{{Example|The count down object from above can be placed in its own predicate, and we can capture the value to count down <vp>From</vp> in the context:

<vip>class predicates
    countDown : (integer From) -> iterator It.
clauses
    countDown(From) =
        implement : iterator
            hasNext() :-
                n > 0.
            next() = N :-
                N = n,
                n := n - 1.
        facts
            n : integer := From.
        end implement.

class predicates
    test3 : ().
clauses
    test3() :-
        It = countDown(2),
        writeAll(It).</vip>

Calling <vp>test3</vp> will produce
  2
  1
 <<<end>>>
}}



{{Example|Here <vp>map</vp> create an iterator that maps the values returned  <vp>iterator</vp> just like it would have modified the values of a list.  Notice how the object expression captures the variables <vp>F</vp> and <vp>It</vp> and accesses them in its member predicates.

<vip>class predicates
    map : (function{integer, integer} Function, iterator It) -> iterator Mapped.
clauses
    map(F, It) =
        implement : iterator
            hasNext() :-
                It:hasNext().
            next() = F(It:next()).
        end implement.

class predicates
    test4 : ().
clauses
    test4() :-
        It1 = countDown(2),
        It2 = map({ (V) = V + 7 }, It1),
        writeAll(It2).</vip>

Calling <vp>test4</vp> will produce
  9
  8
 <<<end>>>
}}

==== Capturing a fact ====

{{Example|Here the fact <vp>count</vp> from the context is captured and manipulated from within the object expression.

<vip>class facts
    count : integer := 3.

class predicates
    test5 : ().
clauses
    test5() :-
        It =
            implement : iterator
                hasNext() :-
                    count > 0.
                next() = N :-
                    N = count,
                    count := count - 1.
            end implement,
        writeAll(It).
</vip>

Calling <vp>test5</vp> will produce
  3
  2
  1
 <<<end>>>
}}

==== inherits ====

{{Example|Suppose we have a class <vp>randomIterator</vp> which generates random numbers and supports the <vp>iterator</vp> iterator.
We can inherit from this iterator to create a iterator that "throws a dice":

<vip>class predicates
    test6 : ().
clauses
    test6() :-
        Dice =
            implement : iterator inherits randomIterator
            clauses
                next() = randomIterator::next() mod 6 + 1.
            end implement,
        foreach _ = std::cIterate(5) do
            writef("Dice : %\n", Dice:next())
        end foreach.</vip>

By inheriting <vp>randomIterator</vp> we get the implementation of <vp>hasNext</vp> and only need to implement <vp>next</vp>.

Notice that it is necessary to use the <vp>clauses</vp> keyword in this case because the class has an <vp>inherits</vp> qualification.

Assuming that <vp>randomIterator</vp> will never end, we just iterate <vp>5</vp> times.

Calling <vp>test5</vp> will produce (something like):
 Dice : 1
 Dice : 2
 Dice : 4
 Dice : 2
 Dice : 3
}}

=== Domain, Functor, and Constant Access ===

Domains, functors, and constants are all accessed as if they are class members. Even if they are declared in an interface. This means that when they are qualified, then they are always qualified with class/interface name and a double colon.

=== foreach ===
{{:Language Reference/Terms/Foreach}}
=== if-then-else ===
{{:Language Reference/Terms/If-then-else}}
=== try-catch-finally ===
{{:Language Reference/Terms/Try-catch-finally}}
Return to Language Reference/Terms.
Retrieved from "https://wiki.visual-prolog.com/index.php?title=Language_Reference/Terms"
View source for Language Reference/Terms

Search

Navigation

external links

collaboration

Personal tools

Views
