Newsgroups: php.internals
Path: news.php.net
Xref: news.php.net php.internals:129539
Precedence: list
MIME-Version: 1.0
References: <87e9d1bf-e407-45c1-9fad-d8759405ab8b@app.fastmail.com> <CAFyg4Hg-YP_jQ7wNS1CBbFc12W6G9JOj6ZSNC+iPWHP+trnDhg@mail.gmail.com>
In-Reply-To: <CAFyg4Hg-YP_jQ7wNS1CBbFc12W6G9JOj6ZSNC+iPWHP+trnDhg@mail.gmail.com>
Date: Thu, 4 Dec 2025 02:08:01 +0100
Message-ID: <CAFyg4HiHwNWAd49x7RxNNWibB9YU-OE_Z6Watuoa5aDSjfehzQ@mail.gmail.com>
Subject: Re: [PHP-DEV] [RFC] Type Aliases
To: Rob Landers <rob@bottled.codes>
Cc: internals@lists.php.net
Content-Type: text/plain; charset="UTF-8"
Content-Transfer-Encoding: quoted-printable
From: azjezz@carthage.software (Seifeddine Gmati)

On Thu, 4 Dec 2025 at 00:38, Seifeddine Gmati <azjezz@carthage.software> wr=
ote:
>
> HI Rob,
>
> Thanks for the RFC. I=E2=80=99m really happy to see a proposal for typed =
aliases, but to be honest, I have some major concerns about the implementat=
ion strategy, specifically the `use types` mechanism.
>
> The proposed syntax (`use types 'file.php'`) feels like a step backward. =
We are essentially re-introducing the same autoloading pain points we curre=
ntly have with functions. I strongly believe type aliases should just be fi=
rst-class citizens like classes, interfaces, or enums, they should live in =
the same symbol table (so you can't have a class `User` and a type `User`) =
and follow standard namespacing and autoloading rules.
>
> It should look like this:
>
> ```php
> namespace App\Aliases;
>
> type UserIdentifier =3D string|int|Uuid;
> ```
>
> And be used just like any other symbol:
>
> ```php
> use App\Aliases\UserIdentifier;
>
> function greet(UserIdentifier $uid): void { ... }
> ```
>
> I also want to highlight a specific issue from a tooling perspective. I m=
aintain a static analyzer (Mago - https://github.com/carthage-software/mago=
), which uses a multi-threaded, and has an architecture similar to Psalm.
>
> The `use types <file>` directive would be a massive headache. If an alias=
 is being imported from a file that was not configured in the source paths,=
 our analyzer would have to pause all analysis threads to fetch, parse, and=
 index that one file and make it available globally. This would severely im=
pact performance and concurrency. This is not a total blocker, and we would=
 probably find a workaround, but it would add significant complexity and sl=
ow down analysis for everyone.
>
> I recommend looking at how Hack handles this. They successfully implement=
 `type` (aliasing) and `newtype` (opaque types) in a way that feels natural=
 and integrates with the autoloader. Adopting a similar approach `type Foo =
=3D ...` would future-proof PHP for potential `newtype` additions later wit=
hout requiring a clunky import syntax now.
>
> Regards,
> Seifeddine Gmati.
>
> On Tue, 2 Dec 2025 at 23:24, Rob Landers <rob@bottled.codes> wrote:
>>
>> Hello Internals,
>>
>> I=E2=80=99d like to request your comments on type aliases (not to be con=
fused with typedefs) at https://wiki.php.net/rfc/typed-aliases
>>
>> TL;DR (it=E2=80=99s actually rather short):
>>
>> Following the same syntax as other use'ing statements, you can alias a t=
ype:
>>
>> use type int|float as Number;
>>
>> function sum(Number $a, Number $b): Number { return $a + $b; }
>>
>>
>> You can also include types, with some restrictions:
>>
>> include types 'math-types.php';
>>
>> function sum(Number $a, Number $b): Number { return $a + $b; }
>>
>>
>> These are compile-time replacements that serve to make code more readabl=
e and reduce repetition with no runtime overhead. Type aliases follow the s=
ame scoping rules as other use imports.
>>
>> =E2=80=94 Rob

Hi again!

I saw that you mentioned in previous emails that implementing
autoloading for type aliases isn't possible, so I wanted to verify
that, I spent some time digging to see if I could get the syntax I
proposed earlier working and I managed to get a working
implementation.

ref: https://github.com/carthage-software/php-src/tree/type-aliases

This approach would resolve the static analysis issues I mentioned
earlier, give us a cleaner mechanism for autoloading, and keep PHP's
behavior consistent.

Note that my implementation above is not complete, and would probably
need to be double and triple checked.

Regards,
Seifeddine Gmati.