use strict; 
use warnings;


package Character;

use AutoExecute;

sub new {
   my ($class) = @_;
   return bless({
      poisoned => 0,
   }, $class); 
}

sub poisoned {
   my ($self) = @_;
   return auto_execute {
      my ($poisoned) = @_;
      $self->{poisoned} = $poisoned if @_;
      return $self->{poisoned};
   };
}


package main;

my $char = Character->new();
my $poisoned = $char->poisoned;
print($poisoned, "\n");  # 0
$poisoned->(1);
print($poisoned, "\n");  # 1
$poisoned->(0);
print($poisoned, "\n");  # 0
[download]

AutoExecute.pm: (Could probably use a better name)

package AutoExecute;

BEGIN {
   our @EXPORT = qw( auto_execute );
   *import = \&Exporter::import;
}

use overload
   '""'  => \&stringify,
   '&{}' => \&code_ref,
;

sub auto_execute(&) {
   my ($sub) = @_;
   return bless(\$sub); 
}

sub new {
   my ($class, $sub) = @_;
   return bless(\$sub, $class); 
}

sub stringify {
   my ($self) = @_;
   my $sub = $$self;
   return $sub->();
}

sub code_ref {
   my ($self) = @_;
   my $sub = $$self;
   return $sub;
}

1;
[download]

But all of the above would be much faster and just as neat if written as follows:

use strict; 
use warnings;


package Character;

sub new {
   my ($class) = @_;
   return bless({
      poisoned => 0,
   }, $class); 
}

sub poisoned {
   my ($self, $poisoned) = @_;
   $self->{poisoned} = $poisoned if @_ >= 2;
   return $self->{poisoned};
}


package main;

my $char = Character->new();
print($char->poisoned, "\n");  # 0
$char->poisoned(1);
print($char->poisoned, "\n");  # 1
$char->poisoned(0);
print($char->poisoned, "\n");  # 0
[download]

There's no need to put your @EXPORT and *import assignment in a BEGIN block. File-level code in modules is run just after it's been compiled. It's where the required "true" value comes from. That is, if Character uses AutoExecute, the work required to set up Exporter has already completed by the time AutoExecute->import() is run. You only need to use a BEGIN block if other code in the same module cares that your snippet runs before later code in the same file is compiled.

⠤⠤ ⠙⠊⠕⠞⠁⠇⠑⠧⠊

There's no need to put your @EXPORT and *import assignment in a BEGIN block.

Oh I realize that. If you read Re: Undefined subroutine errors and Re^3: Undefined subroutine errors, you'll see that not only do I understand execution order quite well, I placed those statements in BEGIN block for a reason: that pattern allows two modules to include each other. Obviously, that's not required here, but I don't see any reason why I shouldn't use the pattern here.

By the way, I also explain execution order in Re: BEGIN and END blocks, use strict and scoping.

++ for the stringify use.

I've not used the overload module before, and that was a nice introduction.

It almost makes me feel Java-esque to realise I can have a toString routine in my objects!

Steve
--

If you don't know if it's a sub, how do you know it takes arguments? This seems exactly why the method syntax is useful.

More convoluted - arrange to pass arguments to everything. Have some wrapper or go-between sub check that the target is a sub or not, and invoke it with arguments if it is.

Last time I checked, ref indicates this for you:

my $x = sub {print "Hello\n"}
print ref($x), "\n";
__OUTPUT__
CODE
[download]

If I make a tie interface to return the return value of the code ref, then I lose the ability to pass in parameters.

#! perl
use strict;
use warnings;

package Doohickey;
require Tie::Scalar;
our @ISA = 'Tie::StdScalar';

# returns the value you presumably want to print.
sub FETCH {
  "Hi\n";
}

# This actually prints a value, and then if you use the assignment,
# the FETCH is called that returns a value
sub STORE {
  my ($this, $val) = @_;
  print "I see arguments ($val)\n";
}

package main;

my $enemy;

tie $enemy->{strength}, 'Doohickey';

printf "%s\n", $enemy->{strength} = 5; # you could "pass" a ref to an 
+argument list, too
print "...\n";
print $enemy->{strength}, "\n";
[download]