35.4.3 Constraint Handling Rules, Syntax

A constraint handling rule has one or more heads, an optional guard, a body and an optional name. A Head is a Constraint. A constraint is a callable Prolog term, whose functor is a declared constraint. The Guard is a Prolog goal. The Body of a rule is a Prolog goal (including constraints). A rule can be named with a Name, which can be any Prolog term (including variables from the rule).

There are three kinds of constraint handling rules:

Rule ::= ?(Name @)
(Simplification | Propagation | Simpagation)
?(pragma Pragma)

Simplification ::= Heads <=> ?(Guard |) Body
Propagation ::= Heads ==> ?(Guard |) Body
Simpagation ::= Heads \ Heads <=> ?(Guard |) Body

Heads ::= Head | Head , Heads
Head ::= Constraint | Constraint # Id
Constraint ::= {a callable term declared as constraint}
Id ::= {a unique variable}

Guard ::= Ask | Ask & Tell
Ask ::= Goal
Tell ::= Goal
Goal ::= {a callable term, including conjunction and disjunction etc.}

Body ::= Goal

Pragma ::= {a conjunction of terms usually referring to one or more heads identified via #/2}

The symbol `|' separates the guard (if present) from the body of a rule. Since `|' is read as `;' (disjunction) by the reader, care has to be taken when using disjunction in the guard or body of the rule. The top-level disjunction will always be interpreted as guard-body separator `|', so proper bracketing has to be used, e.g. a <=> (b;c) | (d;e) instead of a <=> b;c | d;e and a <=> true | (d;e) instead of a <=> (d;e).

In simpagation rules, `\' separates the heads of the rule into two parts.

Individual head constraints may be tagged with variables via `#', which may be used as identifiers in pragma declarations, for example. Constraint identifiers must be distinct variables, not occurring elsewhere in the heads.

Guards test the applicability of a rule. Guards come in two parts, tell and ask, separated by `&'. If the `&' operator is not present, the whole guard is assumed to be of the ask type.

Declaratively, a rule relates heads and body provided the guard is true. A simplification rule means that the heads are true if and only if the body is true. A propagation rule means that the body is true if the heads are true. A simpagation rule combines a simplification and a propagation rule. The rule Heads1 \ Heads2 <=> Body is equivalent to the simplification rule Heads1, Heads2 <=> Heads1, Body. However, the simpagation rule is more compact to write, more efficient to execute and has better termination behavior than the corresponding simplification rule, since the constraints comprising Heads1 will not be removed and inserted again.