Am 2025-03-20 21:27, schrieb Matt Fonda:
If an interface adds a method but makes no promises about what parameters
it accepts, then why is it part of the interface in the first place--why
add a method that can't be used?
It would more cleanly allow for userland / PHPDoc-based generics, while still providing some engine-enforced type safety. Consider this example (not sure if I got the syntax completely right):
/** @template T */
interface Comparable {
/** @param T $other */
public function compareTo(never $other): int;
}
/** @implements Comparable<Number> */
final class Number implements Comparable {
public function compareTo(Number $other): int { return $this <=> $other; }
}
I think I agree with Matt on this: the interface isn't making any usable promises about that method.
In this example, Comparable is a kind of "abstract interface" - in order to actually make use of it, you need to specialise it.
Declaring that a class implements a template interface is like inheriting an abstract method: either you fill in the type parameter ("class Foo implements Comparable<Foo> { ... }"), or the class is also a template ("class Foo<A> implements Comparable<A> { ... }")
I don't think the language should pretend to support something that it doesn't - if the contract is actually enforced by a third-party tool reading docblocks, put the contract in a docblock: