Chapter 6  Gom

6.1  Gom syntax

6.1.1  Builtin sorts and operators

6.1.2  Example of signature

    module Expressions
    imports String int

    abstract syntax
    Bool = True()
         | False()
         | Eq(lhs:Expr, rhs:Expr)
    Expr = Id(stringValue:String)
         | Nat(intValue:int)
         | Add(lhs:Expr, rhs:Expr)
         | Mul(lhs:Expr, rhs:Expr)

• there is no overloading: two operators cannot have the same name
• for a given operator, all slot-names must be different
• if two slots have the same slot-name, they must belong to the same sort. In the previous example, Eq, Add, and Mul can have a slot called lhs of sort Expr. But, Id and Nat cannot have a same slot named value, since their sort are not identical (the slots are respectively of sorts String and int for Id and Nat).

6.2  Generated API

• an abstract class named ModuleNameAbstractType is generated. This class is the generic type for all nodes whose type is declared in this module. It declares generic functions for all tree nodes: a toATerm() method returning a aterm.ATerm representation of the tree; a symbolName() method returning a String representation for the function symbol of the tree root; the toString() method, which returns a string representation. It declares also all accept(Visitor v) to implement the visitor combinators pattern used by the strategy language.
  
  
• the Visitor, BasicStrategy and Forward classes for a module named Module are respectively named ModuleNameVisitor, ModuleNameBasicStrategy, ModuleNameForward. Those classes implement the visitor combinator design pattern for the module, by providing a typed Visitor interface (one visit method per sort), a Forward visitor providing a simple forwarding visitor respecting types, and a BasicStrategy, which is a visitable visitor built on top of the Forward class.
  
  
• in a subpackage types, Gom generates one class for each sort defined in the module, whose name corresponds to the sort name. Each sort class extends AbstractType for the module, and declares methods boolean isOperatorName() for each operator in the module (false by default). It declares getters (methods named getSlotName()) for each slot used in any operator of the sort (throwing an exception by default). A method SortName fromTerm(aterm.ATerm trm) is generated, allowing to use ATerm as an exchange format.
  
  
• for each sort, generate classes for the operators in a package types.SortName. All classes for the operator are named following the operator name, and extend the class generated for the corresponding sort. Thus they provide getters for the slots of the operator, and the isOperatorName() method is overriden to return true. Those classes implement the jjtraveler.Visitable interface. It is worth noting that builtin fields are not accessible from the jjtraveler.Visitable, and thus will not be visited by strategies. The operator class also implements a static make method, building a new instance of the operator. This make method is the only way to obtain a new instance.
  
  
• for each module, one file ModuleName.tom providing a Tom mapping for the sorts and operators defined or imported by the module.

6.2.1  Hooks to alter the creation operations

6.2.2  Hook example

  module Expressions
  imports String int

  abstract syntax
  Bool = True()
       | False()
       | Eq(lhs:Expr, rhs:Expr)
  Expr = Id(stringValue:String)
       | Nat(intValue:int)
       | Add(lhs:Expr, rhs:Expr)
       | Mul(lhs:Expr, rhs:Expr)
  Add:make(l,r) {
    %match(Expr l, Expr r) {
      Nat(lvalue), Nat(rvalue) -> {
        return `Nat(lvalue + rvalue);
      }
    }
  }
  Mul:make(l,r) {
    %match(Expr l, Expr r) {
      Nat(lvalue), Nat(rvalue) -> {
        return `Nat(lvalue * rvalue);
      }
    }
  }

6.2.3  Hooks to alter the generated API

• for a module ModuleName, in the abstract class named ModuleNameAbstractType (for now, you can only use this hook with the current module),
• for a sort SortName, in the abstract class named SortName in the package types,
• for an operator OperatorName of sort SortName, in the class named SortName in the package types/SortName.

• for `import', the code is a well-formed block of Java imports. For example:

  sort term:import {
    import termgraph.term.*;
    import termgraph.term.types.*;
    import tom.library.strategy.mutraveler.*;
    import java.util.HashMap;
  }
  

• for `interface', the code is a well-formed list of Java interfaces. For example:

  sort term:interface { LabelCollectable,Expandable }
  

• for `block', the code is a well-formed Java block which can contain Tom code. For example:

  sort term:block {
    %include{ java/util/HashMap.tom }
    %include{ java/mustrategy.tom }
  
    %strategy CollectTerms(table:HashMap) extends `Identity() {
      visit Term {
        labTerm(label,term) -> {
          table.put(`label,getPosition());
          return `term;
        }
      }
    }
  
    public static HashMap collect(Term t) {
      HashMap table = new HashMap();
      `TopDown(CollectTerms(table)).apply(t);
      return table;
    }
  }
  

6.2.4  Variadic operators

6.2.5  Generated API example

module Mod
abstract syntax
Nat = Zero()
    | Suc(pred:Nat)
    | Plus(lhs:Nat,rhs:Nat)
    | List(Nat*)

mod/Mod.tom                   (the Tom mapping)
mod/ModAbstractType.java
mod/ModBasicStrategy.java
mod/ModForward.java
mod/ModVisitor.java
mod/types/Nat.java            (abstract class for the "Nat" sort)
mod/types/nat/List.java      \
mod/types/nat/ConsList.java   \
mod/types/nat/EmptyList.java  / Implementation for the operator "List"
mod/types/nat/Plus.java       (Implementation for "Plus")
mod/types/nat/Suc.java        (Implementation for "Suc")
mod/types/nat/Zero.java       (Implementation for "Zero")

public aterm.ATerm toATerm()
public String symbolName()
public String toString()
public ModAbstractType accept(mod.ModVisitor v) throws jjtraveler.VisitFailure

public boolean isConsList()
public boolean isEmptyList()
public boolean isPlus()
public boolean isSuc()
public boolean isZero()

public mod.types.Nat getpred()
public mod.types.Nat getlhs()
public mod.types.Nat getHeadList()
public mod.types.Nat getrhs()
public mod.types.Nat getTailList()

public static Plus make(mod.types.Nat lhs, mod.types.Nat rhs)
public int getChildCount()
public jjtraveler.Visitable getChildAt(int index)
public jjtraveler.Visitable setChildAt(int index, jjtraveler.Visitable v)

public int length()
public mod.types.Nat[] toArray()
public mod.types.Nat reverse()

/* the constructor */
public static ConsList make(mod.types.Nat _HeadList, mod.types.Nat _TailList) { ... }
public String symbolName() { ... }
/* From the "Nat" class */
public boolean isConsList() { ... }
public mod.types.Nat getHeadList() { ... }
public mod.types.Nat getTailList() { ... }
/* From the "ModAbstractType" class */
public aterm.ATerm toATerm() { ... }
public static mod.types.Nat fromTerm(aterm.ATerm trm) { ... }
/* The jjtraveler.Visitable interface */
public int getChildCount() { ... }
public jjtraveler.Visitable getChildAt(int index) { ... }
public jjtraveler.Visitable setChildAt(int index, jjtraveler.Visitable v) { ... }
/* The MuVisitable interface */
public jjtraveler.Visitable setChilds(jjtraveler.Visitable[] childs) { ... }

6.3  Combining Gom with Tom

import module.*;
import module.types.*;

class MyClass {
  ...
  %include { module/Module.tom }
  ...
}

package myPackage;

import myPackage.myclass.expressions.*;
import myPackage.myclass.expressions.types.*;

class MyClass {
  %gom{
    module Expressions

    abstract syntax
    Bool = True()
         | False()
    ...
    Expr = Mul(lhs:Expr, rhs:Expr)
  }
  ...
}

6.4  Strategies support

6.4.1  Basic strategy support

6.4.2  Congruence strategies

Term = | a()
       | f(lt:Term,rt:Term)

MuStrategy specPrint = `TopDown(_f(Print(),Identity()));

MuStrategy map(MuStrategy arg) {
  return `mu(MuVar("x"),
    Choice(_Empty(),_Cons(arg,MuVar("x")))
  );
}

6.4.3  Construction strategies

MuStrategy rule = `Sequence(
  _f(_a(),_b()),
  _Make_g(_Make_a(),_Make_b())
);