Pugs

CGI::App to Perl 6: Reference handling not needed here

I'm still wrapping my head around what means that references have been replaced with Capture objects in Perl6.

However, I was pleased to see it means this common idiom is no longer necessary. Often I have a variable that may contain a single scalar value or an arrayref of values.

Perl5:

my @new = (ref $old eq 'ARRAY' ) ? @$old : ($old);

But Perl6 Does The Right Thing, Easily

my @new = @$old;

Perl5 would complain if you tried to deference $old as an array when it wasn't an arrayref.

Now I have look through the CGI::Application code and see all the places I can shave off a few bytes with this refactor...

Here's another case in Perl6 where reference handling is not needed, while Perl5 requires it:

# Perl6 will properly assign @a to the 'k' key,
# without using reference notation. 
my @a = ( 1,2 );
my %h = (
    k => @a,
    j => 'm',
);

Improving CGI.pm for Perl 6

This is one of a few Perl 6 posts I'm bringing over from my use.perl journal. I'll eventually post Perl 6 writing directly here.

As I looked in my failing tests for CGI::Application for Perl6, I realized that CGI.pm for Perl6 wasn't as developed as I thought.

It wasn't an OO interface, apparently because it was developed a while ago before that part of pugs was finished. Further, it didn't yet support creating a new object by passing some params to new().

A little bit of hacking later, I fixed and commited both those parts of CGI.pm for Perl6. You  can now do this in Perl6:

  use Test;
  plan 1;

  use CGI;
  my $q = CGI.new( rm => 'cgiapp_rocks' );
  is($q.param('rm'), 'cgiapp_rocks');

In fact, that looks a lot like one of tests I wrote. ;-).

From there I moved on to providing feedback about the documentation spec for Perl6. Damian Conway responded there, and I look forward to reading the updated spec for that should be available soon.

Until then, back to hacking CGI::Application and Perl6...

refactoring CGI::App for Perl6: less syntax is a theme

One of the themes I've noticed moving from Perl5 to Perl6 is that less syntax is required. While I still need to get the tests to pass, CGI::App is now valid Perl6 syntax. Using "sloccount" on both versions, the Perl6 version has about 4% fewer lines in it. (A drop from 1510 lines to 1450).

Considering Perl5 had fairly efficient syntax already, each little simplification is refreshingly welcome!

Here are some things I noticed that have been removed or simplified:

 
• 1; at the end of a file  
• use strict; (on by default)  
• our $VERSION = 1.23 (part of module declaration now).  
• declaring new()is not needed for simple objects. (See The Objects Synopsis)  
• Simple object methods are automatic.  
• my $self = shift; is gone -- my favorite!  
• $self->{_FOO} is just $!foo.  
• my is no longer necessary in a for loop.       Instead the syntax is: for @array -> $i {

I'm sure there are more shortcuts to be discovered.

I'm also starting to refactor Perl5 idioms into more pleasant Perl6 idioms. Here are two snippets, both valid Perl6, but the second takes advantage of two new features: qw// has been replaced with < >, and any() and all() have added to the core, working like Quatum::Superpositions in Perl5, which I've always been superstitious about using in production.

Perl5ish code in Perl6

my %allowed_header_types = (      header   => 1,      redirect => 1,      none     => 1, ); print "Invalid header_type '$header_type'" if (not %allowed_header_types<$header_type>);

Refactored to use Perl6 quoting and any()

my @allowed_header_types =

; print "Invalid header_type '$header_type'" if not $header_type eq any(@allowed_header_types);

My experience with Perl6 thus far has been the sum of a details like this that add up to a more pleasant syntax.

Thanks to TreyHarris and wolverian for post-launch feedback on this post.

refactoring CGI::App for Perl6:'given' as a switch statement

I'm porting CGI::Application to Perl6 as a way to learn about Perl6. I'm going to share some of these "real world" refactors here to demonstrate some Perl6 features.

Before:
We have a a typical Perl5 if/else chain. The dangling "if" and "die" and at the end should have really be part of the chain, but I did say this was real-world code...

 

sub _send_headers {
    my $self = shift;
    my $q = $self->query();

    my $header_type = $self->header_type();

    if ($header_type eq 'redirect') {
        return $q->redirect($self->header_props());
    } elsif ($header_type eq 'header' ) {
        return $q->header($self->header_props());
    }

    # croak() if we have an unknown header type
    croak ("Invalid header_type '$header_type'") unless ($header_type eq "none");

    # Do nothing if header type eq "none".
    return "";
}

After:
Of course, "my $self = shift" is gone, (Wahoo!), but notice now the new 'given' switch statement cleans things up nicely:

 

method _send_headers {
    my $q = self.query;
    given self.header_type {
        when 'redirect' { return $q.redirect(self.header_props)      }
        when 'header'   { return $q.header(self.header_props)        }
        when 'none'     { return ""                                  }
        default         { die "Invalid header_type '$header_type'" }
    }
}

In total: 18 lines reduced to 9, with a clarity gained!