... gr2.l.¹

Note that the simplest grammars presented in the manual use the standard phrase structure approach S -> NP VP. More advanced grammars use a systemic approach to language (after gr4). In general, the FUG formalism is convenient to write systemic grammars, but it can also be used to implement other linguistic models (PS rules, LFG, GPSG or HPSG).

.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.

... one.²

Note that the possibility to put paths on the left increases the expressive power of the external construct, as it becomes possible to express at run-time constraints on constituents which are not dominated by the position of the external construct in the structure.

.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.

...2³

When using a path on the left, note that the right hand side of the equation is always interpreted as occurring in the context pointed to by the left-hand side. So if you need to use relative paths, the relative path on the right is relative to the end position of the left-hand side. For example, to unify two features {verb syntax number} and {prot number} at level {verb v}, you must write:

((verb ((v (({^ syntax number} {^ ^ ^ prot number}))))))

and not:

((verb ((v (({^ syntax number} {^ prot number}))))))

because in this second equation, the path {^ prot number} is relative to the level {verb syntax number} (not {verb v} as intended) and therefore would end up at level {verb syntax prot number} instead of {prot number}.

.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.

... ((process build) (agent Steve) (object ((concept crane) (weight 2) (height 4)))) build(Steve, Crane(C1, 2, 4)) ⁴

Other representations are of course possible using first-order notation. Some of them have some of the advantages of features structures. For example: build(B1), agent(B1, Steve), object(B1, C1), crane(C1), weight(C1, 2), height(C1, 4). In fact, any FD can always be translated in a one-to-one mapping to a class of restricted first-order terms.

.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.

... role.⁵

In most cases, however, one feature plays a special role: for example, the cat attribute can specify the category or type of a description, but this is not built into the syntax, and several such ``special'' attributes can coexist in the same FD, allowing a reader to adopt several perspectives on the same FD.

.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.

... specification.⁶

Keep in mind that this facility is above all designed for use in large grammars, and the short fragments shown here could easily be handled without incremental CSETs.

.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.

... function.⁷

This means that when given is used, unification is no longer symmetric, but it remains order-independent and monotonic.

.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.

... FUF.⁸

Note that it is also possible to define lists as procedural types, with any desired specialized unification procedure. But in that case, lists are used as black boxes into which path expressions cannot enter.

.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.

... below:⁹

This notion of typing is similar to the Y-terms defined in [#!Ait-kaci!#].

.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.

... NONE].¹⁰

In this example, the grammar could be a simple flat alternation ((cat ((alt (noun pronoun personal-pronoun ... common mass-noun count-noun))))), but this expression would hide the structure of the grammar.

.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.

... process-type.¹¹

Note that this is not even correct, since any other attribute (besides the names of roles) could still be accepted by the grammar.

.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.

... constructs.¹²

A opt construct is actually an alt with 2 branches, one being the trivial nil. It would not make sense to index it. A pattern construct is ambiguous because patterns like (...a...b...) and (...c...d...) can be combined in many ways. Actually, it is always more efficient to put patterns at the end of the grammar, because much of the ambiguity generated by these patterns would not change the unification anyway, except when the (* constituent) device is used. In any case, the equivalent of `indexing' a pattern, that is reducing the ambiguity, is to use as few dots as possible in the patterns.

.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.

... failure.¹³

In an FD, each embedded feature can be viewed as an equation between the path leading to the feature in the total FD and the feature value.

.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.

... measurements.¹⁴

In this table, DN abbreviates Denver Nuggets and BC abbreviates Boston Celtics.

.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.

... value.¹⁵

Special attributes (user defined types) can also issue user-defined syntax messages through the use of syntax-checker functions. Cf section on user-defined types for details.

.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.

... module.¹⁶

on Common Lisp II, the function require is generally not supported anymore. Most of the commercial implementations of Common Lisp, however, still have a form of require available.

.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.

... forced.¹⁷

NOTE: These 2 issues require further optimization: when do you awake a frozen disjunction and which one do you force first can be decided by some sort of dependency analysis, but one that can be done statically by building incrementally a complex data-structure, otw the cost of the analysis would not be justified. Practically, the first issue is most important: it determines how much overhead is added on ALL disjunctions when freeze is used. I am experimenting currently with a ``granularity'' control system, which controls how often the agenda of frozen disj. is checked. This is currently not implemented.

.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.