I see that overload can overload dereferencing, but only for the ${} @{} %{} &{} *{} forms, and not for the arrow operator.

Further, if you wish to call a method with no name, you'd do it thusly: $method = ''; $o->$method(...).

You have made a bad assumption. overload hooks the entire dereferencing method regardless of the mere syntax you use. If you have overloaded array dereferencing then all of $o->[42], @$o, @{$o}[42], etc are all affected.

May I dare to say D'Oh?!?

Further, if you wish to call a method with no name, you'd do it thusly: $method = ''; $o->$method(...).

Well, that I knew, but of course it's a whole another story.

Thus what I'd want would rather be a set of especially named methods such as

sub AS_ARRAY {
    my $self=shift;
    # do something useful here
}
[download]

$obj->[42];  # would be the same as
$obj->AS_ARRAY(42);  # and so on...
[download]

@$m # entire matrix, your syntax: $m->()
$m->[ 1] # second row, your syntax $m->( 1);
$m->[ 1]->[ 0] # individual element, your syntax $m->( 1, 0);
[download]

Later you say:

...which is based, obviously, on blessed subrefs and also takes an Inside-Out approach: the object does contain something, namely a reference to itself, which also builds a closure, but is still used only like an index for property access.

Boo! That spoils most of the inside-out fun. Your objects rely on their body being a coderef, never mind how you access properties. Your class is hybrid to begin with and can't easily accomodate (inheritance-wise) a foereign class.

And it's not necessary either. Subref overloading is powerful enough to make your objects act as if their body were a coderef without it actually being one.

I have re-worked your class to be a true inside-out class without changing its interface or, I believe, its behavior. You may still prefer the more perlish style direct array overloading gives you and rewrite it that way.

Update: Replaced the Matrix code. Essential change: ->init now does a full initialization instead of leaving part of the job to ->new. Inessential: Replaced ->pow with a more efficient implementation. Also added a stringification method

But... that's exactly what arrayref-overloading does. I believe you can base your matrix class entirely on that. You'd access a matrix object $m like this

Yes, yes, yes, diotalevi pointed that out already, I updated the root node, and I'm still D'oh'ing.

The syntax is pure Perl. Your's is more compact and closer to conventional mathematical notation. In fact, I like it and will keep it in mind for future matrix work.

Whoa! Although that was somewhat a minor detail in my post, I'm happy that something good is getting out of it and I feel honoured, and I'm not joking!

It's really all about me being a nut for not having much experience with overload, reading its documentation quickly and making a wrong assumption. Had I read all of it, I would have of course known better.

Boo! That spoils most of the inside-out fun. Your objects rely on their body being a coderef, never mind how you access properties. Your class is hybrid to begin with and can't easily accomodate (inheritance-wise) a foereign class.

No, Anno, why do you say so? My objects IMHO do not rely on being coderefs. The implementation of some methods does, but as an option. One should not care about that and only be concerned about the interface anyway, shouldn't she? Indeed the coderef thingy only provides a shortcut that can, not that must, be used. Granted, sub-deref overloading is a much better means to obtain the same shortcut. (If the shortcut itself is part of the interface as opposed to an implementation detail, I suppose using it in derived classes would be legitimate as well.) Anyway, can't you have a derived class with code such as the following?

Read more... (700 Bytes)

Anyway, can't you have a derived class with code such as the following?

# -*- Perl -*-

use strict;
use warnings;

package Matrix::Named;

use Scalar::Util qw/refaddr/;

use base 'Matrix';

{
    my %name;
[download]

Ha! Yes, that works because you have been careful to implement the name field in inside-out manner. The trouble begins when you want to combine the Matrix class with a foreign (non-inside-out) class.

Say I've picked up your nifty Matrix class from somewhere, and this this lovely Angle class from somewhere else. I want to combine them in a class MyAngle so that matrix operations can be applied to an angle and refer to the corresponding rotational matrix.

Unfortunately, Angle is implemented in the traditional way as a (scalar) ref to the numeric value.

Read more... Angle.pm (885 Bytes)
With a true inside-out implementation of Matrix, this can be easily done like this:

#!/usr/local/bin/perl
use strict; use warnings; $| = 1;
use Vi::QuickFix;

# Definition of MyAngle below

my $alpha = MyAngle->new( rad => atan2( 1, 1));
printf "Angle: %s (%s deg)\n", $alpha->rad, $alpha->deg;  # Angle func
+tions
print "Matrix:\n$alpha\n"; # show the matrix representation

##################################################

package MyAngle;
use lib 'lib';
use base 'Angle';
use base 'Matrix';

sub new {
    my $class = shift;
    $class->Angle::cre->MyAngle::init( @_);
}

sub init {
    my $obj = shift;
    $obj->Angle::init( @_);
    $obj->Matrix::init( cos( $_), -sin( $_), sin( $_), cos( $_)) for
        $obj->rad;
    $obj;
}

__END__
[download]

This relies on the possibility to replace the body of an inside-out object, (normally an undefined scalar) with some foreign object of any provenience, (also a scalar in this case, but with significant content) so that its methods work without a hitch. This approach won't work with a hybrid class where the body is required to be code.

Anno

PS: If you actually want to run the code against the inside-out implementation of Matrix use the updated code from my previous posting. There was a bug in the original that would have been a show-stopper.

use strict;

END { print "END\n" };

{
    package SubRef;
    use Scalar::Util qw(weaken refaddr);

    sub DESTROY { my $self = shift; print "DESTROY ".ref($self) ."\n" 
+}

    sub new {
        my $class = shift;
        my $copy;
        my $self = $copy = bless(sub { $copy->ok }, $class);
        weaken $copy;
        return $self;
    }

    sub ok { print "SubRef ok ".refaddr($_[0])."\n" }
}

{
    package ArrayRef;

    @ArrayRef::ISA = qw(SubRef);

    sub new {
        my $class = shift;
        return bless [], $class;
    }
}

{
    package CircularRef;

    @CircularRef::ISA = qw(SubRef);

    sub new {
        my $class = shift;
        my $s = {};
        $s->{self} = $s;
        return bless $s, $class;
    }
}


for (1..2) {
    my $sub  = SubRef->new;
    my $sub2 = SubRef->new;
    my $arr  = ArrayRef->new;
    my $cir  = CircularRef->new;
    $sub->();
    $sub2->();
}

print "After For\n";
[download]

paul@paul-laptop:~$ perl foo
SubRef ok 135976352
SubRef ok 135976436
DESTROY ArrayRef
DESTROY SubRef
DESTROY SubRef
SubRef ok 135976352
SubRef ok 135976424
DESTROY ArrayRef
DESTROY SubRef
DESTROY SubRef
After For
END
DESTROY CircularRef
DESTROY CircularRef
[download]

       my $self = $copy = bless(sub :lvalue { $copy->ok; my $n }, $cla
+ss);
[download]

I was having issues getting it to work - but then I moved from a one-liner to a program and suddenly the world was fine. I think that the similar action in new would work on your calls also.

Thank you: in view of the other answers the problem is not so much of a problem any more. Yet I was annoyed by not being able to use weaken appropriately, and you gave me an explicit example about how to put it to work. Thinking of your actual example code, anyway, makes me think that while weaken() is a precious tool, perhaps a more direct interface to the ref count of a reference could be desirable. Perhaps a lvalue refcount() function to be used (mostly) like thus:

refcount($ref)--;
[download]

Update - Just to double check I used the following lvalue based subref which worked also.

Well, I wouldn't have expected that to make a difference anyway...