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 toplevel disjunction will
always be interpreted as guardbody 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.