Perl 5.16 for the Working Programmer

This presentation covers the useful-everyday stuff from Perl 5.16, as well as Perl 5.10 - 5.14.

Transcript

1. Perl 5.16 for the working programmer
2. Perl 5 what's new?
3. Perl 5.10 for people who are not totally insane
4. Perl 5.12 for everyday use
5. Perl 5.14 for pragmatists
6. Perl 5.16 for the working programmer
7. Lexical Semantics!
8. use feature ‘say’; say “This is a test!”; { no feature ‘say’; say “This is fatal!”; }
9. use 5.16.0; say “This is a test!”; { no feature ‘say’; say “This is fatal!”; }
10. #!/usr/bin/perl use strict; use warnings; use 5.16.0; # use feature ‘:5.16’; my $x = Reticulator->new; $x->reticulate(@splines);
11. #!/usr/bin/perl use strict; use warnings; # no feature; my $x = Reticulator->new; $x->reticulate(@splines);
12. #!/usr/bin/perl use strict; use warnings; # use feature ‘:default’ my $x = Reticulator->new; $x->reticulate(@splines);
13. array_base: $[
14. Cool New Features!
15. perldiag $str = “Greetings, $name. Your last login was $last. It is now $time.”; Better Error Message(s)
16. perldiag $str = “Greetings, $name. Your last login was $last. It is now $time.”; Better Error Message(s) Use of uninitialized value in concatenation (.) or string at hello.plx line 9.
17. perldiag Better Error Message(s) Use of uninitialized value $time in concatenation (.) or string at hello.plx line 9. $str = “Greetings, $name. Your last login was $last. It is now $time.”;
18. perlsub my $LINES_READ = 0; sub read_line { $LINES_READ++; ... } State Variables
19. perlsub { my $LINES_READ = 0; sub read_line { $LINES_READ++; ... } } State Variables
20. perlsub sub read_line { state $LINES_READ = 0; $LINES_READ++; ... } State Variables
21. perlop truth and definedness
22. perlop truth and definedness sub record_sale {
23. perlop truth and definedness sub record_sale { my ($product, $amount) = @_;
24. perlop truth and definedness sub record_sale { my ($product, $amount) = @_; my $price = $amount
25. perlop truth and definedness sub record_sale { my ($product, $amount) = @_; my $price = $amount || $product->price;
26. perlop truth and definedness sub record_sale { my ($product, $amount) = @_; my $price = $amount || $product->price; ...
27. perlop truth and definedness sub record_sale { my ($product, $amount) = @_; my $price = $amount || $product->price; ... }
28. perlop truth and definedness sub record_sale { my ($product, $amount) = @_; $price = defined $amount ? $amount : $product->price; ... }
29. perlop truth and definedness sub record_sale { my ($product, $amount) = @_; my $price = $amount || $product->price; ... }
30. perlop truth and definedness sub record_sale { my ($product, $amount) = @_; my $price = $amount // $product->price; ... }
31. perlop the new OR operator sub record_sale { my ($product, $amount) = @_; $amount //= $product->cost; ... }
32. perlfunc - new built-in, say - it’s like print - but it adds a newline for you say $what
33. perlfunc say $what
34. perlfunc say $what print “Hello, world!\n”;
35. perlfunc say $what print “Hello, world!\n”; print “$message\n”;
36. perlfunc say $what print “Hello, world!\n”; print “$message\n”; print “$_\n” for @lines;
37. perlfunc say $what print “Hello, world!\n”; print “$message\n”; print “$_\n” for @lines; say “Hello, world!”;
38. perlfunc say $what print “Hello, world!\n”; print “$message\n”; print “$_\n” for @lines; say “Hello, world!”; say $message;
39. perlfunc say $what print “Hello, world!\n”; print “$message\n”; print “$_\n” for @lines; say “Hello, world!”; say $message; say for @lines;
41. $ perl -e ‘print “Foo\n”’
42. $ perl -e ‘print “Foo\n”’ $ perl -E ‘say “Foo”’
43. sub fact { my ($x) = @_; # must be +int return $x if $x == 1; return $x * fact($x - 1); } Recursion!
44. sub fact { my ($x) = @_; # must be +int return $x if $x == 1; return $x * fact($x - 1); } Recursion!
45. my $fact = sub { my ($x) = @_; # must be +int return $x if $x == 1; return $x * $fact->($x - 1); }; Recursion!
46. my $fact = sub { my ($x) = @_; # must be +int return $x if $x == 1; return $x * $fact->($x - 1); }; Recursion!
47. my $fact; $fact = sub { my ($x) = @_; # must be +int return $x if $x == 1; return $x * $fact->($x - 1); }; Recursion!
48. my $fact; $fact = sub { my ($x) = @_; # must be +int return $x if $x == 1; return $x * $fact->($x - 1); }; Recursion!
49. use Scalar::Util qw(weaken); my $fact = do { my $f1; my $f2 = $f1 = sub { my ($x) = @_; return $x if $x == 1; return $x * $f1->($x - 1); }; weaken($f1); $f1; }; Recursion!
50. use 5.16.0; # current_sub my $fact = sub { my ($x) = @_; # must be +int return $x if $x == 1; return $x * __SUB__->($x - 1); }; Recursion!
51. Filehandles!
52. autodie autodie open my $fh, ‘<‘, $filename; while (<$fh>) { ... } close $fh;
53. autodie autodie open my $fh, ‘<‘, $filename or die “couldn’t open $filename: $!”; while (<$fh>) { ... } close $fh or die “couldn’t close $filename: $!”;
54. autodie autodie use autodie; open my $fh, ‘<‘, $filename; while (<$fh>) { ... } close $fh;
55. autodie autodie use autodie; open my $fh, ‘<‘, $filename; while (<$fh>) { no autodie; rmdir or warn “couldn’t remove $_: $!”; } close $fh;
56. autodie autodie use autodie; sub foo { my $filename = shift; open my $fh, ‘<‘, $filename; while (<$fh>) { ... } } # this implicit close DID NOT AUTODIE
57. perlopentut 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: $!”; }
58. 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: $!”; }
59. perlopentut IO::File sub stream_to_fh { ... $fh->print($hunk); ... $fh->close or die “error closing: $!”; } open my $target, ‘>’, ‘/dev/null’ or die “can’t open bit bucket: $!”; stream_to_fh($target);
60. perlopentut IO::File use IO::File; sub stream_to_fh { ... $fh->print($hunk); ... $fh->close or die “error closing: $!”; } open my $target, ‘>’, ‘/dev/null’ or die “can’t open bit bucket: $!”; stream_to_fh($target);
61. perlopentut IO::File use 5.14.0; sub stream_to_fh { ... $fh->print($hunk); ... $fh->close or die “error closing: $!”; } open my $target, ‘>’, ‘/dev/null’ or die “can’t open bit bucket: $!”; stream_to_fh($target);
62. perlopentut IO::File use 5.14.0; use autodie; sub stream_to_fh { ... $fh->print($hunk); ... $fh->close or die “error closing: $!”; } open my $target, ‘>’, ‘/dev/null’ or die “can’t open bit bucket: $!”; stream_to_fh($target);
63. perlfunc Package Blocks package Library::Awesome; our $VERSION = 1.234; sub foo { ... } 1;
64. perlfunc Package Blocks use 5.12.0; package Library::Awesome 1.234; sub foo { ... } 1;
65. perlfunc Package Blocks use 5.12.0; package Library::Awesome 1.234-alpha; sub foo { ... } 1;
66. perlfunc Package Blocks package Library::Awesome 1.234 { sub foo { ... } } 1;
67. perldoc overloading - the -x overload - the qr overload - "no overloading" - unknown overload warns
68. Other New Features!
69. smrt match
70. if ($x ~~ $y) { ... } smrt match
71. perldoc smrt match
72. perldoc smrt match - if $x and $y are unknown, there are 23 possible dispatch paths
73. perldoc smrt match - if $x and $y are unknown, there are 23 possible dispatch paths - and some of them redispatch recursively
74. perldoc smrt match - if $x and $y are unknown, there are 23 possible dispatch paths - and some of them redispatch recursively - no, you won't remember them all
75. perldoc smrt match - if $x and $y are unknown, there are 23 possible dispatch paths - and some of them redispatch recursively - no, you won't remember them all - ...and they can't be intuited
76. Matching
77. if ($x ~~ $y) {...} Matching
78. if ($x ~~ $y) {...} if ($str ~~ %hash) {...} Matching
79. if ($x ~~ $y) {...} if ($str ~~ %hash) {...} if ($str ~~ @arr) {...} Matching
80. if ($x ~~ $y) {...} if ($str ~~ %hash) {...} if ($str ~~ @arr) {...} if ($str ~~ [ \%h, ...]) {...} Matching
81. if ($x ~~ $y) {...} if ($str ~~ %hash) {...} if ($str ~~ @arr) {...} if ($str ~~ [ \%h, ...]) {...} if (%hash ~~ %h) {...} Matching
82. if ($x ~~ $y) {...} if ($str ~~ %hash) {...} if ($str ~~ @arr) {...} if ($str ~~ [ \%h, ...]) {...} if (%hash ~~ %h) {...} if (%hash ~~ @arr) {...} Matching
83. if ($x ~~ $y) {...} if ($str ~~ %hash) {...} if ($str ~~ @arr) {...} if ($str ~~ [ \%h, ...]) {...} if (%hash ~~ %h) {...} if (%hash ~~ @arr) {...} if (%hash ~~ [ \%h,...]) {...} Matching
84. given ($x) { when ($y) { ... } when ($z) { ... } }
85. given ($x) { when ($y) { try { ... } catch { warn “error: $_”; return undef; } } }
86. each @array
87. while (my ($i, $v) = each @array) { say “$i: $v”; } each @array
88. push $aref, @etc;
89. Now With Fewer Bugs!
90. y2038
92. ~$ perl5.10.0 -E ‘say scalar localtime 2**31-1’
93. ~$ perl5.10.0 -E ‘say scalar localtime 2**31-1’ Mon Jan 18 22:14:07 2038
94. ~$ perl5.10.0 -E ‘say scalar localtime 2**31-1’ Mon Jan 18 22:14:07 2038 ~$ perl5.10.0 -E ‘say scalar localtime 2**31’
95. ~$ perl5.10.0 -E ‘say scalar localtime 2**31-1’ Mon Jan 18 22:14:07 2038 ~$ perl5.10.0 -E ‘say scalar localtime 2**31’ Fri Dec 13 15:45:52 1901
97. ~$ perl5.12.0 -E ‘say scalar localtime 2**31-1’
98. ~$ perl5.12.0 -E ‘say scalar localtime 2**31-1’ Mon Jan 18 22:14:07 2038
99. ~$ perl5.12.0 -E ‘say scalar localtime 2**31-1’ Mon Jan 18 22:14:07 2038 ~$ perl5.12.0 -E ‘say scalar localtime 2**31’
100. ~$ perl5.12.0 -E ‘say scalar localtime 2**31-1’ Mon Jan 18 22:14:07 2038 ~$ perl5.12.0 -E ‘say scalar localtime 2**31’ Mon Jan 18 22:14:08 2038
101. perlvar $@
102. Try::Tiny $@
103. Try::Tiny $@ - Well, actually, you use Try::Tiny, right?
104. Try::Tiny $@ - Well, actually, you use Try::Tiny, right? - But this makes Try::Tiny more reliable, too!
105. Try::Tiny $@ - Well, actually, you use Try::Tiny, right? - But this makes Try::Tiny more reliable, too! - You see, eval and $@ are totally awful
106. perlfunc use 5.12.0; { package X; sub DESTROY { eval { } } } eval { my $x = bless {} => ‘X’; die “DEATH!!”; }; warn “ERROR: $@”;
107. perlfunc use 5.12.0; { package X; sub DESTROY { eval { } } } eval { my $x = bless {} => ‘X’; die “DEATH!!”; }; warn “ERROR: $@”; $ perl5.12.4 test.pl ERROR:
108. perlfunc use 5.14.0; { package X; sub DESTROY { eval { } } } eval { my $x = bless {} => ‘X’; die “DEATH!!”; }; warn “ERROR: $@”;
109. perlfunc use 5.14.0; { package X; sub DESTROY { eval { } } } eval { my $x = bless {} => ‘X’; die “DEATH!!”; }; warn “ERROR: $@”; $ perl5.14.1 test.pl ERROR: DEATH!!
111. perl -le ‘print $^X’
112. perl -le ‘print $^X’ 10.0: perl
113. perl -le ‘print $^X’ 10.0: perl 10.1: perl
114. perl -le ‘print $^X’ 10.0: perl 10.1: perl 12.0: perl
115. perl -le ‘print $^X’ 10.0: perl 10.1: perl 12.0: perl 14.0: perl
116. perl -le ‘print $^X’ 10.0: perl 10.1: perl 12.0: perl 14.0: perl 16.0: /Users/rjbs/perl5/perlbrew/perls/16.0/bin/perl
117. Simpler Strings
118. perlunicode Perl is Good at Unicode
119. perlunicode Perl 5.16 is Better
120. perlunicode Perl 5.16 is Better - Unicode 6.1
121. perlunicode Perl 5.16 is Better - Unicode 6.1 - every character property is available
122. perlunicode Perl 5.16 is Better - Unicode 6.1 - every character property is available - \X in regex is more sensible
123. perlunicode “The Unicode Bug”
124. perlunicode “The Unicode Bug” - strings aren’t always treated as Unicode
125. perlunicode “The Unicode Bug” - strings aren’t always treated as Unicode - this causes weird bugs that take ages to find
126. perlunicode “The Unicode Bug” - strings aren’t always treated as Unicode - this causes weird bugs that take ages to find - use feature ‘unicode_strings’;
127. perlunicode “The Unicode Bug” - strings aren’t always treated as Unicode - this causes weird bugs that take ages to find - use feature ‘unicode_strings’; - or use 5.12.0
128. perldoc Unicode eval - eval $str - is that octets or chars? - what if it includes "use utf8" - or you're under "use utf8"?
129. perldoc Unicode eval - evalbytes $str - unicode_eval
130. perldiag My Favorite 5.12-ism? if (length $input->{new_email}) { $user->update_email(...); }
131. perldiag My Favorite 5.12-ism? Use of uninitialized value in length at - line 3120. if (length $input->{new_email}) { $user->update_email(...); }
132. perldiag My Favorite 5.12-ism? if (length $input->{new_email}) { $user->update_email(...); }
133. perlsyn say “I \o{23145} Perl 5.14!”;
134. perlsyn say “I \o{23145} Perl 5.14!”; I — Perl 5.14!
135. perlsyn say “I \23145 Perl 5.14!”; I ?45 Perl 5.14!
136. perlsyn say “I \023145 Perl 5.14!”; I 145 Perl 5.14!
137. perlre qr{ (1) (2) (3) (4) \7 \10 (5) (6) (7) (8) (9) \7 \10 (10) \7 \10 }x;
138. 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;
139. charnames Unicode 6.1
140. charnames Unicode 6.1
141. charnames Unicode 6
142. charnames Unicode 6
143. charnames Unicode 6
144. charnames Unicode 6
145. charnames Unicode 6
146. charnames Unicode 6
147. charnames Unicode 6
148. charnames Unicode 6
149. charnames Unicode 6
150. use 5.16.0; say “I \N{HEAVY BLACK HEART} Queensr” . “\N{LATIN SMALL LETTER Y WITH DIAERESIS}” . “che!”; \N{...}
151. case folding
152. if (lc $foo eq lc $bar) { ... } Case Folding
153. if (fc $foo eq fc $bar) { ... } Case Folding
154. Case Folding
155. lc ‘ς‘ ➔ ‘ς‘ Case Folding
156. lc ‘ς‘ ➔ ‘ς‘ uc ‘ς‘ ➔ ‘Σ‘ Case Folding
157. lc ‘ς‘ ➔ ‘ς‘ uc ‘ς‘ ➔ ‘Σ‘ fc ‘ς‘ ➔ ‘σ‘ Case Folding
158. lc ‘ς‘ ➔ ‘ς‘ uc ‘ς‘ ➔ ‘Σ‘ fc ‘ς‘ ➔ ‘σ‘ lc ‘ß’ ➔ ‘ß’ Case Folding
159. lc ‘ς‘ ➔ ‘ς‘ uc ‘ς‘ ➔ ‘Σ‘ fc ‘ς‘ ➔ ‘σ‘ lc ‘ß’ ➔ ‘ß’ uc ‘ß’ ➔ ‘SS’ Case Folding
160. lc ‘ς‘ ➔ ‘ς‘ uc ‘ς‘ ➔ ‘Σ‘ fc ‘ς‘ ➔ ‘σ‘ lc ‘ß’ ➔ ‘ß’ uc ‘ß’ ➔ ‘SS’ fc ‘ß’ ➔ ‘ss’ Case Folding
161. Case Folding
162. “file under: \L$name” Case Folding
163. “file under: \L$name” “file under: \F$name” Case Folding
164. Better Regex
165. named captures
166. perlre Regex: Named Captures
167. perlre Regex: Named Captures - find matches by name, not position
168. perlre Regex: Named Captures - find matches by name, not position - avoid the dreaded $1
169. perlre Regex: Named Captures - find matches by name, not position - avoid the dreaded $1 - no longer second to Python or .Net!
170. perlre # our hypothetical format section:property = value Regex: Named Captures
171. perlre $line =~ /(\w+):(\w+) = (\w+)/; $section = $1 $name = $2; $value = $3; Regex: Named Captures
172. perlre Regex: Named Captures $line =~ / (?<section> \w+): (?<name> \w+) \s* = \s* (?<value> \w+) /x; $section = $+{section}; $name = $+{name}; $value = $+{value};
173. perlre New Regex Modifiers my $hostname = get_hostname; $hostname =~ s/\..*//s;
174. perlre New Regex Modifiers my $hostname = get_hostname =~ s/\..*//s;
175. perlre New Regex Modifiers (my $hostname = get_hostname) =~ s/\..*//s;
176. perlre New Regex Modifiers my $hostname = get_hostname =~ s/\..*//sr;
177. perlre New Regex Modifiers my @short_names = map { s/\..*//s; } @long_names;
178. perlre New Regex Modifiers my @short_names = map { s/\..*//s; $_ } @long_names;
179. perlre New Regex Modifiers my @short_names = map { my $x = $_; $x =~ s/\..*//s; $x } @long_names;
180. perlre New Regex Modifiers my @short_names = map { s/\..*//sr } @long_names;
181. perlre New Regex Modifiers my @short_names = map s/\..*//sr, @long_names;
182. perldoc New Regex Modifiers
183. perldoc /u /a /aa /d /l "൮" =~ /\d/ ✓ ❌ ❌ ¿? ¿? "ð" =~ /\w/ ✓ ❌ ❌ ¿? ¿? "ff" =~ /ff/i ✓ ✓ ❌ ¿? ¿? "ff" =~ /pL/i ✓ ✓ ✓ ¿? ¿? New Regex Modifiers
184. perldoc /u /a /aa /d /l "൮" =~ /\d/ ✓ ❌ ❌ ¿? ¿? "ð" =~ /\w/ ✓ ❌ ❌ ¿? ¿? "ff" =~ /ff/i ✓ ✓ ❌ ¿? ¿? "ff" =~ /pL/i ✓ ✓ ✓ ¿? ¿? New Regex Modifiers
185. perldoc /u /a /aa /d /l "൮" =~ /\d/ ✓ ❌ ❌ ¿? ¿? "ð" =~ /\w/ ✓ ❌ ❌ ¿? ¿? "ff" =~ /ff/i ✓ ✓ ❌ ¿? ¿? "ff" =~ /pL/i ✓ ✓ ✓ ¿? ¿? New Regex Modifiers
186. perldoc /u /a /aa /d /l "൮" =~ /\d/ ✓ ❌ ❌ ¿? ¿? "ð" =~ /\w/ ✓ ❌ ❌ ¿? ¿? "ff" =~ /ff/i ✓ ✓ ❌ ¿? ¿? "ff" =~ /pL/i ✓ ✓ ✓ ¿? ¿? New Regex Modifiers
187. perldoc /u /a /aa /d /l "൮" =~ /\d/ ✓ ❌ ❌ ¿? ¿? "ð" =~ /\w/ ✓ ❌ ❌ ¿? ¿? "ff" =~ /ff/i ✓ ✓ ❌ ¿? ¿? "ff" =~ /pL/i ✓ ✓ ✓ ¿? ¿? New Regex Modifiers
188. perldoc /u /a /aa /d /l "൮" =~ /\d/ ✓ ❌ ❌ ¿? ¿? "ð" =~ /\w/ ✓ ❌ ❌ ¿? ¿? "ff" =~ /ff/i ✓ ✓ ❌ ¿? ¿? "ff" =~ /pL/i ✓ ✓ ✓ ¿? ¿? New Regex Modifiers
189. perlre New Regex Modifiers # To be really ASCII-only: die “funny un-American characters” if $str =~ /\P{ASCII}/; $str =~ /...actual pattern.../;
190. study
191. my $re = qr{...complex...}; study
192. my $re = qr{...complex...}; my $str = q{...long complex...}; study
193. my $re = qr{...complex...}; my $str = q{...long complex...}; $str =~ $re; # slow!! study
194. my $re = qr{...complex...}; my $str = q{...long complex...}; $str =~ $re; # slow!! study $str; # does stuff study
195. my $re = qr{...complex...}; my $str = q{...long complex...}; $str =~ $re; # slow!! study $str; # does stuff $str =~ $re; # fast!! study
196. my $re = qr{...complex...}; my $str = q{...long complex...}; $str =~ $re; # slow but right!! study $str; # does stuff $str =~ $re; # who knows!! study
197. my $re = qr{...complex...}; my $str = q{...long complex...}; $str =~ $re; # slow but right!! study $str; # does nothing $str =~ $re; # slow but right!! study
198. Modder Modlib
199. perlmodlib Newly Cored Librarys - JSON - HTTP::Tiny - Module::Metadata - CPAN::Meta
200. perlmodlib Newly Ejected Librarys - Devel::DProf - Switch - the perl4 core - ...and more
201. Old Stuff Removed
202. perlop qw() for my $show qw(Smallville Lost V) { $tivo->cancel_pass( $show ); }
203. perlop qw() for my $show (qw(Smallville Lost V)) { $tivo->cancel_pass( $show ); }
204. $[
205. perlvar $[ - first index of array
206. perlvar $[ - first index of array - so you can make $array[1] mean first
207. perlvar $[ - first index of array - so you can make $array[1] mean first - isn’t that awesome???
208. perlvar $[ - first index of array - so you can make $array[1] mean first - isn’t that awesome??? - yeah, about as awesome as Comic Sans
209. perlvar $[ $[ = 1; for (1 .. $#array) { ... }
210. perlvar $[ for ($[ .. $#array) { ... }
211. perlvar $[ Assigned to $[. Are you some kind of idiot or something? at -e line 123.
212. perlvar $[ Use of assignment to $[ is deprecated at -e line 123.
213. defined @arr
214. Any questions?
215. Thank you!