Karjala

It is not a 5.42 thing:


$ perl -E 'print "lbarfThis is perl versionblarfAlexander"->CORE::substr(5, 20);print " ",$^V'
This is perl version v5.16.3


This is just normal Perl 5 behavior, although your need v5.16 or later for CORE.

Here's a demonstration that we build up in [Intermediate Perl](https://www.intermediateperl.com/) (and as a gist where I might expand this). The problem is that the arrow operator is under documented in perlop.

#!/usr/bin/perl

{

package Parent;

sub bar { print "Parent: $_[0]" . "\n" }

}

{

package Foo;

use parent qw(Parent);

sub bar { print $_[0] . "\n" }

}



print "# the invocant\n";

my $string = 'Foo';

$string->bar;

my $blessed = bless {}, $string;

$blessed->bar;

print "\n# the method\n";

my $method = 'bar';

$string->$method;

$blessed->$method;

# in SUPER, the virtual namespace that looks in @ISA

# this looks in the current package, not the package of

# the object. For this to work in main::, main needs a

# parent class

print "\n# main super class\n";

our @ISA = qw(MainSuper);

{

package MainSuper;

sub bar { print "MainSuper: $_[0]" . "\n" }

}

$string->SUPER::bar();

$blessed->SUPER::bar();

# Now start in Foo instead, and get what you probably wanted.

# Check out the SUPER module on CPAN that changes this oddity.

print "\n# Foo super class\n";

{

package Foo;

$string->SUPER::bar();

$blessed->SUPER::bar();

}

# Now, specify any sub you like:

print "\n# arbitrary sub\n";

sub quux { print "quux: @_" . "\n" }

$string->main::quux( 3, 7, 1 );  # really quux( $string, 3, 7, 1 )

$blessed->main::quux( 7, 3, 1 ); # really quux( $blessed, 7, 3, 1 )

# compare this with can, which returns a code ref is it can resolve

# that method, but where you have to supply the first argument yourself

print "\n# can\n";

my $coderef = $blessed->can('bar');

$coderef->($blessed);

$coderef->($string);

# but CORE is another package, and its does the same thing you just

# saw in main. This is a v5.16 thing, but it's using the

{

print "\n# CORE::substr\n";

if( $] 
print $string->CORE::substr( 0, 2 ), "\n";   # really substr( $string, 0, 2 )

print $blessed->CORE::substr( 3, 4 ), "\n"; # really substr( $blessed, 3, 4 )

}

You can run this under v5.8.9 and it works fine (skipping the CORE bits). It probably runs fine on earlier Perls too but I don't have those lying around.

$ perl5.8.9 test.pl
# the invocant
Foo
Foo=HASH(0x143008b70)

# the method

Foo

Foo=HASH(0x143008b70)

# main super class

MainSuper: Foo

MainSuper: Foo=HASH(0x143008b70)

# Foo super class

Parent: Foo

Parent: Foo=HASH(0x143008b70)

# arbitrary sub

quux: Foo 3 7 1

quux: Foo=HASH(0x143008b70) 7 3 1

# can

Foo=HASH(0x143008b70)

Foo

# CORE::substr

v5.16 needed for core, this is 5.008009

As for the pipe operator part of this post, the arrow is not going to do that. A proper pipe operator would feed all of the values from the left hand side to the right hand argument list. The arrow isn't going to do that.

A pipe operator would be good and totally consistent with Perl relationship with unix. You want to check out my Sub::Genius module, which allows you do this using concurrent semantics. There are other modules that do this kind of thing, but as far as I know the concurrent semantics are unique to Sub::Genius. I gave a talk on it when everyone was hiding from covid and we didn't have a Perl conference. The drawback of course is it's "plan" based and not code based like what you're suggesting. I still like it.

https://metacpan.org/pod/Sub::Genius

Other modules (noted in my POD at the time of writing):

Pipeworks, Sub::Pipeline, Process::Pipeline