СГ>>TYPE
СГ>>  BigSet = ARRAY 1000000 OF SET;
СГ>>

PROCEDURE Incl(VAR s: ARRAY OF SET; Element: INTEGER);
PROCEDURE Excl(VAR s: ARRAY OF SET; Element: INTEGER);

PROCEDURE Included(VAR s: ARRAY OF SET; Element: INTEGER): BOOLEAN;

PROCEDURE Union(IN s1, s2: ARRAY OF SET; OUT s3: ARRAY OF SET);
PROCEDURE Difference(IN s1, s2: ARRAY OF SET; OUT s3: ARRAY OF SET);
PROCEDURE Intersection(IN s1, s2: ARRAY OF SET; OUT s3: ARRAY OF SET);
PROCEDURE SymmetricDifference(IN s1, s2: ARRAY OF SET; OUT s3: ARRAY OF SET);

TYPE LongSet = ARRAY OF SET;
PROCEDURE SetAdd(VAR dst: LongSet; x: INTEGER);
PROCEDURE SetUnion(a,b: LongSet; VAR dst: LongSet);
PROCEDURE SetCross(a,b: LongSet; VAR dst: LongSet);
PROCEDURE IsEmptySet(a: LongSet): BOOLEAN; (* проверяет, что вектор заполнен пустыми множествами *)
PROCEDURE CompactSet(VAR dst: LongSet); (* отбрасывает хвост массива, заполненный пустыми множествами *)
.....

TYPE StackOfSets = ARRAY OF SET; (* другой логический смысл такого же контейнера *)
PROCEDURE PushSetIntoStack(VAR stack: StackOfSets; item: SET);
PROCEDURE PopSetFromStack(VAR stack: StackOfSets; VAR item: SET);
PROCEDURE IsEmptyStack(stack: StackOfSets): BOOLEAN; (* проверяет, что размер равен нулю *)
.....

VAR x: LongSet;
    y: StackOfSets;
BEGIN
  ...
  PushSetIntoStack(x, {0,1,2} ); (* Перепутали x и y. Компилятор сожрал. *)
  ...
END;

К>TYPE LongSet = ARRAY OF SET;
К>PROCEDURE SetAdd(VAR dst: LongSet; x: INTEGER);
К>PROCEDURE SetUnion(a,b: LongSet; VAR dst: LongSet);
К>PROCEDURE SetCross(a,b: LongSet; VAR dst: LongSet);
К>PROCEDURE IsEmptySet(a: LongSet): BOOLEAN; (* проверяет, что вектор заполнен пустыми множествами *)
К>PROCEDURE CompactSet(VAR dst: LongSet); (* отбрасывает хвост массива, заполненный пустыми множествами *)
К>.....

К>TYPE StackOfSets = ARRAY OF SET; (* другой логический смысл такого же контейнера *)
К>PROCEDURE PushSetIntoStack(VAR stack: StackOfSets; item: SET);
К>PROCEDURE PopSetFromStack(VAR stack: StackOfSets; VAR item: SET);
К>PROCEDURE IsEmptyStack(stack: StackOfSets): BOOLEAN; (* проверяет, что размер равен нулю *)
К>.....

К>VAR x: LongSet;
К>    y: StackOfSets;
К>BEGIN
К>  ...
К>  PushSetIntoStack(x, {0,1,2} ); (* Перепутали x и y. Компилятор сожрал. *)
К>  ...
К>END;
К>

B.3 Abstract Operators

Oberon supports the definition of abstract data types but lacks a corresponding support for the definition of abstract infix operators. This is unfortunate, because the ordinary procedural notation is clumsy in combination with nesting. Therefore, we allow the overloading of operators by redefinition. Syntactically, a redefinition is identical to a procedure declaration, where the procedure name is replaced by the operator symbol, for example by "*". It should be noted that the identification of operators in the context of an expression is done at compile time, that is, it does not depend on the dynamic types of the operands. The identification algorithm is: (a) identify all matching declarations, i.e. declarations whose formal parameter types are (direct or indirect) base types of the corresponding actual parameter types and (b) select the matching operator that lexicographically minimizes the "type-distance vector", where the components of this vector are the level differences of actual type and corresponding formal type from left to right. Typically, Oberon does not allow structured types for function return values. In the interest of nestable abstract operators, this restriction is removed in our extended compiler.

Syntax:

ProcDecl = PROCEDURE {ProcTags} (IdentDef | '"'OpDef'"' ["*"])
[FormalPars] ";" Scope (ident | '"'OpDef'"').
OpDef = Relation | AddOp | MulOp | "~".
Relation = "=" | "#" | "<" | "<=" | ">" | ">=" | IN.
AddOp = "+" | "-" | OR.
MulOp = " * " | "/" | DIV | MOD | "&".

Example:

TYPE
A = RECORD ... END;
B = RECORD ... END;
A1 = RECORD (A) ... END;
B1 = RECORD (B) ... END;

PROCEDURE "*" (a: A; b: B): A;
BEGIN ... (* implementation 1 *)
END "*";

PROCEDURE "*" (a: A1; b: B): B1;
BEGIN ... (* implementation 2 *)
END "*";

PROCEDURE "*" (a: A1; b: B1): B;
BEGIN ... (* implementation 3 *)
END "*";

VAR a: A; b: B; a1: A1; b1: B1;

a*b identifies implementation 1
a1*b identifies implementation 2
a*b1 identifies implementation 1
a1*b1 identifies implementation 3
(a*b)*b identifies implementation 1 twice
a1*(a1*b1) identifies implementations 3 and 2

MODULE Lists;
TYPE
  List = POINTER TO ListNode;
  ListNode(T) = RECORD
    data: T;
    next, prev: List;
  END;

TYPE
  Foo = POINTER TO FooDesc;
  FooDesc = RECORD ... END;
VAR
  FooList: Lists.List(Foo);

ListNode(T: NeededType) = RECORD ... END;

function "+" (x,y: COMPLEX) return COMPLEX is
begin
  return (x.RE+y.RE, x.IM+y.IM);
end;

generic (type T)
procedure SWAP (x,y: in out T) is
  temp: T;
begin
  temp := x;
  x := y;
  y := temp;
end SWAP;

procedure SWAP_INT is new SWAP(INTEGER);
procedure SWAP_VECT is new SWAP(VECTOR);

generic (type T; SIZE: INTEGER := 100)
package SYMTAB is ...

MODULE Lists;
AVC>TYPE
AVC>  List = POINTER TO ListNode;
AVC>  ListNode(T) = RECORD
AVC>    data: T;
AVC>    next, prev: List;
AVC>  END;

TYPE
AVC>  Foo = POINTER TO FooDesc;
AVC>  FooDesc = RECORD ... END;
AVC>VAR
AVC>  FooList: Lists.List(Foo);

TYPE 
  Ptr(A) = POINTER TO A;
  List(A) = Ptr(ListDesc(A));
  ListDesc(A) = RECORD elem: Ptr(A); next: List(A) END;

A parametric type can be seen as a type definition with a certain degree of freedom. The freedom comes in form of type parameters acting as placeholders for type arguments that are provided when the parametric type is used in a particular context. There are two restrictions on type parameters and type arguments: the parameter must be based on a record pointer, and the argument must be an extension of the parameter's base type.

Take for example the type `ArrayList'. The element type of the list can be any type derived from `Object', like `MyElementType', which is provided when creating an `ArrayList' variable:

TYPE
ArrayList*(E: Object.Object) = POINTER TO ArrayListDesc(E);
ArrayListDesc*(E: Object.Object) = RECORD
...
END;
...
VAR myList: ArrayList(MyElementType);


The compiler statically detects any uses of `myList' or of its methods that are incompatible with the declared element type `MyElementType'.