Hi again, internals My marathon of some crazy ideas continues :D, with less crazy one this time.
## Idea Allow "reimplementing" the non-static public API (that is public properties and methods, excluding constructor) of a class by other classes like this: ```php final class interface A { public string $s; public function __construct(string $s) { $this->s = $s; } public static function fromInt(int $i): self { return new self((string) $i); } public function foo(): int { return 42; } } final class B implements A { public string $s = 'hello'; public function foo(): int { return 69; } } function usesA(A $param): void {} usesA(new B); // this works ``` ## Explanation Consider there is a class like this: ```php final class Service { public function __construct(private SomeDependency $dependency) {} // ... } final class SomeDependency { // ... } ``` We want to write some tests for the Service class, but we don't want to use a real SomeDependency instance during tests. A common approach is to either extract an interface (JUST to make it testable), or to drop the `final` keyword and allow extending the class. Both approaches have their flaws: - extracting an interface unnecessarily complicates the system, where only one "real" implementation of an interface is assumed. - dropping the `final` keyword allows for the rabbit-hole of inheritance abuse, like greatly described in this article: https://front-line-php.com/object-oriented I believe I came up with a better idea: what if we could leave both benefits of prohibiting the inheritance abuse and also allow not to clutter our namespace with excess entities like interfaces? I hereby suggest to combine the responsibilities of a class and an interface into one thing like that: ```php final class interface C {} final class D implements C {} ``` Now other classes can "implement" this class as well. Introduction of the new syntax (`class interface`) also solves BC problem - if you want to forbid your classes to be reimplemented whatsoever, you can still stick to the `final class` syntax. Although it is also possible to allow "reimplementing" ANY class, then new syntax is not needed - but some library writers like Marco Pivetta could be sad about that I suppose. Soo..., what do you think? Could this be a valuable addition to the language? Regards, Illia / someniatko -- PHP Internals - PHP Runtime Development Mailing List To unsubscribe, visit: https://www.php.net/unsub.php