Hi I'm trying out the new enumeration support for PHP 8.1 using https://github.com/php/php-src/pull/6489 thought to implement a polyfill based on class constants and reflection. Doing so I come across the newly defined interfaces:
``` interface UnitEnum{
public string$name;
public staticfunction cases(): array <http://www.php.net/array>;
}
interface BackedEnumextends UnitEnum{
public string$value;
public staticfunction from(int|string$scalar): static;
public staticfunction tryFrom(int|string$scalar): ?static;
}
``` My interest here is on BackedEnum which (currently) supports int|string. First of all the interface defines a "public string $value" but in fact the type needs to be "int|string". As properties are not supported in interfaces this is a pure documentation issue in the RFC itself. Secondly the arguments name $scalar is not really a good name - now as we have named arguments - $value would be much more meaningful. But most interestingly I get the feeling that this should be split into several typed interfaces because this makes wrong impression especially that "tryFrom" would except int|string but actually it doesn't. Additionally, if we want to support other types later on this would blow up the types even more. Example: ``` enum Test:string { case TEST = '1'; } Test::tryFrom('unknown'); // NULL Test::tryFrom(1);// TypeError ``` The TypeError doesn't make sense here as it matches the type and it even matches the string representation of an existing type. I think it would be much clearer if there would be two different interfaces like:
``` interface IntEnum extends UnitEnum { public int $value; public static function from(int$value): static; public static function tryFrom(int$value): ?static; }
interface StringEnum extends UnitEnum { public string $value; public static function from(string $value): static; public static function tryFrom(string $value): ?static; } ``` or else the above example should return a NULL or even case matching the string representation instead of TypeError as it matches the defined argument types. Thoughts? Thanks, Marc