**Rules with a Guard

The full syntax of a rule is: ( '''Head''' :- ['''Guard''' | ] '''Body''' )
The full syntax of a rule is:
>'''Head''' :- ['''Guard''' | ] '''Body'''

where '''Guard''' is a multiset of ''type constraints'' of the form:

Type constraints put constraints on the shapes of processes
(or the names of unary atoms)
with which the process contexts specified in its arguments can match.
The ''type constraint name'' &math(p); is drawn from a built-in set and specifies which kind of constraints is imposed.


Here is an example rule with guard:

 waitint($p) :- int($p) | ok.

This rule can be thought of as an abbreviation
of the following infinite number of rules:

 waitint(0) :- ok.
 waitint(1) :- ok.
 waitint(-1):- ok.
 waitint(2) :- ok.

The following list contains examples of some type constraints that can be written in '''Guard''':

- int($p) --- specifies that $p must be an integer atom.
- 4($p) --- specifies that $p must be a unary integer atom of value 4 (i.e., 4(X)).
- $p < $q --- specifies that $p and $q are integer atoms
such that the value of $p is less than that of $q.
- $r = $p +. $q --- specifies that $p, $q, and $r are floating
point number atoms
such that the sum of the values of $p and $q is equal to the value of $r. 


In reality, each type constraint name (such as int or <)
Each type constraint name (such as int or <)
has its own mode of usage
that specifies which of its arguments are input arguments.
The effect of the constraint specified by a type constraint
is enabled only after the shapes (or values)
of its input arguments are all determined.
For example, $r = $p + $q proceeds only if $p and $q are determined.
For example, $r = $p + $q proceeds only when $p and $q are determined.

The same abbreviation scheme as defined for atoms
applies to type constraints when a process context name &math(\$p_i);
occurs exactly two times in the rule.
occurs exactly twice in the rule.
For example, p($n) :- $n>$z, 0($z) | ok can be abbreviated
to p($n) :- $n>0 | ok.

**Typed Process Contexts

A process context name $p constrained in '''Guard'''
is said to be ''typed'' in that rule.
As a syntactic sugar,
typed process context names can be written as link names as follows:
typed process context names can be written as link names.
For inscance, the above example can be written as:
 waitint(X) :- int(X) | ok.
// ( Res = gen(N) :- N > 0 | Res = [N|gen(N-1)] ), p(gen(10))

 ( Res = gen(N) :- N > 0 | Res = [N|gen(N-1)] ), p(gen(10))

**Guard Library

Currently, the following type constraints can be written in the
guard. The + specifies an input argument.

 '='(+Unary,-Unary)         - equivalence
 '='(-Unary,+Unary)         - equivalence
 '=='(+Unary,+Unary)        - equivalence
 '='(+U1,-U2)               - make sure that U1 and U2 are (connected to)
                              unary atoms with the same name
 '='(-U1,+U2)               - same as above
 '=='(+U1,+U2)              - check if U1 and U2 are (connected to) unary
                              atoms with the same name
 unary(+U)                  - check if U is (connected to) a unary atom
 ground(+G)                 - check if G is (connected to) a connected graph
                              with exactly one free link (which is G)
 int(+I)                    - check if I is (connected to) an integer
 float(+F)                  - check if F is (connected to) a float
 int(+Float,-Int)           - cast
 float(+Int,-Float)         - cast
 345(-Int)                  - for every integer,  not only with 345
 '-3.14'(-Float)            - for every floating, not only with -3.14
 '<'(+Int,+Int)             - integer comparison,  as well as: > =< >= =:= =\=
 '+'(+Int,+Int,-Int)        - integer operation,   as well as: - * / mod
 '<.'(+Float,+Float)        - floating comparison, as well as: >. =<. >=. =:=. =\=.
 '+.'(+Float,+Float,-Float) - floating operation,  as well as: -. *. /.
 345(-Int)                  - defined for every integer (not only with 345)
 '-3.14'(-Float)            - defined for every float
 '<'(+Int,+Int)             - integer comparison; also: > =< >= =:= =\=
 '+'(+Int,+Int,-Int)        - integer operation;  also: - * / mod
 '<.'(+Float,+Float)        - float comparison;   also: >. =<. >=. =:=. =\=.
 '+.'(+Float,+Float,-Float) - float operation;    also: -. *. /.

Front page List of pages Search Recent changes Backup   Help   RSS of recent changes