Class Operators

Arguments

Returns

The value argument.

Description

These operators assign and evaluate object instance values, using familiar C/C++ structure/class reference syntax. The instance and its instance variable are separated by a period and the assignment is made using the = assignment operator. Using two periods between instance and variable makes the reader interpret the instance variable.

Using either the . or the .. without the = assignment operator causes the variable to be evaluated at that instance.

Examples

    Gamma> class cmpny { name; address; }
    (defclass cmpny nil [][address name])
    Gamma> company = new(cmpny);
    {cmpny (address) (name)}
    Gamma> company.name = "Acme Widgets";
    "Acme Widgets"
    Gamma> company.name;
    "Acme Widgets"
    Gamma> var = symbol("name");
    name
    Gamma> company..var;
    "Acme Widgets"
    Gamma> 
    		

Here is an example of how the .. syntax can be used to allow an instance of one class to access a method of another class. This can be useful if a parent and child widget have different methods with the same name, and you want an instance of one to use the method of the other.

    Gamma> class A{}
    (defclass A nil [][])
    Gamma> class B{}
    (defclass B nil [][])
    Gamma> class C B{}
    (defclass C B [][])
    Gamma> method A.get (){princ("Class A's method.\n");}
    (defun A.get (self) (princ "Class A's method.\n"))
    Gamma> method B.get (){princ("Class B's method.\n");}
    (defun B.get (self) (princ "Class B's method.\n"))
    Gamma> a = new(A);
    {A }
    Gamma> a.get();
    Class A's method.
    t
    Gamma> b = new(B);
    {B }
    Gamma> b.get();
    Class B's method.
    t
    Gamma> (b..A.get)();
    Class A's method.
    t
    Gamma> (a..B.get)();
    Class B's method.
    t
    Gamma> c = new(C);
    {C }
    Gamma> (c..A.get)();
    Class A's method.
    t
    Gamma> (c..B.get)();
    Class B's method.
    t
    Gamma>