# Object Orientation

zeptoforth includes an object-orientation layer implemented by the `oo` module. Its object model involves each class having a single superclass (with the ultimatet superclass, `object`, being its own superclass), and methods and members being independent words which are tied to the class for which they are originally declared which may be applied to objects of that class or of any subclass of that class.

Binding is late by default, but if one explicitly specifies a class to use early binding is also available, and is necessary in some use cases such as `new` or `destroy` method implementations calling `new` or `destroy` respectively in their super classes. Early binding is specified via *class*`->`*method*; note that `->` is not a word but is a special method lookup marker and cannot be separated from *class* or *method* by spaces. Note that *class* can contain a module lookup path specified with `::` delimiters.

Outside of early binding, classes provide no sort of namespace mechanism; for that one must rely on modules or naming conventions.

Declaring the methods and members associated with a class and all its subclasses is separate from providing implementations for classes' methods, which may be inherited by subclasses. Methods and members of classes are declared between `begin-class` and `end-class` with `method` and `member` respectively, while method implementations are declared between `begin-implement` and `end-implement` with `define`. Note that no code may call any methods on a class until after `end-implement` is called matching the call to `begin-implement` for that class, but calls to methods on that class can be compiled before that.

For a simple example of the definition of a class and a subclass of it, take the following example:

    oo import
    
    <object> begin-class <my-class>
      cell member member-0
      method member-0@
      method display-msg
    end-class
    
    <my-class> begin-implement
      :noname
        dup <object>->new
        1 swap member-0 !
      ; define new
      :noname
        ." Destroying <my-class> "
        <object>->destroy
      ; define destroy
      :noname member-0 @ ; define member-0@
      :noname drop ." foo" ; define display-msg
    end-implement
    
    <my-class> begin-class <my-subclass>
      cell member member-1
      method member-1@
    end-class

    <my-subclass> begin-implement
      :noname
        dup <my-class>->new
        -1 swap member-1 !
      ; define new
      :noname
        ." Destroying <my-subclass> "
        <my-class>->destroy
      ; define destroy
      :noname drop ." bar" ; define display-msg
      :noname member-1 @ ; define member-1@
    end-implement

Here we define two classes, `<my-class>` and `<my-subclass>`, which inherit from `<object>` and `<my-class>` respectively. `new` defined for `<my-class>`, which overrides `new` in `<object>`, first calls `new` on `<object>`, then initializes its member `my-member-0` to 1. `destroy` defined for `<my-class>`, which overrides `destroy` in `<object>`, first displays a message then calls `destroy` on `<object>`. `member-0@` declared on and defined for `<my-class>` returns the value of `my-member-0`. `display-msg` declared on and defined for `<my-class>` prints `foo`. `new` defined for `<my-subclass>`, which overrides `new` in `<my-class>`, first calls `new` on `<my-class>`, then initializes its member `my-member-1` to -1. `destroy` defined for `<my-subclass>`, which overrides `destroy` in `<my-class>`, first displays a message then calls `destroy` on `<my-class>`. `member-0@` is inherited by `<my-subclass>` from `<my-class>`. `display-msg` defined for `<my-subclass>` prints `bar`, overriding `display-msg` inherited from `<my-class>`. `member-1@` declared on and defined for `<my-subclass>` returns the value of `my-member-1`.

To practically use this object system, one has to consider how to create `<object>`s. The object system does not concern itself with memory management; it is up to the user to manage memory as they see fit. A `<object>` of a given class is a block of memory equal in size to `class-size` applied to the class in general. It may live in a task's dictionary, in a heap, in an array, or like.

Actually initializing an object is not normally done with calling `new` directly but rather through calling `init-object` with the object's class and the starting address at which the `<object>` will live, because `init-object` does preliminary initialization before `new` can be called (which it calls itself).

Note that it is good manners for `new` of a given class to call the `new` of its superclass before it does anything else with a new `<object>`, or else the `<object>` may not function as intended.

Destroying an object is done through calling `destroy` on an object, which will carry out cleanup for an object. Note that actually freeing space for the `<object>` is up to the user. The normal convention is that each `destroy` of a given class calls the `destroy` of its superclass after it has cleaned up for itself; however, this should be broken with if a class handles freeing memory allocated for itself, e.g. in a heap, where this should be done after all superclasses' `destroy` methods have been called.

### `oo`

The following words are defined in this module:

##### `<object>`
( -- class )

The ultimate superclass of all classes.

##### `new`
( object -- )

The class constructor method.

##### `destroy`
( object -- )

The class destructor method.

##### `begin-class`
( superclass "name" -- class member-offset method-list )

Begin the declaration of class *name* inheriting from *superclass* as *class*, with an initial member offset *member-offset* and method list *method-list*.

##### `end-class`
( class member-offset method-list -- )

Finish the declaration of *class* with a final member offset *member-offset* and method list *method-list*, alloting the method table for *class*.

##### `begin-implement`
( class -- class )

Begin the definition of methods of *class*.

##### `end-implement`
( class -- )

End the defintion of methods of *class*, populating the method table for *class* with methods defined in the superclass if they are not defined for *class*.

##### `member`
( member-offset method-list member-size "name" -- member-offset method-list )

Declare a member *name* of size *member-size* of the class currently being declared. Note that no automatic alignment is done, so the user must take care to properly align their members.

##### `method`
( method-list "name" -- method-list )

Declare a method *name* of the class currently being declared.

##### `define`
( class xt "name" -- class )

Define method *name* as being bound to *xt* for *class*.

##### `class-size`
( class -- bytes )

Get the size *bytes* of an object of *class*.

##### `object-class`
( object -- class )

Get the class of *object*.

##### `init-object`
( class addr -- )

Initialize the memory at *addr* to be an object of *class* and then call *new* for that object.