I should use a slightly heavier module for creating objects?

IMO: Yes. :-) I usually use Moo. Of course it's also possible to auto-generate the acessor methods yourself, but that starts being too much reinvention of the wheel. Or maybe consider Mo...

Update: Added a missing word.

UPDATE: Added "Extra parameters" feature to callbacks; improved example.

use strict;
use warnings;
{package Object::Tiny;}

{package Foo;
    use parent -norequire ,"Object::Tiny";
    Object::Tiny::->import( qw|bar baz headers myhash|);
}

my $f = Foo::->new(bar=>44, baz=>"Value of baz");
$f->headers_set(["This is H-1","This is H-2"]); # SETTER - sets arrayr
+ef

print "Object f Scalar: $_=> ",$f->$_,";\n" for qw |baz bar   |;
# Get a callback for each member of array ref:
$f->headers_forEach(sub{print "Object f :(Array component) header=$_[0
+];\n"});
$f->baz_forEach(sub{print "Object f : (Scalar accessed as array) baz v
+alue=$_[0];\n"});

$f->myhash_set({Uno=>"One", Dos=>"Two", Tres=>"Three"}); # Setter - se
+ts hashref
# Get a callback for each KEY.
# Extra parameters (R/W) returned are the extra param passed to forEac
+h()
$f->myhash_forEach(sub{print "Object f (HashRef): myhash KEY:$_[0]; VA
+LUE:$_[1]; Extra args($_[2],", ++$_[3],")\n"}, 
                   "Extra-arg1", 25);
[download]

$ perl   test-obj-tiny.pl 
Object f Scalar: baz=> Value of baz;
Object f Scalar: bar=> 44;
Object f :(Array component) header=This is H-1;
Object f :(Array component) header=This is H-2;
Object f : (Scalar accessed as array) baz value=Value of baz;
Object f (HashRef): myhash KEY:Dos; VALUE:Two; Extra args(Extra-arg1,2
+6)
Object f (HashRef): myhash KEY:Tres; VALUE:Three; Extra args(Extra-arg
+1,27)
Object f (HashRef): myhash KEY:Uno; VALUE:One; Extra args(Extra-arg1,2
+8)
[download]

"...by being able to set properties...a slightly heavier module for creating objects?"

You want them on-the-fly? See also Class::Tiny. Regards, Karl

I generally just use the Perl core object system rather than pulling in other packages. For what Object::Tiny gives you, have you considered using the core fields pragma instead?

I have often used an internal _set method like: (disclaimer: this exact code not tested)

sub _set {
    my $self = shift;
    my ($key, $value);
    while (($key, $value) = splice @_, 0, 2) { $self->{$key} = $value 
+}
}
[download]

sub _set {
    my $self = shift;
    my ($key, $value);
    while (($key, $value) = splice @_, 0, 2) { $self->{$key} = $value 
+}
}
[download]

For this, why not just:

c:\@Work\Perl\monks>perl -wMstrict -MData::Dump -le
"sub _set {
   my $self = shift;
   %$self = (%$self, @_);
   }
 ;;
 my $hr = bless { qw(y 25  z 26) };
 ;;
 $hr->_set(qw(a 1  b 2  c 3));
 dd $hr;
"
bless({ a => 1, b => 2, c => 3, "y" => 25, z => 26 }, "main")
[download]

---

Give a man a fish:  <%-{-{-{-<

Because I had not thought of that? :-) It figures that there would be a more compact way to do that.

Although if I had objects being mutated in an inner loop, I would want to compare both ways, in case changing a few keys is faster than setting the whole hash.

Hi, I'd say it's too "lightweight" if you have to start hacking it :-)

I second haukex and recommend Moo for all OOP work, even for one-liners.

$ perl -wE 'package Foo { use Moo; has bar => (is => "rw", isa => sub 
+{ die "invalid" unless shift =~ /^[a-z]+$/ }) }; my $o = Foo->new(bar
+ => "baz"); $o->bar("qux"); say $o->bar; $o->bar(42)'
qux
isa check for "bar" failed: invalid at -e line 1.
[download]

Hope this helps!