[feature] support $object->&method syntax for private method calls

[haarg]

Although perl conventionally has relied on naming for its privacy protections rather than having them enforced, many people still desire fully private methods. Perl can provide private subs, but the syntax for using them as methods is not very nice:

my $coderef = sub {
  my $self = shift;
  ...
};
$object->$coderef;

my sub lexmethod {
  my $self = shift;
}
$object->${\\&lexmethod};

# a private method is really no different from a direct sub call
lexmethod($object);

Perl could support the syntax $object->&method(...) as an equivalent to &method($object, ...). This would provide a better syntax to indicate the intent of something as method, but not following traditional method lookup. It would work the same as a normal sub call, using either a sub in the current package, or a lexical sub. Keeping this at the call site means any future potential object system wouldn't need to implement complicated visibility rules in its method dispatch.

Currently, $object->&method is invalid syntax, so it shouldn't present backwards compatibility issues.

[dur-randir]

How this would work with inheritance? Looks like it won't, so calling this "method syntax" seems wrong.

[haarg]

It would intentionally not follow inheritance. This is similar to other languages that provide private methods, which don't follow inheritance.

[perigrin]

Methods don't need to follow inheritance to be methods. For example, Go doesn't even have inheritance^1 but has method dispatching. For a subroutine to be a method it simply needs to be a procedure associated with an object. In Perl this means that when you put a function name, or code ref after a dereference operator, that function is called and the thing on the left hand side of the dereference operator is passed as the first argument.

use strict;
my $foo = sub { say @_ };
1->$foo

There's no inheritance involved here, 1 isn't even a blessed object or a valid class name, but $foo is still a method.

I very much like haarg's suggestion, IMO it makes sense that we should be able to drop the intermediate variable in:

use 5.26.0;
my sub foo { say @_ }
my $f = \&foo;
1->$f;

Especially since the reference chicanery is the very much non-obvious 1->${\\&foo}.

1: Go has a form of composition that, if you squint while drinking something probably better used as floor cleaner, looks like inheritance.

[Grinnz]

The syntax strikes me as odd but I can't think of any reason not to do this if it makes lexical private methods more appealing. Personally I just use anonymous coderefs.

[Leont]

Given we already support $foo->$bar, it does make sense to me to add this

[Ovid]

I also use anonymous coderefs and prefer them. However, the $foo->&bar syntax has the advantage of being immediately clear to new devs that we're doing something a touch different.

[haarg]

This was implemented in #22940