Perl 5 at 20: Perl v5.20.0

Cool New Stuff!

Experiments!

Experiments

Experiments •new features we're trying out

Experiments •new features we're trying out •might not stay around

•or might change how they work

•or might change how they work •don't build your business on them

Experiments

Experiments •smartmatch

Experiments •smartmatch •lexical subroutines (my sub {…})

Experiments •smartmatch •lexical subroutines (my sub {…}) •autoderef

sub xyzzy { given (1) { ... } } experimental

sub xyzzy { given (1) { ... } } experimental
syntax error at -e line 1, near ") {"

use feature 'switch'; sub xyzzy { given (1) { ...
} } experimental

use feature 'switch'; sub xyzzy { given (1) { ...
} } experimental given is experimental at -e line 1.

use feature 'switch'; no warnings "experimental::smartmatch"; sub xyzzy { given
(1) { ... } } experimental

use feature 'switch'; no warnings "experimental::smartmatch"; sub xyzzy { given
(1) { ... } } experimental Unknown warnings category 'experimental::smartmatch'

use feature 'switch'; no if $] >= 5.018, warnings =>
"experimental::feature_name"; sub xyzzy { given (1) { ... } } experimental

use experimental 'smartmatch'; sub xyzzy { given (1) { ...
} } experimental

Postﬁx Dereferencing

$sess # is our session

$sess # is our session ->{user} # is the logged
in user

$sess # is our session ->{user} # is the logged
in user ->logins # is an arrayref of logins

$sess # We must record ->{user} # a new login
->logins # to this arrayref.

push $sess # We must record ->{user} # a new
login ->logins # to this arrayref.

push $sess $sess # We must record ->{user} # a
new login ->logins # to this arrayref.

push $sess->{user} $sess # We must record ->{user} # a

push $sess->{user}->logins $sess # We must record ->{user} # a

push $sess->{user}->logins , $login; $sess # We must record ->{user}
# a new login ->logins # to this arrayref.

push @{ $sess->{user}->logins }, $login; $sess # We must record
->{user} # a new login ->logins # to this arrayref.

push $sess->{user}->logins , $login; $sess # We must record ->{user}

push $sess->{user}->logins , $queue $sess # We must record ->{user}

push $sess->{user}->logins , $queue->{unflushed} $sess # We must record ->{user}

push $sess->{user}->logins , $queue->{unflushed}->logins $sess # We must record ->{user}

push $sess->{user}->logins , @{ $queue->{unflushed}->logins }; $sess # We must
record ->{user} # a new login ->logins # to this arrayref.

push $sess->{user}->logins , @{ $queue->{unflushed}->logins }; ! process(@{ $queue->{unhandled}->jobs });
! $sess # We must record ->{user} # a new login ->logins # to this arrayref.

! map { $_ > $#{$in[0]} } @{$job->input} $sess # We must record ->{user} # a new login ->logins # to this arrayref.

! map { $_ > $#{$in[0]} } @{$job->input}

push $sess->{user}->logins->@* , @{ $queue->{unflushed}->logins }; ! process(@{ $queue->{unhandled}->jobs });
! map { $_ > $#{$in[0]} } @{$job->input}

push $sess->{user}->logins->@* , $queue->{unflushed}->logins->@*; ! process(@{ $queue->{unhandled}->jobs }); ! map
{ $_ > $#{$in[0]} } @{$job->input}

push $sess->{user}->logins->@* , $queue->{unflushed}->logins->@*; ! process($queue->{unhandled}->jobs->@*); ! map { $_
> $#{$in[0]} } @{$job->input}

> $#{$in[0]} } $job->input->@*

> $in[0]->$#* } $job->input->@*

@{ expr } ⇢ ⇢ ⇢ ⇢ expr->@*

@{ expr } ⇢ ⇢ ⇢ ⇢ expr->@* %{ expr
} ⇢ ⇢ ⇢ ⇢ expr->%*

@{ expr } ⇢ ⇢ ⇢ ⇢ expr->@* %{ expr
} ⇢ ⇢ ⇢ ⇢ expr->%* ${ expr } ⇢ ⇢ ⇢ ⇢ expr->$*

@{ expr } ⇢ ⇢ ⇢ ⇢ expr->@* %{ expr
} ⇢ ⇢ ⇢ ⇢ expr->%* ${ expr } ⇢ ⇢ ⇢ ⇢ expr->$* &{ expr } ⇢ ⇢ ⇢ ⇢ expr->&*

@{ expr } ⇢ ⇢ ⇢ ⇢ expr->@* %{ expr
} ⇢ ⇢ ⇢ ⇢ expr->%* ${ expr } ⇢ ⇢ ⇢ ⇢ expr->$* &{ expr } ⇢ ⇢ ⇢ ⇢ expr->&* *{ expr } ⇢ ⇢ ⇢ ⇢ expr->**

@{ expr } ⇢ ⇢ ⇢ ⇢ expr->@* %{ expr
} ⇢ ⇢ ⇢ ⇢ expr->%* ${ expr } ⇢ ⇢ ⇢ ⇢ expr->$* &{ expr } ⇢ ⇢ ⇢ ⇢ expr->&* *{ expr } ⇢ ⇢ ⇢ ⇢ expr->** $#{ expr } ⇢ ⇢ ⇢ ⇢ expr->$#*

@{ expr }[1,2,3] ⇢ expr->@[1,2,3]

@{ expr }[1,2,3] ⇢ expr->@[1,2,3] @{ expr }{k1,k2} ⇢ expr->@{k1,k2}

@{ expr }[1,2,3] ⇢ expr->@[1,2,3] @{ expr }{k1,k2} ⇢ expr->@{k1,k2}
*{ expr }{ARRAY} ⇢ expr->*{ARRAY}

say "Items: $arrayref->@*[0,1]"

say "Items: $arrayref->@*[0,1]" say "Content: $body_ref->$*"

Postﬁx Dereferencing!!

Postﬁx Dereferencing!! EXPERIMENTAL

Postﬁx Dereferencing!! EXPERIMENTAL use experimental 'postderef';

Interesting Optimizations

Copy on Write

# terastring.perl $x = "x" x 1_000_000; $y = $x
for 1..1_000_000;

for 1..1_000_000; ~$ time perl5.18.2 terastring.pl

for 1..1_000_000; ~$ time perl5.18.2 terastring.pl 53.476 total

for 1..1_000_000; ~$ time perl5.20.0 terastring.pl ~$ time perl5.18.2 terastring.pl 53.476 total

for 1..1_000_000; ~$ time perl5.20.0 terastring.pl 0.165 total ~$ time perl5.18.2 terastring.pl 53.476 total

for 1..1_000_000; ~$ time perl5.20.0 terastring.pl 0.165 total ~$ time perl5.18.2 terastring.pl 53.476 total …sometimes…

warn "The Warning" if $favorite_band =~ /^Queensrÿche/; ! warn "The
Warning" if $favorite_band =~ /^Queensrÿche/;

my $everything = 'Awesome'; ! sub check_1 { return $everything
} ! sub check_2 { $everything }

Cross-Compilation

Unicode 6.3

Unicode 6.3 Unicode 6.3

Unicode 6.3 (up from 6.2) Unicode 6.3

᠎U+180E

᠎U+180E MONGOLIAN VOWEL SEPARATOR

Bidi_Paired_Bracket

0028; 0029; o # LEFT PARENTHESIS 0029; 0028; c #
RIGHT PARENTHESIS 005B; 005D; o # LEFT SQUARE BRACKET 005D; 005B; c # RIGHT SQUARE BRACKET 007B; 007D; o # LEFT CURLY BRACKET 007D; 007B; c # RIGHT CURLY BRACKET ⋮ 300C; 300D; o # LEFT CORNER BRACKET 300D; 300C; c # RIGHT CORNER BRACKET

RIGHT PARENTHESIS 005B; 005D; o # LEFT SQUARE BRACKET 005D; 005B; c # RIGHT SQUARE BRACKET 007B; 007D; o # LEFT CURLY BRACKET 007D; 007B; c # RIGHT CURLY BRACKET ⋮ 300C; 300D; o # LEFT CORNER BRACKET 300D; 300C; c # RIGHT CORNER BRACKET U+0028 = ( U+0029 = )

RIGHT PARENTHESIS 005B; 005D; o # LEFT SQUARE BRACKET 005D; 005B; c # RIGHT SQUARE BRACKET 007B; 007D; o # LEFT CURLY BRACKET 007D; 007B; c # RIGHT CURLY BRACKET ⋮ 300C; 300D; o # LEFT CORNER BRACKET 300D; 300C; c # RIGHT CORNER BRACKET U+0028 = ( U+0029 = ) qw( x y )

RIGHT PARENTHESIS 005B; 005D; o # LEFT SQUARE BRACKET 005D; 005B; c # RIGHT SQUARE BRACKET 007B; 007D; o # LEFT CURLY BRACKET 007D; 007B; c # RIGHT CURLY BRACKET ⋮ 300C; 300D; o # LEFT CORNER BRACKET 300D; 300C; c # RIGHT CORNER BRACKET U+0028 = ( U+0029 = ) U+300C = ʮ U+300D = ʯ qw( x y )

RIGHT PARENTHESIS 005B; 005D; o # LEFT SQUARE BRACKET 005D; 005B; c # RIGHT SQUARE BRACKET 007B; 007D; o # LEFT CURLY BRACKET 007D; 007B; c # RIGHT CURLY BRACKET ⋮ 300C; 300D; o # LEFT CORNER BRACKET 300D; 300C; c # RIGHT CORNER BRACKET U+0028 = ( U+0029 = ) U+300C = ʮ U+300D = ʯ qw( x y ) qwʮ x y ʯ

Unicode 7

Unicode 7 (in 5.21.1)

U+1F574

U+1F574 RUDE BOY

sub assert_scored {

sub assert_scored { my ($input) = @_;

sub assert_scored { my ($input) = @_; return score_for($awesome_arg)

sub assert_scored { my ($input) = @_; return score_for($awesome_arg) or
die("no score for $input!");

die("no score for $input!"); }

die("no score for $input!"); } warning: Possible precedence issue with control flow operator

Oops •IO::All

Oops •IO::All •IO::Async

Oops •IO::All •IO::Async •JSON::PP

Oops •IO::All •IO::Async •JSON::PP •DBIx::Class

Oops •IO::All •IO::Async •JSON::PP •DBIx::Class •Perl::Critic

Oops •IO::All •IO::Async •JSON::PP •DBIx::Class •Perl::Critic •IO::Socket::SSL

Oops •IO::All •IO::Async •JSON::PP •DBIx::Class •Perl::Critic •IO::Socket::SSL •Parse::CPAN::Meta

Oops •IO::All •IO::Async •JSON::PP •DBIx::Class •Perl::Critic •IO::Socket::SSL •Parse::CPAN::Meta •HTML::Mason

Oops •IO::All •IO::Async •JSON::PP •DBIx::Class •Perl::Critic •IO::Socket::SSL •Parse::CPAN::Meta •HTML::Mason •DBI

•Test::More

•Test::More •…and your code, too

use locale;

use locale; •UTF-8 locales work

use locale; •UTF-8 locales work •"use locale" works if your
OS has no locale support (you get LC=C)

OS has no locale support (you get LC=C) •-DL for tracing locales

OS has no locale support (you get LC=C) •-DL for tracing locales •radix character doesn't leak

use 5.10.0; use POSIX 'locale_h'; ! my $x = 1.234;
! { use locale; setlocale(LC_ALL, 'de_DE'); } ! say $x;

! { use locale; setlocale(LC_ALL, 'de_DE'); } ! say $x; 1,234

! { # this can be in a distant package! use locale; setlocale(LC_ALL, 'de_DE'); } ! say $x; 1,234

! ! ! reticulate_splines; ! ! say $x; 1,234

use 5.10.0; use POSIX 'locale_h'; use JSON; my $x =
1.234; ! ! ! reticulate_splines; ! ! say JSON->new->encode({value => $x});

1.234; ! ! ! reticulate_splines; ! ! say JSON->new->encode({value => $x}); { "value": 1,234 }

1.234; ! ! ! reticulate_splines; ! ! say JSON->new->encode([ 1, 234, $x ]);

1.234; ! ! ! reticulate_splines; ! ! say JSON->new->encode([ 1, 234, $x ]); [1,234,1,234]

$ host-status

$ host-status myhost,up,angry,80 yourhost,down,-,0 hishost,up,happy,62 herhost,up,proud,108 theirhost,down,-,0

Sample input: myhost,up,angry,80

$ host-status | perl -n -F, -le \ 'print "$F[0]
is $F[1]"' Sample input: myhost,up,angry,80

is $F[1]"' Sample input: myhost,up,angry,80 Program output:

is $F[1]"' Sample input: myhost,up,angry,80 Program output: ␠is␠

is $F[1]"' Sample input: myhost,up,angry,80 Program output: ␠is␠ you forgot the -a

-F implies -a ! -a implies -n

rand() doesn't suck

rand() doesn't suck (as much)

Pair Slices

my @array = qw[ foo bar baz quux ];

my @array = qw[ foo bar baz quux ]; my
@slice = @array[ 1, 3 ];

@slice = @array[ 1, 3 ]; # Now @slice is ("bar", "quux")

my %hash = (a => 1, b => 2, c
=> 3);

my %hash = (a => 1, b => 2, c
=> 3); my @slice = @hash{ 'a', 'c' };

my %hash = (a => 1, b => 2, c
=> 3); my @slice = @hash{ 'a', 'c' }; # Now @slice is (1, 3)

my %hash = (a => 1, b => 2, c
=> 3); my %slice = %hash{ 'a', 'c' };

my %hash = (a => 1, b => 2, c
=> 3); my %slice = %hash{ 'a', 'c' }; # Now %slice is (a => 1, c => 3)

my %hash = (a => 1, b => 2, c
=> 3); my @slice = %hash{ 'a', 'd', 'a' };

my %hash = (a => 1, b => 2, c
=> 3); my @slice = %hash{ 'a', 'd', 'a' }; # Now @slice is # (a => 1, d => undef, a => 1)

my $record = {

my $record = { artist => $album{artist}

my $record = { artist => $album{artist} title => $album{title},

tracks => $album{tracks},

tracks => $album{tracks}, year => $album{edition}{year},

tracks => $album{tracks}, year => $album{edition}{year}, label => $album{edition}{lable},

tracks => $album{tracks}, year => $album{edition}{year}, label => $album{edition}{lable}, };

tracks => $album{tracks}, ! year => $album{edition}{year}, label => $album{edition}{lable}, };

tracks => $album{tracks}, ! year => $album{edition}{year}, label => $album{edition}{label}, };

my $record = { %album{qw( artist title tracks )}, !
year => $album{edition}{year}, label => $album{edition}{label}, };

# Your mission: get a slice of values

# Your mission: get a slice of values # from
$hashref->{x}

$hashref->{x} my $hashref = { x => { ... } };

$hashref->{x} my $hashref = { x => { ... } }; $hashref->{x}{ k1, k2 } #1

$hashref->{x} my $hashref = { x => { ... } }; $hashref->{x}{ k1, k2 } #1 @{ $hashref->{x} }->{ k1, k2 } #2

$hashref->{x} my $hashref = { x => { ... } }; $hashref->{x}{ k1, k2 } #1 @{ $hashref->{x} }->{ k1, k2 } #2 @{ $hashref->{x}{ k1, k2 } } #3

$hashref->{x} my $hashref = { x => { ... } }; $hashref->{x}{ k1, k2 } #1 @{ $hashref->{x} }->{ k1, k2 } #2 @{ $hashref->{x}{ k1, k2 } } #3 @{ $hashref->{x} }{ k1, k2} #4

year => $album{edition}{year}, label => $album{edition}{label}, };

$album->{edition}->%{ qw(year label) } );

@slice = @array[ 1, 3 ];

@slice = @array[ 1, 3 ]; # @slice is ("bar", "quux")

@slice = %array[ 1, 3 ];

@slice = %array[ 1, 3 ]; # @slice is (1 => "bar", 3 => "quux")

@slice = %array[ 3, 1 ];

@slice = %array[ 3, 1 ]; # @slice is (3 => "quuz", 1 => "bar")

Pair Slices

Selected Bug Fixes

Selected Bug Fixes (selected for hilarity)

Compiling a split operator whose third argument is a named
constant evaluating to 0 …

constant evaluating to 0 … split /,/, $input, SPLIT_FIELDS;

constant evaluating to 0 no longer causes the constant's value to change. split /,/, $input, SPLIT_FIELDS;

my $x = qr/.../;

my $x = qr/.../; if ($x) { this_gets_run }

my $x = qr/.../; if ($x) { this_gets_run } if
($$x) { this_does_not }

On 64-bit platforms, large ranges like 1..1_000_000_000_000 no longer crash

On 64-bit platforms, large ranges like 1..1_000_000_000_000 no longer crash,
they eat up all your memory instead.

Feature Death

sub add { ($x, $y) = @_; ! return $x
+ $y; }

+ $y; } add(1,2);

+ $y; } add(1,2); &add(1,2);

+ $y; } add(1,2); &add(1,2); do add (1,2);

say $^H; # <-- private compile-time hints

say $^H; # <-- private compile-time hints say ; #
<-- private compile-time hints

say $^H; # <-- private compile-time hints say ; #
<-- private compile-time hints say $␈; # <-- private compile-time hints

$^K ==

$VT $^K ==

Programs Leaving Core

Programs Leaving Core •a2p

Programs Leaving Core •a2p •s2p

Programs Leaving Core •a2p •s2p •ﬁnd2perl

Programs Leaving Core •a2p •s2p •ﬁnd2perl •pl2rb

Modules Leaving Core

Modules Leaving Core •CGI

Modules Leaving Core •CGI •Module::Build

Modules Leaving Core •CGI •Module::Build •encoding.pm

That Other Thing

That Other Thing (humor me; act like you don't know)

sub add { my ($x, $y) = @_; ! return
$x + $y; }

sub add { my $x = shift // 0; my
$y = shift // 0; ! return $x + $y; }

brace yourselves, folks

sub add ($x, $y) { return $x + $y; }

add(1,2) ⇢ 3 sub add ($x, $y) { return $x
+ $y; }

add(1,2) ⇢ 3 add() ⇢ runtime error! sub add ($x,
$y) { return $x + $y; }

add(1,2) ⇢ 3 add() ⇢ runtime error! add(1) ⇢ runtime
error! sub add ($x, $y) { return $x + $y; }

add(1,2) ⇢ 3 add() ⇢ runtime error! add(1) ⇢ runtime
error! add(1,2,3) ⇢ runtime error! sub add ($x, $y) { return $x + $y; }

sub add ($x, $y = 0) { return $x +
$y; }

$y; } add(1,2) ⇢ 3

$y; } add(1,2) ⇢ 3 add() ⇢ runtime error!

$y; } add(1,2) ⇢ 3 add() ⇢ runtime error! add(1) ⇢ 1

$y; } add(1,2) ⇢ 3 add() ⇢ runtime error! add(1) ⇢ 1 add(1,2,3) ⇢ runtime error!

sub add ($x = 0, $y) { return $x +
$y; }

sub add ($x = 0, $y) { return $x +
$y; } compile time error!!

sub add ($x = 0, $y = 0) { !
return $x + $y; }

sub add ($x = 0, $y = 0) { !
return $x + $y; } add(1,2) ⇢ 3

sub add ($x = 0, $y = 0) { !
return $x + $y; } add(1,2) ⇢ 3 add() ⇢ 0

sub add ($x = 0, $y = 0) { !
return $x + $y; } add(1,2) ⇢ 3 add() ⇢ 0 add(1) ⇢ 1

sub add ($x = 0, $y = 0) { !
return $x + $y; } add(1,2) ⇢ 3 add() ⇢ 0 add(1) ⇢ 1 add(1,2,3) ⇢ runtime error!

sub add ($x = 0, $y = 0) { !
return $x + $y; } add(1,2) ⇢ 3 ! add() ⇢ 0 add(1) ⇢ 1 add(1,2,3) ⇢ runtime error!

sub add ($x = 0, $y = (return $x)) {
! return $x + $y; }

sub add ($x = 0, $y = (return $x)) {
! return $x + $y; } add(1,2) ⇢ 3 ! add() ⇢ 0 add(1) ⇢ 1 add(1,2,3) ⇢ runtime error!

sub add ($x = (return 0), $y = (return $x))
{ ! return $x + $y; }

sub add ($x = (return 0), $y = (return $x))
{ ! return $x + $y; } add(1,2) ⇢ 3 ! add() ⇢ 0 add(1) ⇢ 1 add(1,2,3) ⇢ runtime error!

Deparse!

# adder.pl sub add ($x, $y) { return $x +
$y; }

$y; } $ perl -MO=Deparse adder.pl

$y; } sub add { die 'Too many arguments for subroutine' unless @_ <= 2; die 'Too few arguments for subroutine' unless @_ >= 2; my $x = $_[0]; my $y = $_[1]; (); return $x + $y; } $ perl -MO=Deparse adder.pl

# adder.pl sub add ($x, $y = (return $x)) {
return $x + $y; }

return $x + $y; } $ perl -MO=Deparse adder.pl

return $x + $y; } sub add { die 'Too many arguments for subroutine' unless @_ <= 2; die 'Too few arguments for subroutine' unless @_ >= 1; my $x = $_[0]; my $y = @_ >= 2 ? $_[1] : (return $x); (); return $x + $y; } $ perl -MO=Deparse adder.pl

# adder.pl sub add ($x = (return 0), $y =
(return $x)) { return $x + $y; }

(return $x)) { return $x + $y; } $ perl -MO=Deparse adder.pl

(return $x)) { return $x + $y; } sub add { die 'Too many arguments for subroutine' unless @_ <= 2; my $x = @_ >= 1 ? $_[0] : (return 0); my $y = @_ >= 2 ? $_[1] : (return $x); (); return $x + $y; } $ perl -MO=Deparse adder.pl

"Strict Arity"

"Strict Arity" •no fewer than the count of no-default parameters

•no more than the count of all parameters

•no more than the count of all parameters •so what about variadic functions?

sub mult_many { my ($factor, @inputs) = @_; ! return
map {; $factor * $_ } @inputs }

sub mult_many ($factor, @inputs) { return map {; $factor *
$_ } @inputs }

sub send_mail ($self, $mail, %arg) { $self->smtp->deliver( $mail, from =>
$arg->{from}, to => $arg->{to}, ); }

sub send_mail ($self, $mail, %arg) { $self->smtp->deliver( $mail, %arg{ 'from',
'to' }, ); }

sub send_spam (@messages, @addrs) { ... }

sub send_spam (@messages, @addrs) { ... } send_spam(@messages, @addr1, @addr2);

send_spam(@msgs1, @msgs2, @addrs);

send_spam(@msgs1, @msgs2, @addrs); send_spam($msg1, $msg2, $addr1, $addr2);

sub add ($x = 0, $y = 0) { !
return $x + $y; }

sub add ($x = 0, $y = 0) { !
return $x + $y; } my @summands = (8, 6);

sub add ($x = 0, $y = 0) { !
return $x + $y; } my @summands = (8, 6); add(@summands) ⇢

sub add ($x = 0, $y = 0) { !
return $x + $y; } my @summands = (8, 6); ! add(@summands) ⇢ ?????

sub ($x, $y) { return $x + $y; }

sub ($x, $y) { return $x + $y; } sub
($$) { my ($x, $y) = @_; return $x + $y; }

sub add ($x = 0, $y = 0) { !
return $x + $y; }

sub add ($x = 0, $y = 0) { !
return $x + $y; } my @summands = (8, 6);

sub add ($x = 0, $y = 0) { !
return $x + $y; } my @summands = (8, 6); add(@summands) ⇢ 14

sub add ($x = 0, $y = 0) { !
return $x + $y; } my @summands = (8, 6); add(@summands) ⇢ 14 add(@summands) ⇢ 2

sub add ($x = 0, $y = 0) { !
return $x + $y; } my @summands = (8, 6); ! add(@summands) ⇢ 14 add(@summands) ⇢ 2

sub each { my ($code, @rest) = @_; ! $code->()
for @rest; }

sub each { my ($code, @rest) = @_; ! $code->()
for @rest; } each( sub { say }, 1, 2, 3 );

sub each ($code, @rest) { ! $code->($_) for @rest; }
each( sub { say }, 1, 2, 3 );

sub each :prototype(&@) ($code, @rest) { ! $code->($_) for @rest;
} each( sub { say }, 1, 2, 3 );

sub each :prototype(&@) ($code, @rest) { ! $code->($_) for @rest;
} each { say } (1, 2, 3);

package Logger { sub log ($self, $message) { $self->syslog->log($message); }
}

} package Logger::Null { sub log ($self, $message) { # do nothing! } }

} package Logger::Null { sub log ($self, _) { # do nothing! } }

sub xyzzy ($x, @rest) { ! }

sub xyzzy ($x, @_) { ! }

sub xyzzy ($_, @_) { ! }

} package Logger::Null { sub log ($self, $) { # do nothing! } }

} package Logger::Null { sub log ($, $) { # do nothing! } }

package Logger { sub log ($self, $message = '') {
$self->syslog->log($message); } } package Logger::Null { sub log ($, $) { # do nothing! } }

$self->syslog->log($message); } } package Logger::Null { sub log ($, $ = '') { # do nothing! } }

$self->syslog->log($message); } } package Logger::Null { sub log ($, $ =) { # do nothing! } }

sub add ($x = 0, $y = 0) { return
$x + $y; }

sub add ($x = 0, $y = 0, @) {
return $x + $y; }

# adder.pl sub add ($x = 0, $y = 0)
{ return $x + $y; }

{ return $x + $y; } $ perl -MO=Deparse adder.pl

{ return $x + $y; } sub add { die 'Too many arguments for subroutine' unless @_ <= 2; my $x = @_ >= 1 ? $_[0] : 0; my $y = @_ >= 2 ? $_[1] : 0; (); return $x + $y; } $ perl -MO=Deparse adder.pl

# adder.pl sub add ($x = 0, $y = 0,
@) { return $x + $y; }

@) { return $x + $y; } $ perl -MO=Deparse adder.pl

@) { return $x + $y; } sub add { ! my $x = @_ >= 1 ? $_[0] : 0; my $y = @_ >= 2 ? $_[1] : 0; (); return $x + $y; } $ perl -MO=Deparse adder.pl

Signatures!!!

Signatures!!! •sub x ($y, $z)

Signatures!!! •sub x ($y, $z) •sub y ($y = default_expr)

•sub z ($x, $y, @z)

•sub z ($x, $y, @z) •sub w ($self, $, @)

•sub z ($x, $y, @z) •sub w ($self, $, @) •sub wtf :prototype($$) ($ugh, $bah)

Signatures

Signatures sub xyzzy :Attr(foo) ($x, $y)  not  sub xyzzy ($x,
$y) :Attr(foo)

$y) :Attr(foo) lousy errors (from sub, not caller)

$y) :Attr(foo) lousy errors (from sub, not caller) a little slower than necessary

Subroutine Signatures!

Subroutine Signatures! EXPERIMENTAL

Perl 5.20

Perl 5.20 •postﬁx dereferencing!

Perl 5.20 •postﬁx dereferencing! •pair slicing!

Perl 5.20 •postﬁx dereferencing! •pair slicing! •subroutine signatures!

Perl 5.20 •postﬁx dereferencing! •pair slicing! •subroutine signatures! •Mongolian vowel
separation ﬁxes!

Perl 5.20 Available Now!

Perl 5.20 Available Now! Free!

Like 5.10

Like 5.10 But Good Like 5.10

Any Questions?

Thank You!

Perl 5 at 20: Perl v5.20.0

Perl 5 at 20: Perl v5.20.0

More Decks by Ricardo Signes

Other Decks in Programming

Featured

Transcript