Newsgroups: php.internals
Path: news.php.net
Xref: news.php.net php.internals:120104
Message-ID: <d780c00b-43a7-fb47-e3d9-8c3ce2c4f723@bastelstu.be>
Date: Fri, 21 Apr 2023 16:54:30 +0200
MIME-Version: 1.0
To: Deleu <deleugyn@gmail.com>, Robert Landers <landers.robert@gmail.com>
Cc: PHP internals <internals@lists.php.net>
References: <CADK1yXJqCXFGOAmo_-iyGOqXsDJMGMs2L7PCT1zkvsHk+9y46w@mail.gmail.com>
 <CAPzBOBP4ZmDpH9q1B+xht_dP5t97T99E_yRzf9rd2EWuX7EE1w@mail.gmail.com>
 <CADK1yX+fKmKsdZUKcvh7mAhz-UJRjL-godLFApyF1bzCMfFmUg@mail.gmail.com>
Content-Language: en-US
In-Reply-To: <CADK1yX+fKmKsdZUKcvh7mAhz-UJRjL-godLFApyF1bzCMfFmUg@mail.gmail.com>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Subject: Re: [PHP-DEV] Expansion of PHP Symbols?
From: tim@bastelstu.be (=?UTF-8?Q?Tim_D=c3=bcsterhus?=)

Hi

On 4/21/23 12:49, Deleu wrote:
> What is fundamentally different about Type Alias as opposed to something
> like Enums that was recently introduced?

Type aliases might include an unbounded number of types and are … 
aliases, which based on [1] is a major issue.

To my understanding, PHP currently assumes that no object of a 
non-existent type can exist, thus is able to short-circuit checks like:

     $foo instanceof Bar; // If Bar does not exist,
                          // $foo cannot be Bar by definition.

However this might be violated if such type aliases exist, as Bar could 
be an alias to a type that actually exists. Bar could probably even be 
an alias to another alias:

     type Bar = Baz|Quux
     type Baz = Foo

So to check if `$foo instanceof Bar` in this case, the engine would need 
to load Bar, Baz, Quux and Foo in order to determine if $foo is any of 
these.

If folks also want intersection types in there, which they likely want, 
this gets complicated quickly, because nested type definitions would not 
necessarily be in DNF and thus expensive to check. Consider:

     type Foo = Bar&Baz;
     type Bar = Quux|Asdf;
     type Baz = Apple|Banana

Then `type Foo = (Quux|Asdf)&(Apple|Banana);` which is not in DNF and 
explodes into this type when written in DNF: `type Foo = 
(Quux&Apple)|(Quux&Banana)|(Asdf&Apple)|(Asdf&Banana)`.

So you'd likely have to eagerly load all pieces of the definition and 
normalize it, whereas to my understanding currently many type checks can 
happen more lazily. The normalization in itself can be expensive as 
shown with the combinatorial explosion above.

Disclaimer though: I'm just parroting what smarter people than me have 
said before and also drawing my own conclusions from my understanding of 
what they said.

Best regards
Tim Düsterhus

[1] https://chat.stackoverflow.com/transcript/message/55310273#55310273