## 4.11 DCG Grammar rules

Grammar rules form a comfortable interface to difference-lists. They are designed both to support writing parsers that build a parse-tree from a list as for generating a flat list from a term. Unfortunately, Definite Clause Grammar (DCG) handling is not part of the Prolog standard. Most Prolog engines implement DCG, but the details differ slightly.

Grammar rules look like ordinary clauses using -->/2 for separating the head and body rather than :-/2 . Expanding grammar rules is done by expand_term/2, which adds two additional argument to each term for representing the difference list. We will illustrate the behaviour by defining a rule-set for parsing an integer.

    integer(I) -->
            digit(D0),
            digits(D),
            { number_chars(I, [D0|D])
            }.

    digits([D|T]) -->
            digit(D), !,
            digits(T).
    digits([]) -->
            [].

    digit(D) -->
            [D],
            { code_type(D, digit)
            }.

The body of a grammar rule can contain three types of terms. A compound term interpreted as a reference to a grammar-rule. Code between `{`...`}` is interpreted as a reference to ordinary Prolog code and finally, a list is interpreted as a sequence of literals. The Prolog control-constructs ( \+/1 , ->/2 , ;// 2, ,/2 and !/0 ) can be used in grammar rules.

Grammar rule-sets are called using the built-in predicates phrase/2 and phrase/3:

phrase(+RuleSet, +InputList)
  Equivalent to `phrase(RuleSet, InputList, [])`.
phrase(+RuleSet, +InputList, -Rest)
  Activate the rule-set with given name. `InputList' is the list of tokens to parse, `Rest' is unified with the remaining tokens if the sentence is parsed correctly. The example below calls the rule-set `integer' defined above.

      ?- phrase(integer(X), "42 times", Rest).

      X = 42
      Rest = [32, 116, 105, 109, 101, 115]