The syntax for defining a generic type is as follows:

As we can see:

Here is a reprint of the above example of a generic type:

generic type pair

   param item_type end

   type
      attribute item1 type: {item_type} end
      attribute item2 type: {item_type} end
   end

end

The syntax for defining a generified type is as follows:

As we can see, the body of a generified type is introduced by a !, and then simply defined by referencing the generic type and providing an object type for each parameter in the generic type.

Here is a reprint of the above example of a generified type:

type pair_of_books

   !pair<book>

end

Generified types are used the same way standard types are used.

For example, a variable could be declared as:

var pair_of_books two_books

And, after creating a pair of books, the first book could then be retrieved with:

var book first_book = two_books.item1

A generified type can also be defined 'on the fly'.

'On the fly' means that there is no need to define a type as explained in the previous rule. Instead, the following syntax can be used wherever the type of an object reference (e.g. the type of an attribute) must be specified in source code:

As we can see the syntax used to define a generified type 'on the fly' is the same as the syntax used in the previous rule.

Thus, instead of declaring a variable as shown in the previous rule:

var pair_of_books two_books

the same can be achieved without defining type pair_of_books, and declaring the variable as follows:

var !pair<book> two_books

Generified types and 'on the fly' generified types can coexist, even if they use the same type parameters. The compiler automatically checks the parameters for generified types, and if two sets of parameters have the same values, then a single common type is used by the compiler.

Currently, two generified types that use the same generic type are considered to be type compatible at compile-time, but a runtime error is immediately raised in case of any type incompatibility occurring at runtime.

	Note
	This rule will change in a future version, so that type compatibility will be verified at compile-time.

The syntax for defining a generic factory is as follows:

The syntax for defining a generified factory is as follows:

A generified factory can also be defined 'on the fly' with the following syntax: