[Concept] Extension methods

Hey internals. The idea is to introduce extension methods, similar to those in Kotlin, C#, Dart. For those unfamiliar, those are just regular functions with fancy syntax. However, I think having those will not only improve readability, but also cover some of the previously requested features. Say you have a `class Collection` and you want to add a new method `map(callable $callable): Collection`. The first instinct is to go into that file and add the method, this will work. But what if `class Collection` is defined in a vendor package? You could define a regular function like this: `map(Collection $collection, callable $callable): Collection`, then import it whenever you need to use that. This solution works, but in practice is rarely used. The reasons are: - there's no IDE completion: `$collection-> ` <- here I want IDE to auto-complete the `map` method somehow, but since it's a function this is impossible - it's ugly looking and hard to read: `getPromotions(mostExpensiveItem(getShoppingList(getCurrentUser(), 'wishlist'), ['exclude' => 'onSale']), $holiday);` - it's easy to mess up the order of arguments The pipe operator RFC [1] was trying to solve that but got rejected. Major libraries/frameworks like Laravel [2] and Carbon [3] use a solution with `__call` that allows users to define custom methods on their classes: `Carbon::mixin('toMyTimeFormat', fn () => $this->format('MM YYYY DD'));` Again, this solution: - doesn't offer IDE completion and doesn't offer IDE navigation - harder to understand - doesn't work with interfaces, traits, enums or primitives Other languages (Kotlin [4], C# [5], Dart [6]) I'm aware of solve this problem with extension methods. All of them use slightly different syntax, but the main idea is: - you define an extension method the same way you define a function, except you specify which type you're extending - you can use any type that a function can accept. This includes primitives, classes, interfaces, traits and enums - the type you're extending is implicitly bound to `$this` - you only have access to the public scope - you can't access private/protected members - you have to import those the same way you import functions. You can't define extensions globally In PHP this could look like this: ```php // Illuminate/Collection.php namespace Illuminate; class Collection {} // App/CollectionExtension.php namespace App; use Illuminate\Collection; extension CollectionExtension on Collection { function map(callable $callable): Collection { return new Collection(array_map($callable, $this->items)); } } // App/Business/Logic.php namespace App\Business; use extension App\CollectionExtension::map; (new Collection(1, 2, 3)) ->map(fn ($value) => $value + 1) ->map(fn ($value) => $value * 2); ``` The way this should work is PHP first checks whether `Collection` has `map` method. If one's missing, it gets all used extensions that match that method name, autoloads them (the same way other class-likes are loaded) and checks whether current type `Collection` matches the type specified in the extension. If so, calls the method, otherwise attempts to call __call. This same concept eliminates the need for scalar objects or scalar extension methods [7]. I'm guessing there will be problems with optimization and OPCache. What are your thoughts? References: - [1] - https://wiki.php.net/rfc/pipe-operator-v2 - [2] - https://github.com/laravel/framework/blob/9.x/src/Illuminate/Macroable/Traits/Macroable.php - [3] - https://github.com/briannesbitt/Carbon/blob/master/src/Carbon/Traits/Macro.php - [4] - https://kotlinlang.org/docs/extensions.html - [5] - https://docs.microsoft.com/en-us/dotnet/csharp/programming-guide/classes-and-structs/extension-methods - [6] - https://dart.dev/guides/language/extension-methods - [7] - https://github.com/nikic/scalar_objects