[PHP-DEV] classes, instances & objects in ZE2

[Marcus Börger]

Since there is a lot of discussion going on, i had some thoughts.
Clearing some terms before:
class = template for objects/instances
  a class holds a list of methods and knows about its parents
  a class can have static members/methods which can be used without

  creating an object/instance
interface = a collection of methods and members that must be
implemnted
  in  a class/object (for example: java uses this to emulate
missing multiple 
  inheritance)
  most languages do not allow code in an interface. for me i like
the idea
  of having static members/methods in interfaces and the dynamic
part 
  can be done by using properties
  -> leads to operator
$obj->implements('interface-name')
member = a variable bound to an instance/object (like a record
member)
instance = instance of a class with pointer to method table of 
class
  and memory for members (non static class members) for those
who
  do not like pointers: name it class identifier and supply a
hashtable
  to find the class.
object = instance with private method table that can differ from the

 method table of the class it was made of (if made from class)
  in other words an object can modify/override methods without
  changing any class if so it is no longer boundable to any
class
property = a pseudo member realised by a getter and a setter
method
and now some questions:
-> we have no interfaces (as far as i know)
-> we have classes and instances not objects (our instances cannot
change methods, can they? but they can add members)
-> we have private, what about final, public, protected and abstract
(can we remove/hide a method from an object)?
-> do we allow to reduce visability (replace protected by private as
long as we don't have it):
  class A {
    public function f()..
  }
  class B extends A {
    protected function f()...
  }
and some more:
multiple inheritance = class A extends B, C
  the problem is that inheritance graph now is no longer a tree
-> MANY PROBLEMS
  current docu does not allow A:B:X instead it is allways 'A:B':X
therfore you cannot 
  access any X in C if B also has X (or does what is said about : do
apply only for 
  namespaces -> then its confusing!)
  i would appreciate having interfaces with code!
  class A {
    function f(string $s) {
      echo "$s\n";
    }
    function f(string $s1, string $s2, string $s3='')
{
      f($s1.$s2.$s3);
    }
    function f(array $a) {
      foreach($a as $s) f($s);
    }
  }
  class B extends A {
    function f(array $a) {
      foreach($a as $idx=>$s) f($idx, ':',
$s);
    }
  }
  A.f(string) -> executed
  A.f(string, string, string) calls A.f(string)...
  A.f(string, string) uses A.f(string, string, string)...
  A.f(array) calls A.f(string)...
  B.f(string) calls A.f(string)...
  B.f(string, string, string) calls A.f(string, string,
string)...
  B.f(string, string) uses B.f(string, string, string)...
  B.f(array) calls A.f(string, string, string)...
same using interfaces:
  interface L {
    abstract f(string $s);
  }
  interface S { // interface S implemts L should work, too
    f(string $s) {
      echo "$s\n";
    }
    function f(string $s1, string $s2, string $s3='')
{
      f($s1.$s2.$s3);
    }
    f(array $a) {
      foreach($a as $s) f($s);
    }
  }
  interface T extends S {
    f(array $a) {
      foreach($a as $idx=>$s) f($idx, ':',
$s);
    }
  }
  class A implements S,L {
  }
  class B extends A implements T {    // implements L
because A implements L    
  }
  A.f(string) calls S.f(string) -> executed
  (1) A.f(string, string, string) calls S.f(string,string,string)
calls A.f(string)
  A.f(string, string) uses A.f(string, string, string)
  (1) A.f(array) calls S.f(array) calls A.f(string)...
  B.f(string) calls A.f(string)
  B.f(string, string, string) calls A.f(string, string, 
string)
  B.f(string, string) uses B.f(string, string, string)
  (1) B.f(array) calls T.f(array) calls B.f(string, string,
string)
  so i used class info prior to interface info (runtime)
  when interface code is done at compile time the result differs in
<*>:
  (2) A.f(string,string,string) calls S.f(string,string,string)
calls <*>S.f(string) -> executed
  (2) A.f(array) calls S.f(array) <*>calls S.f(string) ->
executed
  (2) B.f(array) calls T.f(array) calls
<*>S.f(string,string,string) calls S.f(string) ->
executes
  that leads to above code doing (2) and the following code
using *needs* performing (1):
  interface S {
    f(string $s) {
      echo "$s\n";
    }
  }
  interface S2 needs S {
    function f(string $s1, string $s2, string $s3='')
{
      f($s1.$s2.$s3);
    }
  }
  interface S3 needs S {
    f(array $a) {
      foreach($a as $s) f($s);
    }
  }
  interface T extends S3 {
    f(array $a) {
      foreach($a as $idx=>$s) f($idx, ':',
$s);
    }
  }
  class A implements S,S2,S3 {
  }
  class B extends A implements T {
  }
parametric inheritance = class A(type-param) ...
  mostly resolved by precompilers to full class-sourcecode
  i think we do not need this
  BUT we will have loose-types in ZE2 so it would make sence to have
it....
  BUT Then we should also have methods with same name but different

  parameter signature
message-handlers?
marcus