What's New in Perl? v5.10 - v5.16

Perl 5.10
for people who are not totally insane

Perl 5.16
for the working programmer

use feature ‘say’;
say “This is a test!”;

{
no feature ‘say’;
say “This is fatal!”;
}

use 5.16.0;
say “This is a test!”;

{
no feature ‘say’;
say “This is fatal!”;
}

#!/usr/bin/perl
use strict;
use warnings;
use 5.16.0; # use feature ‘:5.16’;

my $x = Reticulator->new;

$x->reticulate(@splines);

#!/usr/bin/perl
use strict;
use warnings;
# no feature;



#!/usr/bin/perl
use strict;
use warnings;
# use feature ‘:default’



Better Error Message(s)

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

perldiag



Use of uninitialized value in
concatenation (.) or string at
hello.plx line 9.

perldiag



Use of uninitialized value $time in
concatenation (.) or string at
hello.plx line 9.

perldiag

State Variables
my $LINES_READ = 0;

sub read_line {
$LINES_READ++;

...
}

perlsub

State Variables
{
my $LINES_READ = 0;

sub read_line {
$LINES_READ++;

...
}
}

perlsub

State Variables

sub read_line {
state $LINES_READ = 0;

$LINES_READ++;
...
}

perlsub

truth and definedness

perlop

sub record_sale {

perlop

sub record_sale {
my ($product, $amount) = @_;

perlop

sub record_sale {

my $price = $amount

perlop

sub record_sale {

my $price = $amount
|| $product->price;

perlop

sub record_sale {

my $price = $amount
|| $product->price;

...

perlop

sub record_sale {

my $price = $amount
|| $product->price;

...
}

perlop

sub record_sale {

$price = defined $amount
? $amount
: $product->price;

...
}

perlop

sub record_sale {

my $price = $amount
// $product->price;

...
}

perlop

the new OR operator
sub record_sale {

$amount //= $product->cost;

...
}

perlop

say $what

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

perlfunc

say $what

print “Hello, world!n”;

perlfunc

say $what


print “$messagen”;

perlfunc

say $what



print “$_n” for @lines;

perlfunc

say $what

say “Hello, world!”;


perlfunc

say $what

say $message;

perlfunc

say $what

say $message;
say for @lines;

perlfunc

What's New in Perl? v5.10 - v5.16

$ perl -e ‘print “Foon”’

$ perl -e ‘print “Foon”’

$ perl -E ‘say “Foo”’

Recursion!

sub fact {
my ($x) = @_; # must be +int
return $x if $x == 1;
return $x * fact($x - 1);
}

Recursion!

my $fact = sub {
return $x * $fact->($x - 1);
};

Recursion!

my $fact;
$fact = sub {
return $x * $fact->($x - 1);
};

Recursion!
use Scalar::Util qw(weaken);
my $fact = do {
my $f1;
my $f2 = $f1 = sub {
my ($x) = @_;
return $x * $f1->($x - 1);
};
weaken($f1);
$f1;
};

Recursion!

use 5.16.0; # current_sub

my $fact = sub {
return $x * __SUB__->($x - 1);
};

autodie

open my $fh, ‘<‘, $filename;

while (<$fh>) {
...
}

close $fh;

autodie

autodie
open my $fh, ‘<‘, $filename
or die “couldn’t open $filename: $!”;

while (<$fh>) {
...
}

close $fh
or die “couldn’t close $filename: $!”;

autodie

autodie
use autodie;


while (<$fh>) {
...
}

close $fh;

autodie

autodie
use autodie;


while (<$fh>) {
no autodie;
rmdir or warn “couldn’t remove $_: $!”;
}

close $fh;

autodie

autodie
use autodie;

sub foo {
my $filename = shift;

while (<$fh>) {
...
}
} # this implicit close DID NOT AUTODIE

autodie

IO::File
sub stream_to_fh {
my ($self, $fh) = @_;

fileno $fh
or die “can’t stream to closed fh”;

while (my $hunk = $self->next_hunk) {
print {$fh} $hunk;
}

close $fh or die “error closing: $!”;
}

perlopentut

IO::File
sub stream_to_fh {
my ($self, $fh) = @_;

$fh->fileno
or die “can’t stream to closed fh”;

while (my $hunk = $self->next_hunk) {
$fh->print($hunk);
}

$fh->close or die “error closing: $!”;
}

perlopentut

IO::File

sub stream_to_fh {
...
$fh->print($hunk);
...
}

open my $target, ‘>’, ‘/dev/null’
or die “can’t open bit bucket: $!”;

stream_to_fh($target);

perlopentut

IO::File
use IO::File;

sub stream_to_fh {
...
$fh->print($hunk);
...
}



perlopentut

IO::File
use 5.14.0;

sub stream_to_fh {
...
$fh->print($hunk);
...
}



perlopentut

IO::File
use 5.14.0;
use autodie;
sub stream_to_fh {
...
$fh->print($hunk);
...
}



perlopentut

Package Blocks

package Library::Awesome;
our $VERSION = 1.234;

sub foo { ... }

1;

perlfunc

Package Blocks

use 5.12.0;

package Library::Awesome 1.234;

sub foo { ... }

1;

perlfunc

Package Blocks

use 5.12.0;

package Library::Awesome 1.234-alpha;

sub foo { ... }

1;

perlfunc

Package Blocks

package Library::Awesome 1.234 {

sub foo { ... }

}

1;

perlfunc

overloading

- the -x overload
- the qr overload
- "no overloading"
- unknown overload warns

perldoc

smrt match

if ($x ~~ $y) {
...
}

smrt match

- if $x and $y are unknown, there are 23
possible dispatch paths

perldoc

smrt match

- and some of them redispatch recursively

perldoc

smrt match

- no, you won't remember them all

perldoc

smrt match

- no, you won't remember them all
- ...and they can't be intuited

perldoc

Matching
if ($x ~~ $y) {...}

Matching
if ($x ~~ $y) {...}
if ($str ~~ %hash) {...}

Matching
if ($x ~~ $y) {...}
if ($str ~~ %hash) {...}
if ($str ~~ @arr) {...}

Matching
if ($x ~~ $y) {...}
if ($str ~~ %hash) {...}
if ($str ~~ @arr) {...}
if ($str ~~ [ %h, ...]) {...}

Matching
if ($x ~~ $y) {...}
if ($str ~~ %hash) {...}
if ($str ~~ @arr) {...}
if ($str ~~ [ %h, ...]) {...}
if (%hash ~~ %h) {...}

Matching
if ($x ~~ $y) {...}
if ($str ~~ %hash) {...}
if ($str ~~ @arr) {...}
if ($str ~~ [ %h, ...]) {...}
if (%hash ~~ %h) {...}
if (%hash ~~ @arr) {...}

Matching
if ($x ~~ $y) {...}
if ($str ~~ %hash) {...}
if ($str ~~ @arr) {...}
if ($str ~~ [ %h, ...]) {...}
if (%hash ~~ %h) {...}
if (%hash ~~ @arr) {...}
if (%hash ~~ [ %h,...]) {...}

given ($x) {
when ($y) {
...
}
when ($z) {
...
}
}

given ($x) {
when ($y) {
try { ... }
catch {
warn “error: $_”;
return undef;
}
}
}

each @array

while (my ($i, $v) = each @array) {
say “$i: $v”;
}

~$ perl5.10.0 -E ‘say scalar localtime 2**31-1’

Mon Jan 18 22:14:07 2038

Mon Jan 18 22:14:07 2038

~$ perl5.10.0 -E ‘say scalar localtime 2**31’

Mon Jan 18 22:14:07 2038

Fri Dec 13 15:45:52 1901

Mon Jan 18 22:14:07 2038

Mon Jan 18 22:14:07 2038

Mon Jan 18 22:14:08 2038

$@

- Well, actually, you use Try::Tiny, right?

Try::Tiny

$@

- But this makes Try::Tiny more reliable, too!

Try::Tiny

$@

- But this makes Try::Tiny more reliable, too!
- You see, eval and $@ are totally awful

Try::Tiny

use 5.12.0;

{
package X;
sub DESTROY { eval { } }
}

eval {
my $x = bless {} => ‘X’;
die “DEATH!!”;
};

warn “ERROR: $@”;

perlfunc

use 5.12.0;

{
package X;
}

eval {
my $x = bless {} => ‘X’;
die “DEATH!!”;
};


$ perl5.12.4 test.pl
ERROR:

perlfunc

use 5.14.0;

{
package X;
}

eval {
my $x = bless {} => ‘X’;
die “DEATH!!”;
};


perlfunc

use 5.14.0;

{
package X;
}

eval {
my $x = bless {} => ‘X’;
die “DEATH!!”;
};


$ perl5.14.1 test.pl
ERROR: DEATH!!

perlfunc

perl -le ‘print $^X’

10.0: perl


10.0: perl
10.1: perl


10.0: perl
10.1: perl
12.0: perl


10.0: perl
10.1: perl
12.0: perl
14.0: perl


10.0: perl
10.1: perl
12.0: perl
14.0: perl
16.0: /Users/rjbs/perl5/perlbrew/perls/16.0/bin/perl

Perl is Good at Unicode

perlunicode

Perl 5.16 is Better

perlunicode

Perl 5.16 is Better

- Unicode 6.1

perlunicode

Perl 5.16 is Better

- Unicode 6.1
- every character property is available

perlunicode

Perl 5.16 is Better

- Unicode 6.1
- every character property is available
- X in regex is more sensible

perlunicode

“The Unicode Bug”

perlunicode


- strings aren’t always treated as Unicode

perlunicode


- this causes weird bugs that take ages to find

perlunicode


- use feature ‘unicode_strings’;

perlunicode


- use feature ‘unicode_strings’;
- or use 5.12.0

perlunicode

Unicode eval

- eval $str
- is that octets or chars?
- what if it includes "use utf8"
- or you're under "use utf8"?

perldoc

Unicode eval

- evalbytes $str
- unicode_eval

perldoc

My Favorite 5.12-ism?
if (length $input->{new_email}) {
$user->update_email(...);
}

perldiag

My Favorite 5.12-ism?
if (length $input->{new_email}) {
$user->update_email(...);
}

Use of uninitialized value in length
at - line 3120.

perldiag

say “I o{23145} Perl 5.14!”;

perlsyn

say “I o{23145} Perl 5.14!”;

I ♥ Perl 5.14!

perlsyn

say “I 23145 Perl 5.14!”;

I ?45 Perl 5.14!

perlsyn

say “I 023145 Perl 5.14!”;

I 145 Perl 5.14!

perlsyn

qr{
(1) (2) (3) (4) 7 10
(5) (6) (7) (8) (9) 7 10
(10) 7 10
}x;

perlre

qr{
(1) (2) (3) (4) o{7} o{10}
(5) (6) (7) (8) (9) o{7} o{10}
(10) g{7} g{10}
}x;

perlre

Unicode 6.1

charnames

Unicode 6

charnames

N{...}

use 5.16.0;

say “I N{HEAVY BLACK HEART} Queensr”
. “N{LATIN SMALL LETTER Y WITH DIAERESIS}”
. “che!”;

Case Folding

if (lc $foo eq lc $bar) {
...
}

Case Folding

if (fc $foo eq fc $bar) {
...
}

Case Folding
lc ‘ς‘ ➔ ‘ς‘

Case Folding
lc ‘ς‘ ➔ ‘ς‘
uc ‘ς‘ ➔ ‘Σ‘

Case Folding
lc ‘ς‘ ➔ ‘ς‘
uc ‘ς‘ ➔ ‘Σ‘
fc ‘ς‘ ➔ ‘σ‘

Case Folding
lc ‘ς‘ ➔ ‘ς‘
uc ‘ς‘ ➔ ‘Σ‘
fc ‘ς‘ ➔ ‘σ‘

lc ‘ß’ ➔ ‘ß’

Case Folding
lc ‘ς‘ ➔ ‘ς‘
uc ‘ς‘ ➔ ‘Σ‘
fc ‘ς‘ ➔ ‘σ‘

lc ‘ß’ ➔ ‘ß’
uc ‘ß’ ➔ ‘SS’

Case Folding
lc ‘ς‘ ➔ ‘ς‘
uc ‘ς‘ ➔ ‘Σ‘
fc ‘ς‘ ➔ ‘σ‘

lc ‘ß’ ➔ ‘ß’
uc ‘ß’ ➔ ‘SS’
fc ‘ß’ ➔ ‘ss’

Case Folding

“file under: L$name”

Case Folding

“file under: L$name”

“file under: F$name”

Regex: Named Captures

perlre


- find matches by name, not position

perlre


- avoid the dreaded$1

perlre


- avoid the dreaded $1

- no longer second to Python or .Net!

perlre


# our hypothetical format

section:property = value

perlre


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

$section = $1
$name = $2;
$value = $3;

perlre

$line =~ /
(?<section> w+):
(?<name> w+)
s* = s*
(?<value> w+)
/x;

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

perlre

New Regex Modifiers

my $hostname = get_hostname;

$hostname =~ s/..*//;

perlre

New Regex Modifiers

my $hostname = get_hostname =~ s/..*//;

perlre

New Regex Modifiers

(my $hostname = get_hostname) =~ s/..*//;

perlre

New Regex Modifiers

my $hostname = get_hostname =~ s/..*//r;

perlre

New Regex Modifiers

my @short_names =
map { s/..*//; } @long_names;

perlre

New Regex Modifiers

my @short_names =
map { s/..*//;
$_ } @long_names;

perlre

New Regex Modifiers

my @short_names =
map { my $x = $_;
$x =~ s/..*//;
$x } @long_names;

perlre

New Regex Modifiers

my @short_names =
map { s/..*//r } @long_names;

perlre

New Regex Modifiers

my @short_names =
map s/..*//r, @long_names;

perlre

New Regex Modifiers

perldoc

New Regex Modifiers
/u /a /aa /d /l

"൮" =~ /d/ ✓ ! ! ¿? ¿?

"ð" =~ /w/ ✓ ! ! ¿? ¿?

"ff" =~ /ff/i ✓ ✓ ! ¿? ¿?

"ff" =~ /pL/i ✓ ✓ ✓ ¿? ¿?

perldoc

New Regex Modifiers

# To be really ASCII-only:

die “funny un-American characters”
if $str =~ /P{ASCII}/;

$str =~ /...actual pattern.../;

perlre

study
my $re = qr{...complex...};

study
my $str = q{...long complex...};

study

$str =~ $re; # slow!!

study


study $str; # does stuff

study



$str =~ $re; # fast!!

study

$str =~ $re; # slow but right!!


$str =~ $re; # who knows!!

study


study $str; # does nothing


Newly Cored Librarys

- JSON
- HTTP::Tiny
- Module::Metadata
- CPAN::Meta

perlmodlib

Newly Ejected Librarys

- Devel::DProf
- Switch
- the perl4 core
- ...and more

perlmodlib

qw()

for my $show qw(Smallville Lost V) {
$tivo->cancel_pass( $show );
}

perlop

qw()

for my $show (qw(Smallville Lost V)) {
$tivo->cancel_pass( $show );
}

perlop

$[ - first index of array

perlvar


- so you can make $array[1] mean first

perlvar


- isn’t that awesome???

perlvar


- isn’t that awesome???
- yeah, about as awesome as Comic Sans

perlvar

$[

$[ = 1;

for (1 .. $#array) {
...
}

perlvar

$[

for ($[ .. $#array) {
...
}

perlvar

$[

Assigned to $[. Are you some kind of
idiot or something? at -e line 123.

perlvar

$[

Use of assignment to $[ is deprecated
at -e line 123.

perlvar

What's New in Perl? v5.10 - v5.16

More Related Content

What's hot (20)

Similar to What's New in Perl? v5.10 - v5.16 (20)

More from Ricardo Signes (10)

Recently uploaded (20)

What's New in Perl? v5.10 - v5.16