#### 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.