Send a blank email to [email protected] to get a copy of this message
Hello Internals,
I'm going to try something new. I've been working on another RFC called "Typed
Aliases" (https://wiki.php.net/rfc/typed-aliases). It is very much a draft and in-flux, and
I've already worked out the technical mechanics of it ... however, I am very unhappy with the
syntax, and while I have a few ideas about that; I assume this list will be much better at it than
me. So, please bring your brushes and paint; I brought a bikeshed.
If you haven't read it already, here's the TL;DR:
- This RFC expands the "use ... as ..." syntax to allow any type expression on the left
side. These aliases are PER FILE and expire once the file is compiled.
- This RFC also adds the ability for an alias to survive a file (currently using the "as
alias" syntax that I don't like) which actually just creates a special kind of class. When
this special class is encountered during type-checking, the alias is expanded and checked. It also
allows this via a "type_alias()" function instead of the "use ... as alias ..."
syntax.
How it works:
use string as alias MyString
gets virtually compiled into a special class that would look something like this to ReflectionClass
(as it is currently):
class MyString extends PrimitiveAlias {
const PrimitiveType aliasOf = PrimitiveType::string;
}
- Reflection is a bit weird here, and I'm not exactly happy with it; but I'm curious what
the list thinks. I'm open to virtually anything that makes sense here; including not allowing
ReflectionClass on the type aliases at all.
- Since these are "technically" classes, I went with just "use"-ing them like
normal classes. Originally, I had something different: "use alias ...." (like "use
function ...") to make it more clear. I will probably go back to this, but I'm curious
what others think.
I'm going to take a step back and listen/answer questions. But please, grab a brush and paint.
— Rob