Re: "::" meaning and documentation

From:	waldschrott	Date:	Tue, 04 Jul 2000 13:21:33 +0000
Subject:	Re: "::" meaning and documentation
References:	1 2	Groups:	php.dev
Request:	Send a blank email to php-dev+get-23457@lists.php.net to get a copy of this message

<applause/> that adresses all we discussed about in "[PHP-DEV] Class::? - accessing data, no success..." and more, I´d take the entire mail as an enhancment report! regards

How it _should_ work, if PHP was to behave similarly to other OO languages: Uses of :: in an instance ========================= Using :: on instance functions ------------------------------ If used in an instance of a class, :: should be able to address a shadowed method in a superclass of the current instances class. That is, class a { function somef() { print "I am somef() in a\n"; } } class b extends a { function somef() {
    print "I am somef() in b\n";
} function otherf() {
    $this->somef(); // will print "I am somef in b"
    a::somef();     // will print "I am somef in a"
} } $b_instance = new b; $b_instance->somef(); // will print "I am somef in b" This is useful to address a shadowed instance method in a superclass of a class, for example when extending an initalizing function. Note how the name of the superclass is mentioned multiple times in b, which is a denormalization. Changing the name of a classes superclass will make changed in many code locations necessary. It would be much more elegant if you had a pseudo variable $super instead which could be used to reference a classes superclass as in class b extends a { function somef() {
    print "I am somef() in b\n";
} function otherf() {
    $this->somef();  // will print "I am somef in b"
    $super->somef(); // will print "I am somef in a"
} } Alternatively, it would be useful if the class and function names around a T_PAAMAYIM_NEKUDOTAYIM need not be T_STRING, but can be variable references, facilitating syntax like class b extends a { function somef() {
    print "I am somef() in b\n";
} function otherf() {
    $c = get_parent_class(); // returns (string) "a"
    $this->somef(); // will print "I am somef in b"
    $c::somef();    // will print "I am somef in a"
} } Using :: on instance variables ------------------------------ This could be used to address shadowed instance variables as well, but the concept of "shadowed instance variable" is only useful when you consider static initalizers of instance variables. That is, consider class a { var $some_var = "initializer in a"; } class b extends a { var $some_var = "initializer in b"; function showvar() {
    print $this->some_var; // will print "initializer in b"
    print a::some_var;     // will print "initializer in a"
} } That would be sensible, but if it doesn't work that way, it is of little importance. Uses of :: outside of an instance ================================= Class functions --------------- Outside of an instance, :: does make sense only to address (Objective C name:) class functions alias (Java name:) static class member functions and (Objective C name:) class variables alias (Java name:) static class member variables. A class function/static class member function is a function which can be called in a class even when no instance of that class is available. Such functions are useful for a variety of purposes (see any Objective C runtime documentation or any Java handbook), but they can be emulated with plain functions (raising namespace issues). Example use: class a { function sfunction() {
    print "I am sfunction in a\n";
} } a::sfunction(); // will print "I am sfunction in a" A class function should be able to call other class functions, but cannot call instance functions and therefore not refer to $this, as there is no instance. It is of little use to create a default instance (of a default class), raising an error condition would be more sensible. Class variables --------------- A class may have class variables. Such variables are useful to keep track of all instances of a class, for example a database class keeping track of all database links in all database class instance objects, or for example a Drawable class, keeping track of all Drawable instances and providing a draw_all() class function. This can be emulated using a Keeper class with a single instance and putting all instances into the Keeper after creation, but having it in a class would still be useful in some cases. class a { var $class_var; } a::class_var = 10; Assorted problems ================= :: outside of classes introduces problems with variable interpolation, as the construct is no longer introduced by $ signs. This leads at least to strange syntax and may be creating other, more serious problems as well. In Smalltalk and in Objective C, classes are objects, too. Their class is named "Metaclass" and Metaclass implements a number of standard functions for dealing with Classes. An instance of Metaclass is a class, and belongs to the class Metaclass as well, terminating this recursion. That is, in Objective C and Smalltalk $o = new SomeClass; // $c is an instance of the class SomeClass print $o->get_class_name(); // will print SomeClass $c = $o->get_class(); // does not return a string, but an object
                        // which is the class SomeClass.
print $c->get_class_name(); // will print MetaClass $m = $c->get_class(); // does return the class object for $c,
                        // which is the MetaClass object
  $m->get_class();      // will print MetaClass, also.
Somehow a similar Semantic should be defined for PHP4 as well. It need not be identical, but it should be defined to clear things up. And it should be defined in a way that makes things function in a sensible way (not just "because the implementation happens to be this way"). Kristian