PHP RFC: Interface Default Methods

• Version: 0.9
• Date: 2022-06-27
• Author: Levi Morrison, levim@php.net
• Status: Draft
• First Published at: http://wiki.php.net/rfc/interface-default-methods

Over time, authors sometimes want to add methods to an interface. Today, this causes large breakages to every implementor. This RFC proposes a way to reduce the scale of breakage.

Additionally, some times interfaces can implement some functionality of their interface in terms of other parts. For example, the interface Countable could implement function isEmpty(): bool by using $this->count() == 0. Today, traits are often used to accomplish this, but default interface implementation could be used instead.

Interface methods can now provide a default implementation.

interface Example {
  // Today, you cannot specify an implementation, only a
  // signature.
  function method1(): void;
 
  // With this RFC, you can provide an implementation:
  function method2(): void {
    echo __METHOD__, "\n";
  } 
}

Default methods for interfaces introduce a form of multiple inheritance. How is a method selected?

Java's resolution algorithm looks like this:

1. Class definitions always win. If a class, or a parent class, defines a concrete method, then this will always win over all possible default methods.
2. More specific interfaces take priority over less specific ones. If interfaces A and B exist and B extends A, and both have a default method for the same method, then when a class implements B directly or indirectly the method from B will take precedence over the method from A.
3. If the above rules fail, then the class needs to implement the method itself, possibly delegating to one of the interfaces.

This RFC proposes the same. However, rule 2 has not yet been implemented so I am unsure how feasible it is.

Here's an example of a class delegating to another method:

interface Interface1 {
    function method1() { echo __METHOD__ . "\n"; }
}
 
interface Interface2 {
    function method1() { echo __METHOD__ . "\n"; }
}
 
class Class1 implements Interface1, Interface2 {
    function method1() {
        Interface1::method1();
    }
}
 
(new Class1())->method1(); // Interface1::method1

None, as long as you do not use the feature.

If you do use the feature:

• Adding a default implementation to an existing interface method will not break existing code, because every existing usage has a higher priority than the default.
• If you add a new method to an interface, there is a compatibility break. The impact of the break is limited to places where the implementor/inheritor of the interface has a method of the same name.

PHP 8.NEXT.

Modules can specify an interface implementation as well.

Opcache should also work with this feature.

Make sure there are no open issues when the vote starts!

This feature may be used to enhance existing interfaces in PHP.

• Countable could add function isEmpty(): bool { return $this->count() == 0; }.
• Iterator could add methods like map, filter, and reduce which behave similarly to array_map, array_filter, and array_reduce.

The vote will be a simple yes/no vote on whether to include the feature.

WIP: https://github.com/php/php-src/compare/master...morrisonlevi:php-src:interface-default-methods

After the project is implemented, this section should contain

1. the version(s) it was merged into
2. a link to the git commit(s)
3. a link to the PHP manual entry for the feature
4. a link to the language specification section (if any)

Links to external references, discussions or RFCs

Keep this updated with features that were discussed on the mail lists.