The usual way to generate automatic accessors in perl is with sub AUTOLOAD {...}. The Camel (3ed.) gives an example starting on p. 337. That is immediately followed by an example of generating them by name with closures, instead.

After Compline,
Zaxo

Handy hint to anyone looking at Camel pg. 337: check the errata! Two of the variables are switched, making for some interesting bugs.

You could do something like this with Class::MakeMethods easily enough:

package MyObject;
use Class::MakeMethods::Autoload { 
    'new'     => 'Template::Hash::new', 
    '.*'      => 'Template::Hash::scalar -self_closure',
};

package main;
my $object = MyObject->new();
my $new_func = $object->attrib();
$new_func->('value');
[download]

The Class::MakeMethods::Autoload statement says that we want to generate a constructor for "new", and for any other method name we want to construct a "scalar -self_closure" method.

The "-self_closure" flag informs Class::MakeMethods that you don't want a simple accessor -- you want to return a closure bound the the target object that will act as an accessor.

sub _setter_getter_maker
{
  my($self,$subname) = @_;

  return sub {
    my($val)=@_;
    $self->{$subname} = $val if defined $val;
    return $self->{$subname};
  }
}

my $pretend_object = {};
my $new_func = _setter_getter_maker($pretend_object, 'attrib');

#Now we can set a value for 'attrib' in this object
$new_func->('value');

print $pretend_object->{'attrib'},"\n";
[download]

Slap me around and call me Susan (actually, my name's Jim, but that's another story), but I don't like this. From an OO tandpoint, this makes no sense. Methods are supposed to be attached to the object they're supposed to work upon. With this method, you may create multiple methods that do the same thing, but none of which are accessible directly from the object they work upon. For instance:

# yes, an associative array...but make it objectified
my $pretend_object = bless({},"Pretend::Object");

# enter a block for whatever reason
for (1..10) {
# ok, since we decided to skip on creating methods accessible 
# from the object, let's create our accessor method here
# note: it gets recreated every loop
my $func = _setter_getter_maker($pretend_object,'attrib');
$func->($_);
}
# stupid accessor fell out of scope :-/
my $func = _setter_getter_maker($pretend_object,'attrib');
print $func->();
[download]

You're probably asking yourself, "who would code like that?" Trust me, more people do than you'd expect. Just have a class that generates these accessor methods. Of course, accessor methods are generally considered to be bad design in OO. But anywho, perhaps a module from which these methods are inherited would be more appropriate?

Anonymously yours,
Anonymous Monk

This isn't really the same as Lisp macros. You're doing stuff at runtime. Lisp macros do stuff at compile time. You're using existing syntax to generate a function. Lisp macros make new syntax.

Not that what you're doing is not interesting in its own right. Although (as others have pointed out) there are many other ways of doing similar things, and using the {} style of eval would be more efficient.

You might find the discussion on Macros, LFSPs and LFMs of interest.

The advantage that Lisp macros have over most other non-lisp languages is that they can manipulate the syntax tree as a data structure. This would be like mixing B::Generate into the mix above.

The advantage that Lisp macros have over most other non-lisp languages is that they can manipulate the syntax tree as a data structure.

And that is a hellishly large advantage.

The problem with taking the filter approach in Perl 5 is that multiple filters don't play well together. Since they're based on purely textual substitutions the text that one filter expects can interfere with the expectations of another.

If, however, everybody is dealing with syntax trees this problem disappears... one of the (many) reasons I'm looking forward to Perl6 :-)

The only alternative to this in perl5 is B::Utils and B::Generate and you have to be a wizard to do anything with it. Uck.