Perl 5.10 for People Who Are Not (Totally) Insane

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.

Transcript

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