On Mon, Dec 28, 2020 at 9:22 PM Larry Garfield <la...@garfieldtech.com> wrote:
> Hello, Internalians! > > After considerable discussion and effort, Ilija and I are ready to offer > you round 2 on enumerations. This is in the spirit of the previous > discussion, but based on that discussion a great deal has been reworked. > The main change is that Enumeration Cases are now object instances of the > Enumeration class rather than their own class. Most of the other changes > are knock-on effects of that. > > Of particular note: > > * Cases may not have methods or constants on them. They're just dumb > values. > * Enums themselves may have methods, static methods, or constants. > * Traits are supported, as long as they don't have properties. > * The value() method on scalar enums is now a property. > > The full RFC is here, and I recommend reading it again in full given how > much was updated. > > https://wiki.php.net/rfc/enumerations > > The implementation is 98% complete; there's still a few lagging bits in > reflection, and some opcache bugs that Ilija is still stomping on. > > There are a few outstanding questions listed that we would like feedback > on. We're not entirely certain which direction to go with them, for > reasons explained in the RFC. Input on those is especially welcome. > > Happy New Year. May it be enumerable. Nice work, I like the updated proposal. Some notes: > Similarly, enum names and case names are both case insensitive. I agree that enum names should be case insensitive (like class names), but why should case names be case insensitive? The closest analogon to a case would be a class constant, and those are case sensitive. > All Cases have a read-only property, case, that is the case-sensitive name of the case itself. I can see how this makes sense, but it wouldn't be my first guess as to how you access the case name. I'm wondering if using $enumValue->name or $enumValue->caseName might be preferable. > Scalar equivalent values must be literals. Constants and constant expressions are not supported. Why? This seems inconsistent with the overall language. If I can use a constant expression as a class constant value, why can't I use it as an enum value? > ScalarEnum exposes an additional static method from() that is automatically generated. I think it would be good to be slightly more explicit here and call it fromValue(). (We could have fromName() to construct it from a case name, and any number of custom from* named constructors.) > The from() method will up-cast from a scalar to its corresponding Enumerated Case. Invalid scalars with no matching Case will throw a ValueError. There is also a has() method, which will return boolean true if a case with that value exists and false otherwise Just a thought, but rather than having has() and from(), it may make sense to have from() (throws if invalid) and tryFrom() (returns null if invalid). I think a has() method is pretty much useless in isolation, it will always be used in a combination of has() and from(), in which case it is better to combine them rather than have an implicit contract between them. > Manually defining a static from() or has() method on a Scalar Enum will result in a fatal error. Or a non-static one :) You can't define a static and a non-static method with the same name in PHP. > Enums and cases may have attributes attached to them, like any other language construct. The TARGET_CLASS target filter will include Enums themselves. The TARGET_CONST target filter will include Enum Cases TARGET_CONST should presumably be TARGET_CLASS_CONST. More generally though, I wonder if there should be a separate TARGET_CASE... > Returns the scalar equivalent type of the Enum, if any. If it doesn't have one, it returns a ReflectionType on null. Possibly I'm misunderstanding the sentence, but why does it return a "ReflectionType on null" rather than just "null"? It's not like ::$value will have a null value in this case, it will not exist at all. > Additionally, a new function is_enum(mixed): bool returns true if the value passed is an enum or case object. Could you please clarify what "an enum or case object" means? Is this function both for checking whether an object is a case object and a (string) class an enum class? Some typo/etc notes on the text: > All Unit Enums as implemented as instances of their enum type. "as" -> "are" possibly? > That is one way to determine an Enum from any other object: "determine" -> "distinguish" possibly? > The above hierarchy is logically similar to the following class structure (although this is not the actual code that runs): You might want to change the constructor to private function __construct(public string $case) {} in this example. The use of "new static" for a final class is also confusing. Regards, Nikita
