Implementing Generics, and none scalar default properties.

Hi,

I see what you mean with static properties, that would be more difficult.
I can answer on non-static however.

• When will $p2 be initialized, which properties can it access?

• On class instantiation. It won't have access to $this, because the
  object won't have been created yet. It will have access to the same
  entities as a static method.

• In B's constructor we're overwriting $p1, so $p2 will be initialized with
  the wrong value.

• It won't have access to $this. In effect they are pre-constructor
  assignments, just like any other property.

Concerning reassignment on constructor leading to wasted code, I can only
place faith in the effectiveness of the user to override those properties
to NULL.

Anyway sorry about the mixed post. I've mainly been working on
implementing generics, so I have a separate thread somewhere for that.

Dominic

Hi,

Would be good to split complete different subjects to different threads
anyways:

the
ability to set default values of properties to instances of objects or
calls to static methods or functions (expressions in general).

This causes questions on the order of execution and leads to waste of
CPU time in case the constructor overrides the default value while not
bringing much benefit over initialization in the constructor. It also is
complicated regarding exceptions being thrown.

Take the following code:

<?php

foo();

class A {
protected $p1 = new Something();
private $p2 = new SomethingElse($this->p1, $this->p3);
private $p3 = new Something();
private static $s1 = new StaticSomething();

public function __construct() {}
}

bar();

class B extends A {
private $p4 = new Something();

 public function __construct() {
     parent::__construct();
     $this->p1 = new Whatever();
 }

}

baz();

try {
$b = new B();
} catch (Exception $e) {
}
?>

Some Questions:

  * Where, relative to foo(), bar() and baz() will StaticSomething's
    constructor be called? How do you capture exceptions from there?
  * When will $p2 be initialized, which properties can it access?
    (Only the ones initialized before? None?)
  * In B's constructor we're overwriting $p1, so $p2 will be
    initialized with the wrong value.

I'm sure there are more questions ... doing this i the constructor makes
things clear and explicit with about the same amount of code to write.

johannes

I'm thinking primarily of the benefit to base or abstract classes. For
base classes which expect certain properties be set, they are exposed to
the danger of remaining unset if the derived class overrides the
constructor without calling the parent.

This solution is analogous to:

class Foo
{
private $timestamp;

private function __construct()
{
    $this->timestamp = new DateTime();
    $this->init();
}

public function getTimestamp()
{
    return $this->timestamp;
}

protected function init()
{

}

}

class Bar extends Foo
{
protected function init()
{
// pseudo constructor of Bar
}
}

The problem now though is that derived classes of Foo are unable to do the
same thing, whereas instantiated default properties would allow:

class Foo
{
private $timestamp = new \DateTime();

public function getTimestamp()
{
    return $this->timestamp;
}

}

class Baz extends Foo
{
private $uuid = Uuid::create();

public function getUuid()
{
    return $this->uuid;
}

}

class Bar extends Baz
{
public function __construct()
{
// real constructor of Bar
}
}

$bar = new Bar();
var_dump($bar->getTimestamp());
var_dump($bar->getUuid());

With Traits this is even more necessary, because every class (derived or
base) would need to set the properties in each constructor.

On 25 September 2015 at 22:21, Stanislav Malyshev smalyshev@gmail.com
wrote:

Hi!

ability to set default values of properties to instances of objects or
calls to static methods or functions (expressions in general).

That is what constructors are for. I.e. I can understand initializing
static properties (though it gives a lot of potential for weird race
conditions) but for non-statics constructor is exactly the place where
initialization should happen.

--
Stas Malyshev
smalyshev@gmail.com