The goal was just '(and )', restore the original reachability goal.

This commit adds the parsing utility class "TypesIndex".

TypesIndex is an index for PDDL types and PDDL names/variables. It is used to index PDDL names and variables by their types. OrderedDict is used to preserve the order of the types and the names, e.g. for predicate variables. Other types of validations are performed to ensure that the types index is consistent.

In this commit, it is used only to parse typed lists of names (not variables).

…ompatible)

This commit changes the way typed_list_name rule is parsed. This does not change the parsing behaviour from the user perspective, but it is a non-functional change to improve the performances of the Lark parser.

With the previous version of the rule 'typed_list_name: NAME+ TYPE_SEP primitive_type (typed_list_name)', the Lark parser internals would perform a recursive call whenever a typed_list_name is matched. This might cause an arbitrarily long stack of calls whenever the parser got an input like:

```
element1 - t1 element2 - t1 element3 t1 ...
```

The above list of tokens is parsed as:

```
element1 - t1 <typed_list_name>
    element2 - t1 <typed_list_name>
        element3 - t1 <typed_list_name>
            ...
```

For large inputs, this will easily hit the recursion depth limit.

With the new approach, the entire list of tokens is parsed at once. This adds some complexity in the parsing function for the typed_list_name rule, but we have more control in how the parsing is performed; in particular, we can parse the tokens *iteratively* rather than *recursively*.

Finally, the NAME* pattern is appended at the end of the typed_list_name rule. This is because, according to the syntax specification, the last sublist of names might be non-typed.

The implementation exploits the newly added TypesIndex class which handles corner cases and syntax errors (e.g. duplicated entries in the list).

The order is taken from pag. 168 of the PDDL textbook, where colon ':' is ignored in determining the order.

The value of type dict passed to the Domain constructor in the README is set to None, denoting the fact that the type has no parent type.

This is needed to accomodate future changes and to avoid circular imports.

…getters

in this way, PDDLValidationError is raised, rather than the generic AssertionError.

If the requirements set is given, use it. Otherwise, take the requirements from the domain.

…ain and problem) constants

…e vs domain

Problem objects can be instantiated in two ways: either with a domain object, or without it.

If with a domain object, then both the attributes/args domain_name and requirements must be validated against the provided domain.
Otherwise, the provided arguments are used to set the attributes.

The domain setter will reset both requirements and domain_name attributes.
The property getter of requirements will return empty set even when it was not specified (therefore, interpreting absence of requirements section as empty set of requirements).

- The parser tests are split in two modules: one for domain's, the other for problem's parser tests.
- The parametrization over PDDL fixture files of the parser tests is changed. Now we iterate over all problems, and for each problem we also parse the respective domain, and then we check the validity of the problem against the domain (via the implicit call to the Problem.check method, triggered by the Problem.domain property setter).

The main motivation is that Python 3.7 is going to reach the end of life at the end of June 2023.

Another reason is that we are going to use some language features available only for >=3.8 (e.g. functools.singledispatchmethod).

Needed to avoid circular imports.

This commit adds keyword validation for 'name' types. In particuar, instead of using the raw 'name' constructor, we added 'parse_name' and use it across modules. The same is done for 'types', except that the 'object' keyword should be ignored.

This change is very helpful as the input validation is done during the initialization of the PDDL objects.

The keyword validation functions have been moved to the pddl.custom_types module.

Although not very common, a list of variables might contain duplicated entries.

For example, this allows to define a predicate like P(?x, ?x).

add tests on multi-types, predicates, action parameters/preconditions/effects.

from @francescofuggitti PR comment

Co-authored-by: Francesco Fuggitti <francesco.fuggitti@gmail.com>

i.e. terms with the same name should have the same type tags.

- types are now printed correctly in the :constants section
- in the :objects section, the objects are grouped by type (as in constants)
- minor fixes in how :init and :goal are printed (they are always printed even if empty).

The code changes added here are to be considered temporary, since a refactoring of the formatting module is required. Nevertheless, the printing of the typing information of constants will remain.

This should make the error more clear to the user: instead of just saying that the name is "already present" in the list, we clarify that the problem is that not only it occurs, but it is because it occurs (again) as inheriting name.