comment on

I don't know any reasons why this class can be useful in real life (i.e. production code). I wrote it more for learning perl then for actuall using it. Anyway, as I've mentioned, this technique could be useful for extending Switch or Quantum::Superpositions.

As for the semantics of $o->$m, you are right. It does inherit, and it does accept a stringified glob.

Btw, I think you're playing with fire when you do
for (@$chain) { ... }
[download]
since $chain may change during the loop. I'd feel much safer if you made a local copy of the array.

I disagree here. While the scalar $chain can change, it can point to a different array later, the scalar itself is fetched only once. The important point is that the contents of the array it points to at start doesn't change, and that is true.

Also, it is easy to verify that the implementation is reentrant with a code like this:

#!perl

use warnings;
use strict;

use IO::Handle;


{
package Object::MethodChain;
use overload q[""], "__Set_MethodChain__";
AUTOLOAD {
        my $self = shift;
        my $class = ref($self) || $self;
        my @new = ref($self) ? @$self : ();
        our $AUTOLOAD =~ /.*::(.*)/s or
                die "error: invalid method name";
        push @new, {"method", $1, "args", \@_};
        bless \@new, $class;
}
our $chain;
sub __Set_MethodChain__ {
        $chain = $_[0];
        "Object::MethodChain::__Call_MethodChain__";
}
sub __Call_MethodChain__ {
        my $r = $_[0];
        for my $pair (@$chain) {
                my($method, $args) = @$pair{"method", "args"};
                $r = $r->$method(@$args);
        }
        $r;
}
DESTROY {
}
}


{
package AnObj;
sub new {
        bless [], $_[0];
}
sub foo {
        my $c = Object::MethodChain->print("just ");
        STDOUT->$c;
        $_[0];
}
sub bar {
        $_[1] = "ack";
        OtherObj->new("erl h");
}
}


{
package OtherObj;
sub new {
        bless [$_[1]], $_[0];
}
sub baz {
        print "anot", $_[1], $_[0][0];
        "er,\n";
}
}


{
my $f = "foo";
my $c = Object::MethodChain->new->$f->bar(my $v)->baz("her p");
my $n = AnObj->$c;
print $v, $n;
sub new {
        bless [], $_[0];
}
sub foo {
        my $c = Object::MethodChain->print("just ");
        STDOUT->$c;
        $_[0];
}
sub bar {
        $_[1] = "ack";
        OtherObj->new("erl h");
}
}


{
package OtherObj;
sub new {
        bless [$_[1]], $_[0];
}
sub baz {
        print "anot", $_[1], $_[0][0];
        "er,\n";
}
}


{
my $f = "foo";
my $c = Object::MethodChain->new->$f->bar(my $v)->baz("her p");
my $n = AnObj->$c;
print $v, $n;
}


__END__
[download]

Update: In the simple case, sub { $_[0]->m1(@a1)->m2(@a2) } is of course simpler, but if you want to build a chain of methods without the length of it known in advance, then the sub solution can be more difficult.

In reply to Re^2: Method chain object with easy syntax by ambrus
in thread Method chain object with easy syntax by ambrus

Posts are HTML formatted. Put <p> </p> tags around your paragraphs. Put <code> </code> tags around your code and data!

Titles consisting of a single word are discouraged, and in most cases are disallowed outright.

Read Where should I post X? if you're not absolutely sure you're posting in the right place.

Please read these before you post! —

Posts may use any of the Perl Monks Approved HTML tags:

a, abbr, b, big, blockquote, br, caption, center, col, colgroup, dd, del, details, div, dl, dt, em, font, h1, h2, h3, h4, h5, h6, hr, i, ins, li, ol, p, pre, readmore, small, span, spoiler, strike, strong, sub, summary, sup, table, tbody, td, tfoot, th, thead, tr, tt, u, ul, wbr

You may need to use entities for some characters, as follows. (Exception: Within code tags, you can put the characters literally.)

	For:		Use:
	&		`&`
	<		`<`
	>		`>`
	[		`[`
	]		`]`

Link using PerlMonks shortcuts! What shortcuts can I use for linking?

See Writeup Formatting Tips and other pages linked from there for more info.