Newsgroups: php.internals
Path: news.php.net
Xref: news.php.net php.internals:116038
Content-Type: text/plain;
	charset=us-ascii
Mime-Version: 1.0 (Mac OS X Mail 13.4 \(3608.120.23.2.7\))
In-Reply-To: <CADyq6sJ1h0St4B55P0UEZ-KXHa4m3oYa2-43bzui5XYfWWHsGw@mail.gmail.com>
Date: Mon, 13 Sep 2021 10:05:43 -0400
Cc: David Rodrigues <david.proweb@gmail.com>,
 PHP Internals <internals@lists.php.net>
Content-Transfer-Encoding: quoted-printable
Message-ID: <538C20B2-3491-49DE-BCC0-47F43A51B98F@newclarity.net>
References: <CAEsg9X116QW+_+OKFRXZbPsg=aGdmsxQPgUg4GEHweiAnqvO0w@mail.gmail.com>
 <CADyq6sJ1h0St4B55P0UEZ-KXHa4m3oYa2-43bzui5XYfWWHsGw@mail.gmail.com>
To: Marco Pivetta <ocramius@gmail.com>,
 Rowan Tommins <rowan.collins@gmail.com>
Subject: Re: [PHP-DEV] Class static initialization block
From: mike@newclarity.net (Mike Schinkel)

> On Sep 11, 2021, at 7:35 PM, Marco Pivetta <ocramius@gmail.com> wrote:
>=20
> On Sun, 12 Sep 2021, 01:28 David Rodrigues, <david.proweb@gmail.com> =
wrote:
>=20
>> Hello!
>>=20
>> I would like to suggest a feature I saw being implemented in the V8 =
9.4
>> engine called "*class static initialization block*".
>>=20
>> https://v8.dev/blog/v8-release-94
>>=20
>> In short, it is a method that is executed once when a class is =
imported and
>> loaded, allowing for some more advanced initialization process to be =
done.
>>=20
>> class Test {
>>    static readonly Carbon $now;
>>=20
>>    static () {
>>        self::$now =3D now();
>>    }
>> }
>>=20
>> Currently I can only do this in a very hacky way, usually by creating =
a
>> public static method and calling it after class initialization.
>>=20
>> class Test {
>>    static Carbon $now;
>>=20
>>    public static function init(): void {
>>        self::$now =3D now();
>>    }
>> }
>>=20
>> Test::init();
>>=20
>> I think the way the V8 does is much more interesting.
>>=20
>> Another alternative would be to create a magic method like =
__initialize().
>>=20
>=20
> This already works without any magic.

Not true.  Here are three (3) things you cannot currently do with your =
proposed solution and without said magic:

1.) Use static analysis to recognize a class has an initialization =
functionality and thus provide lint-specific to best practices for =
static initialization.
2.) Make the initialization function private.
3.) Override and/or change order of initialization of parent in child =
class.

I do not know of use-cases of #3, but #1 and #2 use-case should be =
obvious.

> ```
> MyClass::horribleInitializationPractices();
> ```

You named that in a rather condescending and passive-aggressive way.  Is =
that really helpful for respectful dialog?


> That's really all there is to it.
>=20
> What you define as hacky is really normal/boring, and does not need =
special
> constructs.
>=20
> Also, it's generally not a good idea to sprinkle static mutable
> runtime-bound all over the place: it should be an exception, not a =
rule.

Valid use-cases I have come across:

1. Hooking actions and filters in plugins for frameworks and CMS that =
use hooks as an extension mechanism.

2. Initializing what would ideally be constants but because of PHP's =
constraints regarding constant initializes cannot be constants.

> On Sep 12, 2021, at 6:42 AM, Rowan Tommins <rowan.collins@gmail.com> =
wrote:
>=20
> On 12 September 2021 00:28:02 BST, David Rodrigues =
<david.proweb@gmail.com> wrote:
>> Hello!
>>=20
>> I would like to suggest a feature I saw being implemented in the V8 =
9.4
>> engine called "*class static initialization block*".
>=20
>=20
> Hi David,
>=20
> There was a similar proposal for PHP a few years ago: =
https://wiki.php.net/rfc/static_class_constructor
>=20
> Although it didn't go to a vote, the proposal was dropped for lack of =
support. There's some discussion summarised in that RFC, and you can =
probably find the rest by searching for its title on =
https://externals.io
>=20
> Regards,
>=20
> --=20
> Rowan Tommins

Here is the external thread: =20

https://externals.io/message/84602

Rowan, you were definitely the most vocal one to argue against it with =
the most messages on that thread.

But all the arguments against appeared to bog down into discrediting =
Johannes Ott's desired use-case for static class constructors and did =
not really look for other reason why they would be useful.

As I mentioned above, hooking actions and filters in plugins for =
frameworks and CMS is where it would be useful, especially since these =
generally need to be hooked upon initial load of the plugin.=20

Also, initializing variables to act as constants because PHP does not =
support complex initializations on constants is another use-case.

One of your arguments against was the timing of the initialization =
because evidently Johannes Ott wanted them to be lazily evaluated.  =
Given the use-case I just stated I think they should always be loaded =
immediately whenever the file is loaded. That makes that argument about =
debugging cause-and-effect becomes a moot point.=20

And lazy evaluation should be considered as a separate feature. I =
blogged about that a while back but never brought to the list:

https://mikeschinkel.org/2021/lets-add-lazy-evaluation-to-php/

The other main argument you had against was Singletons. But that was a =
moot point because one of the reasons to use static initialization *is* =
to instantiate a Singleton.

Java has static initialization blocks[1], C# has static constructors[2] =
so the idea they would be useful for PHP is not a stretch,

-Mike

[1] https://www.geeksforgeeks.org/g-fact-79/
[2] =
https://docs.microsoft.com/en-us/dotnet/csharp/programming-guide/classes-a=
nd-structs/static-constructors