In object-oriented programming class is a set (a transitive closure) of types bound by the relation of inheritance. It is said that all types derived from some base type T and the type T itself form a class T.

The first type T from the class T sometimes is called the root type of the class.

A class of types itself, as a type, has the values and operations of its own.
The operations of are usually called methods of the root type.
Both operations and values are called  polymorphic.

A polymorphic operation (method) selects an implementation depending on the actual specific type of the polymorphic argument.

The action of choice the type-specific implementation of a polymorphic operation is called dispatch. Correspondingly, polymorphic operations are often called dispatching or virtual.
Operations with multiple arguments and/or the results of the class are called multi-methods.
A further generalization of is the operation with arguments and/or results from different classes.

 single-dispatch languages are those that allow only one argument or result to control the dispatch. Usually it is the first parameter, often hidden, so that a prefix notation x.f() is used instead of mathematical f(x).
 multiple-dispatch languages allow many arguments and/or results to control the dispatch.


A polymorphic value has a type tag indicating its specific type from the class and the corresponding specific value of that type.
This type is sometimes called the most specific type of a [polymorphic] value.
The type tag of the value is used in order to resolve the dispatch.
The set of polymorphic values of a class is a transitive closure of the sets of values of all types from that class.

In many  OO languages
the type of the class of T and T itself are considered equivalent.
In some languages they are distinct (like in Ada).
When class T and T are equivalent, there is no way to distinguish
polymorphic and specific values.



Task

Create a basic class with a method, a constructor, an instance variable and how to instantiate it.




Interface OO_Interface ; Interface for any value of this type 
  Get.i()        
  Set(Value.i) 
  ToString.s()
  Destroy()
EndInterface 
 
Structure OO_Structure ; The *VTable structure  
  Get.i
  Set.i
  ToString.i
  Destroy.i
EndStructure 
 
Structure OO_Var  
  *VirtualTable.OO_Structure
  Value.i 
EndStructure 
 
Procedure OO_Get(*Self.OO_Var)
  ProcedureReturn *Self\Value
EndProcedure
 
Procedure OO_Set(*Self.OO_Var, n)
  *Self\Value = n
EndProcedure
 
Procedure.s OO_ToString(*Self.OO_Var)
  ProcedureReturn Str(*Self\Value)
EndProcedure
 
Procedure Create_OO()
  *p.OO_Var=AllocateMemory(SizeOf(OO_Var))
  If *p
    *p\VirtualTable=?VTable
  EndIf
  ProcedureReturn *p
EndProcedure
 
Procedure OO_Destroy(*Self.OO_Var)
  FreeMemory(*Self)
EndProcedure
 
DataSection
  VTable:
  Data.i @OO_Get()
  Data.i @OO_Set()
  Data.i @OO_ToString()
  Data.i @OO_Destroy()
EndDataSection
 
;- Test the code
*Foo.OO_Interface = Create_OO()
*Foo\Set(341)
MessageRequester("Info", "Foo = " + *Foo\ToString() )
*Foo\Destroy()