Modules are declared similarly as classes. Their declaration include:

• A name
• An optional list of attributes
• An optional list of class/interfaces that are extended/ implemented
• An instantiation declaration

Modules are declared in XL with the keyword module (different from the java keyword module).

module A(int attr1, Object attr2) extends N { /* body */ } ==> ;

Only the Name is non optional in the declaration. Thus, the smallest module declaration is:

module A;

This declaration is equivalent to:

class A extends N {
  public static class Pattern extends UserDefinedPattern {
  private static void signature(@In @Out X node) {}
    ... // suitable implementation of abstract methods
  }
}

The declaration uses an implicit superclass N which is determined by the annotation @DefaultModuleSuperclass of the innermost enclosing declaration which has such an annotation. RGG files have default annotations, one of these is the @DefaultModuleSuperclass. Its value is Node. Thus, by default all module extends Node.

The parametrized pattern is created implicitly and takes the module attributes declared after the name as additional arguments.

Attributes can be declared in :

• The list of typed arguments that follow the name
• As fields directly in the module body

Attributes declared in the the list of typed arguments are used implicitly for both: the constructor, and the pattern.

All attributes implicitly declare their accessors.

module A (float len); // is equiavent to:
class A extends Node {
 
float len;
 
public A(float l) { len = l; }
 
public static class Pattern extends UserDefinedPattern {
  private static void signature(@In @Out X node,
                                              float len ) {}
    ... // suitable implementation of abstract methods
  }
}