Didn’t you know that you can’t do that!

Here’s an example of something I tried the other day and was surprised to find didn’t work:

{
    package Baz;
    use Moose;
    
    sub a  { 'A'  }
    sub aa { 'AA' }
}

my $baz = Baz->new;
my @methods = qw/a aa/;

# OK just to show u that I can call method with normal $a variable
my $a = $methods[0];
say $baz->$a;    # 'a'

# but when I use an array variable instead it wont compile
say $baz->$methods[1];    #! syntax error .... near "$methods["

Bit surprising that? The same also happens for a hash variable.

I assume there is a very good reason why the perl parser won’t compile this.

If you want to avoid having to copy into scalar beforehand (as in $a in above) then one (perhaps only?) solution is:

say $baz->${ \$methods[1] };    # 'AA'

/I3az/

PS. Only thing I could find on this was this Perlmonks post:

• calling methods using array variables (Perlmonks)

event = Event "Festival" do
  date '2008-04-01'
  place "The muddy field"
  place "Beer tent" do
    event "Drinking"
  end
end

Looks good hey. But it got even more interesting when I saw how the class is defined…

require 'rubygems'
require 'date'
require 'pp'
require 'doodle'

class Location  String
  has :events, :init => [], :collect => :Event
end

class Event
  # or if you want to inherit from another class
  include Doodle::Helper
  include Doodle::Factory

  has :name, :kind => String
  has :date do
    kind Date
    default { Date.today }
    must 'be >= today' do |value|
      value >= Date.today
    end
    from String do |s|
      Date.parse(s)
    end
  end
  has :locations, :init => [], :collect => {:place => "Location"}
end

This looks a lot like Moose… a Perl Object system.

Anyway been meaning to get into Moose for ages now and so far only used it to subclass an old library I had.
So as a good way of getting me feet dirty I went ahead and done the above Doodle stuff in Moose….

my $event = Event->new( 
    name  => 'Festival',
    date  => '2008-04-01', 
    locations => [ 
      { place=>'The muddy field' }, 
      { place=>'Beer Tent',events=>['Drinking'] } 
    ],
);

I’m not sure if the Doodle example is a bit contrived but I decided to replicate how the objects worked in exactly same way. However I slightly amended the contructor because it was i) simpler to do this way in Perl! & ii) Probably more accurate as an interface spec!! (changes are… locations & events are clearly defined as a list of things).

package Location;
use Moose;

has 'name'  => ( is => 'rw', isa => 'Str' );
has 'event' => ( is => 'rw', isa => 'ArrayRef[Object]');


package Event;
use Moose;
use Moose::Util::TypeConstraints;
require DateTime;

subtype 'DateTime'
    => as 'Object'
    => where { $_->isa( 'DateTime' ) };

subtype 'EventDate'
    => as 'DateTime'
    => where { $_ >= DateTime->now }
    => message { 'date must be >= today' };

subtype 'Places'
    => as 'ArrayRef[Object]';
            
coerce 'EventDate'
    => from 'Str'
    => via { 
        # below should be DateManip (some strange formatting bug in syntaxhighlighter!)
        require DateTime::Format::dateManip;
        DateTime::Format::dateManip->parse_datetime( $_ );
    };

coerce 'Places'
    => from 'ArrayRef[HashRef]'
    => via {
        my $array_ref = [];
        
        # Go thru all locations in Places
        for my $location ( @{ $_ } ) {
            # events assigned to this location
            my $events_ref = [];
            @$events_ref = map { Event->new( name => $_ )  } @{ $location->{events} }
                 if exists $location->{events};
                    
            push @$array_ref, 
                Location->new( name => $location->{place}, event => $events_ref ) }
        
        return $array_ref;
    };
    
has 'name'  => ( is => 'rw', isa => 'Str' );

has 'date'  => (
   is          => 'rw', 
   isa        => 'EventDate', 
   coerce   => 1, 
   default  => sub { DateTime->now } );
                 
has 'locations' => ( 
   is         => 'rw', 
   isa       => 'Places', 
   coerce  => 1 );
                     

And there we go. The Moose example produced twice as many lines! However this isn’t the fault of Moose but mainly because I had to manually format stuff due to issues with the WordPress syntax highlighter with the Perl code ;-(

More in part 2.