In ROOS, a class definition is actually a function definition. When called, this function returns a closure, with which it has instantiated an 'object'.

Within the bounds of a ROOS object, all functions that are local to a class can be called directly. They are within the 'class closure'.

ROOS knows private methods, public methods, private member variables and public member variables.

ROOS has limited generic function capabilities. It will not make existing scheme definitions generic (e.g. '+'). Instead, it defines a macro, that converts a generic function call on an object to the '->' representation of this call.

ROOS has three kinds of object member calling interfaces (to the same object).

A scheme variable representing an instantiated class is an object. Public methods in the class and it's supers are available to the object by calling them through a generic function or the '->' function.

The 'this' variable can be used from within a function defined in the class. When a public method is called through the 'this' variable, it is virtual, i.e. the method is called through the external object that is represented by 'this' .

The 'supers' variable can be used from within a function defined in the class. It is used to call a method that is defined in the super classes of a class. This call will not be 'virtualized'.

All member variables or methods that are marked 'public', are virtual, when called via an object interface, except when called via the 'supers' object interface.

All private functions are only available within the context of a class closure itself. They cannot be called through an object, this, or supers.

ROOS provides macros to support named variables processing.

ROOS has object-proxying support. It is possible with ROOS, to proxy methods of other objects through an existing object by just adding the other objects to the proxy list of the given object.

Proxy support is not the same as inheritance. It basically allows for adding a member variable of type ROOS to the external interface of the class which holds the member variable. It's implementation is currently quite static, in that object proxying doesn't allow for removing the proxied objects.

Object proxying is especially usefull in situations, that inheritance cannot be used, but it is desirable to have the proxied object's methods at the interface level of the object, which holds the proxied object.

An example is a class that derives from two classes that derive from the same base class. The public members of the base class are virtual (all public members in ROOS are virtual). If a member of the base class is called, it will be a virtual call, desending from the outside of an object to the base object. Calling this member from either base object level will result in a call to only one of the base objects members. Using proxying, this situation can be avoided.

Inline documentation. ROOS supports inline documentation. When the documentation is generated, the class hierarchy will be part of the (linked) documentation. Documentation will be written in pod. For more information see ROOS inline documentation.

(-> object member arg1 ...): This construct can be used to call a member of a given object. This is the most standard way to call a member function.

(->> object member): This construct can be used to get the procedure associated with the given member. (procedure? (->> object member)) will be true.

(member object arg1 ...): This construct can be used to call a member function of a given object, after the member function has been made 'generic', using def-generic member); it transforms into (-> object member arg1 ...).

(-> this member arg1 ...): This construct can be used to call a member function from within an object. Use it to call a member as if it was called from outside of the object.

(-> supers member arg1 ...): This construct can be used to call a member of the object its 'super' objects.

(member arg1 ...): Use this construct to call a member function in the current object ('class closure'), e.g.:

    (def-class 
    (this (operation2 _a _b))
    (supers)
    (private
      (define a _a)
      (define b _b))
    (public
      (define (operation2 a b) 'nil)
      (define (calculate) (-> this operation2 a b))
      (define (calcthis) (operation2 a b)))
    (constructor))

    (def-class 
    (this (add a b))
    (supers (operation2 a b))
    (private)
    (public
      (define (operation2 a b) (+ a b)))
    (constructor))

    > (define a (add 3 4))
    > (-> a calculate)
    7
    > (-> a calcthis)
    nil
    >

Member calcthis calls operation2 in the current closure context.