The document discusses new features and changes in Perl 5.10. Some key points include: - Perl 5.10 introduces many new features and changes that are not backwards compatible with Perl 5.8.x. - Notable new features include lexically scoped pragmas, pluggable regular expression engines, smarter pattern matching, and state variables. - The document provides examples of new operators and functions like smart matching (~~), given/when, and say that output a newline.

1. Perl 5.10
for people who are not insane

2. Perl 5.10
for people who are not totally insane

3. 5.10 isn’t like 5.8.x
perl5100delta

4. 5.10 isn’t like 5.8.x
- features only get added in new 5.x releases
perl5100delta

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. 5.10 is Way Cool
perl51000delta

7. 5.10 is Way Cool
- no significant new features in Perl since 2002
perl51000delta

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. 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. 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. Lexicascopasmartwhat?
perl51000delta

12. Lexicascopasmartwhat?
- lexically scoped user pragmata!
perl51000delta

13. Lexicascopasmartwhat?
- lexically scoped user pragmata!
- pluggable regex compilation engines!
perl51000delta

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

15. Lexicascopasmartwhat?
- lexically scoped user pragmata!
- pluggable regex compilation engines!
- trie-based non-recursive pattern matching!
- thread-safe weak refkey hashes!
perl51000delta

16. Yes, You Care
perl51000delta

17. Yes, You Care
- Not everything in 5.10 is esoteric.
perl51000delta

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

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. 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. First: A Warning
feature

22. First: A Warning
- 5.10 is backwards compatible
feature

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

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

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. 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. 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. 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. 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. say what

31. say $what
- new built-in, say
- it’s like print
- but it adds a newline for you
perlfunc

32. say $what
perlfunc

33. say $what
print “Hello, world!n”;
perlfunc

34. say $what
print “Hello, world!n”;
print “$messagen”;
perlfunc

35. say $what
print “Hello, world!n”;
print “$messagen”;
print “$_n” for @lines;
perlfunc

36. say $what
print “Hello, world!n”;
say “Hello, world!”;
print “$messagen”;
print “$_n” for @lines;
perlfunc

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

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

39. truth and definedness

40. truth and definedness
perlop

41. truth and definedness
sub record_sale {
perlop

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

43. truth and definedness
sub record_sale {
my ($product, $amount) = @_;
$amount ||= $product->cost;
perlop

44. truth and definedness
sub record_sale {
my ($product, $amount) = @_;
$amount ||= $product->cost;
...
perlop

45. truth and definedness
sub record_sale {
my ($product, $amount) = @_;
$amount ||= $product->cost;
...
}
perlop

46. truth and definedness
sub record_sale {
my ($product, $amount) = @_;
$amount = defined $amount
? $amount
: $product->cost;
...
}
perlop

47. truth and definedness
sub record_sale {
my ($product, $amount) = @_;
$amount ||= $product->cost;
...
}
perlop

48. truth and definedness
sub record_sale {
my ($product, $amount) = @_;
$amount ||= $product->cost;
...
}
perlop

49. the new OR operator
sub record_sale {
my ($product, $amount) = @_;
$amount //= $product->cost;
...
}
perlop

50. the new OR operator
$setting = defined $given
? $given
: $default;
perlop

51. the new OR operator
$setting = $given;
unless (defined $setting) {
$setting = $default;
}
perlop

52. the new OR operator
$setting = $given || $default;
perlop

53. the new OR operator
$setting = $given // $default;
perlop

54. keeping state

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

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

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

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. State Variables
{
my $lines_left = 100;
sub read_line {
die “trial period expired”
unless $lines_left-- > 0;
...
}
}
perlsub

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

61. -x stacking

62. Stackable File Tests
if (
-f $file
and -w $file
and -z $file
) {
unlink $file;
}
perlfunc

63. Stackable File Tests
if (
-f $file and -w _ and -z _
) {
unlink $file;
}
perlfunc

64. Stackable File Tests
if (-f -w -z $file) {
unlink $file;
}
perlfunc

65. smart matching

66. Smart Matching
perlsyn

67. Smart Matching
- a new kind of comparison operator
perlsyn

68. Smart Matching
- a new kind of comparison operator
- its behavior depends on its inputs
perlsyn

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

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. Smart Matching
perlsyn

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

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

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

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

76. Smart Matching
if ($foo ~~ undef) { ... }
elsif ($foo ~~ @array) { ... }
elsif ($foo ~~ $code) { ... }
elsif ($foo ~~ %hash) { ... }
elsif ($foo ~~ qr/re/) { ... }
perlsyn

77. Smart Matching
if ($foo ~~ undef) { ... }
elsif ($foo ~~ @array) { ... }
elsif ($foo ~~ $code) { ... }
elsif ($foo ~~ %hash) { ... }
elsif ($foo ~~ qr/re/) { ... }
elsif ($foo ~~ $bar) { ... }
perlsyn

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. Smart Matching
given ($foo) {
when (undef) { ... }
when (@array) { ... }
when ($code) { ... }
when (%hash) { ... }
when (qr/re/) { ... }
when ($bar) { ... }
default { ... }
}
perlsyn

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. Smart Matching
if ($foo ~~ undef) { ... }
elsif ($foo ~~ $array) { ... }
elsif ($foo ~~ $code) { ... }
elsif ($foo ~~ $hash) { ... }
elsif ($foo ~~ qr/re/) { ... }
elsif ($foo ~~ $bar) { ... }
else { ... }
perlsyn

82. Smart Matching
my $test;
perlsyn

83. Smart Matching
given ($foo) {
when (undef) { ... }
when ($aref) { ... }
when ($code) { ... }
when ($href) { ... }
when ($regex) { ... }
when ($object) { ... }
default { ... }
}
perlsyn

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. Smart Matching
perlsyn

86. Smart Matching
@want = @have->where($test)
perlsyn

87. Smart Matching
@want = @have->where($test)
@want = @have->where(sub{ …… })
perlsyn

88. Smart Matching
@want = @have->where($test)
@want = @have->where(sub{ …… })
@want = @have->where(qr/.../sm)
perlsyn

89. Smart Matching
@want = @have->where($test)
@want = @have->where(sub{ …… })
@want = @have->where(qr/.../sm)
@want = @have->where([ 1,2,3 ])
perlsyn

90. Smart Matching
perlsyn

91. Smart Matching
sub where {
perlsyn

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

93. Smart Matching
sub where {
my ($array, $test) = @_;
if (ref $test eq ‘ARRAY’) {
perlsyn

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

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

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

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. 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. 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. 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. 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. 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. 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. 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. Smart Matching
sub where {
my ($array, $test) = @_;
grep { $_ ~~ $test } @$array;
}
perlsyn

106. Smart Matching
SmartMatch::Sugar
perlsyn

107. Smart Matching
SmartMatch::Sugar
@want = @have->where( hash )
perlsyn

108. Smart Matching
SmartMatch::Sugar
@want = @have->where( hash )
@want = @have->where( class )
perlsyn

109. Smart Matching
SmartMatch::Sugar
@want = @have->where( hash )
@want = @have->where( class )
@want = @have->where(isa(‘Foo’))
perlsyn

110. unknown undefined

111. Better Error Message(s)
$str = “Greetings, $name. Your last
login was $last. It is now $time.”;
perldiag

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. 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. inside-out objects

115. Inside-Out Objects
Hash::Util::FieldHash

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

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

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. 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. 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. Inside-Out Objects
sub size {
my $self = shift;
if (@_) {
return $self->{size} = shift;
} else {
return $self->{size};
}
}
Hash::Util::FieldHash

122. Inside-Out Objects
my %size;
sub size {
my $self = shift;
if (@_) {
return $size{ $self } = shift;
} else {
return $size{ $self };
}
}
Hash::Util::FieldHash

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. 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. 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. 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. Field Hashes
Hash::Util::FieldHash

128. Field Hashes
- they’re just like hashes
Hash::Util::FieldHash

129. Field Hashes
- they’re just like hashes
- objects as keys become object ids
Hash::Util::FieldHash

130. Field Hashes
- they’re just like hashes
- objects as keys become object ids
- but get destroyed and cloned
Hash::Util::FieldHash

131. Field Hashes
my %size;
sub size {
my $self = shift;
if (@_) {
return $size{ $self } = shift;
} else {
return $size{ $self };
}
}
Hash::Util::FieldHash

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

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

134. Field Hashes
sub size {
my $self = shift;
fieldhash state %size;
if (@_) {
return $size{ $self } = shift;
} else {
return $size{ $self };
}
}
Hash::Util::FieldHash

135. lexical topic

136. (topic is how you say $_)

137. Lexical Topic
for (@lines) {
chomp;
next if /^#/;
next unless length;
s/a/b/;
sanity_check;
say;
}
perlvar

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. Lexical Topic
for my $_ (@lines) {
chomp;
next if /^#/;
next unless length;
s/a/b/;
sanity_check;
say;
}
perlvar

140. Regex

141. named captures

142. Regex: Named Captures
perlre

143. Regex: Named Captures
- find matches by name, not position
perlre

144. Regex: Named Captures
- find matches by name, not position
- avoid the dreaded$1
perlre

145. Regex: Named Captures
- find matches by name, not position
- avoid the dreaded $1
- no longer second to Python or .Net!
perlre

146. Regex: Named Captures
# our hypothetical format
section:property = value
perlre

147. Regex: Named Captures
$line ~~ /(w+):(w+) = (w+)/;
$name = $2;
$value = $3;
perlre

148. Regex: Named Captures
$lhs_re = qr/(w+):(w+)/;
$rhs_re = qr/(w+)/;
$line ~~ /$lhs_re = $rhs_re/;
$name = $2;
$value = $3;
perlre

149. Regex: Named Captures
$line ~~ /$lhs_re = $rhs_re/;
$name = $2;
$value = $3;
perlre

150. Regex: Named Captures
$line ~~ /$lhs_re = $rhs_re/;
$name = $+{ name };
$value = $+{ value };
perlre

151. Regex: Named Captures
$lhs_re = qr/(w+):(w+)/;
$rhs_re = qr/(w+)/;
perlre

152. Regex: Named Captures
$lhs_re = qr/(w+):(?<name>w+)/;
$rhs_re = qr/(?<value>w+)/;
perlre

153. better backrefs

154. Regex: Backreference
m{< (w+) > .+ < /1 > }x
perlre

155. Regex: Backreference
m{< (w+) > .+ < /1 > }x
perlre

156. Regex: Backreference
10
perlre

157. Regex: Backreference
qr{(d)10}
perlre

158. Regex: Backreference
qr{ (d) 1 0}x
perlre

159. Regex: Backreference
m{< (w+) > .+ < /1 > }x
perlre

160. Regex: Backreference
m{< (w+) > .+ < /g{1} > }x
perlre

161. Regex: Backreference
10
perlre

162. Regex: Backreference
g{10}
perlre

163. Regex: Backreference
qr{(d)10}
perlre

164. Regex: Backreference
qr{(d)g{1}0}
perlre

165. Regex: Backreference
qr{(d)g{-1}0}
perlre

166. Regex: Backreference
qr{
(?<digit>d)
g{digit}
0
}x
perlre

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. Regex: Backreference
if ($str =~ $wtf_re) {
...
}
perlop

169. Regex: Backreference
if ($str ~~ $wtf_re) {
...
}
perlop

170. lexically scoped alternate
trie-based reentrant user-
defined regex pragmata

171. flexible regex

172. Alternate Regex Engines
perlreapi

173. Alternate Regex Engines
- lets you change how regex work
perlreapi

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

175. Alternate Regex Engines
re::engine::POSIX

176. Alternate Regex Engines
egrep -r -l PATTERN DIR
re::engine::POSIX

177. Alternate Regex Engines
my $regex = qr{ ... };
my @files = $find->file->in( $root );
say for grep { slurp ~~ $re } @files;
re::engine::POSIX

178. Alternate Regex Engines
re::engine::POSIX

179. Alternate Regex Engines
egrep -r -l ‘.+?’ DIR
re::engine::POSIX

180. Alternate Regex Engines
my $regex = qr{ ... };
my @files = $find->file->in( $root );
say for grep { slurp ~~ $re } @files;
re::engine::POSIX

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. 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. http://www.perl.org/get.html

184. Any questions?