Type extension is used to introduce new data types. Following the categories of BIR basic types, there are two kinds of type extension: (1) primitive type extension using the "ptypedef" keyword, and (2) non-primitive (reference) type extension using the "typedef" keyword. Regardless of the kind, each type can be declared as a generic type by specifying the parameters of the type using type variables.

In general, a type variable can be substituted by any basic type when the extension (generic) type is instantiated. However, there are special prefixes for type variable identifiers to constraint the kind of types that they may match

Generic type is used to conveniently reduce redundant extension declarations. For example, one can contribute a set type that works for all BIR types. A non-generic type solution would reguire one to declare the set extensions for every element type instance that is used in a model. Instead, a generic solution allows the possibility of the generic set to be instantiated with any basic type for its element. However, we limit the use of generic types only for extensions because all types in closed systems (i.e., BIR models) should be known. Thus, all other constructs in BIR only need to work with non-generic types or instances of generic types.

Examples. 

  extension MyExtension for mypackage.MyExtensionModule {
    typedef type1; // non-primitive extension type
    typedef type2<'a>; // parametric non-primitive extension type
    typedef type3<'enum$a, 'rec$a>; // parametric non-primitive extension type
    ptypedef type4; // primitive extension type
    ptypedef type5<'numeral$a>; // parametric primitive extension type
    ptypedef type6<'array$a, 'real$a>; // parametric primitive extension type
  }

Abstract Syntax Tree.  The Java AST class for type extension is the TypeExtension class.

Expression extension is used to introduce new BIR expressions. Following the spirit of BIR expression, the new expression constructs should be side-effect free, but they are allowed to be non-deterministic. Note that an expression can create a new object because the object creation does not change the state (until the new object is assigned to a variable). An expression extension can also be defined to be polymorphic by specifying type parameters using type variables similar to generic type extension. If the expression extension takes or returns a parametric type, then it has to be declared to be parametric. In addition, expression extension parameters can be defined as lazy parameters. Arguments to lazy parameters are not evaluated, instead the argument expression ASTs are passed. Furthermore, expression extension can take a functional expression as its parameter.

Examples. 

  extension MyExtension for mypackage.MyExtensionModule {
    typedef type<'a>; // parametric non-primitive extension type

    // foo is parameterized by 'a and 'b, takes two parameters 
    // and returns an int
    expdef int foo<'a, 'b>(MyExtension.type<'a>, MyExtension.type<'b>);
    
    // bar takes zero or more int parameters and returns an int
    expdef int bar(int ...);

    // bar takes one or more int parameters and returns an int
    expdef int baz(int, int...);
    
    // bazz takes two lazy expressions of type boolean
    expdef boolean bazz(lazy boolean, lazy boolean);
    
    // bazzz takes: (1) a function that takes an int and 
    // returns boolean and (2) one or more ints
    expdef int bazzz(int -> boolean, int, int ...);
  }

Abstract Syntax Tree.  The Java AST class for exp extension is the ExpExtension class.

Action extension is similar to expression extension. However, it is allowed to have side-effect, but cannot return values.

Examples. 

  extension MyExtension for mypackage.MyExtensionModule {
    typedef type<'a>; // parametric non-primitive extension type

    // foo is parameterized by 'a and 'b, takes two parameters 
    actiondef foo<'a, 'b>(MyExtension.type<'a>, MyExtension.type<'b>);
    
    // bar takes zero or more int parameters
    actiondef bar(MyExtension.type<int>, int ...);

    // bazz takes two expressions of type boolean
    actiondef bazz(lazy boolean, boolean);
    
    // bazzz takes: (1) a function that takes an int and 
    // (2) one or more ints
    actiondef bazzz(int -> boolean, int, int ...);
  }

Abstract Syntax Tree.  The Java AST class for action extension is the ActionExtension class.