Re^2: Moose - my new religion

[tobyink]

Assuming you already use OO, Moose makes a lot of common tasks much easier. Writing object accessors (i.e. getter/setter methods) all the time gets tedious. Moose makes them trivial - and even adds type checking. So if your BankAccount class has a "current_balance" attribute, rather than writing something like this:

sub current_balance {
  my $self = shift;
  if (@_) {
    my $new = shift;
    croak "not a number"
      unless Scalar::Util::looks_like_number($new);
    $self->{current_balance} = $new;
  }
  return $self->{current_balance};
}

You just write this:

has current_balance => (is => 'rw', isa => 'Num');

And as a bonus, you get the same type checking thrown in to your constructor. (And you never need to write sa constructor again!)

It frees you from having to worry about the ins and outs of writing constructors and accessors and so on, allowing you to spend more time focussed on higher level stuff. That's got to be a good thing.

Method modifiers are another great thing. Say you have a class DB which offers methods "select", "insert", "update" and "delete". For debugging you might want to create this class:

package DebuggingDB;
use Moose;
foreach my $method (qw/select insert update delete/)
{
  before $method => sub { warn "$method was called" };
}

That way, whenever one of those methods is called, you see a warning about it. But for this to work, you'd need to go through your code and replace DB->new with DebuggingDB->new everywhere. But we can go better than that...

package DebuggingDB;
use Moose::Role;
foreach my $method (qw/select insert update delete/)
{
  before $method => sub { warn "$method was called" };
}

Now DebuggingDB is not a class, but a role, and we can compose it at run-time:

use Moose::Util qw/apply_all_roles/;
apply_all_roles('DB', 'DebuggingDB') if $ENV{DEBUG};

But maybe we know the connection to the accounts database is working fine, and we only need to debug the connection to marketing...

my $accounts  = DB->new(...);
my $marketing = DB->new(...);

use Moose::Util qw/apply_all_roles/;
apply_all_roles($marketing, 'DebuggingDB') if $ENV{DEBUG};

The ability to apply roles not just to classes, but to objects at run-time, is very powerful. This is something you can do without Moose, certainly, but Moose makes it a lot easier.

Lastly, it gives you some very powerful introspection: much more so than Perl's default OO introspection (isa, can and DOES).

Yes, Moose does have a performance hit. However, much of that is compile-time rather than run-time. So if you have a long-running process, such as a daemon, this is usually quite acceptable. (Whereas in a CGI script, where start-up time is important, Moose would probably be impractical.)

Moose isn't right for every project, but if you're doing OO, if start-up time isn't so important, and you don't care about adding some pretty heavy dependencies to your project, then it's a natural choice.

[cavac]

I value your input. Thanks!

Update: Seems like this reply is getting the odd negative vote. I agree that this post may not be to the likings of everybody. And you're in your rights to give me negative votes. But i'll ask you to add a comment explaining what you didn't like about it so i can use it as a learning experience.

My programs usually have very few traditional getter/setter constructs. These days, i mostly work with multiple processes (prefork stuff), so i do more or less all data exchange though DBI or Memcached (depending on if the data needs to be valid all the time or is just for debugging or non-critical single user settings).

If i need to add multiple similar functions (in this case specifying a modular plugin API) i do something like this:

Read more... (8 kB)

Update 2: Added readmore tags

I don't think i have more than a dozen really classical getter/setters in my 40.000+ lines of Maplat Perl code (OSS + DarkPAN).