In Perl 5, I always appreciated the convenience of constructs like these two:

my @things = $text =~ /thing/g; my %things = $text =~ /(key)...(value)/g;

You take some nice, predictable text, pop a regex next to it, and BOOM! You get a nice list of things or a pretty hash. Magical!

There are some similarities to this construct in Perl 6, but if you're a new programmer, with Perl 5 background, there might be some confusion. First, using several captures doesn't result in nice hashes right off the bat. Second, you don't get strings, you get Match objects.

While Matches are fine, let's look at a tool more suited for the job: The comb

Plain 'Ol Characters

You can use comb as a subroutine or as a method. In its basic form, comb simply breaks up strings into characters:

'foobar moobar 駱駝道bar'.comb.join('|').say; 'foobar moobar 駱駝道bar'.comb(6).join('|').say; # OUTPUT: # f|o|o|b|a|r| |m|o|o|b|a|r| |駱|駝|道|b|a|r # foobar| mooba|r 駱駝道b|ar

Without arguments, you get individual characters. Supply an integer and you'll get a list of strings at most that many characters long, receiving a shorter string when there are not enough characters left. This method is also about 30x faster than using a regex for the job.

Limits

You can also provide a second integer, the limit, to indicate that you want at most that many items in the final list:

'foobar moobar 駱駝道bar'.comb(1, 5).join('|').say; 'foobar moobar 駱駝道bar'.comb(6, 2).join('|').say; # OUTPUT: # f|o|o|b|a # foobar| mooba

This applies to all forms of using comb , not just the one shown above.

Counting Things

The comb also takes a regular Str as an argument, returning a list of matches containing... that string. So this is useful to get the total number the substring appears inside a string:

'The 🐈 ran after a 🐁, but the 🐁 ran away'.comb('🐈').Int.say; 'The 🐈 ran after a 🐁, but the 🐁 ran away'.comb('ran').Int.say; # OUTPUT: # 1 # 2

Simple Matching

Moving onto the realm of regexes, there are several ways to obtain what you want using comb . The simplest way is to just match what you want. The entire match will be returned as an item by the comb:

'foobar moobar 駱駝道bar'.comb(/<[a..z]>+ 'bar'/).join('|').say; # OUTPUT: # foobar|moobar

The bar with Rakuda-dō Japaneese characters did not match our a through z character class and so was excluded from the list.

The wildcard match can be useful, but sometimes you don't want to include the wildcard in the resulting strings... Well, good news!

Limit What's Captured

You could use look-around assertions but an even simpler way is to use <( and )> regex capture markers ( <( is similar to \K in Perl 5):

'moo=meow ping=pong'.comb(/\w+ '=' <( \w**4/).join('|').say; # values 'moo=meow ping=pong'.comb(/\w+ )> '=' \w**4/).join('|').say; # keys # OUTPUT: # meow|pong # moo|ping

You can use one or the other or both of them. <( will exclude from the match anything described before it and )> anything that follows it. That is, /'foo' <('bar')> 'ber'/ , will match things containing foobarber , but the returned string from comb would only be string bar .

Multi Captures

As powerful as comb has been so far, we still haven't seen the compliment to Perl 5's way of fishing out key/value pairs out of text using regex. We won't be able to achieve the same clarity and elegance, but we can still use comb ... we'll just ask it to give us Match objects:

my %things = 'moo=meow ping=pong'.comb(/(\w+) '=' (\w+)/, :match)».Slip».Str; say %things; # OUTPUT: # moo => meow, ping => pong

Let's break that code down: it uses the same old .comb to look for a sequence of word characters, followed by the = character, followed by another sequence of word characters. We use () parentheses to capture both of those sequences in separate captures. Also, notice we added :match argument to .comb , this causes it to return a list of Match objects instead of strings. Next, we use two hyper operators (») to first convert the Matches to Slips , which gives us a list of captures, but they're still Match objects, which is why we convert them to Str as well.

An even more verbose, but much clearer, method is to use named captures instead and then .map them into Pairs :

my %things = 'moo=meow ping=pong' .comb(/$<key>=\w+ '=' $<value>=\w+/, :match) .map({ .<key> => .<value>.Str }); say %things; # OUTPUT: # moo => meow, ping => pong

Lastly, an astute reader will rember I mentioned at the beginning that simply using Perl 5's method will result in a list of Match objects... the same Match objects we're asking .comb to give us above. Thus, you can also write the above code like this, without .comb :

my %things = ('moo=meow ping=pong' ~~ m:g/(\w+) '=' (\w+)/)».Slip».Str; say %things; # OUTPUT: # moo => meow, ping => pong

Conclusion

We've learned how to break up a string into bits any way we want to. Be it one or more characters. Be it simple strings or regex matches. Be it partial captures or multiple ones. You can use comb for all. Combined with .rotor , the power is limitless.