Re: [RFC] [Discussion] Bound-Erased Generic Types

Hi Nicolas, I'd like to push back on the inheritance-BC framing. The claim that bounded types have no sensible default or wildcard is not quite accurate; defaults can be any type expression that satisfies the bound, including the bound itself. For example, consider this docblock: ``` /** * @template Id of string|object * @template T of UserInterface */ interface UserProvider { /** * @param Id $id * @return T|null */ public function load(string|object $id): null|UserInterface; } ``` Under this RFC, the migration would be: ``` interface UserProvider< Id : string|object = string|object, T : UserInterface = UserInterface, > { public function load(Id $id): T|null; } ``` By using the bounds themselves as defaults, every existing implementer continues to work unchanged: ``` class DummyProvider implements UserProvider { public function load(string|object $x): ?UserInterface { return null; } } ``` This is the general pattern: for any bounded type parameter, the widest legal default is the bound itself. There is no shape of generic declaration where a library cannot supply a default that satisfies its own bound. The migration story for adding generics to existing classes is to declare parameters with the bound as the default. Every existing subclass continues to compile and run, while downstream code can specialize on its own schedule. Consequently, the deprecation-window proposal addresses a problem that doesn't exist if defaults are used correctly. If a library declares defaults equal to its bounds, missing arguments resolve to those defaults, maintaining existing behavior. A deprecation window would only be necessary if an author chooses not to provide sensible defaults. I don't see a need to bake a deprecation window into the RFC. The existing mechanism (using defaults equal to bounds), already covers the migration path for zero-BC adoption. Cheers, Seifeddine >