RFC probability

[abramchikd]

Hey! Is there any chance that this will be implemented as and RFC?

I can also think of another method of achieving such functionality: allowing any function to be called as an extension method.
If the left operand of $a->callSomething() is a primitive type or the method on object does not exist and __call is not implemented, then try to execute callSomething as a function and pass $a as a first parameter.
Are there any drawbacks of implementing it this way? I tried to do it myself, but php src seems to be too complicated for me

[abramchikd]

@nikic

[rodrigoslayertech]

Not only register methods, but properties too.

[jakeandreoli]

I'm sort of necroing this post, but

Are there any drawbacks of implementing it this way?

Yes. Things like str_replace would not work as the subject is the third parameter. The other drawback I could think of is it wouldn't work with anything namespaced, such as the new URI extension

I do think the concept of extending objects is interesting. I don't think that userland should work the way it does in this proof of concept, but I do think being able to say string::register('methodName', fn($str) => ...); would work. Though that also runs the same risk as messing with the prototype in JavaScript -- Don't want things just jamming them in there out of laziness.

[HallofFamer]

I am thinking that this feature can be easily expanded into extension methods as seen in C# and Kotlin. For reference, the syntax for C#'s extension methods look stunningly similar to how scalar object methods are implemented:

public static class StringExtensions
{
    public static int WordCount(this string input)
    {
        if (string.IsNullOrEmpty(input))
            return 0;

        // Split the string by whitespace and return the length of the resulting array
        return input.Split(new[] { ' ', '\t', '\r', '\n' }, StringSplitOptions.RemoveEmptyEntries).Length;
    }
}

Apparently, how to load extensions on a per file basis can be enough tricky, especially when one file includes/requires another file, and different extensions are loaded with same methods on the same type/class. I have not seen any dynamically typed languages with extension methods though, this may be attributed to the fact that most dynamically typed languages support monkey patching so there is less need for extension methods. For PHP however, a class is closed upon creation, so the idea of extension methods will work nicely with this language.

[jakeandreoli]

@HallofFamer I like what you put here. I'm kind of wondering if class names should be required to call extensions to remove ambiguity across implementations. Example here.

namespace My\Extensions;

#[ExtensionFor(string)]
final class StringExtensions
{
    public static wordCount(this string $input) : int
    {
        if ($input === '') {
            return 0;
        }

        $words = preg_split('/\s+/', trim($input));

        return count($words);
    }
}

use My\Extensions\StringExtensions;

$str = "Hello world";
$str->length(); // output: 11
$str->StringExtensions::wordCount(); // output: 2

This would require new lexing, so we could instead keep it more simple and approach extensions like this. Admittedly, a little less elegant

use My\Extensions\StringExtensions;

$str = "Hello world";
$str->ext(StringExtensions::class)->wordCount(); // output: 2

The #[ExtensionFor(string)] attribute could be used to signal this class is not to be used with anything that isn't a string. For example:

$myFavouriteNumber = 42;
$myFavouriteNumber->StringExtensions::wordCount(); // Fatal error

The argument would then be does it need to be declared for the entire class, or should this string $input be the thing that catches it.