Beta Shell v2.0

File Manager

Name	Size	Perms	Modified	Actions
[ .. / .. ]
AnyDBM_File.pm	2.56 KB	-rw-r--r--	2023-01-19 08:45:37	Edit Del
App	-	drwxr-xr-x	2022-02-23 09:06:46	Del
Attribute	-	drwxr-xr-x	2023-09-05 10:53:46	Del
AutoLoader.pm	15.43 KB	-rw-r--r--	2023-01-19 08:45:37	Edit Del
AutoSplit.pm	19.18 KB	-rw-r--r--	2023-01-19 08:45:37	Edit Del
B	-	drwxr-xr-x	2023-09-05 10:53:26	Del
Benchmark.pm	30.3 KB	-rw-r--r--	2023-01-19 08:45:37	Edit Del
CORE.pod	3.11 KB	-rw-r--r--	2023-01-19 08:45:37	Edit Del
CPAN	-	drwxr-xr-x	2022-02-23 09:06:46	Del
CPAN.pm	144.4 KB	-r--r--r--	2021-11-21 21:00:05	Edit Del
Capture	-	drwxr-xr-x	2022-02-23 11:26:37	Del
Class	-	drwxr-xr-x	2023-09-05 10:53:26	Del
Compress	-	drwxr-xr-x	2022-02-22 12:00:43	Del
Config	-	drwxr-xr-x	2023-09-05 10:53:26	Del
Convert	-	drwxr-xr-x	2022-02-23 11:31:35	Del
DB.pm	18.48 KB	-rw-r--r--	2023-01-19 08:45:37	Edit Del
DBM_Filter	-	drwxr-xr-x	2023-09-05 10:53:26	Del
DBM_Filter.pm	14.05 KB	-rw-r--r--	2023-01-19 08:45:37	Edit Del
Devel	-	drwxr-xr-x	2023-09-05 10:53:46	Del
DirHandle.pm	1.52 KB	-rw-r--r--	2023-01-19 08:45:37	Edit Del
Dumpvalue.pm	17.14 KB	-rw-r--r--	2023-01-19 08:45:37	Edit Del
English.pm	4.65 KB	-rw-r--r--	2023-01-19 08:45:37	Edit Del
ExtUtils	-	drwxr-xr-x	2023-09-05 10:55:58	Del
File	-	drwxr-xr-x	2023-09-05 10:53:26	Del
FileCache.pm	5.44 KB	-rw-r--r--	2023-01-19 08:45:37	Edit Del
FileHandle.pm	6.63 KB	-rw-r--r--	2023-01-19 08:45:37	Edit Del
FindBin.pm	4.45 KB	-rw-r--r--	2023-01-19 08:45:37	Edit Del
Getopt	-	drwxr-xr-x	2023-09-05 10:53:26	Del
I18N	-	drwxr-xr-x	2023-09-05 10:53:26	Del
IO	-	drwxr-xr-x	2023-09-05 10:53:46	Del
IPC	-	drwxr-xr-x	2023-09-05 10:53:26	Del
Internals.pod	2.52 KB	-rw-r--r--	2023-01-19 08:45:37	Edit Del
Locale	-	drwxr-xr-x	2023-01-19 08:45:37	Del
Math	-	drwxr-xr-x	2023-09-05 10:53:27	Del
Memoize	-	drwxr-xr-x	2023-09-05 10:53:27	Del
Memoize.pm	35.34 KB	-rw-r--r--	2023-01-19 08:45:37	Edit Del
Module	-	drwxr-xr-x	2023-09-05 10:53:46	Del
NEXT.pm	18.4 KB	-rw-r--r--	2023-01-19 08:45:37	Edit Del
Net	-	drwxr-xr-x	2023-09-05 10:53:46	Del
Perl	-	drwxr-xr-x	2022-02-23 11:30:57	Del
PerlIO.pm	10.21 KB	-rw-r--r--	2023-01-19 08:45:37	Edit Del
Pod	-	drwxr-xr-x	2023-09-05 10:53:46	Del
Safe.pm	24.49 KB	-rw-r--r--	2023-01-19 08:45:37	Edit Del
Search	-	drwxr-xr-x	2023-09-05 10:53:26	Del
SelectSaver.pm	1.05 KB	-rw-r--r--	2023-01-19 08:45:37	Edit Del
SelfLoader.pm	17.28 KB	-rw-r--r--	2023-01-19 08:45:37	Edit Del
Statistics	-	drwxr-xr-x	2022-02-23 11:31:07	Del
Symbol.pm	4.69 KB	-rw-r--r--	2023-01-19 08:45:37	Edit Del
Term	-	drwxr-xr-x	2023-09-05 10:53:26	Del
Test.pm	29.35 KB	-rw-r--r--	2023-01-19 08:45:37	Edit Del
Text	-	drwxr-xr-x	2023-09-05 10:53:26	Del
Thread	-	drwxr-xr-x	2023-09-05 10:53:26	Del
Thread.pm	8.09 KB	-rw-r--r--	2023-01-19 08:45:37	Edit Del
Tie	-	drwxr-xr-x	2023-09-05 10:53:26	Del
Time	-	drwxr-xr-x	2023-09-05 10:53:26	Del
UNIVERSAL.pm	6.44 KB	-rw-r--r--	2023-01-19 08:45:37	Edit Del
URI	-	drwxr-xr-x	2022-02-22 10:46:50	Del
URI.pm	33.97 KB	-rw-r--r--	2018-01-09 06:42:55	Edit Del
Unicode	-	drwxr-xr-x	2023-09-05 10:53:26	Del
User	-	drwxr-xr-x	2023-09-05 10:53:26	Del
XML	-	drwxr-xr-x	2022-02-23 11:26:40	Del
XSLoader.pm	11 KB	-rw-r--r--	2023-01-19 08:45:37	Edit Del
_charnames.pm	32.39 KB	-rw-r--r--	2023-01-19 08:45:37	Edit Del
autouse.pm	4.14 KB	-rw-r--r--	2023-01-19 08:45:37	Edit Del
base.pm	10.72 KB	-rw-r--r--	2023-01-19 08:45:37	Edit Del
blib.pm	2.04 KB	-rw-r--r--	2023-01-19 08:45:37	Edit Del
bytes.pm	3.67 KB	-rw-r--r--	2023-01-19 08:45:37	Edit Del
bytes_heavy.pl	758 B	-rw-r--r--	2023-01-19 08:45:37	Edit Del
charnames.pm	20.38 KB	-rw-r--r--	2023-01-19 08:45:37	Edit Del
deprecate.pm	3.01 KB	-rw-r--r--	2023-01-19 08:45:37	Edit Del
diagnostics.pm	18.59 KB	-rw-r--r--	2023-01-19 08:45:37	Edit Del
dumpvar.pl	15.19 KB	-rw-r--r--	2023-01-19 08:45:37	Edit Del
encoding	-	drwxr-xr-x	2023-09-05 10:53:26	Del
feature.pm	16.68 KB	-rw-r--r--	2023-01-19 08:45:37	Edit Del
fields.pm	9.27 KB	-rw-r--r--	2023-01-19 08:45:37	Edit Del
filetest.pm	3.91 KB	-rw-r--r--	2023-01-19 08:45:37	Edit Del
if.pm	3.26 KB	-rw-r--r--	2023-01-19 08:45:37	Edit Del
integer.pm	3.18 KB	-rw-r--r--	2023-01-19 08:45:37	Edit Del
less.pm	3.13 KB	-rw-r--r--	2023-01-19 08:45:37	Edit Del
locale.pm	4.74 KB	-rw-r--r--	2023-01-19 08:45:37	Edit Del
meta_notation.pm	2.07 KB	-rw-r--r--	2023-01-19 08:45:37	Edit Del
open.pm	7.83 KB	-rw-r--r--	2023-01-19 08:45:37	Edit Del
overload	-	drwxr-xr-x	2023-09-05 10:53:26	Del
overload.pm	52.06 KB	-rw-r--r--	2023-01-19 08:45:37	Edit Del
overloading.pm	1.77 KB	-rw-r--r--	2023-01-19 08:45:37	Edit Del
perl5db.pl	309 KB	-rw-r--r--	2023-01-19 08:45:37	Edit Del
pod	-	drwxr-xr-x	2023-09-05 10:53:46	Del
sigtrap.pm	7.43 KB	-rw-r--r--	2023-01-19 08:45:37	Edit Del
sort.pm	5.94 KB	-rw-r--r--	2023-01-19 08:45:37	Edit Del
strict.pm	4.63 KB	-rw-r--r--	2023-01-19 08:45:37	Edit Del
subs.pm	848 B	-rw-r--r--	2023-01-19 08:45:37	Edit Del
unicore	-	drwxr-xr-x	2023-09-05 10:53:07	Del
utf8.pm	8.9 KB	-rw-r--r--	2023-01-19 08:45:37	Edit Del
utf8_heavy.pl	30.87 KB	-rw-r--r--	2023-01-19 08:45:37	Edit Del
vars.pm	2.36 KB	-rw-r--r--	2023-01-19 08:45:37	Edit Del
vendor_perl	-	drwxr-xr-x	2025-05-28 10:13:59	Del
vmsish.pm	4.21 KB	-rw-r--r--	2023-01-19 08:45:37	Edit Del
warnings	-	drwxr-xr-x	2023-09-05 10:53:27	Del
warnings.pm	43.71 KB	-rw-r--r--	2023-01-19 08:45:37	Edit Del

Editing: NEXT.pm (18.4 KB)

package NEXT;

use Carp;
use strict;
use warnings;
use overload ();

our $VERSION = '0.67';

sub NEXT::ELSEWHERE::ancestors
{
	my @inlist = shift;
	my @outlist = ();
	while (my $next = shift @inlist) {
		push @outlist, $next;
		no strict 'refs';
		unshift @inlist, @{"$outlist[-1]::ISA"};
	}
	return @outlist;
}

sub NEXT::ELSEWHERE::ordered_ancestors
{
	my @inlist = shift;
	my @outlist = ();
	while (my $next = shift @inlist) {
		push @outlist, $next;
		no strict 'refs';
		push @inlist, @{"$outlist[-1]::ISA"};
	}
	return sort { $a->isa($b) ? -1
	            : $b->isa($a) ? +1
	            :                0 } @outlist;
}

sub NEXT::ELSEWHERE::buildAUTOLOAD
{
    my $autoload_name = caller() . '::AUTOLOAD';

    no strict 'refs';
    *{$autoload_name} = sub {
        my ($self) = @_;
        my $depth = 1;
        until (((caller($depth))[3]||q{}) !~ /^\(eval\)$/) { $depth++ }
        my $caller = (caller($depth))[3];
        my $wanted = $NEXT::AUTOLOAD || $autoload_name;
        undef $NEXT::AUTOLOAD;
        my ($caller_class, $caller_method) = do { $caller =~ m{(.*)::(.*)}g };
        my ($wanted_class, $wanted_method) = do { $wanted =~ m{(.*)::(.*)}g };
        croak "Can't call $wanted from $caller"
            unless $caller_method eq $wanted_method;

        my $key = ref $self && overload::Overloaded($self)
            ? overload::StrVal($self) : $self;

        local ($NEXT::NEXT{$key,$wanted_method}, $NEXT::SEEN) =
            ($NEXT::NEXT{$key,$wanted_method}, $NEXT::SEEN);

        unless ($NEXT::NEXT{$key,$wanted_method}) {
            my @forebears =
                NEXT::ELSEWHERE::ancestors ref $self || $self,
                            $wanted_class;
            while (@forebears) {
                last if shift @forebears eq $caller_class
            }
            no strict 'refs';
            @{$NEXT::NEXT{$key,$wanted_method}} =
                map {
                    my $stash = \%{"${_}::"};
                    ($stash->{$caller_method} && (*{$stash->{$caller_method}}{CODE}))
                        ? *{$stash->{$caller_method}}{CODE}
                        : () } @forebears
                    unless $wanted_method eq 'AUTOLOAD';
            @{$NEXT::NEXT{$key,$wanted_method}} =
                map {
                    my $stash = \%{"${_}::"};
                    ($stash->{AUTOLOAD} && (*{$stash->{AUTOLOAD}}{CODE}))
                        ? "${_}::AUTOLOAD"
                        : () } @forebears
                    unless @{$NEXT::NEXT{$key,$wanted_method}||[]};
            $NEXT::SEEN->{$key,*{$caller}{CODE}}++;
        }
        my $call_method = shift @{$NEXT::NEXT{$key,$wanted_method}};
        while (do { $wanted_class =~ /^NEXT\b.*\b(UNSEEN|DISTINCT)\b/ }
            && defined $call_method
            && $NEXT::SEEN->{$key,$call_method}++) {
            $call_method = shift @{$NEXT::NEXT{$key,$wanted_method}};
        }
        unless (defined $call_method) {
            return unless do { $wanted_class =~ /^NEXT:.*:ACTUAL/ };
            (local $Carp::CarpLevel)++;
            croak qq(Can't locate object method "$wanted_method" ),
                qq(via package "$caller_class");
        };
        return $self->$call_method(@_[1..$#_]) if ref $call_method eq 'CODE';
        no strict 'refs';
        do { ($wanted_method=${$caller_class."::AUTOLOAD"}) =~ s/.*::// }
            if $wanted_method eq 'AUTOLOAD';
        $$call_method = $caller_class."::NEXT::".$wanted_method;
        return $call_method->(@_);
    };
}

no strict 'vars';
package NEXT;                                  NEXT::ELSEWHERE::buildAUTOLOAD();
package NEXT::UNSEEN;		@ISA = 'NEXT';     NEXT::ELSEWHERE::buildAUTOLOAD();
package NEXT::DISTINCT;		@ISA = 'NEXT';     NEXT::ELSEWHERE::buildAUTOLOAD();
package NEXT::ACTUAL;		@ISA = 'NEXT';     NEXT::ELSEWHERE::buildAUTOLOAD();
package NEXT::ACTUAL::UNSEEN;	@ISA = 'NEXT'; NEXT::ELSEWHERE::buildAUTOLOAD();
package NEXT::ACTUAL::DISTINCT;	@ISA = 'NEXT'; NEXT::ELSEWHERE::buildAUTOLOAD();
package NEXT::UNSEEN::ACTUAL;	@ISA = 'NEXT'; NEXT::ELSEWHERE::buildAUTOLOAD();
package NEXT::DISTINCT::ACTUAL;	@ISA = 'NEXT'; NEXT::ELSEWHERE::buildAUTOLOAD();

package
    EVERY;

sub EVERY::ELSEWHERE::buildAUTOLOAD {
    my $autoload_name = caller() . '::AUTOLOAD';

    no strict 'refs';
    *{$autoload_name} = sub {
        my ($self) = @_;
        my $depth = 1;
        until (((caller($depth))[3]||q{}) !~ /^\(eval\)$/) { $depth++ }
        my $caller = (caller($depth))[3];
        my $wanted = $EVERY::AUTOLOAD || $autoload_name;
        undef $EVERY::AUTOLOAD;
        my ($wanted_class, $wanted_method) = do { $wanted =~ m{(.*)::(.*)}g };

        my $key = ref($self) && overload::Overloaded($self)
            ? overload::StrVal($self) : $self;

        local $NEXT::ALREADY_IN_EVERY{$key,$wanted_method} =
            $NEXT::ALREADY_IN_EVERY{$key,$wanted_method};

        return if $NEXT::ALREADY_IN_EVERY{$key,$wanted_method}++;

        my @forebears = NEXT::ELSEWHERE::ordered_ancestors ref $self || $self,
                                        $wanted_class;
        @forebears = reverse @forebears if do { $wanted_class =~ /\bLAST\b/ };
        no strict 'refs';
        my %seen;
        my @every = map { my $sub = "${_}::$wanted_method";
                    !*{$sub}{CODE} || $seen{$sub}++ ? () : $sub
                    } @forebears
                    unless $wanted_method eq 'AUTOLOAD';

        my $want = wantarray;
        if (@every) {
            if ($want) {
                return map {($_, [$self->$_(@_[1..$#_])])} @every;
            }
            elsif (defined $want) {
                return { map {($_, scalar($self->$_(@_[1..$#_])))}
                        @every
                    };
            }
            else {
                $self->$_(@_[1..$#_]) for @every;
                return;
            }
        }

        @every = map { my $sub = "${_}::AUTOLOAD";
                !*{$sub}{CODE} || $seen{$sub}++ ? () : "${_}::AUTOLOAD"
                } @forebears;
        if ($want) {
            return map { $$_ = ref($self)."::EVERY::".$wanted_method;
                    ($_, [$self->$_(@_[1..$#_])]);
                } @every;
        }
        elsif (defined $want) {
            return { map { $$_ = ref($self)."::EVERY::".$wanted_method;
                    ($_, scalar($self->$_(@_[1..$#_])))
                    } @every
                };
        }
        else {
            for (@every) {
                $$_ = ref($self)."::EVERY::".$wanted_method;
                $self->$_(@_[1..$#_]);
            }
            return;
        }
    };
}

package EVERY::LAST;   @ISA = 'EVERY';   EVERY::ELSEWHERE::buildAUTOLOAD();
package
    EVERY;             @ISA = 'NEXT';    EVERY::ELSEWHERE::buildAUTOLOAD();

1;

__END__

=head1 NAME

NEXT - Provide a pseudo-class NEXT (et al) that allows method redispatch

=head1 SYNOPSIS

    use NEXT;

    package P;
    sub P::method   { print "$_[0]: P method\n";   $_[0]->NEXT::method() }
    sub P::DESTROY  { print "$_[0]: P dtor\n";     $_[0]->NEXT::DESTROY() }

    package Q;
    use base qw( P );
    sub Q::AUTOLOAD { print "$_[0]: Q AUTOLOAD\n"; $_[0]->NEXT::AUTOLOAD() }
    sub Q::DESTROY  { print "$_[0]: Q dtor\n";     $_[0]->NEXT::DESTROY() }

    package R;
    sub R::method   { print "$_[0]: R method\n";   $_[0]->NEXT::method() }
    sub R::AUTOLOAD { print "$_[0]: R AUTOLOAD\n"; $_[0]->NEXT::AUTOLOAD() }
    sub R::DESTROY  { print "$_[0]: R dtor\n";     $_[0]->NEXT::DESTROY() }

    package S;
    use base qw( Q R );
    sub S::method   { print "$_[0]: S method\n";   $_[0]->NEXT::method() }
    sub S::AUTOLOAD { print "$_[0]: S AUTOLOAD\n"; $_[0]->NEXT::AUTOLOAD() }
    sub S::DESTROY  { print "$_[0]: S dtor\n";     $_[0]->NEXT::DESTROY() }

    package main;

    my $obj = bless {}, "S";

    $obj->method();		# Calls S::method, P::method, R::method
    $obj->missing_method(); # Calls S::AUTOLOAD, Q::AUTOLOAD, R::AUTOLOAD

    # Clean-up calls S::DESTROY, Q::DESTROY, P::DESTROY, R::DESTROY



=head1 DESCRIPTION

The C<NEXT> module adds a pseudoclass named C<NEXT> to any program
that uses it. If a method C<m> calls C<$self-E<gt>NEXT::m()>, the call to
C<m> is redispatched as if the calling method had not originally been found.

B<Note:> before using this module,
you should look at L<next::method|https://metacpan.org/pod/mro#next::method>
in the core L<mro> module.
C<mro> has been a core module since Perl 5.9.5.

In other words, a call to C<$self-E<gt>NEXT::m()> resumes the depth-first,
left-to-right search of C<$self>'s class hierarchy that resulted in the
original call to C<m>.

Note that this is not the same thing as C<$self-E<gt>SUPER::m()>, which
begins a new dispatch that is restricted to searching the ancestors
of the current class. C<$self-E<gt>NEXT::m()> can backtrack
past the current class -- to look for a suitable method in other
ancestors of C<$self> -- whereas C<$self-E<gt>SUPER::m()> cannot.

A typical use would be in the destructors of a class hierarchy,
as illustrated in the SYNOPSIS above. Each class in the hierarchy
has a DESTROY method that performs some class-specific action
and then redispatches the call up the hierarchy. As a result,
when an object of class S is destroyed, the destructors of I<all>
its parent classes are called (in depth-first, left-to-right order).

Another typical use of redispatch would be in C<AUTOLOAD>'ed methods.
If such a method determined that it was not able to handle a
particular call, it might choose to redispatch that call, in the
hope that some other C<AUTOLOAD> (above it, or to its left) might
do better.

By default, if a redispatch attempt fails to find another method
elsewhere in the objects class hierarchy, it quietly gives up and does
nothing (but see L<"Enforcing redispatch">). This gracious acquiescence
is also unlike the (generally annoying) behaviour of C<SUPER>, which
throws an exception if it cannot redispatch.

Note that it is a fatal error for any method (including C<AUTOLOAD>)
to attempt to redispatch any method that does not have the
same name. For example:

        sub S::oops { print "oops!\n"; $_[0]->NEXT::other_method() }


=head2 Enforcing redispatch

It is possible to make C<NEXT> redispatch more demandingly (i.e. like
C<SUPER> does), so that the redispatch throws an exception if it cannot
find a "next" method to call.

To do this, simple invoke the redispatch as:

	$self->NEXT::ACTUAL::method();

rather than:

	$self->NEXT::method();

The C<ACTUAL> tells C<NEXT> that there must actually be a next method to call,
or it should throw an exception.

C<NEXT::ACTUAL> is most commonly used in C<AUTOLOAD> methods, as a means to
decline an C<AUTOLOAD> request, but preserve the normal exception-on-failure 
semantics:

	sub AUTOLOAD {
		if ($AUTOLOAD =~ /foo|bar/) {
			# handle here
		}
		else {  # try elsewhere
			shift()->NEXT::ACTUAL::AUTOLOAD(@_);
		}
	}

By using C<NEXT::ACTUAL>, if there is no other C<AUTOLOAD> to handle the
method call, an exception will be thrown (as usually happens in the absence of
a suitable C<AUTOLOAD>).


=head2 Avoiding repetitions

If C<NEXT> redispatching is used in the methods of a "diamond" class hierarchy:

	#     A   B
	#    / \ /
	#   C   D
	#    \ /
	#     E

	use NEXT;

	package A;                 
	sub foo { print "called A::foo\n"; shift->NEXT::foo() }

	package B;                 
	sub foo { print "called B::foo\n"; shift->NEXT::foo() }

	package C; @ISA = qw( A );
	sub foo { print "called C::foo\n"; shift->NEXT::foo() }

	package D; @ISA = qw(A B);
	sub foo { print "called D::foo\n"; shift->NEXT::foo() }

	package E; @ISA = qw(C D);
	sub foo { print "called E::foo\n"; shift->NEXT::foo() }

	E->foo();

then derived classes may (re-)inherit base-class methods through two or
more distinct paths (e.g. in the way C<E> inherits C<A::foo> twice --
through C<C> and C<D>). In such cases, a sequence of C<NEXT> redispatches
will invoke the multiply inherited method as many times as it is
inherited. For example, the above code prints:

        called E::foo
        called C::foo
        called A::foo
        called D::foo
        called A::foo
        called B::foo

(i.e. C<A::foo> is called twice).

In some cases this I<may> be the desired effect within a diamond hierarchy,
but in others (e.g. for destructors) it may be more appropriate to 
call each method only once during a sequence of redispatches.

To cover such cases, you can redispatch methods via:

        $self->NEXT::DISTINCT::method();

rather than:

        $self->NEXT::method();

This causes the redispatcher to only visit each distinct C<method> method
once. That is, to skip any classes in the hierarchy that it has
already visited during redispatch. So, for example, if the
previous example were rewritten:

        package A;                 
        sub foo { print "called A::foo\n"; shift->NEXT::DISTINCT::foo() }

        package B;                 
        sub foo { print "called B::foo\n"; shift->NEXT::DISTINCT::foo() }

        package C; @ISA = qw( A );
        sub foo { print "called C::foo\n"; shift->NEXT::DISTINCT::foo() }

        package D; @ISA = qw(A B);
        sub foo { print "called D::foo\n"; shift->NEXT::DISTINCT::foo() }

        package E; @ISA = qw(C D);
        sub foo { print "called E::foo\n"; shift->NEXT::DISTINCT::foo() }

        E->foo();

then it would print:

        called E::foo
        called C::foo
        called A::foo
        called D::foo
        called B::foo

and omit the second call to C<A::foo> (since it would not be distinct
from the first call to C<A::foo>).

Note that you can also use:

        $self->NEXT::DISTINCT::ACTUAL::method();

or:

        $self->NEXT::ACTUAL::DISTINCT::method();

to get both unique invocation I<and> exception-on-failure.

Note that, for historical compatibility, you can also use
C<NEXT::UNSEEN> instead of C<NEXT::DISTINCT>.


=head2 Invoking all versions of a method with a single call

Yet another pseudo-class that C<NEXT> provides is C<EVERY>.
Its behaviour is considerably simpler than that of the C<NEXT> family.
A call to:

	$obj->EVERY::foo();

calls I<every> method named C<foo> that the object in C<$obj> has inherited.
That is:

	use NEXT;

	package A; @ISA = qw(B D X);
	sub foo { print "A::foo " }

	package B; @ISA = qw(D X);
	sub foo { print "B::foo " }

	package X; @ISA = qw(D);
	sub foo { print "X::foo " }

	package D;
	sub foo { print "D::foo " }

	package main;

	my $obj = bless {}, 'A';
	$obj->EVERY::foo();        # prints" A::foo B::foo X::foo D::foo

Prefixing a method call with C<EVERY::> causes every method in the
object's hierarchy with that name to be invoked. As the above example
illustrates, they are not called in Perl's usual "left-most-depth-first"
order. Instead, they are called "breadth-first-dependency-wise".

That means that the inheritance tree of the object is traversed breadth-first
and the resulting order of classes is used as the sequence in which methods
are called. However, that sequence is modified by imposing a rule that the
appropriate method of a derived class must be called before the same method of
any ancestral class. That's why, in the above example, C<X::foo> is called
before C<D::foo>, even though C<D> comes before C<X> in C<@B::ISA>.

In general, there's no need to worry about the order of calls. They will be
left-to-right, breadth-first, most-derived-first. This works perfectly for
most inherited methods (including destructors), but is inappropriate for
some kinds of methods (such as constructors, cloners, debuggers, and
initializers) where it's more appropriate that the least-derived methods be
called first (as more-derived methods may rely on the behaviour of their
"ancestors"). In that case, instead of using the C<EVERY> pseudo-class:

	$obj->EVERY::foo();        # prints" A::foo B::foo X::foo D::foo      

you can use the C<EVERY::LAST> pseudo-class:

	$obj->EVERY::LAST::foo();  # prints" D::foo X::foo B::foo A::foo      

which reverses the order of method call.

Whichever version is used, the actual methods are called in the same
context (list, scalar, or void) as the original call via C<EVERY>, and return:

=over

=item *

A hash of array references in list context. Each entry of the hash has the
fully qualified method name as its key and a reference to an array containing
the method's list-context return values as its value.

=item *

A reference to a hash of scalar values in scalar context. Each entry of the hash has the
fully qualified method name as its key and the method's scalar-context return values as its value.

=item *

Nothing in void context (obviously).

=back

=head2 Using C<EVERY> methods

The typical way to use an C<EVERY> call is to wrap it in another base
method, that all classes inherit. For example, to ensure that every
destructor an object inherits is actually called (as opposed to just the
left-most-depth-first-est one):

        package Base;
        sub DESTROY { $_[0]->EVERY::Destroy }

        package Derived1; 
        use base 'Base';
        sub Destroy {...}

        package Derived2; 
        use base 'Base', 'Derived1';
        sub Destroy {...}

et cetera. Every derived class than needs its own clean-up
behaviour simply adds its own C<Destroy> method (I<not> a C<DESTROY> method),
which the call to C<EVERY::LAST::Destroy> in the inherited destructor
then correctly picks up.

Likewise, to create a class hierarchy in which every initializer inherited by
a new object is invoked:

        package Base;
        sub new {
		my ($class, %args) = @_;
		my $obj = bless {}, $class;
		$obj->EVERY::LAST::Init(\%args);
	}

        package Derived1; 
        use base 'Base';
        sub Init {
		my ($argsref) = @_;
		...
	}

        package Derived2; 
        use base 'Base', 'Derived1';
        sub Init {
		my ($argsref) = @_;
		...
	}

et cetera. Every derived class than needs some additional initialization
behaviour simply adds its own C<Init> method (I<not> a C<new> method),
which the call to C<EVERY::LAST::Init> in the inherited constructor
then correctly picks up.

=head1 SEE ALSO

L<mro>
(in particular L<next::method|https://metacpan.org/pod/mro#next::method>),
which has been a core module since Perl 5.9.5.

=head1 AUTHOR

Damian Conway (damian@conway.org)

=head1 BUGS AND IRRITATIONS

Because it's a module, not an integral part of the interpreter, C<NEXT>
has to guess where the surrounding call was found in the method
look-up sequence. In the presence of diamond inheritance patterns
it occasionally guesses wrong.

It's also too slow (despite caching).

Comment, suggestions, and patches welcome.

=head1 COPYRIGHT

 Copyright (c) 2000-2001, Damian Conway. All Rights Reserved.
 This module is free software. It may be used, redistributed
    and/or modified under the same terms as Perl itself.