Raku Regexen: Reducing line noise in your code. Steven Lembark Workhorse Computing [email protected] 

The difference … prefer readabity over compactness. – Larry Wall Regexes you can read. Code you can maintain. Do what I mean need. 

Aside: Just what is line noise? Random g88;d^C\@x*fhe screen. Due to acous*^&(*&;dljfa;dskjf tic interference. 

Raku Is more than "just syntax". New way to approach problems. Also true with regexen. Not just isolated "pattern matching" 

The old way RX-from-hell with alternations. Regex tokenizes, code parses. Interwined mess of code and regexes. Order-of-execution errors abound. 

Parse *.ini file my $header = qr{ ^ \h* \[ (? [^][]+ ) \] \h* $ }xm; my $property = qr{ ^ \h* (? .+? ) \h* = \h* (? .+ ) $ }xm; my $comment = qr{ ^ \h* \# }xm; my $empty_line = qr{ ^ \h* $}xm; 

Parse *.ini file for my $nextline (readline($INI_FILE)) { # If it's a header line, start a new section... if ($nextline =~ /$header/) { $section = $config{ $+{name} } //= {}; } # If it's a property, add the key and value to the current section... elsif ($nextline =~ /$property/) { $section->{ $+{key} } = $+{value}; } # Ignore comments or empty lines elsif ($nextline =~ /$comment|$empty_line/) { # Do nothing } # Report anything else as a probable error... else { warn "Invalid data in INI file at line $.\n" . "\t$nextline\n"; } } 

Maintainable? Inter-related order of code and rx. Code changes affect rx? Rx changes affect code? Find out: Try it and see... 

Raku: Grammars Structure in one place. Declarative. No iterative code. 

Tokens & Structure grammar INI { token TOP { * } token section { [ ^ | ] } token header { '[' $ = <-[ \[ \] \n ]>+ ']' \h* \n } token block { [ | <.emptylines> | <.comment> ]* } token property { \h* $=\N+? \h* '=' \h* $=\N+ \n } token comment { ^^ \h* '#' \N* \n } token emptylines { [ ^^ \h* \n ]+ } } 

Tokens & Structure grammar INI { token TOP { * } token section { [ ^ | ] } token header { '[' $ = <-[ \[ \] \n ]>+ ']' \h* \n } token block { [ | <.emptylines> | <.comment> ]* } token property { \h* $=\N+? \h* '=' \h* $=\N+ \n } token comment { ^^ \h* '#' \N* \n } token emptylines { [ ^^ \h* \n ]+ } } 

Tokens & Structure grammar INI { token TOP { * } token section { [ ^ | ] } token header { '[' $ = <-[ \[ \] \n ]>+ ']' \h* \n } token block { [ | <.emptylines> | <.comment> ]* } token property { \h* $=\N+? \h* '=' \h* $=\N+ \n } token comment { ^^ \h* '#' \N* \n } token emptylines { [ ^^ \h* \n ]+ } } 

Tokens & Structure grammar INI { token TOP { * } token section { [ ^ | ] } token header { '[' $ = <-[ \[ \] \n ]>+ ']' \h* \n } token block { [ | <.emptylines> | <.comment> ]* } token property { \h* $=\N+? \h* '=' \h* $=\N+ \n } token comment { ^^ \h* '#' \N* \n } token emptylines { [ ^^ \h* \n ]+ } } 

Tokens & Structure grammar INI { token TOP { * } token section { [ ^ | ] } token header { '[' $ = <-[ \[ \] \n ]>+ ']' \h* \n } token block { [ | <.emptylines> | <.comment> ]* } token property { \h* $=\N+? \h* '=' \h* $=\N+ \n } token comment { ^^ \h* '#' \N* \n } token emptylines { [ ^^ \h* \n ]+ } } 

Tokens & Structure grammar INI { token TOP { * } token section { [ ^ | ] } token header { '[' $ = <-[ \[ \] \n ]>+ ']' \h* \n } token block { [ | <.emptylines> | <.comment> ]* } token property { \h* $=\N+? \h* '=' \h* $=\N+ \n } token comment { ^^ \h* '#' \N* \n } token emptylines { [ ^^ \h* \n ]+ } } 

Process the content class INI::hash_builder { method TOP ($/) { make %( $».ast ) } method section ($/) { make ~($//'') => $.ast } method block ($/) { make %( $».ast ) } method property ($/) { make ~$ => ~$ } } my %config = INI.parsefile( 'example.ini', :actions(INI::hash_builder) ).ast; say %config.perl; 

Process the content class INI::hash_builder { method TOP ($/) { make %( $».ast ) } method section ($/) { make ~($//'') => $.ast } method block ($/) { make %( $».ast ) } method property ($/) { make ~$ => ~$ } } my %config = INI.parsefile( 'example.ini', :actions(INI::hash_builder) ).ast; say %config.perl; 

Process the content class INI::hash_builder { method TOP ($/) { make %( $».ast ) } method section ($/) { make ~($//'') => $.ast } method block ($/) { make %( $».ast ) } method property ($/) { make ~$ => ~$ } } my %config = INI.parsefile( 'example.ini', :actions(INI::hash_builder) ).ast; say %config.perl; 

Process the content class INI::hash_builder { method TOP ($/) { make %( $».ast ) } method section ($/) { make ~($//'') => $.ast } method block ($/) { make %( $».ast ) } method property ($/) { make ~$ => ~$ } } my %config = INI.parsefile( 'example.ini', :actions(INI::hash_builder) ).ast; say %config.perl; 

Process the content class INI::hash_builder { method TOP ($/) { make %( $».ast ) } method section ($/) { make ~($//'') => $.ast } method block ($/) { make %( $».ast ) } method property ($/) { make ~$ => ~$ } } my %config = INI.parsefile( 'example.ini', :actions(INI::hash_builder) ).ast; say %config.perl; 

Care to guess what this does? /{~}!@#$%^(&*)-+=[\/]:;"'<.,>?/ 

Care to guess what this does? Q: Which char's match themselves? /{~}!@#$%^(&*)-+=[\/]:;"'<.,>?/ 

Care to guess what this does? Q: Which char's match themselves? A: None, in Raku, since they are punctuation. /{~}!@#$%^(&*)-+=[\/]:;"'<.,>?/ 

Saner metachars Match integers enclosed in braces: [ 1, 2, 3 ] Perl 5: / \[ \s* (?: \d+ (?: \s* , \s* \d+ )* \s* )? \] /x 

Saner metachars Match integers enclosed in braces: [ 1, 2, 3 ] Perl 5: / \[ \s* (?: \d+ (?: \s* , \s* \d+ )* \s* )? \] /x 

Saner metachars Match integers enclosed in braces: [ 1, 2, 3 ] Perl 5: / \[ \s* (?: \d+ (?: \s* , \s* \d+ )* \s* )? \] /x 

Saner metachars Match integers enclosed in braces: [ 1, 2, 3 ] Perl 5: / \[ \s* (?: \d+ (?: \s* , \s* \d+ )* \s* )? \] /x 

Saner metachars Match integers enclosed in braces: [ 1, 2, 3 ] Perl 5: / \[ \s* (?: \d+ (?: \s* , \s* \d+ )* \s* )? \] /x 

Saner metachars Match integers enclosed in braces: [ 1, 2, 3 ] Perl 5: / \[ \s* (?: \d+ (?: \s* , \s* \d+ )* \s* )? \] /x Raku: / :s '[' [\d+]* % ',' ']' / 

Saner metachars Match integers enclosed in braces: [ 1, 2, 3 ] Perl 5: / \[ \s* (?: \d+ (?: \s* , \s* \d+ )* \s* )? \] /x Raku: / :s '[' [\d+]* % ',' ']' / Consume WS 

Saner metachars Match integers enclosed in braces: [ 1, 2, 3 ] Perl 5: / \[ \s* (?: \d+ (?: \s* , \s* \d+ )* \s* )? \] /x Raku: / :s '[' [\d+]* % ',' ']' / Literals 

Saner metachars Match integers enclosed in braces: [ 1, 2, 3 ] Perl 5: / \[ \s* (?: \d+ (?: \s* , \s* \d+ )* \s* )? \] /x Raku: / :s '[' [\d+]* % ',' ']' / Non-capturing match 

Saner metachars Match integers enclosed in braces: [ 1, 2, 3 ] Perl 5: / \[ \s* (?: \d+ (?: \s* , \s* \d+ )* \s* )? \] /x Raku: / :s '[' [\d+]* % ',' ']' / Separator 

Saner metachars Match integers enclosed in braces: [ 1, 2, 3 ] Perl 5: / \[ \s* (?: \d+ (?: \s* , \s* \d+ )* \s* )? \] /x Raku: / :s '[' [\d+]* % ',' ']' / 

Aside: Future speed Raku regexen execute as DFA where possible. Opportunity for much faster execution. For some definition of ... 

Aside: Future speed Raku regexen execute as DFA where possible. Also benefit from saner results. DFA more likely to Do What I Mean. Alternations match best, not first match. 

Smartest matching Raku: say $& if 'Which regex engine is smartest?' =~ /smart|smarter|smartest/; 

Smartest matching Raku: say $& if 'Which regex engine is smartest?' =~ /smart|smarter|smartest/; 

Smartest matching Raku: say $& if 'Which regex engine is smartest?' =~ /smart|smarter|smartest/; Perl 6: say $/ if 'Which regex engine is smartest?' ~~ /smart|smarter|smartest/; 

Smartest matching Raku: say $& if 'Which regex engine is smartest?' =~ /smart|smarter|smartest/; Perl 6: say $/ if 'Which regex engine is smartest?' ~~ /smart|smarter|smartest/; 

Smartest matching Raku: say $& if 'Which regex engine is smartest?' =~ /smart|smarter|smartest/; Perl 6: say $/ if 'Which regex engine is smartest?' ~~ /smart|smarter|smartest/; 

Perl5 nested structure #! /usr/bin/env perl use 5.010; # We're going to need this to extract hierarchical data structures... our @stack = []; my $LIST = qr{ # Match this... (?&NESTED) # Which is defined as... (?(DEFINE) (? # Keep track of recursions on a stack... (?{ local @::stack = (@::stack, []); }) # Match a list of items... \[ \s* (?> (?&ITEM) (?: \s* , \s* (?&ITEM) )*+ )? \s* \] # Pop the stack and add that frame to the growing data structure... (?{ local @::stack = @::stack; my $nested = pop @stack; push @{$::stack[-1]}, $nested; }) ) # For each item, push it onto the stack if it's a leaf node... (? (\d+) (?{ push @{$stack[-1]}, $^N }) | (?&NESTED) ) ) }x; # Match, extracting a data structure... '[1,2,[3,3,[4,4]],5]' =~ /$LIST/; # Retrieve the data structure... my $parse_tree = pop @stack; # Show it... use Data::Dumper 'Dumper'; say Dumper($parse_tree); 

Perl6 nested grammar #! /usr/bin/env rakudo use v6; # Define the structure of a list... grammar LIST { rule TOP { '[' * % ',' ']' } token ITEM { \d+ | } } # Define how to convert list elements to a suitable data structure... class TREE { method TOP ($/) { make [ $».ast ] } method ITEM ($/) { make $.ast // +$/ } } # Parse, extracting the data structure... my $parse_tree = LIST.parse('[1,2,[3,3,[4,4]],5]', :actions(TREE)).ast; say $parse_tree.perl; 

Perl6 nested regex #! /usr/bin/env rakudo use v6; '[1,2,[3,3,[4,4]],5]' ~~ /'[' [ (\d+ ) | $<0>=<~~> ]* % ',' ']' /; say $/; 

Perl6 nested regex #! /usr/bin/env rakudo use v6; '[1,2,[3,3,[4,4]],5]' ~~ /'[' [ (\d+) | $<0>=<~~> ]* % ',' ']' /; say $/; 

In Raku Regexen are saner. 

In Raku Regexen are saner. Grammars offer cleaner code. 

In Raku Regexen are saner. Grammars offer cleaner code. Smart matching works. 

In Raku Regexen are saner. Grammars offer cleaner code. Smart matching works. Objects have useful methods. 

In Raku Regexen are saner. Grammars offer cleaner code. Smart matching works. Objects have useful methods. It's new. 

In Raku Regexen are saner. Grammars offer cleaner code. Smart matching works. Objects have useful methods. It's worth learning.