Perl 5.10
for people who are not insane
Perl 5.10
for people who are not totally insane
5.10 isn’t like 5.8.x




                    perl5100delta
5.10 isn’t like 5.8.x


- features only get added in new 5.x releases



                                          perl510...
5.10 isn’t like 5.8.x


- features only get added in new 5.x releases
- it’s been 5 years since the last release (5.8)


 ...
5.10 is Way Cool




                   perl51000delta
5.10 is Way Cool

- no significant new features in Perl since 2002




                                        perl51000de...
5.10 is Way Cool

- no significant new features in Perl since 2002
- remember how bad you wanted to see Star
  Wars: Episo...
5.10 is Way Cool

- no significant new features in Perl since 2002
- remember how bad you wanted to see Star
  Wars: Episo...
5.10 is Way Cool

- no significant new features in Perl since 2002
- remember how bad you wanted to see Star
  Wars: Episo...
Lexicascopasmartwhat?




                  perl51000delta
Lexicascopasmartwhat?

- lexically scoped user pragmata!




                                    perl51000delta
Lexicascopasmartwhat?

- lexically scoped user pragmata!
- pluggable regex compilation engines!



                       ...
Lexicascopasmartwhat?

- lexically scoped user pragmata!
- pluggable regex compilation engines!
- trie-based non-recursive...
Lexicascopasmartwhat?

- lexically scoped user pragmata!
- pluggable regex compilation engines!
- trie-based non-recursive...
Yes, You Care




                perl51000delta
Yes, You Care

- Not everything in 5.10 is esoteric.




                                        perl51000delta
Yes, You Care

- Not everything in 5.10 is esoteric.
- Not everything in 5.10 is for gurus.



                           ...
Yes, You Care

- Not everything in 5.10 is esoteric.
- Not everything in 5.10 is for gurus.
- Not everything in 5.10 is fo...
Yes, You Care

- Not everything in 5.10 is esoteric.
- Not everything in 5.10 is for gurus.
- Not everything in 5.10 is fo...
First: A Warning




                   feature
First: A Warning
- 5.10 is backwards compatible




                                 feature
First: A Warning
- 5.10 is backwards compatible
- but adds new keywords and operators




                                ...
First: A Warning
- 5.10 is backwards compatible
- but adds new keywords and operators
- they’re not enabled by default



...
First: A Warning
- 5.10 is backwards compatible
- but adds new keywords and operators
- they’re not enabled by default
-  ...
First: A Warning
- 5.10 is backwards compatible
- but adds new keywords and operators
- they’re not enabled by default
-  ...
First: A Warning
- 5.10 is backwards compatible
- but adds new keywords and operators
- they’re not enabled by default
-  ...
First: A Warning
- 5.10 is backwards compatible
- but adds new keywords and operators
- they’re not enabled by default
-  ...
First: A Warning
- 5.10 is backwards compatible
- but adds new keywords and operators
- they’re not enabled by default
-  ...
say what
say $what


- new built-in, say
- it’s like print
- but it adds a newline for you

                                  perlf...
say $what




            perlfunc
say $what

print “Hello, world!n”;




                           perlfunc
say $what

print “Hello, world!n”;


print “$messagen”;




                           perlfunc
say $what

print “Hello, world!n”;


print “$messagen”;


print “$_n” for @lines;


                           perlfunc
say $what

print “Hello, world!n”;
say “Hello, world!”;
print “$messagen”;


print “$_n” for @lines;


                   ...
say $what

print “Hello, world!n”;
say “Hello, world!”;
print “$messagen”;
say $message;
print “$_n” for @lines;


       ...
say $what

print “Hello, world!n”;
say “Hello, world!”;
print “$messagen”;
say $message;
print “$_n” for @lines;
say for @...
truth and definedness
truth and definedness




                        perlop
truth and definedness
sub record_sale {




                          perlop
truth and definedness
sub record_sale {
  my ($product, $amount) = @_;




                             perlop
truth and definedness
sub record_sale {
  my ($product, $amount) = @_;

  $amount ||= $product->cost;




                ...
truth and definedness
sub record_sale {
  my ($product, $amount) = @_;

  $amount ||= $product->cost;

  ...



          ...
truth and definedness
sub record_sale {
  my ($product, $amount) = @_;

    $amount ||= $product->cost;

    ...
}


     ...
truth and definedness
sub record_sale {
  my ($product, $amount) = @_;

    $amount = defined $amount
            ? $amoun...
truth and definedness
sub record_sale {
  my ($product, $amount) = @_;

    $amount ||= $product->cost;

    ...
}


     ...
truth and definedness
sub record_sale {
  my ($product, $amount) = @_;

    $amount ||= $product->cost;

    ...
}


     ...
the new OR operator
sub record_sale {
  my ($product, $amount) = @_;

    $amount //= $product->cost;

    ...
}


       ...
the new OR operator


$setting = defined $given
         ? $given
         : $default;




                            per...
the new OR operator

$setting = $given;
unless (defined $setting) {
  $setting = $default;
}




                         ...
the new OR operator


$setting = $given || $default;




                             perlop
the new OR operator


$setting = $given // $default;




                             perlop
keeping state
State Variables
$lines_left = 100;

sub read_line {
  die “trial period expired”
    unless $lines_left-- > 0;
  ...
}


 ...
State Variables
my $lines_left = 100;

sub read_line {
  die “trial period expired”
    unless $lines_left-- > 0;
  ...
}
...
State Variables
{
    my $lines_left = 100;

    sub read_line {
      die “trial period expired”
       unless $lines_lef...
State Variables
package Trial::Period;
sub new {
  my ($class, $arg) = @_;
  my $guts = {
    lines_left => $arg->{lines},...
State Variables
{
    my $lines_left = 100;

    sub read_line {
      die “trial period expired”
       unless $lines_lef...
State Variables

sub read_line {
  state $lines_left = 100;
  die “trial period expired”
    unless $lines_left-- > 0;
  ....
-x stacking
Stackable File Tests
if (
  -f $file
  and -w $file
  and -z $file
) {
  unlink $file;
}


                          perlf...
Stackable File Tests

if (
  -f $file and -w _ and -z _
) {
  unlink $file;
}



                               perlfunc
Stackable File Tests


if (-f -w -z $file) {
  unlink $file;
}




                          perlfunc
smart matching
Smart Matching




                 perlsyn
Smart Matching

- a new kind of comparison operator




                                      perlsyn
Smart Matching

- a new kind of comparison operator
- its behavior depends on its inputs



                              ...
Smart Matching

- a new kind of comparison operator
- its behavior depends on its inputs
- “if these two things match...”
...
Smart Matching

- a new kind of comparison operator
- its behavior depends on its inputs
- “if these two things match...”
...
Smart Matching




                 perlsyn
Smart Matching
if ($foo ~~ undef)   { ... }




                           perlsyn
Smart Matching
   if ($foo ~~ undef) { ... }
elsif ($foo ~~ @array) { ... }




                             perlsyn
Smart Matching
   if ($foo ~~ undef) { ... }
elsif ($foo ~~ @array) { ... }
elsif ($foo ~~ $code) { ... }




            ...
Smart Matching
   if   ($foo   ~~   undef)    {   ...   }
elsif   ($foo   ~~   @array)   {   ...   }
elsif   ($foo   ~~   ...
Smart Matching
   if   ($foo   ~~   undef)    {   ...   }
elsif   ($foo   ~~   @array)   {   ...   }
elsif   ($foo   ~~   ...
Smart Matching
   if   ($foo   ~~   undef)    {   ...   }
elsif   ($foo   ~~   @array)   {   ...   }
elsif   ($foo   ~~   ...
Smart Matching
   if   ($foo   ~~   undef)    {   ...   }
elsif   ($foo   ~~   @array)   {   ...   }
elsif   ($foo   ~~   ...
Smart Matching
given ($foo) {
  when (undef)    {   ...   }
  when (@array)   {   ...   }
  when ($code)    {   ...   }
  ...
Smart Matching
   if   ($foo   ~~   undef)    {   ...   }
elsif   ($foo   ~~   @array)   {   ...   }
elsif   ($foo   ~~   ...
Smart Matching
   if   ($foo   ~~   undef)    {   ...   }
elsif   ($foo   ~~   $array)   {   ...   }
elsif   ($foo   ~~   ...
Smart Matching



my $test;

                 perlsyn
Smart Matching
given ($foo) {
  when (undef)     {   ...   }
  when ($aref)     {   ...   }
  when ($code)     {   ...   }...
Smart Matching
given ($foo) {
  when ($test_1)   {   ...   }
  when ($test_2)   {   ...   }
  when ($test_3)   {   ...   }...
Smart Matching




                 perlsyn
Smart Matching

@want = @have->where($test)




                              perlsyn
Smart Matching

 @want = @have->where($test)

@want = @have->where(sub{ …… })




                               perlsyn
Smart Matching

 @want = @have->where($test)

@want = @have->where(sub{ …… })

@want = @have->where(qr/.../sm)




       ...
Smart Matching

 @want = @have->where($test)

@want = @have->where(sub{ …… })

@want = @have->where(qr/.../sm)

@want = @h...
Smart Matching




                 perlsyn
Smart Matching
sub where {




                           perlsyn
Smart Matching
sub where {
  my ($array, $test) = @_;




                             perlsyn
Smart Matching
sub where {
  my ($array, $test) = @_;

 if (ref $test eq ‘ARRAY’)   {




                                ...
Smart Matching
sub where {
  my ($array, $test) = @_;

 if (ref $test eq ‘ARRAY’) {
   my %known = map {$_=>1} @$test;



...
Smart Matching
sub where {
  my ($array, $test) = @_;

 if (ref $test eq ‘ARRAY’) {
   my %known = map {$_=>1} @$test;
   ...
Smart Matching
sub where {
  my ($array, $test) = @_;

 if (ref $test eq ‘ARRAY’) {
   my %known = map {$_=>1} @$test;
   ...
Smart Matching
sub where {
  my ($array, $test) = @_;

 if (ref $test   eq ‘ARRAY’) {
   my %known =   map {$_=>1} @$test;...
Smart Matching
sub where {
  my ($array, $test) = @_;

 if (ref $test   eq ‘ARRAY’) {
   my %known =   map {$_=>1} @$test;...
Smart Matching
sub where {
  my ($array, $test) = @_;

 if (ref $test   eq ‘ARRAY’) {
   my %known =   map {$_=>1} @$test;...
Smart Matching
sub where {
  my ($array, $test) = @_;

 if (ref $test   eq ‘ARRAY’) {
   my %known =   map {$_=>1} @$test;...
Smart Matching
sub where {
  my ($array, $test) = @_;

 if (ref $test   eq ‘ARRAY’) {
   my %known =   map {$_=>1} @$test;...
Smart Matching
sub where {
  my ($array, $test) = @_;

 if (ref $test   eq ‘ARRAY’) {
   my %known =   map {$_=>1} @$test;...
Smart Matching
sub where {
  my ($array, $test) = @_;

 if (ref $test   eq ‘ARRAY’) {
   my %known =   map {$_=>1} @$test;...
Smart Matching
sub where {
  my ($array, $test) = @_;

    if (ref $test   eq ‘ARRAY’) {
      my %known =   map {$_=>1} @...
Smart Matching


sub where {
  my ($array, $test) = @_;
  grep { $_ ~~ $test } @$array;
}




                            ...
Smart Matching
  SmartMatch::Sugar




                      perlsyn
Smart Matching
      SmartMatch::Sugar

@want = @have->where( hash )




                               perlsyn
Smart Matching
       SmartMatch::Sugar

@want = @have->where( hash )

@want = @have->where( class )




                 ...
Smart Matching
        SmartMatch::Sugar

 @want = @have->where( hash )

 @want = @have->where( class )

@want = @have->wh...
unknown undefined
Better Error Message(s)

$str = “Greetings, $name. Your last
login was $last. It is now $time.”;




                     ...
Better Error Message(s)

$str = “Greetings, $name. Your last
login was $last. It is now $time.”;




Use of uninitialized ...
Better Error Message(s)

$str = “Greetings, $name. Your last
login was $last. It is now $time.”;




Use of uninitialized ...
inside-out objects
Inside-Out Objects




              Hash::Util::FieldHash
Inside-Out Objects
- traditional objects are a hashref




                                      Hash::Util::FieldHash
Inside-Out Objects
- traditional objects are a hashref
  - look up attrs in the obj itself by attr name




              ...
Inside-Out Objects
- traditional objects are a hashref
  - look up attrs in the obj itself by attr name
- inside-out objec...
Inside-Out Objects
- traditional objects are a hashref
  - look up attrs in the obj itself by attr name
- inside-out objec...
Inside-Out Objects
- traditional objects are a hashref
  - look up attrs in the obj itself by attr name
- inside-out objec...
Inside-Out Objects
sub size {
  my $self = shift;

    if (@_) {
      return $self->{size} = shift;
    } else {
      re...
Inside-Out Objects
my %size;
sub size {
  my $self = shift;

    if (@_) {
      return $size{ $self } = shift;
    } else...
Inside-Out Objects
my %size;
sub size {
  my $self = shift;
  my $id   = refaddr $self;

    if (@_) {
      return $size{...
Inside-Out Objects
my %size;
sub size {
  my $self = shift;
  my $id   = refaddr $self;

    if (@_) {
      return $size{...
Inside-Out Objects
my %size;                            sub CLONE {
sub size {                             my $class = shi...
Inside-Out Objects
my %OBJECT_REGISTRY;                   sub CLONE {
my %size;                                my $class =...
Field Hashes




           Hash::Util::FieldHash
Field Hashes

- they’re just like hashes




                             Hash::Util::FieldHash
Field Hashes

- they’re just like hashes
- objects as keys become object ids



                                  Hash::Ut...
Field Hashes

- they’re just like hashes
- objects as keys become object ids
- but get destroyed and cloned

             ...
Field Hashes
my %size;
sub size {
  my $self = shift;

    if (@_) {
      return $size{ $self } = shift;
    } else {
   ...
Field Hashes
fieldhash my %size;
sub size {
  my $self = shift;

    if (@_) {
      return $size{ $self } = shift;
    } ...
Field Hashes
{
    fieldhash my %size;
    sub size {
      my $self = shift;
      if (@_) {
        return $size{ $self ...
Field Hashes
sub size {
  my $self = shift;
  fieldhash state %size;

    if (@_) {
      return $size{ $self } = shift;
 ...
lexical topic
(topic is how you say $_)
Lexical Topic
for (@lines) {
  chomp;
  next if /^#/;
  next unless length;
  s/a/b/;
  sanity_check;
  say;
}

          ...
Lexical Topic
for my $line (@lines) {
  chomp $line;
  next if $line ~~ /^#/;
  next unless length $line;
  $line =~ s/a/b...
Lexical Topic
for my $_ (@lines) {
  chomp;
  next if /^#/;
  next unless length;
  s/a/b/;
  sanity_check;
  say;
}

    ...
Regex
named captures
Regex: Named Captures




                        perlre
Regex: Named Captures

- find matches by name, not position




                                       perlre
Regex: Named Captures

- find matches by name, not position
- avoid the dreaded$1




                                    ...
Regex: Named Captures

- find matches by name, not position
- avoid the dreaded $1


- no longer second to Python or .Net!...
Regex: Named Captures


# our hypothetical format

section:property = value




                            perlre
Regex: Named Captures

$line ~~ /(w+):(w+) = (w+)/;

$name = $2;
$value = $3;




                                  perlre
Regex: Named Captures

$lhs_re = qr/(w+):(w+)/;
$rhs_re = qr/(w+)/;

$line ~~ /$lhs_re = $rhs_re/;

$name = $2;
$value = $...
Regex: Named Captures

$line ~~ /$lhs_re = $rhs_re/;

$name = $2;
$value = $3;




                                perlre
Regex: Named Captures

$line ~~ /$lhs_re = $rhs_re/;

$name = $+{ name };
$value = $+{ value };




                      ...
Regex: Named Captures


$lhs_re = qr/(w+):(w+)/;
$rhs_re = qr/(w+)/;




                             perlre
Regex: Named Captures


$lhs_re = qr/(w+):(?<name>w+)/;
$rhs_re = qr/(?<value>w+)/;




                                  ...
better backrefs
Regex: Backreference


 m{< (w+) > .+ < /1 > }x




                             perlre
Regex: Backreference


 m{< (w+) > .+ < /1 > }x




                             perlre
Regex: Backreference



      10
                       perlre
Regex: Backreference


  qr{(d)10}


                       perlre
Regex: Backreference


qr{ (d) 1 0}x


                       perlre
Regex: Backreference


 m{< (w+) > .+ < /1 > }x




                             perlre
Regex: Backreference


m{< (w+) > .+ < /g{1} > }x




                               perlre
Regex: Backreference



      10
                       perlre
Regex: Backreference



   g{10}
                       perlre
Regex: Backreference


  qr{(d)10}


                       perlre
Regex: Backreference


qr{(d)g{1}0}


                       perlre
Regex: Backreference


qr{(d)g{-1}0}


                       perlre
Regex: Backreference
qr{
   (?<digit>d)
   g{digit}
   0
}x
                       perlre
Regex: Exit Strategy
my $wtf_re = qr{
xffn015()]*(?:[^x80-xff][^x80-xffn015()]*)*))[^x80-xf
fn015()]*)*)[040t]*)*(?:(?:[^(...
Regex: Backreference


if ($str =~ $wtf_re) {
  ...
}



                       perlop
Regex: Backreference


if ($str ~~ $wtf_re) {
  ...
}



                       perlop
lexically scoped alternate
trie-based reentrant user-
 defined regex pragmata
flexible regex
Alternate Regex Engines




                      perlreapi
Alternate Regex Engines


- lets you change how regex work



                                   perlreapi
Alternate Regex Engines


- lets you change how regex work
- but not how you use them ( ,
                            =~ s...
Alternate Regex Engines




                  re::engine::POSIX
Alternate Regex Engines


egrep -r -l PATTERN DIR




                          re::engine::POSIX
Alternate Regex Engines

my $regex = qr{ ... };

my @files = $find->file->in( $root );

say for grep { slurp ~~ $re } @fil...
Alternate Regex Engines




                  re::engine::POSIX
Alternate Regex Engines


egrep -r -l ‘.+?’ DIR




                        re::engine::POSIX
Alternate Regex Engines

my $regex = qr{ ... };

my @files = $find->file->in( $root );

say for grep { slurp ~~ $re } @fil...
Alternate Regex Engines

use re::engine::POSIX;

my $regex = qr{ ... };

my @files = $find->file->in( $root );

say for gr...
Alternate Regex Engines

use re::engine::POSIX;

my $regex = qr{ ... }x;

my @files = $find->file->in( $root );

say for g...
http://www.perl.org/get.html
Any questions?
Upcoming SlideShare
Loading in...5
×

Perl 5.10 for People Who Aren't Totally Insane

84,607

Published on

All the hype about perl 5.10 can sound a little intimidating. User-level pragmata! Overloadable smartmatching operator! Thread-safe refkey hashes! For Pete's sake, have you heard about lexically scoped pluggable regexp engines?

It's enough to make you think that 5.10's changes are just for the hard-core perl hackers, but it couldn't be further from the truth! The new version of Perl is full of changes that are easy to use and pack lots of useful benefits for doing plain old every day Perl programming.

We'll look at the new features, small and large, and see why you, too, will love 5.10.

Published in: Business, Technology
12 Comments
39 Likes
Statistics
Notes
  • Must see for camel riders
       Reply 
    Are you sure you want to  Yes  No
    Your message goes here
  • I have learned a couple of things from your presentation. Nicely done!

    http://www.riding-mower.org/

    http://www.riding-mower.org/la105-john-deere-lawn-tractor/
       Reply 
    Are you sure you want to  Yes  No
    Your message goes here
  • The slides showing how awful it can be to have to manage your own inside-out objects are not intended to be a robust explanation of how to force yourself to suffer through it, but an overview of the various levels of annoyance that heap up without fieldhashes.<br /><br/>
       Reply 
    Are you sure you want to  Yes  No
    Your message goes here
  • Errata: (?)

    Slide 88:
    =======
    Unless you meant to leave $id as an unused variable to resolve in later slides, I'd suggest this change....

    s( $site{$self} )
    ( $site{$id} )gx

    Slide 89:
    =======
    Ditto

    Also, make these changes
    $new should be $new_id
    $old should be $old_id<br /><br/>
       Reply 
    Are you sure you want to  Yes  No
    Your message goes here
  • Perl 5.10 has been released!
    http://search.cpan.org/~rgarcia/perl-5.10.0/<br /><br/>
       Reply 
    Are you sure you want to  Yes  No
    Your message goes here
No Downloads
Views
Total Views
84,607
On Slideshare
0
From Embeds
0
Number of Embeds
6
Actions
Shares
0
Downloads
1,814
Comments
12
Likes
39
Embeds 0
No embeds

No notes for slide

Perl 5.10 for People Who Aren't Totally Insane

  1. 1. Perl 5.10 for people who are not insane
  2. 2. Perl 5.10 for people who are not totally insane
  3. 3. 5.10 isn’t like 5.8.x perl5100delta
  4. 4. 5.10 isn’t like 5.8.x - features only get added in new 5.x releases perl5100delta
  5. 5. 5.10 isn’t like 5.8.x - features only get added in new 5.x releases - it’s been 5 years since the last release (5.8) perl5100delta
  6. 6. 5.10 is Way Cool perl51000delta
  7. 7. 5.10 is Way Cool - no significant new features in Perl since 2002 perl51000delta
  8. 8. 5.10 is Way Cool - no significant new features in Perl since 2002 - remember how bad you wanted to see Star Wars: Episode 1? perl51000delta
  9. 9. 5.10 is Way Cool - no significant new features in Perl since 2002 - remember how bad you wanted to see Star Wars: Episode 1? - that’s how excited you should be for 5.10 perl51000delta
  10. 10. 5.10 is Way Cool - no significant new features in Perl since 2002 - remember how bad you wanted to see Star Wars: Episode 1? - that’s how excited you should be for 5.10 - but it won’t suck (no POD race scene) perl51000delta
  11. 11. Lexicascopasmartwhat? perl51000delta
  12. 12. Lexicascopasmartwhat? - lexically scoped user pragmata! perl51000delta
  13. 13. Lexicascopasmartwhat? - lexically scoped user pragmata! - pluggable regex compilation engines! perl51000delta
  14. 14. Lexicascopasmartwhat? - lexically scoped user pragmata! - pluggable regex compilation engines! - trie-based non-recursive pattern matching! perl51000delta
  15. 15. Lexicascopasmartwhat? - lexically scoped user pragmata! - pluggable regex compilation engines! - trie-based non-recursive pattern matching! - thread-safe weak refkey hashes! perl51000delta
  16. 16. Yes, You Care perl51000delta
  17. 17. Yes, You Care - Not everything in 5.10 is esoteric. perl51000delta
  18. 18. Yes, You Care - Not everything in 5.10 is esoteric. - Not everything in 5.10 is for gurus. perl51000delta
  19. 19. Yes, You Care - Not everything in 5.10 is esoteric. - Not everything in 5.10 is for gurus. - Not everything in 5.10 is for C programmers. perl51000delta
  20. 20. Yes, You Care - Not everything in 5.10 is esoteric. - Not everything in 5.10 is for gurus. - Not everything in 5.10 is for C programmers. - Not everything in 5.10 is super advanced. perl51000delta
  21. 21. First: A Warning feature
  22. 22. First: A Warning - 5.10 is backwards compatible feature
  23. 23. First: A Warning - 5.10 is backwards compatible - but adds new keywords and operators feature
  24. 24. First: A Warning - 5.10 is backwards compatible - but adds new keywords and operators - they’re not enabled by default feature
  25. 25. First: A Warning - 5.10 is backwards compatible - but adds new keywords and operators - they’re not enabled by default - use feature ‘mtfnpy’; feature
  26. 26. First: A Warning - 5.10 is backwards compatible - but adds new keywords and operators - they’re not enabled by default - use feature ‘mtfnpy’; - use 5.010; feature
  27. 27. First: A Warning - 5.10 is backwards compatible - but adds new keywords and operators - they’re not enabled by default - use feature ‘mtfnpy’; - use 5.010; - read the perldoc feature
  28. 28. First: A Warning - 5.10 is backwards compatible - but adds new keywords and operators - they’re not enabled by default - use feature ‘mtfnpy’; - use 5.010; - read the perldoc I’m a perldoc ref! feature
  29. 29. First: A Warning - 5.10 is backwards compatible - but adds new keywords and operators - they’re not enabled by default - use feature ‘mtfnpy’; - use 5.010; - read the perldoc feature
  30. 30. say what
  31. 31. say $what - new built-in, say - it’s like print - but it adds a newline for you perlfunc
  32. 32. say $what perlfunc
  33. 33. say $what print “Hello, world!n”; perlfunc
  34. 34. say $what print “Hello, world!n”; print “$messagen”; perlfunc
  35. 35. say $what print “Hello, world!n”; print “$messagen”; print “$_n” for @lines; perlfunc
  36. 36. say $what print “Hello, world!n”; say “Hello, world!”; print “$messagen”; print “$_n” for @lines; perlfunc
  37. 37. say $what print “Hello, world!n”; say “Hello, world!”; print “$messagen”; say $message; print “$_n” for @lines; perlfunc
  38. 38. say $what print “Hello, world!n”; say “Hello, world!”; print “$messagen”; say $message; print “$_n” for @lines; say for @lines; perlfunc
  39. 39. truth and definedness
  40. 40. truth and definedness perlop
  41. 41. truth and definedness sub record_sale { perlop
  42. 42. truth and definedness sub record_sale { my ($product, $amount) = @_; perlop
  43. 43. truth and definedness sub record_sale { my ($product, $amount) = @_; $amount ||= $product->cost; perlop
  44. 44. truth and definedness sub record_sale { my ($product, $amount) = @_; $amount ||= $product->cost; ... perlop
  45. 45. truth and definedness sub record_sale { my ($product, $amount) = @_; $amount ||= $product->cost; ... } perlop
  46. 46. truth and definedness sub record_sale { my ($product, $amount) = @_; $amount = defined $amount ? $amount : $product->cost; ... } perlop
  47. 47. truth and definedness sub record_sale { my ($product, $amount) = @_; $amount ||= $product->cost; ... } perlop
  48. 48. truth and definedness sub record_sale { my ($product, $amount) = @_; $amount ||= $product->cost; ... } perlop
  49. 49. the new OR operator sub record_sale { my ($product, $amount) = @_; $amount //= $product->cost; ... } perlop
  50. 50. the new OR operator $setting = defined $given ? $given : $default; perlop
  51. 51. the new OR operator $setting = $given; unless (defined $setting) { $setting = $default; } perlop
  52. 52. the new OR operator $setting = $given || $default; perlop
  53. 53. the new OR operator $setting = $given // $default; perlop
  54. 54. keeping state
  55. 55. State Variables $lines_left = 100; sub read_line { die “trial period expired” unless $lines_left-- > 0; ... } perlsub
  56. 56. State Variables my $lines_left = 100; sub read_line { die “trial period expired” unless $lines_left-- > 0; ... } perlsub
  57. 57. State Variables { my $lines_left = 100; sub read_line { die “trial period expired” unless $lines_left-- > 0; ... } } perlsub
  58. 58. State Variables package Trial::Period; sub new { my ($class, $arg) = @_; my $guts = { lines_left => $arg->{lines}, error_msg => $arg->{error}, }; return bless $guts => $class; } my $LINES = 100; my $ERROR = “sorry, trial period over”; sub consume_line { my $TRIAL = Trial::Period->new({ my ($self) = @_; lines => $LINES, $self->{lines_left}--; error => $ERROR, } }); sub lines_left { sub read_line { my ($self) = @_; $TRIAL->assert_lines_left; return $self->{lines_left}; ... } } sub assert_lines_left { my ($self) = @_; unless ($self->lines_left) { die $self->{error_msg}; } } 1; perlsub
  59. 59. State Variables { my $lines_left = 100; sub read_line { die “trial period expired” unless $lines_left-- > 0; ... } } perlsub
  60. 60. State Variables sub read_line { state $lines_left = 100; die “trial period expired” unless $lines_left-- > 0; ... } perlsub
  61. 61. -x stacking
  62. 62. Stackable File Tests if ( -f $file and -w $file and -z $file ) { unlink $file; } perlfunc
  63. 63. Stackable File Tests if ( -f $file and -w _ and -z _ ) { unlink $file; } perlfunc
  64. 64. Stackable File Tests if (-f -w -z $file) { unlink $file; } perlfunc
  65. 65. smart matching
  66. 66. Smart Matching perlsyn
  67. 67. Smart Matching - a new kind of comparison operator perlsyn
  68. 68. Smart Matching - a new kind of comparison operator - its behavior depends on its inputs perlsyn
  69. 69. Smart Matching - a new kind of comparison operator - its behavior depends on its inputs - “if these two things match...” perlsyn
  70. 70. Smart Matching - a new kind of comparison operator - its behavior depends on its inputs - “if these two things match...” - hard to tell, easy to show... perlsyn
  71. 71. Smart Matching perlsyn
  72. 72. Smart Matching if ($foo ~~ undef) { ... } perlsyn
  73. 73. Smart Matching if ($foo ~~ undef) { ... } elsif ($foo ~~ @array) { ... } perlsyn
  74. 74. Smart Matching if ($foo ~~ undef) { ... } elsif ($foo ~~ @array) { ... } elsif ($foo ~~ $code) { ... } perlsyn
  75. 75. Smart Matching if ($foo ~~ undef) { ... } elsif ($foo ~~ @array) { ... } elsif ($foo ~~ $code) { ... } elsif ($foo ~~ %hash) { ... } perlsyn
  76. 76. Smart Matching if ($foo ~~ undef) { ... } elsif ($foo ~~ @array) { ... } elsif ($foo ~~ $code) { ... } elsif ($foo ~~ %hash) { ... } elsif ($foo ~~ qr/re/) { ... } perlsyn
  77. 77. Smart Matching if ($foo ~~ undef) { ... } elsif ($foo ~~ @array) { ... } elsif ($foo ~~ $code) { ... } elsif ($foo ~~ %hash) { ... } elsif ($foo ~~ qr/re/) { ... } elsif ($foo ~~ $bar) { ... } perlsyn
  78. 78. Smart Matching if ($foo ~~ undef) { ... } elsif ($foo ~~ @array) { ... } elsif ($foo ~~ $code) { ... } elsif ($foo ~~ %hash) { ... } elsif ($foo ~~ qr/re/) { ... } elsif ($foo ~~ $bar) { ... } else { ... } perlsyn
  79. 79. Smart Matching given ($foo) { when (undef) { ... } when (@array) { ... } when ($code) { ... } when (%hash) { ... } when (qr/re/) { ... } when ($bar) { ... } default { ... } } perlsyn
  80. 80. Smart Matching if ($foo ~~ undef) { ... } elsif ($foo ~~ @array) { ... } elsif ($foo ~~ $code) { ... } elsif ($foo ~~ %hash) { ... } elsif ($foo ~~ qr/re/) { ... } elsif ($foo ~~ $bar) { ... } else { ... } perlsyn
  81. 81. Smart Matching if ($foo ~~ undef) { ... } elsif ($foo ~~ $array) { ... } elsif ($foo ~~ $code) { ... } elsif ($foo ~~ $hash) { ... } elsif ($foo ~~ qr/re/) { ... } elsif ($foo ~~ $bar) { ... } else { ... } perlsyn
  82. 82. Smart Matching my $test; perlsyn
  83. 83. Smart Matching given ($foo) { when (undef) { ... } when ($aref) { ... } when ($code) { ... } when ($href) { ... } when ($regex) { ... } when ($object) { ... } default { ... } } perlsyn
  84. 84. Smart Matching given ($foo) { when ($test_1) { ... } when ($test_2) { ... } when ($test_3) { ... } when ($test_4) { ... } when ($test_5) { ... } when ($test_6) { ... } default { ... } } perlsyn
  85. 85. Smart Matching perlsyn
  86. 86. Smart Matching @want = @have->where($test) perlsyn
  87. 87. Smart Matching @want = @have->where($test) @want = @have->where(sub{ …… }) perlsyn
  88. 88. Smart Matching @want = @have->where($test) @want = @have->where(sub{ …… }) @want = @have->where(qr/.../sm) perlsyn
  89. 89. Smart Matching @want = @have->where($test) @want = @have->where(sub{ …… }) @want = @have->where(qr/.../sm) @want = @have->where([ 1,2,3 ]) perlsyn
  90. 90. Smart Matching perlsyn
  91. 91. Smart Matching sub where { perlsyn
  92. 92. Smart Matching sub where { my ($array, $test) = @_; perlsyn
  93. 93. Smart Matching sub where { my ($array, $test) = @_; if (ref $test eq ‘ARRAY’) { perlsyn
  94. 94. Smart Matching sub where { my ($array, $test) = @_; if (ref $test eq ‘ARRAY’) { my %known = map {$_=>1} @$test; perlsyn
  95. 95. Smart Matching sub where { my ($array, $test) = @_; if (ref $test eq ‘ARRAY’) { my %known = map {$_=>1} @$test; return grep { $known{$_} } @$array; perlsyn
  96. 96. Smart Matching sub where { my ($array, $test) = @_; if (ref $test eq ‘ARRAY’) { my %known = map {$_=>1} @$test; return grep { $known{$_} } @$array; } perlsyn
  97. 97. Smart Matching sub where { my ($array, $test) = @_; if (ref $test eq ‘ARRAY’) { my %known = map {$_=>1} @$test; return grep { $known{$_} } @$array; } if (ref $test eq ‘Regexp’) { perlsyn
  98. 98. Smart Matching sub where { my ($array, $test) = @_; if (ref $test eq ‘ARRAY’) { my %known = map {$_=>1} @$test; return grep { $known{$_} } @$array; } if (ref $test eq ‘Regexp’) { return grep { $_ =~ $test } @$array; perlsyn
  99. 99. Smart Matching sub where { my ($array, $test) = @_; if (ref $test eq ‘ARRAY’) { my %known = map {$_=>1} @$test; return grep { $known{$_} } @$array; } if (ref $test eq ‘Regexp’) { return grep { $_ =~ $test } @$array; } perlsyn
  100. 100. Smart Matching sub where { my ($array, $test) = @_; if (ref $test eq ‘ARRAY’) { my %known = map {$_=>1} @$test; return grep { $known{$_} } @$array; } if (ref $test eq ‘Regexp’) { return grep { $_ =~ $test } @$array; } if (ref $test eq ‘CODE’) { perlsyn
  101. 101. Smart Matching sub where { my ($array, $test) = @_; if (ref $test eq ‘ARRAY’) { my %known = map {$_=>1} @$test; return grep { $known{$_} } @$array; } if (ref $test eq ‘Regexp’) { return grep { $_ =~ $test } @$array; } if (ref $test eq ‘CODE’) { return grep { $test->($_) } @$array; perlsyn
  102. 102. Smart Matching sub where { my ($array, $test) = @_; if (ref $test eq ‘ARRAY’) { my %known = map {$_=>1} @$test; return grep { $known{$_} } @$array; } if (ref $test eq ‘Regexp’) { return grep { $_ =~ $test } @$array; } if (ref $test eq ‘CODE’) { return grep { $test->($_) } @$array; } perlsyn
  103. 103. Smart Matching sub where { my ($array, $test) = @_; if (ref $test eq ‘ARRAY’) { my %known = map {$_=>1} @$test; return grep { $known{$_} } @$array; } if (ref $test eq ‘Regexp’) { return grep { $_ =~ $test } @$array; } if (ref $test eq ‘CODE’) { return grep { $test->($_) } @$array; } die “invalid test” perlsyn
  104. 104. Smart Matching sub where { my ($array, $test) = @_; if (ref $test eq ‘ARRAY’) { my %known = map {$_=>1} @$test; return grep { $known{$_} } @$array; } if (ref $test eq ‘Regexp’) { return grep { $_ =~ $test } @$array; } if (ref $test eq ‘CODE’) { return grep { $test->($_) } @$array; } die “invalid test” } perlsyn
  105. 105. Smart Matching sub where { my ($array, $test) = @_; grep { $_ ~~ $test } @$array; } perlsyn
  106. 106. Smart Matching SmartMatch::Sugar perlsyn
  107. 107. Smart Matching SmartMatch::Sugar @want = @have->where( hash ) perlsyn
  108. 108. Smart Matching SmartMatch::Sugar @want = @have->where( hash ) @want = @have->where( class ) perlsyn
  109. 109. Smart Matching SmartMatch::Sugar @want = @have->where( hash ) @want = @have->where( class ) @want = @have->where(isa(‘Foo’)) perlsyn
  110. 110. unknown undefined
  111. 111. Better Error Message(s) $str = “Greetings, $name. Your last login was $last. It is now $time.”; perldiag
  112. 112. Better Error Message(s) $str = “Greetings, $name. Your last login was $last. It is now $time.”; Use of uninitialized value in concatenation (.) or string at hello.plx line 9. perldiag
  113. 113. Better Error Message(s) $str = “Greetings, $name. Your last login was $last. It is now $time.”; Use of uninitialized value $time in concatenation (.) or string at hello.plx line 9. perldiag
  114. 114. inside-out objects
  115. 115. Inside-Out Objects Hash::Util::FieldHash
  116. 116. Inside-Out Objects - traditional objects are a hashref Hash::Util::FieldHash
  117. 117. Inside-Out Objects - traditional objects are a hashref - look up attrs in the obj itself by attr name Hash::Util::FieldHash
  118. 118. Inside-Out Objects - traditional objects are a hashref - look up attrs in the obj itself by attr name - inside-out objects are content-free refs Hash::Util::FieldHash
  119. 119. Inside-Out Objects - traditional objects are a hashref - look up attrs in the obj itself by attr name - inside-out objects are content-free refs - look up attrs in an external hash by obj id Hash::Util::FieldHash
  120. 120. Inside-Out Objects - traditional objects are a hashref - look up attrs in the obj itself by attr name - inside-out objects are content-free refs - look up attrs in an external hash by obj id - there are complications for inside-out objects Hash::Util::FieldHash
  121. 121. Inside-Out Objects sub size { my $self = shift; if (@_) { return $self->{size} = shift; } else { return $self->{size}; } } Hash::Util::FieldHash
  122. 122. Inside-Out Objects my %size; sub size { my $self = shift; if (@_) { return $size{ $self } = shift; } else { return $size{ $self }; } } Hash::Util::FieldHash
  123. 123. Inside-Out Objects my %size; sub size { my $self = shift; my $id = refaddr $self; if (@_) { return $size{ $id } = shift; } else { return $size{ $id }; } } Hash::Util::FieldHash
  124. 124. Inside-Out Objects my %size; sub size { my $self = shift; my $id = refaddr $self; if (@_) { return $size{ $id } = shift; } else { return $size{ $id }; } } sub DESTROY { my $id = refaddr $_[0]; delete $size{ $id }; } Hash::Util::FieldHash
  125. 125. Inside-Out Objects my %size; sub CLONE { sub size { my $class = shift; my $self = shift; my $id = refaddr $self; my @properties = map { values %$_ } values %PROP_DATA_FOR; if (@_) { return $size{ $id } = shift; for my $old_id ( keys %OBJ ) { } else { return $size{ $id }; my $object = $OBJ{ $old_id }; } my $new_id = refaddr $object; } for my $prop ( @properties ) { sub DESTROY { next unless exists $prop->{ $old }; my $id = refaddr $_[0]; $prop->{ $new } = $prop->{ $old }; delete $size{ $id }; delete $prop->{ $old }; } } weaken ( $OBJ{ $new } = $object ); delete $OBJ{ $old }; } } Hash::Util::FieldHash
  126. 126. Inside-Out Objects my %OBJECT_REGISTRY; sub CLONE { my %size; my $class = shift; sub size { my $self = shift; my @properties = map { values %$_ } my $id = refaddr $self; values %PROP_DATA_FOR; $self->register_object; for my $old_id ( keys %OBJECT_REGISTRY ) { if (@_) { return $size{ $self } = shift; my $object = } else { $OBJECT_REGISTRY{ $old_id }; return $size{ $self }; my $new_id = refaddr $object; } } for my $prop ( @properties ) { next unless exists $prop- sub DESTROY { >{ $old_id }; my $id = refaddr $_[0]; $prop->{ $new_id } = $prop- delete $size{ $id }; >{ $old_id }; delete $OBJECT_REGISTRY{ $id }; delete $prop->{ $old_id }; } } sub register_object { weaken ( $OBJECT_REGISTRY{ $new_id } = my ($self) = @_; $object ); my $id = refaddr $self; delete $OBJECT_REGISTRY{ $old_id }; $OBJECT_REGISTRY{ $id } = $self; } } } Hash::Util::FieldHash
  127. 127. Field Hashes Hash::Util::FieldHash
  128. 128. Field Hashes - they’re just like hashes Hash::Util::FieldHash
  129. 129. Field Hashes - they’re just like hashes - objects as keys become object ids Hash::Util::FieldHash
  130. 130. Field Hashes - they’re just like hashes - objects as keys become object ids - but get destroyed and cloned Hash::Util::FieldHash
  131. 131. Field Hashes my %size; sub size { my $self = shift; if (@_) { return $size{ $self } = shift; } else { return $size{ $self }; } } Hash::Util::FieldHash
  132. 132. Field Hashes fieldhash my %size; sub size { my $self = shift; if (@_) { return $size{ $self } = shift; } else { return $size{ $self }; } } Hash::Util::FieldHash
  133. 133. Field Hashes { fieldhash my %size; sub size { my $self = shift; if (@_) { return $size{ $self } = shift; } else { return $size{ $self }; } } } Hash::Util::FieldHash
  134. 134. Field Hashes sub size { my $self = shift; fieldhash state %size; if (@_) { return $size{ $self } = shift; } else { return $size{ $self }; } } Hash::Util::FieldHash
  135. 135. lexical topic
  136. 136. (topic is how you say $_)
  137. 137. Lexical Topic for (@lines) { chomp; next if /^#/; next unless length; s/a/b/; sanity_check; say; } perlvar
  138. 138. Lexical Topic for my $line (@lines) { chomp $line; next if $line ~~ /^#/; next unless length $line; $line =~ s/a/b/; sanity_check($line); say $line; } perlvar
  139. 139. Lexical Topic for my $_ (@lines) { chomp; next if /^#/; next unless length; s/a/b/; sanity_check; say; } perlvar
  140. 140. Regex
  141. 141. named captures
  142. 142. Regex: Named Captures perlre
  143. 143. Regex: Named Captures - find matches by name, not position perlre
  144. 144. Regex: Named Captures - find matches by name, not position - avoid the dreaded$1 perlre
  145. 145. Regex: Named Captures - find matches by name, not position - avoid the dreaded $1 - no longer second to Python or .Net! perlre
  146. 146. Regex: Named Captures # our hypothetical format section:property = value perlre
  147. 147. Regex: Named Captures $line ~~ /(w+):(w+) = (w+)/; $name = $2; $value = $3; perlre
  148. 148. Regex: Named Captures $lhs_re = qr/(w+):(w+)/; $rhs_re = qr/(w+)/; $line ~~ /$lhs_re = $rhs_re/; $name = $2; $value = $3; perlre
  149. 149. Regex: Named Captures $line ~~ /$lhs_re = $rhs_re/; $name = $2; $value = $3; perlre
  150. 150. Regex: Named Captures $line ~~ /$lhs_re = $rhs_re/; $name = $+{ name }; $value = $+{ value }; perlre
  151. 151. Regex: Named Captures $lhs_re = qr/(w+):(w+)/; $rhs_re = qr/(w+)/; perlre
  152. 152. Regex: Named Captures $lhs_re = qr/(w+):(?<name>w+)/; $rhs_re = qr/(?<value>w+)/; perlre
  153. 153. better backrefs
  154. 154. Regex: Backreference m{< (w+) > .+ < /1 > }x perlre
  155. 155. Regex: Backreference m{< (w+) > .+ < /1 > }x perlre
  156. 156. Regex: Backreference 10 perlre
  157. 157. Regex: Backreference qr{(d)10} perlre
  158. 158. Regex: Backreference qr{ (d) 1 0}x perlre
  159. 159. Regex: Backreference m{< (w+) > .+ < /1 > }x perlre
  160. 160. Regex: Backreference m{< (w+) > .+ < /g{1} > }x perlre
  161. 161. Regex: Backreference 10 perlre
  162. 162. Regex: Backreference g{10} perlre
  163. 163. Regex: Backreference qr{(d)10} perlre
  164. 164. Regex: Backreference qr{(d)g{1}0} perlre
  165. 165. Regex: Backreference qr{(d)g{-1}0} perlre
  166. 166. Regex: Backreference qr{ (?<digit>d) g{digit} 0 }x perlre
  167. 167. Regex: Exit Strategy my $wtf_re = qr{ xffn015()]*(?:[^x80-xff][^x80-xffn015()]*)*))[^x80-xf fn015()]*)*)[040t]*)*(?:(?:[^(040)<>@,;:”.[]000-037x80-x ff]+(?![^(040)<>@,;:”.[]000-037x80-xff])|”[^x80-xffn015 “]*(?:[^x80-xff][^x80-xffn015”]*)*”)[040t]*(?:([^x80- xffn015()]*(?:(?:[^x80-xff]|([^x80-xffn015()]*(?:[^x80 -xff][^x80-xffn015()]*)*))[^x80-xffn015()]*)*)[040t]* )*(?:.[040t]*(?:([^x80-xffn015()]*(?:(?:[^x80-xff]|([^ x80-xffn015()]*(?:[^x80-xff][^x80-xffn015()]*)*))[^ x80-xffn015()]*)*)[040t]*)*(?:[^(040)<>@,;:”.[]000-037x8 0-xff]+(?![^(040)<>@,;:”.[]000-037x80-xff])|”[^x80-xffn 015”]*(?:[^x80-xff][^x80-xffn015”]*)*”)[040t]*(?:([^x 80-xffn015()]*(?:(?:[^x80-xff]|([^x80-xffn015()]*(?:[^ x80-xff][^x80-xffn015()]*)*))[^x80-xffn015()]*)*)[040 t]*)*)*@[040t]*(?:([^x80-xffn015()]*(?:(?:[^x80-xff]|([ ^x80-xffn015()]*(?:[^x80-xff][^x80-xffn015()]*)*))[^ x80-xffn015()]*)*)[040t]*)*(?:[^(040)<>@,;:”.[]000-037 x80-xff]+(?![^(040)<>@,;:”.[]000-037x80-xff])|[(?:[^x80- xffn015[]]|[^x80-xff])*])[040t]*(?:([^x80-xffn015() ]*(?:(?:[^x80-xff]|([^x80-xffn015()]*(?:[^x80-xff][^ x80-xffn015()]*)*))[^x80-xffn015()]*)*)[040t]*)*(?:.[04 }; wtf
  168. 168. Regex: Backreference if ($str =~ $wtf_re) { ... } perlop
  169. 169. Regex: Backreference if ($str ~~ $wtf_re) { ... } perlop
  170. 170. lexically scoped alternate trie-based reentrant user- defined regex pragmata
  171. 171. flexible regex
  172. 172. Alternate Regex Engines perlreapi
  173. 173. Alternate Regex Engines - lets you change how regex work perlreapi
  174. 174. Alternate Regex Engines - lets you change how regex work - but not how you use them ( , =~ s///, etc) perlreapi
  175. 175. Alternate Regex Engines re::engine::POSIX
  176. 176. Alternate Regex Engines egrep -r -l PATTERN DIR re::engine::POSIX
  177. 177. Alternate Regex Engines my $regex = qr{ ... }; my @files = $find->file->in( $root ); say for grep { slurp ~~ $re } @files; re::engine::POSIX
  178. 178. Alternate Regex Engines re::engine::POSIX
  179. 179. Alternate Regex Engines egrep -r -l ‘.+?’ DIR re::engine::POSIX
  180. 180. Alternate Regex Engines my $regex = qr{ ... }; my @files = $find->file->in( $root ); say for grep { slurp ~~ $re } @files; re::engine::POSIX
  181. 181. Alternate Regex Engines use re::engine::POSIX; my $regex = qr{ ... }; my @files = $find->file->in( $root ); say for grep { slurp ~~ $re } @files; re::engine::POSIX
  182. 182. Alternate Regex Engines use re::engine::POSIX; my $regex = qr{ ... }x; my @files = $find->file->in( $root ); say for grep { slurp ~~ $re } @files; re::engine::POSIX
  183. 183. http://www.perl.org/get.html
  184. 184. Any questions?
  1. A particular slide catching your eye?

    Clipping is a handy way to collect important slides you want to go back to later.

×