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 ) {}
  }
}

Module declarations may also specify their superclass explicitly, use inherited fields in the pattern, and contain an entire class body:

module B ( super.len, String s) extends A; //is equivalent to (given the previous declaration of A)
 
class B extends A {
  String s;
  B(float l, String s) {super(l); this.s = s;}
 
  public static class Pattern extends UserDefinedPattern {
    private static void signature(@In @Out Y node,
                                          float a, String b ) {}
  }
}

It is also possible to declare the superclass constructor explicitly.

module C ( super.len ) extends B(len, "VAL") ; 
 
class B extends A {
 
  B(float l) {
    super(l, "VAL"); 
  }
 
  ... // pattern
}

It is possible to add a list of expression statements to be included in the constructor (using the syntax of with-instance expression lists):

module C ( super.len, super.s ) extends B . ( int i = 0, i++, println(i) ) ; 
 
class B extends A {
 
  B(float l, String s) {
    super(l, s); 
    int i = 0;
    i++;
    println(i);
  }
 
  ... // pattern
}