greppable6

query

\bcomb\b

result.md

File	Code
ALOREN/Terminal-Table …/LightWrap.pm6 :60:	self.__concat_line($key.comb());
BDUGGAN/Digest-SHA256-Native …/Native.pm6 :27:	Blob.new( sha256-hex($in).comb(2).map({ :16($_) }))
ELIZABETH/List-MoreUtils …/mode.t :10:	my @lorem = $lorem.comb( / \w+ | <[,.]> / );
ELIZABETH/List-MoreUtils …/occurrences.t :10:	my @lorem = $lorem.comb( / \w+ | <[,.]> / );
ELIZABETH/List-UtilsBy …/nsort_by.t :24:	is-deeply nsort_by( +*.comb("a"), <apple hello armageddon>),
ELIZABETH/List-UtilsBy …/unzip_by.t :15:	is-deeply unzip_by( { .comb }, "a1","b2","c3"), [ ["a","b","c"],["1","2","3"] ],
ELIZABETH/List-UtilsBy …/unzip_by.t :18:	is-deeply unzip_by( { .comb }, "a","b2","c"), [ ["a","b","c"],[Any,"2"] ],
ELIZABETH/P5reset …/P5reset.pm6 :12:	for $pattern.comb -> $letter {
FISCHER/Lingua-Lipogram …/Lipogram.pm6 :52:	return lipogram($path.slurp, $letters.comb.unique);
FISCHER/Lingua-Lipogram …/Lipogram.pm6 :60:	return lipogram($string, $letters.comb.unique);
FISCHER/Lingua-Pangram …/Pangram.pm6 :58:	return pangram($string, $unigraphs.comb.unique);
FISCHER/Lingua-Pangram …/Pangram.pm6 :66:	return pangram($string, ($unigraphs.comb.unique, @multigraphs).flat);
HANENKAMP/DOM-Tiny …/HTML.pm6 :663:	make (~$/).comb(/ <-[ < > = \s / ]>+ /).first(*.chars > 0)
HANENKAMP/HTTP-Headers …/Headers.pm6 :75:	$self.prepared-values[0].comb(/ <-[ ; ]>+ /)[0].trim
HANENKAMP/HTTP-Headers …/Headers.pm6 :84:	my @items = try { $value.comb(/ <-[ ; ]>+ /, 2) };
HANENKAMP/HTTP-Headers …/Headers.pm6 :95:	my @pairs = try { self.prepared-values».comb(/ <-[ ; ]>+ /)».grep(/'='/).flat };
HANENKAMP/HTTP-Headers …/Headers.pm6 :107:	my @pairs = try { $prep-value.comb(/ <-[ ; ]>+ /) };
HANENKAMP/IO-Glob …/Glob.pm6 :184:	my @class = $<class>.Str.comb;
JNTHN/Concurrent-Trie …/Trie.pm6 :47:	my @chars = $value.comb;
JNTHN/Concurrent-Trie …/Trie.pm6 :61:	for $value.comb {
JNTHN/Concurrent-Trie …/Trie.pm6 :72:	for $prefix.comb {
JNTHN/Cro-HTTP …/Client.pm6 :344:	$parsed-url.Str.comb[0..$pos-1].join ~ $path;
JNTHN/Cro-HTTP …/CookieJar.pm6 :41:	return $path.comb[0..$index].join if $index > 0;
JNTHN/Cro-HTTP …/CookieJar.pm6 :116:	@cookie-list.sort({ .cookie.path.comb.elems, .creation-time });
JNTHN/Cro-HTTP …/http-request.t :68:	for "\b\n\0\r".comb -> $cc {
JNTHN/Cro-HTTP …/http-request.t :93:	for "\b\n\0\r".comb -> $cc {
JNTHN/Cro-HTTP …/http-response.t :49:	for "\b\n\0\r".comb -> $cc {
JNTHN/Cro-HTTP …/http-response.t :53:	for "\b\n\0\r".comb -> $cc {
KAIEPI/Net-LibIDN2 …/LibIDN2.pm6 :12:	my $digits := IDN2_VERSION.comb(/\d+/).map({ :16($_) });
KOORCHIK/LIVR …/Modifiers.pm6 :44:	my $chars-set = set($chars.comb);
KOORCHIK/LIVR …/Modifiers.pm6 :45:	$output= $value.comb.grep(-> $c { $chars-set{$c} }).join('');
KOORCHIK/LIVR …/Utils.pm6 :11:	&& $value.comb.grep(* eq '.').elems <= 1;
PATRICKZ/RPi-Device-ST7036 …/ST7036.pm6 :266:	for $text.comb -> $char {
SCIMON/Algorithm-GooglePolylineEncoding …/GooglePolylineEncoding.pm6 :43:	my @chunks = $bin.comb( /\d ** 5/ ).reverse.map( *.parse-base(2) );
SCIMON/Algorithm-GooglePolylineEncoding …/GooglePolylineEncoding.pm6 :84:	my @values = $encoded.comb(/ .*? (.) <?{ $/[0] ~~ END-VALUES }> /).map( &decode-str );
SCIMON/Algorithm-GooglePolylineEncoding …/GooglePolylineEncoding.pm6 :95:	my $value = ( $encoded.comb().reverse.map( *.ord - 63 ).map( * +& 0x1f ).map( *.base(2) ).map( { '0' x ( $_.chars %% 5 ?? 0 !! 5 - $_.chars % 5 ) ~ $_ } ).join() ).parse-base(2);
SCIMON/Game-Sudoku …/Sudoku.pm6 :17:	my @tmp = $code.comb.map( *.Int );
SCIMON/Game-Sudoku …/Sudoku.pm6 :29:	my @tmp = $code.comb.map( *.Int );
TBROWDER/Net-IP …/IP.pm6 :59:	@fields = $ip.comb;
TBROWDER/Net-IP …/IP.pm6 :89:	my @c = $binip.comb;
TBROWDER/Net-IP …/IP.pm6 :106:	my @c = $binip.comb;
TBROWDER/Net-IP …/IP.pm6 :137:	my @q = $q.comb;
TBROWDER/Net-IP …/IP.pm6 :249:	my @c = $ip.comb;
TBROWDER/Number-More …/base2dec-simple.p6 :78:	my @num'r = $num.comb.reverse;
TBROWDER/Number-More …/simple-dec2base.p6 :79:	my @num'r = $num.comb.reverse;
TBROWDER/Number-More …/test-base-37-62.p6 :101:	my @num'r = $num.comb.reverse;
TBROWDER/Number-More …/More.pm6 :583:	my @num'r = $num.comb.reverse;
TIMOTIMO/JSON-Fast …/08-sorted-keys.t :8:	is $_, .sort.List, $message given $result.comb(/@keys/).List;
TITSUKI/Terminal-Getpass …/Getpass.pm6 :45:	_putch($_.ord) for $prompt.comb;
UFOBAT/I18N-LangTags …/50_super.t :44:	my @in = $/[0].Str.comb( /[<alnum>||'-']+/ );
UFOBAT/I18N-LangTags …/50_super.t :45:	my @should = $/[1].Str.comb( /[<alnum>||'-']+/ );
UFOBAT/I18N-LangTags …/55_super_strict.t :34:	my @in = $/[0].Str.comb( /[<alnum>||'-']+/ );
UFOBAT/I18N-LangTags …/55_super_strict.t :35:	my @should = $/[1].Str.comb( /[<alnum>||'-']+/ );
UGEXE/zef …/SystemInfo.pm6 :19:	my $cols = $/<cols>.comb(/\d/).join;
UGEXE/zef …/SystemInfo.pm6 :29:	my $cols = ~$/<cols>.comb(/\d/).join;
WARRINGD/Font-AFM …/AFM.pm :228:	when Array[Int] { [ $val.comb(/[<[+-]>|\w|"."]+/).map(*.Int) ] }
WARRINGD/Font-AFM …/AFM.pm :229:	when Array[Num] { [ $val.comb(/[<[+-]>|\w|"."]+/).map(*.Num) ] }
WARRINGD/Font-AFM …/AFM.pm :452:	for $string.comb {
WARRINGD/Font-AFM …/AFM.pm :482:	for $string.comb {
WARRINGD/Font-FreeType …/10metrics_5x7bdf.t :142:	my ($left, $right) = .comb;
WARRINGD/Font-FreeType …/10metrics_verasans.t :168:	my ($left, $right) = .comb;
WARRINGD/Font-FreeType …/20bitmap.t :38:	my uint @bit-map = $line.comb.map: { $_ eq '#' ?? 0xFF !! 0x00 };
WARRINGD/PDF-Font-Loader …/Stream.pm :43:	@body.append: .comb.map: -> $a, $b { :16($a ~ $b) };
0racle/p6-Net-Netmask …/Netmask.pm6 :437:	$!netmask.split('.').map(*.Int.base: 2).comb('1').elems;
AlexDaniel/orgsleep …/bdf2json :43:	@bitmap.push: $conv.substr(0, $width).comb».Int».so.Array;
AlexDaniel/orgsleep …/orgsleep :144:	for ($bt ?? $text.flip !! $text).comb {
Altai-man/p6-Texas-To-Uni …/test-file1.p6 :30:	sub encode ($c) { @enc[($c.ord).fmt("%07b").comb].join('') }
Altai-man/p6-Texas-To-Uni …/test-file1.p6 :36:	($head.comb «~» $msg.comb(/. ** 8/)).join('') ~ $tail;
Altai-man/p6-Texas-To-Uni …/test-file1.p6 :40:	join '', map { :2(%dec{$_.comb}.join('')).chr },
Altai-man/p6-Texas-To-Uni …/test-file1.p6 :41:	$steg.subst( /\w | <punct> | " " | "\n" /, '', :g).comb(/. ** 7/);
Altai-man/p6-Texas-To-Uni …/test-file1.p6 :44:	my $hidden = join '', map { .&encode }, $secret.comb;
Altai-man/perl6-Text-Tabs …/Tabs.pm6 :30:	.comb($tabstop)
FCO/ProblemSolver …/ProblemSolver.pm6 :71:	my @comb = @vars.combinations($pars);
FCO/ProblemSolver …/ProblemSolver.pm6 :72:	for @comb -> @pars {
FCO/ProblemSolver …/ProblemSolver.pm6 :91:	my @comb = @vars.combinations(2);
FCO/ProblemSolver …/ProblemSolver.pm6 :92:	for @comb -> @pars {
FCO/ProblemSolver …/sudoku.p6 :10:	my @cols = get().comb(/<[-\w]>/);
FCO/json-stream …/Stream.pm6 :28:	my @chunks = $chunk.comb: /'[' | ']' | '{' | '}' | <!after \\> '"' | ':' | ',' | [<-[[\]{}":,]> | <after \\> '"']+/;
Juerd/p6-mqtt …/Client.pm :28:	my @parts = $filter.comb(/ '/#' | '/' | <-[/]>+ /);
LLFourn/p6-CompUnit-Util …/README.md :359:	my $exported-name = '&' ~ $r.name.comb[0];
MARTIMM/BSON …/ObjectId.pm6 :37:	$!oid .= new: ($string.comb(/../) ==> map { :16($_) });
MARTIMM/BSON …/ObjectId.pm6 :141:	for $!time.fmt('%08x').comb(/../)[3...0] -> $hexnum {
MARTIMM/BSON …/ObjectId.pm6 :147:	for $!machine-id.fmt('%6.6s').comb(/../)[2...0] -> $hexnum {
MARTIMM/BSON …/ObjectId.pm6 :153:	for $!pid.fmt('%04x').comb(/../)[1,0] -> $hexnum {
MARTIMM/BSON …/ObjectId.pm6 :159:	for $!count.fmt('%08x').comb(/../)[2...0] -> $hexnum {
MattOates/BioInfo …/Nucleic.pm6 :21:	sequence => $seq.comb.map({%comp{$_}}).join
MattOates/BioInfo …/Nucleic.pm6 :53:	sequence => %codon_table{map *~*~*, $.sequence.uc.comb}.join
MattOates/BioInfo …/Nucleic.pm6 :77:	for $seq.sequence.comb(/<-[\*]>+/).kv -> $index, $orf {
MattOates/Text--Homoglyph …/README.md :23:	say "Woohoo this is some nice text".comb.map({(rand > 0.8)?? $_ !! homoglyphs($_)[1] }).join;
MattOates/Text--Homoglyph …/Homoglyph.pm6 :101:	return $string, |%homoglyphs{$string}.comb;
Skarsnik/p6-linux-proc-statm …/Statm.pm :9:	return $var.flip.comb(/.**1..3/).join('.').flip ~ ($unit eq 'b' ?? "" !! " {$unit}B");
Skarsnik/perl6-irc-art …/Art.pm6 :127:	my @letters = $text.comb;
Takadonet/Algorithm--Diff …/base.t :209:	@a = $a.comb(/ \S+ /);
Takadonet/Algorithm--Diff …/base.t :210:	@b = $b.comb(/ \S+ /);
Takadonet/Algorithm--Diff …/oo.t :30:	my @a = $a.comb(/ \S+ /);
Takadonet/Algorithm--Diff …/oo.t :31:	my @b = $b.comb(/ \S+ /);
TiMBuS/Net--IRC …/CommandHandler.pm :29:	sub abbrev($name) { [\~] $name.comb }
TiMBuS/Net--IRC …/Seen.pm :37:	my @params = ($<params> // '').comb(/\S+/);
Tux/CSV …/Notes :7:	gist perl comb subst-mutate subst lines split words
Tux/CSV …/CSV.pm :711:	my %sep = $hdr.comb.Bag{$sep-set.list}:kv;
Uladox/Editscr-Uggedit …/README.md :58:	ok 1 == $capturedText.comb(/"# This is some added Text"/),
Uladox/Editscr-Uggedit …/basic.t :21:	ok 1 == $capturedText.comb(/"# This is some added Text"/),
ab5tract/Terminal-Print …/Commands.pm6 :125:	return %human-commands{$command}.comb.join(' ');
ab5tract/Terminal-Print …/Grid.pm6 :80:	my @cells = $text.comb.map: { Cell.new(:char($_), :$color) };
ab5tract/Terminal-Print …/Grid.pm6 :84:	my @chars = $text.comb;
ab5tract/Terminal-Print …/Grid.pm6 :93:	for $text.comb.kv -> $i, $char {
ajs/perl6-Math-Sequences …/Integer.pm :300:	our @A000069 is export = lazy 𝕀.grep: -> $n { ([+] $n.base(2).comb) !%% 2 };
ajs/perl6-Math-Sequences …/Integer.pm :322:	our @A000120 is export = lazy 𝕀.map: -> $n {$n.base(2).comb.grep({+$_}).elems};
araraloren/perl6-getopt-advance …/Parser.pm6 :170:	my @opts = $!name.comb;
araraloren/perl6-getopt-advance …/Parser.pm6 :252:	my @opts = @ret[0].comb;
araraloren/perl6-getopt-advance …/Parser.pm6 :334:	my @opts = @ret[0].comb;
araraloren/perl6-getopt-advance …/Parser.pm6 :421:	my @opts = @ret[0].comb;
araraloren/perl6-getopt-advance …/Parser.pm6 :503:	my @opts = @ret[0].comb;
araraloren/perl6-getopt-advance …/Parser.pm6 :547:	my @options = $arg.comb();
araraloren/perl6-terminal-table …/LightWrap.pm6 :60:	self.__concat_line($key.comb());
azawawi/farabi6 …/Util.pm6 :164:	for $output.comb(/ \x1B '[' [ (\d+) ';'? ]+ 'm' /, :match) -> $/ {
azawawi/farabi6 …/rust.js :173:	function commasep(comb, end) {
azawawi/farabi6 …/rust.js :175:	if (type == ",") return cont(comb, more);
azawawi/farabi6 …/rust.js :181:	return pass(comb, more);
azawawi/farabi6 …/rust.js :185:	function stat_of(comb, tag) {
azawawi/farabi6 …/rust.js :186:	return cont(pushlex("stat", tag), comb, poplex, block);
azawawi/farabi6 …/rust.js :239:	function record_of(comb) {
azawawi/farabi6 …/rust.js :243:	if (type == ":") return cont(comb, ro);
azawawi/farabi6 …/rust.js :381:	function matchBrackets(type, comb) {
azawawi/farabi6 …/rust.js :382:	if (type == "[") return cont(pushlex("]"), commasep(comb, "]"), poplex);
azawawi/farabi6 …/rust.js :383:	if (type == "(") return cont(pushlex(")"), commasep(comb, ")"), poplex);
azawawi/farabi6 …/rust.js :384:	if (type == "{") return cont(pushlex("}"), commasep(comb, "}"), poplex);
azawawi/farabi6 …/perl6-mode.js :291:	"lcfirst uc ucfirst capitalize normalize pack unpack quotemeta comb",
azawawi/perl6-gtk-scintilla …/02-basic.t :60:	ok( $editor.char-at(0) eq $text.comb[0], "char-at(0) works");
azawawi/perl6-gtk-scintilla …/02-basic.t :61:	ok( $editor.char-at(5) eq $text.comb[5], "char-at(5) works");
azawawi/perl6-selenium-webdriver …/WebElement.pm6 :19:	"value" => $keys.comb;
azawawi/perl6-selenium-webdriver …/Wire.pm6 :514:	return self._post( "keys", value => $keys.comb );
bbkr/TinyID …/TinyID.pm :9:	@!positions_to_chars = $key.comb;
bbkr/TinyID …/TinyID.pm :25:	method decode ( Str:D $in where $in.comb (<=) @!positions_to_chars ) returns Int:D {
bbkr/TinyID …/TinyID.pm :28:	for $in.comb.reverse.kv -> $pos, $tmp {
bduggan/p6-digest-sha1-native …/Native.pm6 :27:	Blob.new( sha1-hex($in).comb(2).map({ :16($_) }))
bduggan/p6-log-async …/04-filter.t :39:	is $debug-or-error.comb.sort.join, "34", 'filter with junction';
bduggan/p6-log-async …/04-filter.t :40:	is $severe.comb.sort.join, '45', 'filter with whatever';
bduggan/p6-log-async …/04-filter.t :41:	is $not-severe.comb.sort.join, '123', 'not severe';
bradclawsie/Net-IP-Parse …/Parse.pm6 :122:	given ($octets_part.comb: '::').Int {
cjfields/bioperl6 …/CodonTable.pm6 :330:	@nts = map { %iub{uc $_}} , $value.comb();
cjfields/bioperl6 …/IUPAC.pm6 :84:	@!alpha = map { %IUB{uc($_)} } , comb(/\S/, $!seq.seq);
cjfields/bioperl6 …/IUPAC.pm6 :88:	@!alpha = map { %IUP{uc($_)} } , comb(/\S/, $!seq.seq);
cjfields/bioperl6 …/FastaIO.pm6 :38:	my $sequence = $seq.seq().comb( /. ** {1..$!width}/).join("\n");
cjfields/bioperl6 …/Range.t :106:	my @tests = %map{"r$i"}.comb(/\d/).map: { ?+$_ };
cjfields/bioperl6 …/CodonTable.t :71:	@ii = $seq.comb(/. ** 3/);
cjfields/bioperl6 …/CodonTable.t :82:	@res = $prot.comb();
coke/p6-lingua-en-syllable …/Syllable.pm :57:	my $syl = $word.comb(/<[aeiouy]>+/)
coke/p6-uni …/uni :30:	for $word.comb -> $char {
colomon/ABC …/abc2ly :207:	if $chunk !~~ /"["/ && $chunk.comb(/\d+/).grep(* > 4) > 1 {
colomon/ABC …/dg-check.pl :6:	my @matches = $*IN.slurp.comb(m/ <ABC::tune> /, :match);
colomon/ABC …/Utils.pm :82:	for $octave-symbol.comb {
colomon/Benchmark-Plot …/results.txt :9:	latest-rakudo, non-str-comb.pl, 1.8930577, 1.8759, 1.90718
colomon/Benchmark-Plot …/results.txt :24:	rakudo-star-2010.07, non-str-comb.pl, 107.7005473, 107.136774, 109.201271
colomon/Benchmark-Plot …/results.txt :39:	rakudo-star-2010.08, non-str-comb.pl, 10.4472525, 10.384362, 10.502796
colomon/Benchmark-Plot …/results.txt :54:	rakudo-star-2010.09, non-str-comb.pl, 12.9278122, 12.877803, 12.959001
colomon/Benchmark-Plot …/results.txt :69:	rakudo-star-2010.10, non-str-comb.pl, 15.4697686, 15.415907, 15.554623
colomon/Benchmark-Plot …/results.txt :84:	rakudo-star-2010.11, non-str-comb.pl, 16.0855291, 15.516537, 16.458584
colomon/Benchmark-Plot …/results.txt :99:	rakudo-star-2010.12, non-str-comb.pl, 10.3568852, 10.158314, 10.564507
colomon/Benchmark-Plot …/results.txt :114:	rakudo-star-2011.01, non-str-comb.pl, 2.1262127, 2.062292, 2.183146
colomon/TagTools …/fixup-youtube-dl :7:	# (($a.comb Z=> $b.comb) ...^ { $_.key ne $_.value }).map(*.key).join;
colomon/TagTools …/fixup-youtube-dl :9:	for $a.comb Z $b.comb -> $c, $d {
colomon/mandelbrot …/2.5-mandelbrot.pl :108:	my @red = @color_map.map({ SystemByte.Parse($_.comb(/\d+/)[0]) });
colomon/mandelbrot …/2.5-mandelbrot.pl :109:	my @green = @color_map.map({ SystemByte.Parse($_.comb(/\d+/)[1]) });
colomon/mandelbrot …/2.5-mandelbrot.pl :110:	my @blue = @color_map.map({ SystemByte.Parse($_.comb(/\d+/)[2]) });
colomon/mandelbrot …/gtk-mandelbrot.pl :108:	my @red = @color_map.map({ SystemByte.Parse($_.comb(/\d+/)[0]) });
colomon/mandelbrot …/gtk-mandelbrot.pl :109:	my @green = @color_map.map({ SystemByte.Parse($_.comb(/\d+/)[1]) });
colomon/mandelbrot …/gtk-mandelbrot.pl :110:	my @blue = @color_map.map({ SystemByte.Parse($_.comb(/\d+/)[2]) });
cygx/p6-image-rgba-text …/Text.pm6 :110:	when 3 { $value.comb.map(&convert1).join ~ 'FF' => $key }
cygx/p6-image-rgba-text …/Text.pm6 :111:	when 4 { $value.comb.map(&convert1).join => $key }
cygx/p6-image-rgba-text …/Text.pm6 :112:	when 6 { $value.comb.map(&convert2).join ~ 'FF' => $key }
cygx/p6-image-rgba-text …/Text.pm6 :113:	when 8 { $value.comb.map(&convert2).join => $key }
cygx/p6-image-rgba-text …/Text.pm6 :162:	for $value.comb;
cygx/p6-image-rgba-text …/Text.pm6 :169:	for $value.comb;
cygx/p6-image-rgba-text …/Text.pm6 :174:	for $value.comb(2);
cygx/p6-image-rgba-text …/Text.pm6 :181:	for $value.comb(2);
cygx/p6-uni63 …/Uni63.pm6 :23:	for .substr(2).comb {
cygx/p6-uni63 …/01-sanity.t :14:	ok $enc.comb(/_/) == 1, 'count escapes';
dagurval/HTML-Strip …/Strip.pm6 :67:	if $!emit_space and $!out.comb[*-1] ne " ";
drforr/perl6-Perl6-Parser …/999-regression.t :137:	bag +« flat @a».comb: 1
drforr/perl6-Perl6-Parser …/999-regression.t :194:	("a".comb «~» "a".comb);
drforr/perl6-Perl6-Parser …/999-regression.t :274:	1 given [\+] '\\' «leg« $s.comb;
drforr/perl6-Perl6-Parser …/rosetta-1.t :348:	~ '(repeats allowed): ').comb(/<[1..9]>/);
drforr/perl6-Perl6-Parser …/rosetta-a.t :48:	my @regex = @blocks.map({ my @c = .comb; rx/<@c>/ }).grep: { .ACCEPTS($word.uc) }
drforr/perl6-Perl6-Parser …/rosetta-a.t :49:	can-spell-word $word.uc.comb.list, @regex;
drforr/perl6-Perl6-Parser …/rosetta-a.t :580:	my %anagram = slurp('unixdict.txt').words.classify( { .comb.sort.join } );
drforr/perl6-Perl6-Parser …/rosetta-a.t :597:	.classify( {.comb.sort.join} )\ # group by common anagram
drforr/perl6-Perl6-Parser …/rosetta-a.t :613:	my %anagram = slurp('dict.ie').words.map({[.comb]}).classify({ .sort.join });
drforr/perl6-Perl6-Parser …/rosetta-a.t :721:	my @chars = $str.comb;
drforr/perl6-Perl6-Parser …/rosetta-a.t :1247:	sub tod2rad($_) { [+](.comb(/\d+/) Z* 3600,60,1) * tau / 86400 }
drforr/perl6-Perl6-Parser …/rosetta-b.t :59:	sub encode ($c) { @enc[($c.ord).fmt("%07b").comb].join('') }
drforr/perl6-Perl6-Parser …/rosetta-b.t :65:	($head.comb «~» $msg.comb(/. ** 8/)).join('') ~ $tail;
drforr/perl6-Perl6-Parser …/rosetta-b.t :69:	join '', map { :2(%dec{$_.comb}.join('')).chr },
drforr/perl6-Perl6-Parser …/rosetta-b.t :70:	$steg.subst( /\w | <punct> | " " | "\n" /, '', :g).comb(/. ** 7/);
drforr/perl6-Perl6-Parser …/rosetta-b.t :73:	my $hidden = join '', map { .&encode }, $secret.comb;
drforr/perl6-Perl6-Parser …/rosetta-b.t :95:	for $s.comb {
drforr/perl6-Perl6-Parser …/rosetta-b.t :120:	given [\+] '\\' «leg« $s.comb;
drforr/perl6-Perl6-Parser …/rosetta-b.t :173:	self.bless(*, coeff => %bt2co{$s.flip.comb});
drforr/perl6-Perl6-Parser …/rosetta-b.t :176:	self.bless(*, coeff => carry $i.base(3).comb.reverse);
drforr/perl6-Perl6-Parser …/rosetta-b.t :298:	sub benford(@a) { bag +« flat @a».comb: /<( <[ 1..9 ]> )> <[ , . \d ]>*/ }
drforr/perl6-Perl6-Parser …/rosetta-b.t :392:	my @s = $orig.comb;
drforr/perl6-Perl6-Parser …/rosetta-b.t :577:	>.pairs.invert.hash{$/.comb}
drforr/perl6-Perl6-Parser …/rosetta-b.t :795:	my @b = $s.ords».fmt("%07b")».comb;
drforr/perl6-Perl6-Parser …/rosetta-b.t :801:	my @b = $b.list».fmt("%08b")».comb;
drforr/perl6-Perl6-Parser …/rosetta-b.t :1048:	@guess = (prompt("Guess $guesses: ") // exit).comb;
fayland/perl6-Lingua-Unihan …/Unihan.pm :17:	for comb(/\N/, $text) -> $char {
finanalyst/p6-inform …/README.md :81:	for $data.data<Laundry>.comb(/\w+/) { say "I will clean your $_" }
finanalyst/p6-inform …/example.p6 :73:	for $data.data<Laundry>.comb(/\w+/) { say "I will clean your $_" }
fjwhittle/p6-Path-Map …/Map.pm6 :119:	for $path.comb($componentrx, :match).list -> $/ {
fjwhittle/p6-Path-Map …/Map.pm6 :254:	self.lookup($path.comb(/<-[/]>+/).Array);
grondilu/chess …/Chess.pm6 :11:	my @pieces = flat map { /\d/ ?? ' ' xx +$/ !! %pieces{$_} // "?" }, .comb;
hankache/Acme-Cow …/Cow.pm6 :23:	my @text = $.initial-text.comb(36).List;
hartenfels/Text-Markdown-Discount …/05_dump.t :13:	my $got = $want ∩ set comb /\S+/, slurp $file;
hoelzro/p6-io-string …/07-getc.t :11:	for $buf.comb {
jaffa4/pathutil …/Util.pm :198:	my @list = comb(/<[\\\/]><before .>/,$filenamelocal);
jaffa4/pathutil …/Util.pm :222:	#my @list = comb(/<[\\\/]><before .>/,$filenamelocal);
jaldhar/Algorithm-DawkinsWeasel …/DawkinsWeasel.pm6 :16:	@!target-phrase = $target-phrase.comb;
jnthn/p6-app-moarvm-heapanalyzer …/Shell.pm6 :162:	$n.Str.flip.comb(3).join(',').flip
johnspurr/Lingua-EN-Stem-Porter …/wordlist-expected.txt :5141:	comb
johnspurr/Lingua-EN-Stem-Porter …/wordlist-expected.txt :5148:	comb
johnspurr/Lingua-EN-Stem-Porter …/wordlist-expected.txt :5154:	comb
johnspurr/Lingua-EN-Stem-Porter …/wordlist-expected.txt :5157:	comb
johnspurr/Lingua-EN-Stem-Porter …/wordlist-input.txt :5141:	comb
jonathanstowe/Audio-Liquidsoap …/Liquidsoap.pm :883:	$rids.comb(/\d+/).map({Int($_)});
kalkin/Ddt …/CLI.pm6 :108:	$name = $name.comb[0..*-5].join;
kalkin/Ddt …/Distribution.pm6 :32:	has Bool $.relaxed-name = '-' ∈ $!META6.name.comb;
kalkin/perl6-hashids …/Hashids.pm6 :6:	subset Alphabet of Str where !.comb.repeated and .chars >= 16;
kalkin/perl6-hashids …/Hashids.pm6 :18:	has Str $.separators where !.comb.repeated;
kalkin/perl6-hashids …/Hashids.pm6 :24:	for $separators.comb -> $c {
kalkin/perl6-hashids …/Hashids.pm6 :43:	$s = $a.comb[0…^$split-at].join;
kalkin/perl6-hashids …/Hashids.pm6 :44:	$a = $a.comb[$split-at…*].join;
kalkin/perl6-hashids …/Hashids.pm6 :53:	$guards = $s.comb[0..^$num-guards].join;
kalkin/perl6-hashids …/Hashids.pm6 :54:	$s = $s.comb[$num-guards..*].join;
kalkin/perl6-hashids …/Hashids.pm6 :56:	$guards = $a.comb[0..^$num-guards].join;
kalkin/perl6-hashids …/Hashids.pm6 :57:	$a = $a.comb[$num-guards..*].join;
kalkin/perl6-hashids …/Hashids.pm6 :64:	for $alphabet.comb -> $c {
kalkin/perl6-hashids …/Hashids.pm6 :75:	my $lottery = self.alphabet.comb[$values-hash % self.alphabet.chars];
kalkin/perl6-hashids …/Hashids.pm6 :83:	$encoded ~= $.separators.comb[$new-index];
kalkin/perl6-hashids …/Hashids.pm6 :85:	$encoded = $encoded.comb[0..*-2].join;
kalkin/perl6-hashids …/Hashids.pm6 :93:	return ($lottery ~ $salt ~ $alphabet).comb[0..^$alphabet.chars].join
kalkin/perl6-hashids …/Hashids.pm6 :100:	my $lottery = $hashid.comb[0];
kalkin/perl6-hashids …/Hashids.pm6 :101:	$hashid = $hashid.comb[1..*].join;
kalkin/perl6-hashids …/Hashids.pm6 :117:	for $string.comb -> $c {
kalkin/perl6-hashids …/Hashids.pm6 :131:	my $index = ($values-hash + $string.comb[0].ord) % $len-separators;
kalkin/perl6-hashids …/Hashids.pm6 :132:	my $encoded = $!separators.comb[$index] ~ $string;
kalkin/perl6-hashids …/Hashids.pm6 :135:	$index = ($values-hash + $encoded.comb[2].ord) % $len-separators;
kalkin/perl6-hashids …/Hashids.pm6 :150:	$hashed = $alphabet.comb[$number % $alphabet-len] ~ $hashed;
kalkin/perl6-hashids …/Hashids.pm6 :160:	for $hashed.comb.kv -> $i, $c {
kalkin/perl6-hashids …/Hashids.pm6 :176:	my $integer = ord $salt.comb[$index];
kalkin/perl6-hashids …/Hashids.pm6 :179:	my $tmp_char = $str.comb[$j];
kalkin/perl6-hashids …/Hashids.pm6 :180:	my $trailer = $j+1 < $str.chars ?? $str.comb[$j+1…*].join !! '';
kalkin/perl6-hashids …/Hashids.pm6 :181:	$str= $str.comb[0…^$j].join ~ $str.comb[$i] ~ $trailer;
kalkin/perl6-hashids …/Hashids.pm6 :182:	$str = $str.comb[0…^$i].join ~ $tmp_char ~ $str.comb[$i+1…*].join;
krunen/unicode-utf8-parser …/parse.t :12:	if (@parse eq $s.comb) {
kuerbis/Term-Choose-Util-p6 …/Util.pm6 :618:	$new ~= $<int>.flip.comb( / . ** 1..3 / ).join( $sep ).flip;
labster/p6-Lingua-Number …/Number.pm :107:	my @fracspelling = $fpart.comb.map: { rule2text($lingua, $ruletype, $_) };
labster/p6-Lingua-Number …/Number.pm :195:	for $number.comb -> $n {
leejo/geo-ip2location-lite-p6 …/Lite.pm :71:	my $ipnum = :256[$ipaddr.comb(/\d+/)]; # convert ipv4 to int!
madcapjake/p6dx …/Diviner.pm6 :197:	my $name1 = $a.name.substr(1) if $a.name.comb[0] ~~ /<[$@%&]>/;
madcapjake/p6dx …/Diviner.pm6 :198:	my $name2 = $b.name.substr(1) if $b.name.comb[0] ~~ /<[$@%&]>/;
marcoonroad/Coro-Simple …/basic.t :28:	yield [ "Bye-bye!".comb ];
masak/007 …/Test.pm :268:	my @actual-builtins = $emitted-js.comb(/^^ "function " <(<-[(]>+)>/);
masak/007 …/do-not-use-str-in-typecheck.t :10:	for $content.comb(/"X::TypeCheck.new" <-[;]>+ ";"/) -> $typecheck {
masak/007 …/meta-info.t :71:	my $line = $.text.substr(0, $pos).comb(/\n/) + 1;
masak/druid …/generate-board :76:	my $brighter-color = [~] '#', map { sprintf '%x', :16($_)+3 }, $c.comb;
masak/druid …/generate-board :77:	my $darker-color = [~] '#', map { sprintf '%x', :16($_)-3 }, $c.comb;
masak/druid …/Text.pm :159:	my @old = $old.comb;
masak/druid …/Text.pm :160:	my @new = $new.comb;
masak/gge …/01-regex.t :8:	sub dirname($path) { $path.comb(/<-[/]>+ '/'/).join() } #' (vim fix)
masak/perl6-literate …/Literate.pm :13:	for $text.comb(/\N*\n|\N+\n?/).kv -> $n, $line {
masak/text-indented …/parse-indent.t :23:	$string.comb(/<:Lu><:Ll>+/)>>.lc.join(' ') ~ " exception thrown";
mcsnolte/Text-UpsideDown …/UpsideDown.pm6 :99:	return $s.flip.comb.map({ %upside_down_map_all{$_} // $_ }).join;
nkh/P6-Data-Dump-Tree …/diff_string.pl :45:	return ($s1.comb(1), $s2.comb(1)) ;
nkh/P6-Data-Dump-Tree …/Tree.pm :619:	$text.lines.map: { (|.comb($width)) || '' } ;
nkh/P6-Data-Dump-Tree …/Ddt.pm :30:	for $string.comb.rotor(63 * 1024, :partial)
nkh/P6-Data-Dump-Tree …/ExtraRoles.pm :121:	sub do_superscribe($text) { ($text.comb.map: { @ssl[$_.ord] // $_}).join }
nkh/P6-Data-Dump-Tree …/ExtraRoles.pm :125:	method do_superscribe($text) { ($text.comb.map: { @ssl[$_.ord] // $_}).join }
p6-css/CSS-Grammar-p6 …/Actions.pm :12:	[~] $str.comb.map: {
p6-css/CSS-Grammar-p6 …/Actions.pm :221:	?? $id.comb.map: {$^hex-digit ~ $^hex-digit}
p6-css/CSS-Grammar-p6 …/Actions.pm :222:	!! $id.comb.map: {$^hex-digit ~ $^hex-digit2};
p6-css/CSS-Writer-p6 …/Writer.pm :229:	[~] .comb.map({
p6-css/CSS-Writer-p6 …/Writer.pm :329:	$str.comb.map({
p6-pdf/PDF-Content-p6 …/Block.pm :36:	method comb(Str $_) {
p6-pdf/PDF-Content-p6 …/Block.pm :37:	.comb(/<Text::word> | <Text::space>/);
p6-pdf/PDF-Content-p6 …/Block.pm :41:	my Str @chunks = self.comb: $!text;
p6-pdf/PDF-Content-p6 …/text-block-images.t :19:	my @chunks = PDF::Content::Text::Block.comb: 'I must go down to the seas';
p6-pdf/PDF-Content-p6 …/text-block-images.t :65:	my @chunks = PDF::Content::Text::Block.comb($text);
p6-pdf/PDF-Content-p6 …/text-block.t :15:	my @chunks = PDF::Content::Text::Block.comb: "z80 a-b. -3 {nbsp}A{nbsp}bc{nbsp} 42";
p6-pdf/PDF-Content-p6 …/text-block.t :16:	is-deeply @chunks, ["z80", " ", "a-", "b.", " ", "-", "3", " ", "{nbsp}A{nbsp}bc{nbsp}", " ", "42"], 'text-block comb';
p6-pdf/PDF-Grammar-p6 …/Actions.pm :36:	my @hex-codes = $xdigits.comb.map: -> $a, $b = '0' { :16($a ~ $b) };
p6-pdf/PDF-p6 …/Writer.pm :247:	[~] flat '/', .comb.map( {
p6-pdf/PDF-p6 …/filter-asciihex.t :60:	my $actual_bytes = PDF::IO::Filter::ASCIIHex.decode($odd_out).Str.comb>>.ord.join: ' ';
p6-pdf/PDF-p6 …/filter.t :11:	my $longish = [~] (map { $_ x 3 }, $latin-chars.comb ) x 2;
peelle/Finance-CompoundInterest …/README.md :53:	But wait, I am a programmer. I am totally smarter than all those other guys that use their gut to choose stocks, loans, ponies, etc. I can use ~~spread sheets~~ databases, to comb through the data and make better choices.
perl6-community-modules/URI-Encode …/Encode.pm6 :20:	return $text.comb.map({ if $RFC3986_unreserved or $RFC3986_reserved { $_ } else { &enc($_) }}).join;
perl6-community-modules/URI-Encode …/Encode.pm6 :25:	return $text.comb.map({ if $RFC3986_unreserved { $_ } else { &enc($_) }}).join;
perl6-community-modules/p6-irc-utils …/Utils.pm :516:	# TODO Use comb/join hack to get around unsupported escapes in character classes
perl6-community-modules/p6-irc-utils …/Utils.pm :835:	for $arg.comb -> $c {
perl6-community-modules/p6-irc-utils …/Utils.pm :853:	my @a = @chan_modes[0..1].join('').comb;
perl6-community-modules/p6-irc-utils …/Utils.pm :856:	if $c ~~ ($stat_modes.comb | any(@a));
perl6-community-modules/p6-irc-utils …/Utils.pm :861:	&& $c ~~ (any(@chan_modes[2].join.comb)) {
perl6/Perl6-MIME-Base64 …/Perl.pm6 :72:	for $encoded.comb -> $char {
perl6/doc …/p6doc :278:	my %prefixes = do for %options.kv -> $k,@o { @o.map(*.comb[0].lc) X=> %found{$k} };
perl6/doc …/5to6-perlfunc.pod6 :1691:	they are in Perl 5. For that behavior, see C<comb>. Details on C<split>
perl6/doc …/io-guide.pod6 :201:	L«.comb|/type/IO::Handle#method_comb»,
perl6/doc …/objects.pod6 :48:	@words.push("said", $formatted-text.comb(/\w+/));
perl6/doc …/operators.pod6 :1232:	sub g($str){ $str.comb }
perl6/doc …/testing.pod6 :427:	letters => +.comb(/<:letter>/),
perl6/doc …/testing.pod6 :428:	digits => +.comb(/<:digit>/),
perl6/doc …/testing.pod6 :429:	other => +.comb(/<.-:letter-:digit>/),
perl6/doc …/traps.pod6 :468:	say "cba".comb.sort.join; # OUTPUT: «abc␤»
perl6/doc …/Any.pod6 :145:	say 'bca'.comb.sort.join; # OUTPUT: «abc␤»
perl6/doc …/Any.pod6 :146:	say 'bca'.comb.sort({$^b cmp $^a}).join; # OUTPUT: «cba␤»
perl6/doc …/Any.pod6 :147:	say '231'.comb.sort(&infix:«<=>»).join; # OUTPUT: «123␤»
perl6/doc …/Code.pod6 :87:	my &comber = Str.^lookup('comb').assuming: *, /P \w+/;
perl6/doc …/Cool.pod6 :104:	comb Str
perl6/doc …/Cool.pod6 :977:	say "Ḍ̇'oh".comb>>.uninames.perl;
perl6/doc …/Cool.pod6 :1131:	See also: L<comb>.
perl6/doc …/Cool.pod6 :1184:	=head2 routine comb
perl6/doc …/Cool.pod6 :1188:	multi sub comb(Regex $matcher, Str(Cool) $input, $limit = * --> Seq)
perl6/doc …/Cool.pod6 :1189:	multi method comb(Regex $matcher, $limit = * --> Seq)
perl6/doc …/Cool.pod6 :1195:	say "6 or 12".comb(/\d+/).join(", "); # OUTPUT: «6, 12␤»
perl6/doc …/CatHandle.pod6 :124:	=head2 method comb
perl6/doc …/CatHandle.pod6 :128:	method comb(IO::CatHandle:D: |args --> Seq:D)
perl6/doc …/CatHandle.pod6 :131:	L«C<Str.comb>|/type/Str#routine_comb» does, taking the same arguments.
perl6/doc …/CatHandle.pod6 :138:	IO::CatHandle.new($f1, $f2).comb(2).perl.say;
perl6/doc …/Handle.pod6 :118:	=head2 method comb
perl6/doc …/Handle.pod6 :122:	method comb(IO::Handle:D: Bool :$close, |args --> Seq:D)
perl6/doc …/Handle.pod6 :125:	L«C<Str.comb>|/type/Str#routine_comb» does, taking the same arguments, closing
perl6/doc …/Handle.pod6 :135:	say "The file has {+$fh.comb: '♥', :close} ♥s in it";
perl6/doc …/Path.pod6 :176:	=head2 method comb
perl6/doc …/Path.pod6 :180:	method comb(IO::Path:D: |args --> Seq:D)
perl6/doc …/Path.pod6 :183:	L«C<Str.comb>|/type/Str#routine_comb» does, taking the same arguments.
perl6/doc …/Iterable.pod6 :19:	method iterator(){ self.comb.iterator }
perl6/doc …/Routine.pod6 :88:	.signature.say for "foo".^can("comb")[0].cando: \(Cool, "o");
perl6/doc …/Slip.pod6 :71:	say "".comb ~~ Empty;
perl6/doc …/Str.pod6 :419:	=head2 routine comb
perl6/doc …/Str.pod6 :421:	multi sub comb(Str:D $matcher, Str:D $input, $limit = Inf)
perl6/doc …/Str.pod6 :422:	multi sub comb(Regex:D $matcher, Str:D $input, $limit = Inf, Bool :$match)
perl6/doc …/Str.pod6 :423:	multi sub comb(Int:D $size, Str:D $input, $limit = Inf)
perl6/doc …/Str.pod6 :424:	multi method comb(Str:D $input:)
perl6/doc …/Str.pod6 :425:	multi method comb(Str:D $input: Str:D $matcher, $limit = Inf)
perl6/doc …/Str.pod6 :426:	multi method comb(Str:D $input: Regex:D $matcher, $limit = Inf, Bool :$match)
perl6/doc …/Str.pod6 :427:	multi method comb(Str:D $input: Int:D $size, $limit = Inf)
perl6/doc …/Str.pod6 :438:	say "abc".comb.perl; # OUTPUT: «("a", "b", "c").Seq␤»
perl6/doc …/Str.pod6 :439:	say 'abcdefghijk'.comb(3).perl; # OUTPUT: «("abc", "def", "ghi", "jk").Seq␤»
perl6/doc …/Str.pod6 :440:	say 'abcdefghijk'.comb(3, 2).perl; # OUTPUT: «("abc", "def").Seq␤»
perl6/doc …/Str.pod6 :441:	say comb(/\w/, "a;b;c").perl; # OUTPUT: «("a", "b", "c").Seq␤»
perl6/doc …/Str.pod6 :442:	say comb(/\N/, "a;b;c").perl; # OUTPUT: «("a", ";", "b", ";", "c").Seq␤»
perl6/doc …/Str.pod6 :443:	say comb(/\w/, "a;b;c", 2).perl; # OUTPUT: «("a", "b").Seq␤»
perl6/doc …/Str.pod6 :444:	say comb(/\w\;\w/, "a;b;c", 2).perl; # OUTPUT: «("a;b",).Seq␤»
perl6/doc …/Str.pod6 :445:	say comb(/.<(.)>/, "<>").perl; # OUTPUT: «(">", "]", ")").Seq␤»
perl6/doc …/Str.pod6 :447:	If the matcher is an integer value, C<comb> behaves as if the matcher
perl6/doc …/Str.pod6 :459:	same as a call to C<$input.comb( / ^^ \N* /, $limit )> would.
perl6/doc …/Str.pod6 :474:	C<$input.comb( / \S+ /, $limit )> would.
perl6/doc …/Supply.pod6 :596:	my $s = Supply.from-list("Hello Word!".comb);
perlpilot/p6-HexDump-Tiny …/Tiny.pm :4:	my @chars = $value.comb;
ppentchev/perl6-Getopt-Std …/01-getopts.t :56:	my %exp-opts = $t.optstring.comb(/ . ':'? /).flatmap(-> $opt {
rakudo-p5/v5 …/Terms.pm :858:	for SELF.subst(/'#'\N*<?before $$ >/, '', :g).comb(/<[a..zA..Z]>[\d+|'*']?/) -> $unit {
rakudo-p5/v5 …/Terms.pm :867:	for $binary.comb -> $char {
rakudo-p5/v5 …/Terms.pm :876:	for $ascii.comb -> $char {
rakudo-p5/v5 …/Terms.pm :886:	for $ascii.comb -> $char {
rakudo-p5/v5 …/Terms.pm :899:	@bytes.push: map { :16($_) }, $hexstring.comb(/../);
rakudo-p5/v5 …/Terms.pm :1291:	gather for $s.comb(/ (\w) '..' (\w) | . /, :match) {
rakudo-p5/v5 …/Terms.pm :1380:	for SELF.subst(/'#'\N*<?before $$ >/, '', :g).comb(/<[a..zA..Z]>[\d+|'*']?/) -> $unit {
retupmoca/P6-Net-IMAP …/Simple.pm6 :71:	my @messages = @lines[0].comb(/\d+/);
retupmoca/p6-MIME-QuotedPrint …/QuotedPrint.pm6 :59:	for $stuff.comb -> $char {
ronaldxs/Perl6-US-ASCII …/01-basic.t :32:	%charset-str< punct >.comb
ronaldxs/Perl6-US-ASCII …/01-basic.t :37:	%charset-str< punct >.comb,
ronaldxs/Perl6-US-ASCII …/01-basic.t :38:	%charset-str< space >.comb,
ronaldxs/Perl6-US-ASCII …/01-basic.t :50:	is $latin-chars.comb(/<US-ASCII::alpha>/).join, %charset-str< alpha >,
ronaldxs/Perl6-US-ASCII …/01-basic.t :52:	is $latin-chars.comb(/<US-ASCII::upper>/).join, %charset-str< upper >,
ronaldxs/Perl6-US-ASCII …/01-basic.t :54:	is $latin-chars.comb(/<US-ASCII::lower>/).join, %charset-str< lower >,
ronaldxs/Perl6-US-ASCII …/01-basic.t :56:	is $latin-chars.comb(/<US-ASCII::digit>/).join, %charset-str< digit >,
ronaldxs/Perl6-US-ASCII …/01-basic.t :58:	is $latin-chars.comb(/<US-ASCII::xdigit>/).join, %charset-str< xdigit >,
ronaldxs/Perl6-US-ASCII …/01-basic.t :60:	is $latin-chars.comb(/<US-ASCII::hexdig>/).join, %charset-str< hexdig >,
ronaldxs/Perl6-US-ASCII …/01-basic.t :62:	is $latin-chars.comb(/<US-ASCII::alnum>/).join, %charset-str< alnum >,
ronaldxs/Perl6-US-ASCII …/01-basic.t :64:	is $latin-chars.comb(/<US-ASCII::punct>/).join, %charset-str< punct >,
ronaldxs/Perl6-US-ASCII …/01-basic.t :66:	is $latin-chars.comb(/<US-ASCII::graph>/).join, %charset-str< graph >,
ronaldxs/Perl6-US-ASCII …/01-basic.t :68:	is $latin-chars.comb(/<US-ASCII::blank>/).join, %charset-str< blank >,
ronaldxs/Perl6-US-ASCII …/01-basic.t :70:	is $latin-chars.comb(/<US-ASCII::space>/).join, %charset-str< space >,
ronaldxs/Perl6-US-ASCII …/01-basic.t :72:	is $latin-chars.comb(/<US-ASCII::print>/).join, %charset-str< print >,
ronaldxs/Perl6-US-ASCII …/01-basic.t :74:	is $latin-chars.comb(/<US-ASCII::cntrl>/).join, %charset-str< cntrl >,
ronaldxs/Perl6-US-ASCII …/01-basic.t :76:	is $latin-chars.comb(/<US-ASCII::vchar>/).join, %charset-str< vchar >,
ronaldxs/Perl6-US-ASCII …/01-basic.t :238:	is $latin-chars.comb(/<ALPHA>/).join, %charset-str< alpha >,
ronaldxs/Perl6-US-ASCII …/01-basic.t :240:	is $latin-chars.comb(/<UPPER>/).join, %charset-str< upper >,
ronaldxs/Perl6-US-ASCII …/01-basic.t :242:	is $latin-chars.comb(/<LOWER>/).join, %charset-str< lower >,
ronaldxs/Perl6-US-ASCII …/01-basic.t :244:	is $latin-chars.comb(/<DIGIT>/).join, %charset-str< digit >,
ronaldxs/Perl6-US-ASCII …/01-basic.t :246:	is $latin-chars.comb(/<XDIGIT>/).join, %charset-str< xdigit >,
ronaldxs/Perl6-US-ASCII …/01-basic.t :248:	is $latin-chars.comb(/<HEXDIG>/).join, %charset-str< hexdig >,
ronaldxs/Perl6-US-ASCII …/01-basic.t :250:	is $latin-chars.comb(/<ALNUM>/).join, %charset-str< alnum >,
ronaldxs/Perl6-US-ASCII …/01-basic.t :252:	is $latin-chars.comb(/<PUNCT>/).join, %charset-str< punct >,
ronaldxs/Perl6-US-ASCII …/01-basic.t :254:	is $latin-chars.comb(/<GRAPH>/).join, %charset-str< graph >,
ronaldxs/Perl6-US-ASCII …/01-basic.t :256:	is $latin-chars.comb(/<BLANK>/).join, %charset-str< blank >,
ronaldxs/Perl6-US-ASCII …/01-basic.t :258:	is $latin-chars.comb(/<SPACE>/).join, %charset-str< space >,
ronaldxs/Perl6-US-ASCII …/01-basic.t :260:	is $latin-chars.comb(/<PRINT>/).join, %charset-str< print >,
ronaldxs/Perl6-US-ASCII …/01-basic.t :262:	is $latin-chars.comb(/<CNTRL>/).join, %charset-str< cntrl >,
ronaldxs/Perl6-US-ASCII …/01-basic.t :264:	is $latin-chars.comb(/<VCHAR>/).join, %charset-str< vchar >,
ronaldxs/Perl6-US-ASCII …/02-abnf.t :11:	is $latin-chars.comb( /
ronaldxs/Perl6-US-ASCII …/02-abnf.t :32:	#say $latin-chars.comb( /<ascii-by-count::abnf-named>/ ).map: {.ord};
ronaldxs/Perl6-US-ASCII …/02-abnf.t :46:	is $latin-chars.comb( /
samcv/URL-Find …/Find.pm6 :32:	$string.comb($url-regex, $limit).List;
samgwise/Net-OSC …/Message.pm6 :185:	for $chars.decode('ISO-8859-1').comb -> $char {
samgwise/Net-OSC …/Message.pm6 :199:	@types = $extract-string.().comb: /\w/; #extract type chars and ignore the ','
samgwise/Net-OSC …/Message.pm6 :242:	@bin.push: |sprintf( '%08d', $bits[$_].base(2) ).comb;
skids/perl6-Proc-Screen …/Screen.pm6 :322:	@options.append("-e" → [~] $.escape.comb.map({ munge-escape-char($_).key }));
skids/perl6-Proc-Screen …/Screen.pm6 :332:	@options.append("escape" → [~] $.escape.comb.map({ munge-escape-char($_).key }));
skids/perl6sum …/adler.t :76:	is $p.accum, $Sum::Adler::Doc::synopsis.comb(/<.after \x23\s> (<.ws> <.xdigit>+)+/).join("\n") ~ "\n", 'Code in manpage synopsis actually works';
skids/perl6sum …/crc.t :177:	ok .check(0x2d,?<<+<<comb(/./,"000100")), "CRC_14_DARC self-verifies (0)";
skids/perl6sum …/crc.t :197:	ok .check(?<<+<<comb(/./,"0100101"),0x66), "CRC_15_MPT1327 self-verifies (residual)";
skids/perl6sum …/crc.t :215:	my $s = .finalize(?<<(+<<comb(/./,11000100101000101110011010010001)));
skids/perl6sum …/gost.t :83:	is $p.accum, $Sum::GOST::Doc::synopsis.comb(/<.after \x23\s> (<.ws> <.xdigit>+)+/).join("\n") ~ "\n", 'Code in manpage synopsis actually works';
skids/perl6sum …/has.t :52:	is $p.accum, $Sum::HAS::Doc::synopsis.comb(/<.after \x23\s> (<.ws> <.xdigit>+)+/).join("\n") ~ "\n", 'Code in manpage synopsis actually works';
skids/perl6sum …/libcrypto.t :75:	is $p.accum, $Sum::libcrypto::Doc::synopsis.comb(/<.after \x23\s> (<.ws> <.xdigit>+)+/).join("\n") ~ "\n", 'Code in manpage synopsis actually works';
skids/perl6sum …/libmhash.t :80:	is $p.accum, $Sum::libmhash::Doc::synopsis.comb(/<.after \x23\s> (<.ws> <.xdigit>+)+/).join("\n") ~ "\n", 'Code in manpage synopsis actually works';
skids/perl6sum …/librhash.t :76:	is $p.accum, $Sum::librhash::Doc::synopsis.comb(/<.after \x23\s> (<.ws> <.xdigit>+)+/).join("\n") ~ "\n", 'Code in manpage synopsis actually works';
skids/perl6sum …/md.t :288:	is $p.accum, $Sum::MD::Doc::synopsis.comb(/<.after \x23\s> (<.ws> <.xdigit>+)+/).join("\n") ~ "\n", 'Code in manpage synopsis actually works';
skids/perl6sum …/sha.t :271:	is $p.accum, $Sum::SHA::Doc::synopsis.comb(/<.after \x23\s> (<.ws> <.xdigit>+)+/).join("\n") ~ "\n", 'Code in manpage synopsis actually works';
skids/perl6sum …/siphash.t :32:	is $p.accum, $Sum::SipHash::Doc::synopsis.comb(/<.after \x23\s> (<.ws> <.xdigit>+)+/).join("\n") ~ "\n", 'Code in manpage synopsis actually works';
skids/perl6sum …/sm3.t :47:	is $p.accum, $Sum::SM3::Doc::synopsis.comb(/<.after \x23\s> (<.ws> <.xdigit>+)+/).join("\n") ~ "\n", 'Code in manpage synopsis actually works';
skids/perl6sum …/sum.t :298:	is $s.accum, $Sum::Doc::synopsis.comb(/<.after \x23\s> (<.ws> <[\d\(\)\[\]]>+)+/).join("\n") ~ "\n", 'Code in manpage synopsis actually works';
skids/perl6sum …/tiger.t :1715:	is $p.accum, $Sum::Tiger::Doc::synopsis.comb(/<.after \x23\s> (<.ws> <.xdigit>+)+/).join("\n") ~ "\n", 'Code in manpage synopsis actually works';
softmoth/p6-Template-Mustache …/Mustache.pm :102:	my @delim = $0.comb(/\S+/);
spitsh/spitsh …/Parse.pm6 :508:	my @orig = $orig.comb;
spitsh/spitsh …/Exceptions.pm6 :29:	my @orig = $orig.comb;
spitsh/spitsh …/Exceptions.pm6 :296:	if $.match.orig.comb[$.match.to - 1] eq ')' {
spitsh/spitsh …/Grammar.pm6 :9:	constant @brackets := "<>\{}\x[0028]\x[0029]\x[003C]\x[003E]\x[005B]\x[005D]\x[007B]\x[007D]\x[00AB]\x[00BB]\x[0F3A]\x[0F3B]\x[0F3C]\x[0F3D]\x[16…
spitsh/spitsh …/Quote.pm6 :144:	my @chars = $str.comb;
spitsh/spitsh …/Composer.pm6 :479:	]".comb xx ∞).flat.Array;
supernovus/flower …/TALES.pm6 :140:	$string.comb(/ [ '{{'.*?'}}' | '${'.*?'}' | '$('.*?')' | ':'\w+'('.*?')' | \'.*?\' | \S+ ] /);
supernovus/hinges …/XMLParser.pm :58:	my $line-num = +$text.substr(0, $t.from).comb(/\n/) + 1;
supernovus/template6 …/Parser.pm6 :178:	my @stmts = $statement.split(/\n/).map({ self.remove-comment(.comb(/\".*?\" | \'.*?\' | \S+/)) }).flat;
tadzik/Getopt-Type …/Type.pm :26:	my @letters = $k.comb;
tadzik/Grammar-BNF …/ABNF.pm :363:	(~$/[0].comb.map({ "<[" ~
tadzik/Grammar-BNF …/abnf.t :308:	my $rfc4466g_meths2 = Set($rfc4466.comb(/<after [ ^ | \n ]><-[\s\=]>+/)».lc);
tadzik/Terminal-ANSIColor …/ANSIColor.pm :82:	my @list = $what.comb(/\d+/);
tadzik/Text-T9 …/T9.pm :31:	if $candidate.comb.map({%keys{$_}}).join eq $input {
tadzik/panda …/App.pm :80:	return $str.comb(/ . ** 0..40 [ << | $ ]/).grep({ .chars > 0 }).join("\n" ~ " " x 36);
tadzik/perl6-Term-ANSIColor …/ANSIColor.pm :73:	my @list = $what.comb(/\d+/);
thundergnat/Acme-Scrub …/Scrub.pm6 :3:	my @socks = '​'.comb;
thundergnat/Acme-Scrub …/Scrub.pm6 :13:	@socks[$soap[*]».fmt("%08b").join.comb].join, $suds;
thundergnat/Acme-Scrub …/Scrub.pm6 :16:	EVAL Blob.new( map { :2(%pants{$_.comb}.join) },
thundergnat/Acme-Scrub …/Scrub.pm6 :17:	$wash.comb(8)).decode;
thundergnat/Lingua-EN-Numbers-Cardinal …/Cardinal.pm6 :120:	return join ', ', reverse gather for $int.flip.comb(/\d ** 1..3/) {
thundergnat/Lingua-EN-Numbers-Cardinal …/Cardinal.pm6 :121:	my ( $i, $x, $c ) = .comb».Int;
thundergnat/Lingua-EN-Numbers-Cardinal …/Cardinal.pm6 :149:	my $f = +$fraction ?? join( ' ', ' point', @I[$fraction.comb]) !! '';
thundergnat/Lingua-EN-Numbers-Cardinal …/Cardinal.pm6 :151:	"{@I[$whole.comb]}$f times ten to the { $exponent.&ordinal }" !!
thundergnat/Lingua-EN-Numbers-Cardinal …/Cardinal.pm6 :152:	"{@I[$whole.comb]}$f";
thundergnat/Lingua-EN-Numbers-Cardinal …/Cardinal.pm6 :159:	my ($, $cen) = $year.flip.comb(/\d ** 1..2/);
thundergnat/Lingua-EN-Numbers-Cardinal …/Cardinal.pm6 :162:	my ($l, $h) = $year.flip.comb(/\d ** 1..2/).».flip;
tony-o/perl6-encoding-huffman-pp6 …/PP6.pm6 :264:	my $bits = $s.comb.map({ %codes{$_}.Str }).join('');
tony-o/perl6-encoding-huffman-pp6 …/PP6.pm6 :267:	for ($bits.comb, %codes<_eos>.comb).flat -> $c {
tony-o/perl6-encoding-huffman-pp6 …/PP6.pm6 :287:	for $s.map({ .base(2).Str.comb }) -> @i {
tony-o/perl6-html-parser-xml …/S05.html :10648:	<pre> $str.comb(/pat/, :match)</pre>
ugexe/Perl6-Base64 …/Base64.pm6 :39:	$str.comb(/@alpha/).rotor(4, :partial).map: -> $chunk {
ugexe/zef …/SystemInfo.pm6 :23:	my $cols = $/<cols>.comb(/\d/).join;
vendethiel/hydrate6 …/Hydrate.pm :44:	%made{$name} = value-for($attr.type, $attr.name.comb[0], value,
wollmers/P6-LCS-BV …/01-basic.t :92:	my $A = [$a.comb(/<-[_]>/)];
wollmers/P6-LCS-BV …/01-basic.t :93:	my $B = [$b.comb(/<-[_]>/)];
wollmers/P6-LCS-BV …/50_diff_bench.t :5:	my $A = ['Chrerrplzon'.comb(/<-[_]>/)];
wollmers/P6-LCS-BV …/50_diff_bench.t :6:	my $B = ['Choerephon'.comb(/<-[_]>/)];
wollmers/P6-LCS-BV …/50_diff_bench.t :35:	$A = ['ChrerrplzonChrerrplzon'.comb(/<-[_]>/)];
wollmers/P6-LCS-BV …/50_diff_bench.t :36:	$B = ['ChoerephonChoerephon'.comb(/<-[_]>/)];
zoffixznet/perl6-Color …/Utilities.pm6 :28:	my ( $r, $g, $b, $a ) = map { :16($_) }, $hex.comb(/../);
zoffixznet/perl6-IRC-Client-Plugin-Factoid …/bot.pl6 :13:	:channels($channel.comb: /<-[,]>+/),
zoffixznet/perl6-IRC-Client …/Actions.pm6 :104:	for %args<params>[1..*-1].join.comb: /\S/ {
zoffixznet/perl6-IRC-Client …/Actions.pm6 :116:	:modes( %args<params>[1..*-1].join.comb: /<[a..zA..Z]>/ ),
zoffixznet/perl6-Inline-Brainfuck …/Brainfuck.pm6 :16:	my @code = $code.comb: /<[-<\>+.,[\]]>/;
zoffixznet/perl6-Inline-Brainfuck …/Brainfuck.pm6 :55:	for $code.comb {
zoffixznet/perl6-Pythonic-Str …/README.md :55:	`.comb` if you need that.
zoffixznet/perl6-Pythonic-Str …/README.md :59:	- `Str.comb`
zoffixznet/perl6-Pythonic-Str …/Str.pm6 :9:	my $r := CORE::{'&postcircumfix:<[ ]>'}(SELF.comb.cache, |c);
zostay/p6-DOM-Tiny …/HTML.pm6 :663:	make (~$/).comb(/ <-[ < > = \s / ]>+ /).first(*.chars > 0)
zostay/p6-HTTP-Headers …/Headers.pm6 :75:	$self.prepared-values[0].comb(/ <-[ ; ]>+ /)[0].trim
zostay/p6-HTTP-Headers …/Headers.pm6 :84:	my @items = try { $value.comb(/ <-[ ; ]>+ /, 2) };
zostay/p6-HTTP-Headers …/Headers.pm6 :95:	my @pairs = try { self.prepared-values».comb(/ <-[ ; ]>+ /)».grep(/'='/).flat };
zostay/p6-HTTP-Headers …/Headers.pm6 :107:	my @pairs = try { $prep-value.comb(/ <-[ ; ]>+ /) };
zostay/p6-Path-Router …/Router.pm6 :95:	my Str @parts = $url.comb(/ <-[ \/ ]>+ /);
zostay/p6-Path-Router …/Route.pm6 :71:	$!path.comb(/ <-[ \/ ]>+ /).grep({ .chars });
zostay/p6-Path-Router …/013_false_path_components.t :14:	is-deeply($match.route.components, Array[Str].new($path.comb(/ <-[ \/ ]>+ /).Slip));
zostay/perl6-IO-Glob …/Glob.pm6 :184:	my @class = $<class>.Str.comb;