greppable6

query

comb

result.md

File	Code
ALOREN/App-FindSource …/LICENSE :237:	and which are not combined with it such as to form a larger program,
ALOREN/App-FindSource …/LICENSE :555:	permission to link or combine any covered work with a work licensed
ALOREN/App-FindSource …/LICENSE :557:	combined work, and to convey the resulting work. The terms of this
ALOREN/App-FindSource …/LICENSE :561:	combination as such.
ALOREN/Terminal-Table …/LightWrap.pm6 :60:	self.__concat_line($key.comb());
ALOREN/Terminal-Table …/04-style.t :45:	}, "style combination {++$count} ok";
BDUGGAN/Digest-SHA256-Native …/Native.pm6 :27:	Blob.new( sha256-hex($in).comb(2).map({ :16($_) }))
CHSANCH/Lingua-Stem-Es …/diffs.txt :1058:	airecombustible airecombust
CHSANCH/Lingua-Stem-Es …/diffs.txt :5623:	combate combat
CHSANCH/Lingua-Stem-Es …/diffs.txt :5624:	combaten combat
CHSANCH/Lingua-Stem-Es …/diffs.txt :5625:	combates combat
CHSANCH/Lingua-Stem-Es …/diffs.txt :5626:	combatido combat
CHSANCH/Lingua-Stem-Es …/diffs.txt :5627:	combatió combat
CHSANCH/Lingua-Stem-Es …/diffs.txt :5628:	combatir combat
CHSANCH/Lingua-Stem-Es …/diffs.txt :5629:	combatirán combat
CHSANCH/Lingua-Stem-Es …/diffs.txt :5630:	combatividad combat
CHSANCH/Lingua-Stem-Es …/diffs.txt :5631:	combativo combat
CHSANCH/Lingua-Stem-Es …/diffs.txt :5632:	combina combin
CHSANCH/Lingua-Stem-Es …/diffs.txt :5633:	combinación combin
CHSANCH/Lingua-Stem-Es …/diffs.txt :5634:	combinaciones combin
CHSANCH/Lingua-Stem-Es …/diffs.txt :5635:	combinada combin
CHSANCH/Lingua-Stem-Es …/diffs.txt :5636:	combinadas combin
CHSANCH/Lingua-Stem-Es …/diffs.txt :5637:	combinado combin
CHSANCH/Lingua-Stem-Es …/diffs.txt :5638:	combinados combin
CHSANCH/Lingua-Stem-Es …/diffs.txt :5639:	combinan combin
CHSANCH/Lingua-Stem-Es …/diffs.txt :5640:	combinando combin
CHSANCH/Lingua-Stem-Es …/diffs.txt :5641:	combinar combin
CHSANCH/Lingua-Stem-Es …/diffs.txt :5642:	combinará combin
CHSANCH/Lingua-Stem-Es …/diffs.txt :5643:	combinarlo combin
CHSANCH/Lingua-Stem-Es …/diffs.txt :5644:	combinarlos combin
CHSANCH/Lingua-Stem-Es …/diffs.txt :5645:	combinen combin
CHSANCH/Lingua-Stem-Es …/diffs.txt :5646:	combis combis
CHSANCH/Lingua-Stem-Es …/diffs.txt :5647:	combustible combust
CHSANCH/Lingua-Stem-Es …/diffs.txt :5648:	combustibles combust
CHSANCH/Lingua-Stem-Es …/diffs.txt :5649:	combustión combustion
CHSANCH/Lingua-Stem-Es …/diffs.txt :10788:	escombrera escombrer
CHSANCH/Lingua-Stem-Es …/diffs.txt :10789:	escombros escombr
CHSANCH/Lingua-Stem-Es …/diffs.txt :16004:	lavercombe lavercomb
ELIZABETH/List-MoreUtils …/mode.t :10:	my @lorem = $lorem.comb( / \w+ | <[,.]> / );
ELIZABETH/List-MoreUtils …/occurrences.t :10:	my @lorem = $lorem.comb( / \w+ | <[,.]> / );
ELIZABETH/List-Util …/README.md :91:	The above example code blocks also suggest how to use `reduce` to build a more efficient combined version of one of these basic functions and a `map` block. For example, to find the total length of all the strings in a list, we could use
ELIZABETH/List-Util …/Util.pm6 :294:	more efficient combined version of one of these basic functions and a C<map>
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);
FRITH/Archive-Libarchive …/README.md :150:	determine automatically the right combination of parameters.
FRITH/Archive-Libarchive …/Libarchive.pm6 :646:	determine automatically the right combination of parameters.
HANENKAMP/ArrayHash …/README.md :113:	This provides the usual value lookup by key. You can use this to retrieve a value, assign a value, or bind a value. You may also combine this with the hash adverbs `:delete` and `:exists`.
HANENKAMP/ArrayHash …/README.md :120:	This returns the value lookup by index. You can use this to retrieve the pair at the given index or assign a new pair or even bind a pair. It may be combined with the array adverbs `:delete` and `:exists` as well.
HANENKAMP/ArrayHash …/ArrayHash.pm6 :91:	pick roll reduce combinations
HANENKAMP/ArrayHash …/ArrayHash.pm6 :160:	This provides the usual value lookup by key. You can use this to retrieve a value, assign a value, or bind a value. You may also combine this with the hash adverbs C<:delete> and C<:exists>.
HANENKAMP/ArrayHash …/ArrayHash.pm6 :174:	This returns the value lookup by index. You can use this to retrieve the pair at the given index or assign a new pair or even bind a pair. It may be combined with the array adverbs C<:delete> and C<:exists> as well.
HANENKAMP/DOM-Tiny …/CSS.pm6 :7:	has @.combine;
HANENKAMP/DOM-Tiny …/CSS.pm6 :9:	submethod BUILD(:@combine) {
HANENKAMP/DOM-Tiny …/CSS.pm6 :10:	PRE { @combine.elems !%% 2 }
HANENKAMP/DOM-Tiny …/CSS.pm6 :11:	@!combine = @combine.reverse;
HANENKAMP/DOM-Tiny …/CSS.pm6 :17:	my sub next-combination(@next, $current) {
HANENKAMP/DOM-Tiny …/CSS.pm6 :19:	try-combination(@next[0], @next[1], @next[2..*], $current);
HANENKAMP/DOM-Tiny …/CSS.pm6 :22:	my multi try-combination('', $test, @next, $current) {
HANENKAMP/DOM-Tiny …/CSS.pm6 :28:	return True if next-combination(@next, $ancestor);
HANENKAMP/DOM-Tiny …/CSS.pm6 :34:	my multi try-combination('>', $test, @next, $current) {
HANENKAMP/DOM-Tiny …/CSS.pm6 :37:	next-combination(@next, $current.parent);
HANENKAMP/DOM-Tiny …/CSS.pm6 :40:	my multi try-combination('+', $test, @next, $current) {
HANENKAMP/DOM-Tiny …/CSS.pm6 :45:	next-combination(@next, $previous-sibling);
HANENKAMP/DOM-Tiny …/CSS.pm6 :48:	my multi try-combination('~', $test, @next, $current) {
HANENKAMP/DOM-Tiny …/CSS.pm6 :55:	return True if next-combination(@next, $sibling);
HANENKAMP/DOM-Tiny …/CSS.pm6 :62:	return False unless $current ~~ @!combine[0];
HANENKAMP/DOM-Tiny …/CSS.pm6 :63:	return True if @!combine.elems == 1;
HANENKAMP/DOM-Tiny …/CSS.pm6 :64:	next-combination(@!combine[1..*], $current);
HANENKAMP/DOM-Tiny …/CSS.pm6 :312:	combine => flat roundrobin(
HANENKAMP/DOM-Tiny …/HTML.pm6 :663:	make (~$/).comb(/ <-[ < > = \s / ]>+ /).first(*.chars > 0)
HANENKAMP/DOM-Tiny …/052-dom-sibling-combinator.t :7:	# Sibling combinator
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;
HOLLI/Color-Named …/COPYING :240:	and which are not combined with it such as to form a larger program,
HOLLI/Color-Named …/COPYING :558:	permission to link or combine any covered work with a work licensed
HOLLI/Color-Named …/COPYING :560:	combined work, and to convey the resulting work. The terms of this
HOLLI/Color-Named …/COPYING :564:	combination as such.
HOLLI/Color-Names …/COPYING :240:	and which are not combined with it such as to form a larger program,
HOLLI/Color-Names …/COPYING :558:	permission to link or combine any covered work with a work licensed
HOLLI/Color-Names …/COPYING :560:	combined work, and to convey the resulting work. The terms of this
HOLLI/Color-Names …/COPYING :564:	combination as such.
HOLLI/Color-Scheme …/COPYING :240:	and which are not combined with it such as to form a larger program,
HOLLI/Color-Scheme …/COPYING :558:	permission to link or combine any covered work with a work licensed
HOLLI/Color-Scheme …/COPYING :560:	combined work, and to convey the resulting work. The terms of this
HOLLI/Color-Scheme …/COPYING :564:	combination as such.
HOLLI/Test-Color …/COPYING :240:	and which are not combined with it such as to form a larger program,
HOLLI/Test-Color …/COPYING :558:	permission to link or combine any covered work with a work licensed
HOLLI/Test-Color …/COPYING :560:	combined work, and to convey the resulting work. The terms of this
HOLLI/Test-Color …/COPYING :564:	combination as such.
JGOFF/ANTLR4-Grammar …/CSharp4.g4 :713:	| combined_join_clause
JGOFF/ANTLR4-Grammar …/CSharp4.g4 :729:	combined_join_clause
JGOFF/ANTLR4-Grammar …/CSharp4.g4 :1173:	// combines all available modifiers
JGOFF/ANTLR4-Grammar …/UCBLogo.g4 :54:	put("combine", 2);
JGOFF/ANTLR4-Grammar …/Verilog2001.g4 :604:	udp_body : combinational_body | sequential_body ;
JGOFF/ANTLR4-Grammar …/Verilog2001.g4 :605:	combinational_body : 'table' Combinational_entry+ 'endtable' ;
JGOFF/ANTLR4-Grammar …/Perl6.pm6 :660:	# XXX other combinations, exponents explode, oh the humanity.
JMERELO/Algorithm-Evolutionary-Simple …/LICENSE :237:	and which are not combined with it such as to form a larger program,
JMERELO/Algorithm-Evolutionary-Simple …/LICENSE :555:	permission to link or combine any covered work with a work licensed
JMERELO/Algorithm-Evolutionary-Simple …/LICENSE :557:	combined work, and to convey the resulting work. The terms of this
JMERELO/Algorithm-Evolutionary-Simple …/LICENSE :561:	combination as such.
JMERELO/Algorithm-Evolutionary-Simple …/META6.json :17:	"examples/concurrent-selecto-recombinative-EA.p6",
JMERELO/Algorithm-Evolutionary-Simple …/ChangeLog :124:	* concurrent-selecto-recombinative-EA.p6: Adds parameter printing
JMERELO/Algorithm-Evolutionary-Simple …/ChangeLog :134:	* concurrent-selecto-recombinative-EA.p6: Start making experiments
JMERELO/Algorithm-Evolutionary-Simple …/ChangeLog :135:	for finding out the population needed in a selecto-recombinative
JMERELO/Algorithm-Evolutionary-Simple …/ChangeLog :141:	examples/concurrent-selecto-recombinative-EA.p6
JMERELO/Algorithm-Evolutionary-Simple …/ChangeLog :144:	perl6 -Ilib examples/concurrent-selecto-recombinative-EA.p6
JMERELO/Algorithm-Evolutionary-Simple …/concurrent-selecto-recombinative-EA.p6 :7:	sub selecto-recombinative-EA( |parameters (
JMERELO/Algorithm-Evolutionary-Simple …/concurrent-selecto-recombinative-EA.p6 :83:	my $result = selecto-recombinative-EA( length => $length,
JMERELO/Wikidata-API …/LICENSE :237:	and which are not combined with it such as to form a larger program,
JMERELO/Wikidata-API …/LICENSE :555:	permission to link or combine any covered work with a work licensed
JMERELO/Wikidata-API …/LICENSE :557:	combined work, and to convey the resulting work. The terms of this
JMERELO/Wikidata-API …/LICENSE :561:	combination as such.
JNTHN/Concurrent-Queue …/README.md :39:	* A `Failure` is returned to indicate emptiness, rather than a combination of
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 {
JNTHN/cro …/cro-yml.md :6:	some metadata about the service that is used in combination with the `cro`
JNTHN/cro …/http-auth-and-sessions.md :209:	a valid combination and `False` otherwise.
JNTHN/cro …/cro-websocket-client.md :59:	Since this JSON combination is so common, the above example can simply be
JNTHN/cro …/cro-zeromq.md :128:	already subscribed to, and so this likely only makes sense in combination with
JNTHN/cro …/app.js :3784:	!(propertyInfo.hasBooleanValue + propertyInfo.hasNumericValue + propertyInfo.hasOverloadedBooleanValue <= 1) ? process.env.NODE_ENV !== 'produc…
JNTHN/cro …/app.js :12004:	// Probably in the "in body" parsing mode, so we outlaw only tag combos
JNTHN/cro …/app.js :13623:	rcombinators = new RegExp( "^" + whitespace + "*([>+~]|" + whitespace + ")" + whitespace + "*" ),
JNTHN/cro …/app.js :14301:	// In-page `selector#id sibling-combinator selector` fails
JNTHN/cro …/app.js :14945:	// spaces as combinators
JNTHN/cro …/app.js :15179:	if ( (match = rcombinators.exec( soFar )) ) {
JNTHN/cro …/app.js :15183:	// Cast descendant combinators to space
JNTHN/cro …/app.js :15229:	function addCombinator( matcher, combinator, base ) {
JNTHN/cro …/app.js :15230:	var dir = combinator.dir,
JNTHN/cro …/app.js :15231:	skip = combinator.next,
JNTHN/cro …/app.js :15236:	return combinator.first ?
JNTHN/cro …/app.js :15252:	// We can't set arbitrary data on XML nodes, so they don't benefit from combinator caching
JNTHN/cro …/app.js :15472:	// If the preceding token was a descendant combinator, insert an implicit any-element `*`
JNTHN/cro …/app.js :15671:	// Abort if we hit a combinator
JNTHN/cro …/app.js :15676:	// Search, expanding context for leading sibling combinators
JNTHN/cro …/app.js :29551:	/* harmony import */ var __WEBPACK_IMPORTED_MODULE_1__combineReducers__ = __webpack_require__(458);
JNTHN/cro …/app.js :29557:	/* harmony reexport (binding) */ __webpack_require__.d(__webpack_exports__, "combineReducers", function() { return __WEBPACK_IMPORTED_MODULE_1__combineReducers__["a"]; });
JNTHN/cro …/app.js :29608:	* parts of the state tree respond to actions, you may combine several reducers
JNTHN/cro …/app.js :29609:	* into a single reducer function by using `combineReducers`.
JNTHN/cro …/app.js :29617:	* If you use `combineReducers` to produce the root reducer function, this must be
JNTHN/cro …/app.js :29618:	* an object with the same shape as `combineReducers` keys.
JNTHN/cro …/app.js :41920:	var store = (0, _redux.createStore)((0, _redux.combineReducers)({
JNTHN/cro …/app.js :43894:	/* WEBPACK VAR INJECTION */(function(process) {/* harmony export (immutable) */ __webpack_exports__["a"] = combineReducers;
JNTHN/cro …/app.js :43914:	return 'Store does not have a valid reducer. Make sure the argument passed ' + 'to combineReducers is an object whose values are reducers.';
JNTHN/cro …/app.js :43957:	* reducer functions that need to be combined into one. One handy way to obtain
JNTHN/cro …/app.js :43966:	function combineReducers(reducers) {
JNTHN/cro …/app.js :43996:	return function combination() {
JNTHN/cro …/app.js :44950:	* this key combination and no character is inserted into the
JNTHN/cro …/app.js :44954:	* - `which` is the pressed key code, but a command combination is
JNTHN/cro …/app.js :55272:	* Returns true if a <Link> to the given pathname/query combination is
JNTHN/cro …/app.js :67123:	// The core of the algorithm. Here, a new subtree is combined with the
JNTHN/cro …/app.js :83451:	throw new Error('Expected the routing state to be available either as `state.routing` ' + 'or as the custom expression you can specify as `select…
JNTHN/cro …/index.js :19:	import { createStore, applyMiddleware, combineReducers } from 'redux';
JNTHN/cro …/index.js :23:	const store = createStore(combineReducers({
KAIEPI/Net-LibIDN2 …/README.md :189:	Invalid combination of flags.
KAIEPI/Net-LibIDN2 …/README.md :205:	String has forbidden leading combining character.
KAIEPI/Net-LibIDN2 …/LibIDN2.pm6 :12:	my $digits := IDN2_VERSION.comb(/\d+/).map({ :16($_) });
KAIEPI/Net-LibIDN2 …/LibIDN2.pm6 :341:	Invalid combination of flags.
KAIEPI/Net-LibIDN2 …/LibIDN2.pm6 :357:	String has forbidden leading combining character.
KOORCHIK/LIVR …/README.md :40:	### You can use modifiers separately or can combine them with validation:
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;
MORITZ/Grammar-ErrorReporting …/COPYING :240:	and which are not combined with it such as to form a larger program,
MORITZ/Grammar-ErrorReporting …/COPYING :558:	permission to link or combine any covered work with a work licensed
MORITZ/Grammar-ErrorReporting …/COPYING :560:	combined work, and to convey the resulting work. The terms of this
MORITZ/Grammar-ErrorReporting …/COPYING :564:	combination as such.
MORITZ/Grammar-ErrorReporting …/ErrorReporting.pm6 :91:	the match of the C<~> parser combinator fails, as in this example:
MORITZ/JSON-Tiny …/Actions.pm :32:	# when a combining character comes after an opening quote,
MORITZ/JSON-Tiny …/Actions.pm :35:	# so we need to extract those combining character(s)
PATRICKZ/RPi-Device-ST7036 …/ST7036.pm6 :266:	for $text.comb -> $char {
SAMGWISE/Result …/README.md :40:	The Second call will either say the returned `Str` or through an exception with the error returned from the function combined with the error provided in `ok` method.
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 …/README.md :40:	The default constructor will accept and 81 character long string comprising of combinations of 0-9. This code can be got from an existing Game::Sudoku object by calling it's .Str method.
SCIMON/Game-Sudoku …/Sudoku.pm6 :17:	my @tmp = $code.comb.map( *.Int );
SCIMON/Game-Sudoku …/Sudoku.pm6 :29:	my @tmp = $code.comb.map( *.Int );
SCIMON/Game-Sudoku …/Sudoku.pm6 :188:	The default constructor will accept and 81 character long string comprising of combinations of 0-9.
TBROWDER/Net-IP …/IP.pm6 :59:	@fields = $ip.comb;
TBROWDER/Net-IP …/IP.pm6 :89:	my @c = $binip.comb;
TBROWDER/Net-IP …/IP.pm6 :91:	# convert each 8-bit octet to decimal and combine into the ip
TBROWDER/Net-IP …/IP.pm6 :106:	my @c = $binip.comb;
TBROWDER/Net-IP …/IP.pm6 :108:	# convert each 16-bit field to 4 hex chars and combine into the ip
TBROWDER/Net-IP …/IP.pm6 :137:	my @q = $q.comb;
TBROWDER/Net-IP …/IP.pm6 :201:	# then combine the two parts and we have the new, compressed ip
TBROWDER/Net-IP …/IP.pm6 :249:	my @c = $ip.comb;
TBROWDER/Net-IP …/IP.pm6 :251:	# convert each 4-bit hex digit to 4-bit binary, and combine into the ip
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;
TBROWDER/Proc-More …/030-process-time.t :154:	# check all arg combinations
TIMOTIMO/JSON-Fast …/Fast.pm :74:	"\\\\" ~ tear-off-combiners($str, 0)
TIMOTIMO/JSON-Fast …/Fast.pm :78:	"\\\"" ~ tear-off-combiners($str, 0)
TIMOTIMO/JSON-Fast …/Fast.pm :87:	to-surrogate-pair($/.Str) ~ tear-off-combiners($/.Str, 0);
TIMOTIMO/JSON-Fast …/Fast.pm :197:	my sub tear-off-combiners(str $text, int $pos) {
TIMOTIMO/JSON-Fast …/Fast.pm :198:	my str $combinerstuff = nqp::substr($text, $pos, 1);
TIMOTIMO/JSON-Fast …/Fast.pm :199:	my @parts = $combinerstuff.NFD.list;
TIMOTIMO/JSON-Fast …/Fast.pm :226:	my str $startcombiner = "";
TIMOTIMO/JSON-Fast …/Fast.pm :231:	$startcombiner = tear-off-combiners($text, $startpos - 1);
TIMOTIMO/JSON-Fast …/Fast.pm :297:	if $startcombiner {
TIMOTIMO/JSON-Fast …/Fast.pm :298:	$raw = $startcombiner ~ $raw
TIMOTIMO/JSON-Fast …/Fast.pm :333:	$endpiece = tear-off-combiners(@caps.tail, 0);
TIMOTIMO/JSON-Fast …/Fast.pm :350:	$replacement ~ tear-off-combiners($0.Str, 0);
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;
TITSUKI/Text-Sift4 …/01-basic.t :59:	}, "combination";
TOKUHIROM/HTTP-Server-Tiny …/Tiny.pm6 :372:	# TODO combine response header and small request body
TYIL/App-MPD-AutoQueue …/LICENSE :237:	and which are not combined with it such as to form a larger program,
TYIL/App-MPD-AutoQueue …/LICENSE :555:	permission to link or combine any covered work with a work licensed
TYIL/App-MPD-AutoQueue …/LICENSE :557:	combined work, and to convey the resulting work. The terms of this
TYIL/App-MPD-AutoQueue …/LICENSE :561:	combination as such.
TYIL/Dist-Helper …/LICENSE :237:	and which are not combined with it such as to form a larger program,
TYIL/Dist-Helper …/LICENSE :555:	permission to link or combine any covered work with a work licensed
TYIL/Dist-Helper …/LICENSE :557:	combined work, and to convey the resulting work. The terms of this
TYIL/Dist-Helper …/LICENSE :561:	combination as such.
TYIL/IRC-Client-Plugin-Ignore …/LICENSE :237:	and which are not combined with it such as to form a larger program,
TYIL/IRC-Client-Plugin-Ignore …/LICENSE :555:	permission to link or combine any covered work with a work licensed
TYIL/IRC-Client-Plugin-Ignore …/LICENSE :557:	combined work, and to convey the resulting work. The terms of this
TYIL/IRC-Client-Plugin-Ignore …/LICENSE :561:	combination as such.
TYIL/Ops-SI …/LICENSE.txt :225:	and which are not combined with it such as to form a larger program,
TYIL/Ops-SI …/LICENSE.txt :554:	permission to link or combine any covered work with a work licensed
TYIL/Ops-SI …/LICENSE.txt :556:	combined work, and to convey the resulting work. The terms of this
TYIL/Ops-SI …/LICENSE.txt :558:	but the work with which it is combined will remain governed by version
UFOBAT/Bailador …/README.md :338:	Instead of using simple subs for routes (e.g in combination with `get`, `post`, `delete` etc) you could also use Controller Classes. Contro…
UFOBAT/Bailador …/README.md :512:	| template-format | predefined format strings | 'combined' (Apache combined format) |
UFOBAT/Bailador …/README.md :523:	This parameter can be used to specify predefined formats like Apache "combined", or Apache "simple" error log.
UFOBAT/Bailador …/README.md :527:	- combined
UFOBAT/Bailador …/Configuration.pm :58:	# Available template-format: 'common', 'combined' and 'simple' wich are defaults in Apache ;
UFOBAT/Bailador …/Configuration.pm :62:	# Accesses logs, in combined format
UFOBAT/Bailador …/Configuration.pm :63:	# 'file:logs/access.log' => { 'template-filter' => 'http-requests', 'template-format' => 'combined' },
UFOBAT/Bailador …/Formatter.pm :23:	when 'combined' {
UFOBAT/Bailador …/Formatter.pm :79:	when 'combined' {
UFOBAT/Bailador …/19-logging.t :60:	$f = Bailador::Log::Formatter.new( :template-format<combined> );
UFOBAT/Bailador …/19-logging.t :61:	is $format-attribute.get_value( $f ), '\e{h} \e{l} \e{u} [\e{t}] "\e{r}" \e{s} \e{b} "\e{Referer}" \e{User-agent}', 'combined format';
UFOBAT/Bailador …/19-logging.t :68:	'combined formatted log match';
UFOBAT/I18N-LangTags …/List.pm6 :172:	a particular place, in combination with non-linguistic
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 …/README.pod :97:	A request may contain any number and combination of these. Paths and URLs will be resolved first so they are available
UGEXE/zef …/README.pod :334:	In most cases the default configuration combined with command line options should be enough for most users.
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 …/glyphlist.txt :813:	acutecomb;0301
WARRINGD/Font-AFM …/glyphlist.txt :1672:	dotbelowcomb;0323
WARRINGD/Font-AFM …/glyphlist.txt :2035:	gravecomb;0300
WARRINGD/Font-AFM …/glyphlist.txt :2183:	hookabovecomb;0309
WARRINGD/Font-AFM …/glyphlist.txt :3829:	tildecomb;0303
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 …/README.md :66:	The following load flags are available. They can be combined with the bit-wise OR operator (`|`). The symbols are exported by the module and so will be available once you do `use Font::FreeType`.
WARRINGD/Font-FreeType …/FreeType.pm :137:	The following load flags are available. They can be combined with
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/Font-FreeType …/5x7.bdf :8251:	STARTCHAR gravecomb
WARRINGD/Font-FreeType …/5x7.bdf :8265:	STARTCHAR acutecomb
WARRINGD/Font-FreeType …/5x7.bdf :8293:	STARTCHAR tildecomb
WARRINGD/Font-FreeType …/5x7.bdf :8377:	STARTCHAR hookabovecomb
WARRINGD/Font-FreeType …/5x7.bdf :8503:	STARTCHAR dotbelowcomb
WARRINGD/Font-FreeType …/bdf_glyphs.txt :588:	0300 gravecomb
WARRINGD/Font-FreeType …/bdf_glyphs.txt :589:	0301 acutecomb
WARRINGD/Font-FreeType …/bdf_glyphs.txt :591:	0303 tildecomb
WARRINGD/Font-FreeType …/bdf_glyphs.txt :597:	0309 hookabovecomb
WARRINGD/Font-FreeType …/bdf_glyphs.txt :606:	0323 dotbelowcomb
WARRINGD/PDF-Class …/CMap.pm :19:	has ZeroOrOne $.WMode is entry; #| (Optional) A code that determines the writing mode for any CIDFont with which this CMap is combined. The possible values are 0 for horizontal and 1 for vertical
WARRINGD/PDF-Class …/Catalog.pm :104:	has $.Intent is entry; #| name or array (Optional) A single intent name or an array containing any combination of names.
WARRINGD/PDF-Class …/DeviceN.pm :51:	#| This dictionary provides information about the individual colorants that may be useful to some applications. In particular, the alternate color s…
WARRINGD/PDF-Class …/DeviceN.pm :55:	#| This dictionary provides information about the individual colorants that may be useful to some applications. In particular, the alternate color s…
WARRINGD/PDF-Class …/Stitching.pm :14:	has Numeric @.Bounds is entry(:required); #| (Required) An array of k − 1 numbers that, in combination with Domain, define the interv…
WARRINGD/PDF-Class …/OCG.pm :21:	has PDF::COS::Name @.Intent is entry; #| (Optional) A single intent name or an array containing any combination of names…
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 …/LICENSE :237:	and which are not combined with it such as to form a larger program,
AlexDaniel/orgsleep …/LICENSE :555:	permission to link or combine any covered work with a work licensed
AlexDaniel/orgsleep …/LICENSE :557:	combined work, and to convey the resulting work. The terms of this
AlexDaniel/orgsleep …/LICENSE :561:	combination as such.
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/Slang-Kazu …/COPYING :240:	and which are not combined with it such as to form a larger program,
Altai-man/Slang-Kazu …/COPYING :558:	permission to link or combine any covered work with a work licensed
Altai-man/Slang-Kazu …/COPYING :560:	combined work, and to convey the resulting work. The terms of this
Altai-man/Slang-Kazu …/COPYING :564:	combination as such.
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)
Bailador/Bailador …/README.md :338:	Instead of using simple subs for routes (e.g in combination with `get`, `post`, `delete` etc) you could also use Controller Classes. Contro…
Bailador/Bailador …/README.md :512:	| template-format | predefined format strings | 'combined' (Apache combined format) |
Bailador/Bailador …/README.md :523:	This parameter can be used to specify predefined formats like Apache "combined", or Apache "simple" error log.
Bailador/Bailador …/README.md :527:	- combined
Bailador/Bailador …/Configuration.pm :58:	# Available template-format: 'common', 'combined' and 'simple' wich are defaults in Apache ;
Bailador/Bailador …/Configuration.pm :62:	# Accesses logs, in combined format
Bailador/Bailador …/Configuration.pm :63:	# 'file:logs/access.log' => { 'template-filter' => 'http-requests', 'template-format' => 'combined' },
Bailador/Bailador …/Formatter.pm :23:	when 'combined' {
Bailador/Bailador …/Formatter.pm :79:	when 'combined' {
Bailador/Bailador …/19-logging.t :60:	$f = Bailador::Log::Formatter.new( :template-format<combined> );
Bailador/Bailador …/19-logging.t :61:	is $format-attribute.get_value( $f ), '\e{h} \e{l} \e{u} [\e{t}] "\e{r}" \e{s} \e{b} "\e{Referer}" \e{User-agent}', 'combined format';
Bailador/Bailador …/19-logging.t :68:	'combined formatted log match';
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 \\> '"']+/;
GildedHonour/TelegramBot …/LICENSE :80:	Contribution(s) alone or by combination of their Contribution(s)
JJ/p6-math-constants …/LICENSE :237:	and which are not combined with it such as to form a larger program,
JJ/p6-math-constants …/LICENSE :555:	permission to link or combine any covered work with a work licensed
JJ/p6-math-constants …/LICENSE :557:	combined work, and to convey the resulting work. The terms of this
JJ/p6-math-constants …/LICENSE :561:	combination as such.
JJ/p6-wikidata-API …/LICENSE :237:	and which are not combined with it such as to form a larger program,
JJ/p6-wikidata-API …/LICENSE :555:	permission to link or combine any covered work with a work licensed
JJ/p6-wikidata-API …/LICENSE :557:	combined work, and to convey the resulting work. The terms of this
JJ/p6-wikidata-API …/LICENSE :561:	combination as such.
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 {
MARTIMM/mongo-perl6-driver …/Design-tests.md :79:	Test server table. In this table, the key name is saying something about the server used in the tests. This key is mentioned below in the test explan…
MARTIMM/mongo-perl6-driver …/2015-11-3-answer-d-golden.txt :10:	them are combined into one package. For me it would be a lot easier especially
MARTIMM/mongo-perl6-driver …/Cursor.pod6 :38:	In both examples find()/new() and the following C<while> can be combined with
MARTIMM/mongo-perl6-driver …/driver-authentication.sxml :61:	$p1 [ Some combinations of credential parameters should fail ]
MARTIMM/unicode-precis …/g-all.sh :6:	# canonical-combining-classes bidirectional-category
MARTIMM/unicode-precis …/generate-module.pl6 :200:	canonical-combining-classes bidirectional-category
MattOates/BioInfo …/Nucleic.pm6 :21:	sequence => $seq.comb.map({%comp{$_}}).join
MattOates/BioInfo …/Nucleic.pm6 :29:	#Get all the combinations of bases that map to the @aminos ordering
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--Emotion …/AFINN-111.txt :434:	combat -1
MattOates/Text--Emotion …/AFINN-111.txt :435:	combats -1
MattOates/Text--Emotion …/ODBL1.0-LICENSE.txt :107:	combination of both. The repeated and systematic Extraction or
MattOates/Text--Emotion …/Scorer.pm :6:	has %dictionary = split /<[,;]>/, "abandon,-2;abandoned,-2;abandons,-2;abducted,-2;abduction,-2;abductions,-2;abhor,-3;abhorred,-3;abhorrent,-3;a…
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;
Perl6-Noise-Gang/Audio-PortMIDI …/PortMIDI.pm :120:	really just a shortcut combining the above two methods. If there is a problem
Perl6-Noise-Gang/p6-Music-Helpers …/README.md :32:	The arithmetic operators `&infix:<+>` and `&infix:<->` are overloaded and exported for any combination between `Note`s and `Interval`s, and return new `Note`s or `Interval`s, depending on invocation:
Perl6-Noise-Gang/p6-Music-Helpers …/Helpers.pm :44:	exported for any combination between C<Note>s and C<Interval>s, and return new
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+/);
TiMBuS/Net--IRC …/unsmith :159:	Hearin snippets about this Insane Clown Party concert, lots of Faygo? No thx, I'll be bringing my standard CodeRed/SierraMist combo cooler
TiMBuS/Net--IRC …/unsmith :574:	Was feelin like a fat loser but then realized that every time I wear mismatched socks I'm creating not one but two brand new sock combos
Tux/CSV …/43-1.t :20:	ok ($csv.combine (1, $u, 3), "Combine");
Tux/CSV …/43_binary.t :17:	ok ($csv.combine (1, $u, 3), "Combine");
Tux/CSV …/MANIFEST :12:	t/21_combine.t
Tux/CSV …/MANIFEST :22:	t/55_combi.t
Tux/CSV …/Makefile :20:	perl6 -Ilib t/21_combine.t
Tux/CSV …/Makefile :28:	perl6 -Ilib t/55_combi.t
Tux/CSV …/110-multi.txt :1:	multi method combine (Capture $c) returns Bool {
Tux/CSV …/110-multi.txt :2:	multi method combine ( *@f) returns Bool {
Tux/CSV …/110-multi.txt :3:	multi method combine ( @f) returns Bool {
Tux/CSV …/Notes :7:	gist perl comb subst-mutate subst lines split words
Tux/CSV …/README.md :9:	combine fields into a CSV string and parse a CSV string into fields.
Tux/CSV …/README.speed :15:	under. Then there are several lines with the test combination tested followed
Tux/CSV …/speed.pl :24:	$csv.combine (@fields1 ); my $str1 = $csv.string;
Tux/CSV …/speed.pl :25:	$csv.combine (@fields10 ); my $str10 = $csv.string;
Tux/CSV …/speed.pl :26:	$csv.combine (@fields100); my $str100 = $csv.string;
Tux/CSV …/speed.pl :30:	"combine 1" => sub { $csv.combine (@fields1 ) },
Tux/CSV …/speed.pl :31:	"combine 10" => sub { $csv.combine (@fields10 ) },
Tux/CSV …/speed.pl :32:	"combine 100" => sub { $csv.combine (@fields100) },
Tux/CSV …/CSV.pm :711:	my %sep = $hdr.comb.Bag{$sep-set.list}:kv;
Tux/CSV …/CSV.pm :888:	# combine : direction = 0
Tux/CSV …/CSV.pm :988:	multi method combine (Capture $c) returns Bool {
Tux/CSV …/CSV.pm :989:	self.combine ($c.list);
Tux/CSV …/CSV.pm :991:	multi method combine (*@f) returns Bool {
Tux/CSV …/CSV.pm :992:	self.combine (@f);
Tux/CSV …/CSV.pm :994:	multi method combine (@f) returns Bool {
Tux/CSV …/CSV.pm :1556:	self.combine (@fld) or return False;
Tux/CSV …/CSV.pod6 :45:	comma-separated values. An instance of the Text::CSV class will combine
Tux/CSV …/CSV.pod6 :648:	By default, all "unsafe" bytes inside a string cause the combined field to
Tux/CSV …/CSV.pod6 :749:	Similar to L</combine> + L</string> + L</print>, but much more efficient.
Tux/CSV …/CSV.pod6 :753:	NYI: no fields in combination with L</bind_columns>, like
Tux/CSV …/CSV.pod6 :780:	=head2 combine
Tux/CSV …/CSV.pod6 :781:	X<combine>
Tux/CSV …/CSV.pod6 :783:	$status = $csv.combine(@fields);
Tux/CSV …/CSV.pod6 :784:	$status = $csv.combine($fld, ...);
Tux/CSV …/CSV.pod6 :785:	$status = $csv.combine(\@fields);
Tux/CSV …/CSV.pod6 :800:	of L</combine>, whichever was called more recently. If L<C<eol>|/eol> is
Tux/CSV …/CSV.pod6 :812:	L</combine>: it parses a row from the C<$io> handle or C<$str> using the
Tux/CSV …/CSV.pod6 :905:	has index C<1>. Selections can be combined with the semi-colon (C<;>).
Tux/CSV …/CSV.pod6 :907:	When using this method in combination with L</column_names>, the returned
Tux/CSV …/CSV.pod6 :909:	cell-based combined selection might return rows with different number of
Tux/CSV …/CSV.pod6 :964:	Cells and cell ranges may be combined with C<;>, possibly resulting in rows
Tux/CSV …/CSV.pod6 :996:	types of specs to be combined (either C<row> I<or> C<col> I<or> C<cell>).
Tux/CSV …/CSV.pod6 :1000:	to combine row- and column selecting as a grid.
Tux/CSV …/CSV.pod6 :1216:	This method returns the input to L</combine> or the resultant decomposed
Tux/CSV …/CSV.pod6 :1226:	This method returns the input to L</combine> or the resultant decomposed
Tux/CSV …/CSV.pod6 :1310:	This method returns success (or failure) of the last invoked L</combine> or
Tux/CSV …/CSV.pod6 :1321:	This method returns the erroneous argument (if it exists) of L</combine>,
Tux/CSV …/CSV.pod6 :1737:	combined with the use of C<fragment>:
Tux/CSV …/CSV.pod6 :2225:	This callback is not active for L</combine>.
Tux/CSV …/CSV.pod6 :2426:	=head3 The slow way: using L</combine> and L</string>
Tux/CSV …/CSV.pod6 :2428:	or using the slower L</combine> and L</string> methods:
Tux/CSV …/CSV.pod6 :2437:	if ($csv.combine(@sample_input_fields)) {
Tux/CSV …/CSV.pod6 :2441:	print "combine failed on argument: ",
Tux/CSV …/10_base.t :14:	is ($csv.string, Str, "string () undef before combine");
Tux/CSV …/10_base.t :17:	ok (1, "combine () & string () tests");
Tux/CSV …/10_base.t :18:	is ($csv.combine (), True, "Combine no args");
Tux/CSV …/10_base.t :21:	ok ($csv.combine (""), "Empty string - combine ()");
Tux/CSV …/10_base.t :23:	ok ($csv.combine ("", " "), "Two fields, one space - combine ()");
Tux/CSV …/10_base.t :25:	ok ($csv.combine ("", 'I said, "Hi!"', ""), "Hi! - combine ()");
Tux/CSV …/10_base.t :27:	ok ($csv.combine ('"', "abc"), "abc - combine ()");
Tux/CSV …/10_base.t :29:	ok ($csv.combine (","), "comma - combine ()");
Tux/CSV …/10_base.t :31:	ok ($csv.combine ("abc", '"'), "abc + \" - combine ()");
Tux/CSV …/10_base.t :33:	ok ($csv.combine ("abc", "def", "ghi", "j,k"), "abc .. j,k - combine ()");
Tux/CSV …/10_base.t :35:	ok ($csv.combine ("abc\tdef", "ghi"), "abc + TAB - combine ()");
Tux/CSV …/10_base.t :41:	is ($csv.combine ("abc", "def\n", "g"), False, "Bad character");
Tux/CSV …/10_base.t :68:	ok ($csv.combine ("", 2, 3.25, "a", "a b"), "Mixed - combine ()");
Tux/CSV …/12_acc.t :78:	ok ($csv.combine (@fld), "combine");
Tux/CSV …/12_acc.t :143:	ok ($csv.combine (@fld), "combine");
Tux/CSV …/12_acc.t :189:	# Some forbidden combinations
Tux/CSV …/15_flags.t :170:	ok ($csv.combine (1..3), "Combine");
Tux/CSV …/15_flags.t :174:	ok ($csv.combine (1..3), "Combine");
Tux/CSV …/15_flags.t :178:	ok ($csv.combine (1..3), "Combine");
Tux/CSV …/15_flags.t :185:	ok ($csv.combine (1, " ", 3), "Combine");
Tux/CSV …/15_flags.t :189:	ok ($csv.combine (1, " ", 3), "Combine");
Tux/CSV …/15_flags.t :193:	ok ($csv.combine (1, " ", 3), "Combine");
Tux/CSV …/15_flags.t :201:	ok ($csv.combine (1, Str, "", " ", 2), "combine qe = False");
Tux/CSV …/15_flags.t :204:	ok ($csv.combine (1, Str, "", " ", 2), "combine qe = True");
Tux/CSV …/16_methods.t :48:	is ($csv.combine (), True, "combine");
Tux/CSV …/21_combine.t :14:	ok ($csv.combine (1, "foo", "a b", Str, 3, ""), "combine (list)");
Tux/CSV …/21_combine.t :16:	ok ($csv.combine ( @args), "combine (array)");
Tux/CSV …/21_combine.t :18:	ok ($csv.combine (|@args), "combine (flattened array)");
Tux/CSV …/21_combine.t :20:	ok ($csv.combine ([@args]), "combine (anon array)");
Tux/CSV …/21_combine.t :22:	ok ($csv.combine (\(@args)), "combine (array ref)");
Tux/CSV …/22_print.t :18:	ok ($csv.print ($fh, 1, "foo", "a b", Str, 3, ""), "combine (list)");
Tux/CSV …/22_print.t :19:	ok ($csv.print ($fh, @args), "combine (array)");
Tux/CSV …/22_print.t :20:	ok ($csv.print ($fh, |@args), "combine (flattened array)");
Tux/CSV …/22_print.t :21:	ok ($csv.print ($fh, [@args]), "combine (anon array)");
Tux/CSV …/22_print.t :22:	ok ($csv.print ($fh, \(@args)), "combine (array ref)");
Tux/CSV …/40_misc.t :14:	ok ($csv.combine (@binField), "combine ()");
Tux/CSV …/40_misc.t :30:	ok ($csv.combine (@binField), "combine ()");
Tux/CSV …/40_misc.t :36:	ok ($csv.combine (@binField), "combine ()");
Tux/CSV …/40_misc.t :42:	ok ($csv.combine (@binField), "combine ()");
Tux/CSV …/40_misc.t :49:	ok ($csv.combine ("abc","def","ghi"), "combine");
Tux/CSV …/40_misc.t :55:	ok ($csv2.combine ("abc","def","ghi"), "combine ()");
Tux/CSV …/41_null.t :47:	ok ($csv.combine (@line), "combine [ ... ]");
Tux/CSV …/41_null.t :90:	ok ($csv.combine (@line), "combine [ ... ]");
Tux/CSV …/45_eol.t :43:	ok ($csv.combine (@f), "combine |$s_eol|");
Tux/CSV …/46_eol_si.t :35:	ok ($csv.combine (@f), "combine |$s_eol|");
Tux/CSV …/50_utf8.t :35:	ok ($csv.combine (@in), "combine $msg");
Tux/CSV …/50_utf8.t :69:	$csv.combine (@row);
Tux/CSV …/50_utf8.t :77:	ok ($csv.combine (" ", 1, "\x[20ac] "), "Combine");
Tux/CSV …/50_utf8.t :80:	ok ($csv.combine (" ", 1, "\x[20ac] "), "Combine");
Tux/CSV …/50_utf8.t :85:	ok ($csv.combine (" ", 1, "\x[20ac] "), "Combine");
Tux/CSV …/50_utf8.t :88:	ok ($csv.combine (" ", 1, "\x[20ac] "), "Combine");
Tux/CSV …/55_combi.t :19:	sub combi (*%attr)
Tux/CSV …/55_combi.t :21:	my $combi = join " ", "--", map { sprintf "%6s", %attr{$_}.perl; },
Tux/CSV …/55_combi.t :23:	ok (1, $combi);
Tux/CSV …/55_combi.t :45:	ok (%state{1001}.defined, "Illegal combo sep == quo || sep == esc");
Tux/CSV …/55_combi.t :46:	is (%state{1001}, "INI - separator is equal to quote- or escape sequence", "Illegal combo 1001");
Tux/CSV …/55_combi.t :59:	ok (%state{1003} ~~ rx{"in main attr not"}, "Illegal combo (1003)");
Tux/CSV …/55_combi.t :65:	#diag (join " -> ** " => $combi, join ", " => sort %state);
Tux/CSV …/55_combi.t :66:	ok (%state{1002}.defined, "Illegal combo under allow_whitespace");
Tux/CSV …/55_combi.t :67:	ok (%state{1002} ~~ rx{"allow_whitespace with"}, "Illegal combo (1002)");
Tux/CSV …/55_combi.t :74:	my $ret = $csv.combine (@input);
Tux/CSV …/55_combi.t :76:	ok ($ret, "combine");
Tux/CSV …/55_combi.t :85:	%fail<parse>{$combi} = $csv.error_input;
Tux/CSV …/55_combi.t :92:	%fail<fields>{$combi} = $csv.error_input;
Tux/CSV …/55_combi.t :98:	%fail{'$#fields'}{$combi} = $str;
Tux/CSV …/55_combi.t :104:	} # combi
Tux/CSV …/55_combi.t :111:	combi (
Tux/CSV …/60_samples.t :22:	ok ($csv.combine (@list), "combine ()");
Tux/CSV …/65_allow.t :117:	ok ($csv.combine (1, "", " ", '""', 2, Str, "", Str), "combine ()");
Tux/CSV …/65_allow.t :140:	ok ($csv.combine (1, "", " ", '""', 2, Str, "", Str), "combine ()");
Tux/CSV …/66_formula.t :121:	ok ($csv.combine ("1", "=2+3", "4"), "combine $formula");
Tux/CSV …/79_callbacks.t :218:	ok ($csv->combine (11, "fri", 22, 18), "combine - no hook");
Tux/CSV …/80_diag.t :124:	"col=4;row=3", # cannot combine rows and columns
Tux/CSV …/81_subclass.t :19:	ok ($csv.combine (""), "Subclass combine ()");
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 {
ab5tract/Terminal-Print …/RawInput.pm6 :9:	# Reads bytes in order to work around lower-layer grapheme combiner handling
adaptiveoptics/HTML-Tag …/README.md :51:	Tags can be combined into one another by placing them into another
adaptiveoptics/HTML-Tag …/Tag.pod6 :51:	Tags can be combined into one another by placing them into another
adaptiveoptics/HTML-Tag …/Table.pm6 :66:	Creates a combination of ::th ::td ::tr tags swallowed by a ::table
ahalbert/perl6-itertools …/README.md :11:	I needed a ``itertools.combinations_with_replacement`` and couldn't find an easy
ahalbert/perl6-itertools …/itertools.pm :19:	I needed a itertools.combinations_with_replacement and couldn't find an easy builtin or library to do it. So why not write the library myself? It turns out
ahalbert/perl6-itertools …/itertools.pm :55:	=head2 combinations_with_replacement(@iterable, $r)
ahalbert/perl6-itertools …/itertools.pm :56:	Gathers all combinations of length $r from @iterable, allowing elements to repeat.
ahalbert/perl6-itertools …/itertools.pm :59:	combinations_with_replacement(('a','b','c'), 2) -> (('a','a'), ('a','b'), ('a','c'), ('b','a'), ('b','b'), ('b','c'), ('c','a'), ('c','b'), ('c','c'));
ahalbert/perl6-itertools …/itertools.pm :140:	sub combinations_with_replacement(@iterable, $r) is export {
ahalbert/perl6-itertools …/itertools.t :39:	is combinations_with_replacement(('a','b','c'), 2), (('a','a'), ('a','b'), ('a','c'), ('b','a'), ('b','b'), ('b','c'), ('c','a'), ('c','b'), ('c','c'));
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};
andydude/p6-c-parser …/LICENSE :27:	A "Combined Work" is a work produced by combining or linking an
andydude/p6-c-parser …/LICENSE :104:	recombine or relink the Application with a modified version of
andydude/p6-c-parser …/LICENSE :120:	Combined Work produced by recombining or relinking the
andydude/p6-c-parser …/LICENSE :133:	License, and convey such a combined library under terms of your
andydude/p6-c-parser …/LICENSE :136:	a) Accompany the combined library with a copy of the same work based
andydude/p6-c-parser …/LICENSE :137:	on the Library, uncombined with any other library facilities,
andydude/p6-c-parser …/LICENSE :140:	b) Give prominent notice with the combined library that part of it
andydude/p6-c-parser …/LICENSE :142:	accompanying uncombined form of the same work.
andydude/p6-c-parser …/gbytes.pp.c :1272:	gint g_unichar_combining_class (gunichar uc) __attribute__((__const__));
araraloren/perl6-app-findsource …/LICENSE :237:	and which are not combined with it such as to form a larger program,
araraloren/perl6-app-findsource …/LICENSE :555:	permission to link or combine any covered work with a work licensed
araraloren/perl6-app-findsource …/LICENSE :557:	combined work, and to convey the resulting work. The terms of this
araraloren/perl6-app-findsource …/LICENSE :561:	combination as such.
araraloren/perl6-app-snippet …/LICENSE :237:	and which are not combined with it such as to form a larger program,
araraloren/perl6-app-snippet …/LICENSE :555:	permission to link or combine any covered work with a work licensed
araraloren/perl6-app-snippet …/LICENSE :557:	combined work, and to convey the resulting work. The terms of this
araraloren/perl6-app-snippet …/LICENSE :561:	combination as such.
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());
araraloren/perl6-terminal-table …/04-style.t :45:	}, "style combination {++$count} ok";
avuserow/perl6-binary-structured …/Structured.pm6 :259:	has Int $.pos is readonly = 0; # XXX consider replacing with private attr+method+trusts combo
azawawi/farabi6 …/Util.pm6 :164:	for $output.comb(/ \x1B '[' [ (\d+) ';'? ]+ 'm' /, :match) -> $/ {
azawawi/farabi6 …/foldcode.js :110:	CodeMirror.registerHelper("fold", "combine", function() {
azawawi/farabi6 …/overlay.js :4:	// Utility function that allows modes to be combined. The mode given
azawawi/farabi6 …/overlay.js :9:	// overlay wins, unless the combine argument was true and not overridden,
azawawi/farabi6 …/overlay.js :10:	// or state.overlay.combineTokens was true, in which case the styles are
azawawi/farabi6 …/overlay.js :11:	// combined.
azawawi/farabi6 …/overlay.js :23:	CodeMirror.overlayMode = function(base, overlay, combine) {
azawawi/farabi6 …/overlay.js :61:	// state.overlay.combineTokens always takes precedence over combine,
azawawi/farabi6 …/overlay.js :65:	state.overlay.combineTokens ||
azawawi/farabi6 …/overlay.js :66:	combine && state.overlay.combineTokens == null)
azawawi/farabi6 …/codemirror.js :1377:	// some key combos in Mac (#2689).
azawawi/farabi6 …/codemirror.js :2877:	// combined and executed at once.
azawawi/farabi6 …/codemirror.js :4010:	// Opera has no cut event... we try to at least catch the key combo
azawawi/farabi6 …/gfm.js :36:	state.combineTokens = null;
azawawi/farabi6 …/gfm.js :85:	state.combineTokens = true;
azawawi/farabi6 …/gfm.js :91:	state.combineTokens = true;
azawawi/farabi6 …/gfm.js :100:	state.combineTokens = true;
azawawi/farabi6 …/javascript.js :242:	// Communicate our context to the combinators.
azawawi/farabi6 …/javascript.js :250:	var combinator = cc.length ? cc.pop() : jsonMode ? expression : statement;
azawawi/farabi6 …/javascript.js :251:	if (combinator(type, content)) {
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 …/rust.js :390:	// Communicate our context to the combinators.
azawawi/farabi6 …/rust.js :395:	var combinator = cc.length ? cc.pop() : block;
azawawi/farabi6 …/rust.js :396:	if (combinator(tcat)) {
azawawi/farabi6 …/mousetrap.min.js :3:	l[a][g],!(!c&&k.seq&&n[k.seq]!=k.level||h!=k.action||("keypress"!=h||d.metaKey||d.ctrlKey)&&b.sort().join(",")!==k.modifiers.sort().join(","))){var m…
azawawi/farabi6 …/mousetrap.min.js :6:	c,a,e),l[d.key]c?"unshift":"push")}var h={8:"backspace",9:"tab"…
azawawi/farabi6 …/mousetrap.min.js :9:	b[c[e].seq]=1,x(c[e].callback,d,c[e].combo,c[e].seq)):g||x(c[e].callback,d,c[e].combo);c="keypress"==d.type&&I;d.type!=u||w(a)||c||t(b);I=g&&"keydown"==d.type}};J.Mousetrap=m;"function"===typeof define&&define.amd&&define(m)})(window,document);
azawawi/farabi6 …/dropdown.min.js :11:	!function(e,t,n,i){"use strict";e.fn.dropdown=function(o){var a,r=e(this),s=e(n),c=r.selector||"",l="ontouchstart"in n.documentElement,u=(new Date).g…
azawawi/farabi6 …/semantic.min.js :12:	},instantiate:function(){m.verbose("Storing instance of module",m),S=m,k.data(x,S)},destroy:function(){m.verbose("Destroying previous module",d),k.re…
azawawi/farabi6 …/perl6-mode.js :291:	"lcfirst uc ucfirst capitalize normalize pack unpack quotemeta comb",
azawawi/perl6-gtk-scintilla …/GTK-Scintilla-Editor.md :136:	Each byte in a Scintilla document is associated with a byte of styling information. The combination of a character byte and a style byte is called a cell. Style bytes are interpreted an index into an array of styles.
azawawi/perl6-gtk-scintilla …/GTK-Scintilla-Editor.md :259:	Scintilla has multiple level undo and redo. It will continue to collect undoable actions until memory runs out. Scintilla saves actions that change t…
azawawi/perl6-gtk-scintilla …/Editor.pm6 :289:	information. The combination of a character byte and a style byte is called a
azawawi/perl6-gtk-scintilla …/Editor.pm6 :634:	actions can be combined into transactions that are undone as a unit. These
azawawi/perl6-gtk-scintilla …/ScintillaView.mm :576:	* Called by the input manager to set text which might be combined with further input to form
azawawi/perl6-gtk-scintilla …/ScintillaDoc.html :216:	is set in the range 0 to 255. If you have three such intensities, they are combined as:
azawawi/perl6-gtk-scintilla …/ScintillaDoc.html :413:	information. The combination of a character byte and a style byte is called a cell. Style bytes
azawawi/perl6-gtk-scintilla …/ScintillaDoc.html :787:	Uses Scintilla's base implementation unless combined with <code>SCFIND_CXX11REGEX</code>.</td>
azawawi/perl6-gtk-scintilla …/ScintillaDoc.html :1094:	level of detail. Sequences of actions can be combined into transactions that are undone as a unit.
azawawi/perl6-gtk-scintilla …/ScintillaDoc.html :1153:	combined with the preceding or following operations if they are undone.</p>
azawawi/perl6-gtk-scintilla …/ScintillaDoc.html :1169:	<code>SCI_ADDUNDOACTION</code> commands are not combined together
azawawi/perl6-gtk-scintilla …/ScintillaDoc.html :1651:	On GTK+, the key used to indicate that a rectangular selection should be created when combined with a mouse drag can be set.
azawawi/perl6-gtk-scintilla …/ScintillaDoc.html :1838:	These set the caret policy. The value of <code class="parameter">caretPolicy</code> is a combination of
azawawi/perl6-gtk-scintilla …/ScintillaDoc.html :3153:	<p>The block character draws most combining and multibyte character sequences successfully,
azawawi/perl6-gtk-scintilla …/ScintillaDoc.html :3631:	combined background without clipping text to the line boundaries. This allows
azawawi/perl6-gtk-scintilla …/ScintillaDoc.html :3902:	<p>There are 32 markers, numbered 0 to <code>MARKER_MAX</code> (31), and you can assign any combination of them to each
azawawi/perl6-gtk-scintilla …/ScintillaDoc.html :3921:	their line moves. When a line is deleted, its markers are combined, by an <code>OR</code>
azawawi/perl6-gtk-scintilla …/ScintillaDoc.html :4167:	marker is after moving or combining lines and with <a class="message"
azawawi/perl6-gtk-scintilla …/ScintillaDoc.html :5308:	16-bits. To combine <code>keyCode</code> and <code>keyMod</code> set:<br />
azawawi/perl6-gtk-scintilla …/ScintillaDoc.html :5322:	<p>The modifiers are a combination of zero or more of <code>SCMOD_ALT</code>,
azawawi/perl6-gtk-scintilla …/ScintillaDoc.html :6673:	separated by spaces, tabs, <code>"\n"</code> or <code>"\r"</code> or any combination of these.
azawawi/perl6-gtk-scintilla …/ScintillaDoc.html :7593:	<td align="left">The appropriate combination of <code>SCI_SHIFT</code>,
azawawi/perl6-gtk-scintilla …/ScintillaHistory.html :97:	<td>James Larcombe</td>
azawawi/perl6-gtk-scintilla …/ScintillaHistory.html :1520:	SciTE on GTK+ 3.x disables arrow in search combo when no entries.
azawawi/perl6-gtk-scintilla …/ScintillaHistory.html :3718:	Fixed problems with multiple clicks in margin and with mouse actions combined with virtual space.
azawawi/perl6-gtk-scintilla …/ScintillaHistory.html :4242:	Incorrect drawing fixed for combination of background colour change and translucent selection.
azawawi/perl6-gtk-scintilla …/ScintillaHistory.html :5029:	SciTE on Windows bug fixed where combo boxes were not allowing Unicode characters.
azawawi/perl6-gtk-scintilla …/ScintillaHistory.html :8912:	VS .NET project files available for combined Scintilla and
azawawi/perl6-gtk-scintilla …/ScintillaHistory.html :9212:	file name and line number combination.
azawawi/perl6-gtk-scintilla …/ScintillaToDo.html :58:	combining lexers.
azawawi/perl6-gtk-scintilla …/Scintilla.iface :585:	# When key+modifier combination keyDefinition is pressed perform sciCommand.
azawawi/perl6-gtk-scintilla …/Scintilla.iface :588:	# When key+modifier combination keyDefinition is pressed do nothing.
azawawi/perl6-gtk-scintilla …/Scintilla.iface :843:	# it will use a combination of tabs and spaces.
azawawi/perl6-gtk-scintilla …/LexKVIrc.cxx :419:	/* Preparing indentation information to return - combining
azawawi/perl6-gtk-scintilla …/LexKVIrc.cxx :448:	* Preparing indentation information to return - combining current
azawawi/perl6-gtk-scintilla …/LexRuby.cxx :1203:	// Stay here, \c is a combining sequence
azawawi/perl6-gtk-scintilla …/README :40:	On OS X, a combined package with PySide libraries and PySide development
azawawi/perl6-gtk-scintilla …/README :43:	This package works best in combination with the Qt libraries for Mac from
azawawi/perl6-gtk-scintilla …/Document.cxx :969:	// and also trying to avoid breaking inside a pair of combining characters.
azawawi/perl6-gtk-scintilla …/Document.cxx :1604:	// Mark - includes combining diacritics
azawawi/perl6-gtk-scintilla …/EditView.cxx :1225:	// glyph / combining character. If so we'll need to draw that too.
azawawi/perl6-gtk-scintilla …/Editor.cxx :1775:	// Should be merged back into a combined Draw method.
azawawi/perl6-gtk-scintilla …/ScintillaWin.cxx :700:	int combination = ::CombineRgn(hRgnDifference, hRgnCheck, hRgnBounds, RGN_DIFF);
azawawi/perl6-gtk-scintilla …/ScintillaWin.cxx :701:	if (combination != NULLREGION) {
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-gtk-simpler …/GTK-Simpler.md :187:	combo-box-text
azawawi/perl6-gtk-simpler …/06-combo.pl6 :10:	my $combo = combo-box-text;
azawawi/perl6-gtk-simpler …/06-combo.pl6 :13:	$combo.append-text("Entry " ~ $item);
azawawi/perl6-gtk-simpler …/06-combo.pl6 :17:	$combo.set-active(5);
azawawi/perl6-gtk-simpler …/06-combo.pl6 :21:	$combo.changed.tap({
azawawi/perl6-gtk-simpler …/06-combo.pl6 :22:	$label.text = $combo.active-text();
azawawi/perl6-gtk-simpler …/06-combo.pl6 :27:	my $pre-set-combo = combo-box-text;
azawawi/perl6-gtk-simpler …/06-combo.pl6 :31:	$pre-set-combo.append-text( $item )
azawawi/perl6-gtk-simpler …/06-combo.pl6 :34:	$pre-set-combo.set-active( 3 );
azawawi/perl6-gtk-simpler …/06-combo.pl6 :38:	$pre-set-combo.changed.tap: { $lbl2.text = $pre-set-combo.active-text(); };
azawawi/perl6-gtk-simpler …/06-combo.pl6 :41:	$app.set-content(vbox($label, $combo, $lbl2, $pre-set-combo));
azawawi/perl6-gtk-simpler …/Simpler.pm6 :325:	=head2 combo-box-text
azawawi/perl6-gtk-simpler …/Simpler.pm6 :329:	sub combo-box-text(|args) is export {
azawawi/perl6-magickwand …/Deprecated.pm6 :383:	MagickFlattenImages() merges a sequence of images. This useful for combining Photoshop layers into a single image.
azawawi/perl6-magickwand …/Image.pm6 :686:	MagickCombineImages() combines one or more images into a single image. The grayscale value of the pixels of each image in the sequence is …
azawawi/perl6-magickwand …/Image.pm6 :991:	MagickConstituteImage() adds an image to the wand comprised of the pixel data you supply. The pixel data must be in scanline order top-to-bottom. Th…
azawawi/perl6-magickwand …/Image.pm6 :1316:	MagickExportImagePixels() extracts pixel data from an image and returns it to you. The method returns MagickTrue on success otherwise MagickFalse if…
azawawi/perl6-magickwand …/Image.pm6 :2670:	MagickImportImagePixels() accepts pixel datand stores it in the image at the location you specify. The method returns MagickFalse on success otherwi…
azawawi/perl6-magickwand …/Image.pm6 :2871:	MagickMontageImage() creates a composite image by combining several separate
azawawi/perl6-net-curl …/post-callback.c :116:	NOTE: if you want chunked transfer too, you need to combine these two
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/mosdef …/README.md :34:	Compute 5 factorial using a Y combinator:
bduggan/p6-digest-sha1-native …/Native.pm6 :27:	Blob.new( sha1-hex($in).comb(2).map({ :16($_) }))
bduggan/p6-jupyter-kernel …/README.md :143:	* `#% html > latex`: The above two can be combined to render, for instance,
bduggan/p6-jupyter-kernel …/04-completions.t :60:	is $completions, <cache can categorize classify clone collate combinations>, 'Mu class';
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';
bioduds/EC-Grammars-DIG …/LICENSE :238:	and which are not combined with it such as to form a larger program,
bioduds/EC-Grammars-DIG …/LICENSE :556:	permission to link or combine any covered work with a work licensed
bioduds/EC-Grammars-DIG …/LICENSE :558:	combined work, and to convey the resulting work. The terms of this
bioduds/EC-Grammars-DIG …/LICENSE :562:	combination as such.
bioduds/EC-Grammars-DIG …/DIG.pm6 :308:	and which are not combined with it such as to form a larger program,
bioduds/EC-Grammars-DIG …/DIG.pm6 :626:	permission to link or combine any covered work with a work licensed
bioduds/EC-Grammars-DIG …/DIG.pm6 :628:	combined work, and to convey the resulting work. The terms of this
bioduds/EC-Grammars-DIG …/DIG.pm6 :632:	combination as such.
bluebear94/Terminal-WCWidth …/README.md :14:	* `0` for a character that does not advance the cursor (NULL or combining)
bluebear94/Terminal-WCWidth …/WCWidth.pm6 :70:	=item C<0> for a character that does not advance the cursor (NULL or combining)
bluebear94/Terminal-WCWidth …/basics.t :32:	"Simple combining character test."
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 …/IUPAC.pm6 :179:	# Function: Returns a hash of nucleotide combinations -> IUPAC code
cjfields/bioperl6 …/FastaIO.pm6 :38:	my $sequence = $seq.seq().comb( /. ** {1..$!width}/).join("\n");
cjfields/bioperl6 …/FeatureCollection.pm6 :6:	# Wondering if this and FeatureHolder should be combined for
cjfields/bioperl6 …/Simple.t :199:	# 'fuzzy' locations are combined with simple ones in Bio::Role
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/List-Utils …/Utils.pm :58:	proto combinations(@items, $count?) is export { * }
colomon/List-Utils …/Utils.pm :60:	multi sub combinations(@items, $count) is export {
colomon/List-Utils …/Utils.pm :79:	multi sub combinations(@items, Range $counts = 0..+@items) is export {
colomon/List-Utils …/Utils.pm :80:	$counts.map({ combinations(@items, $_) });
colomon/List-Utils …/08-combinations.t :12:	sub are-unique-combinations(@c) {
colomon/List-Utils …/08-combinations.t :16:	sub are-bits-of-combination-unique(@c) {
colomon/List-Utils …/08-combinations.t :20:	sub are-bits-of-each-combination-unique(@c) {
colomon/List-Utils …/08-combinations.t :21:	[&&] @c.map(&are-bits-of-combination-unique);
colomon/List-Utils …/08-combinations.t :24:	sub is-combination-from-source(@c, @source) {
colomon/List-Utils …/08-combinations.t :28:	sub are-combinations-from-source(@c, @source) {
colomon/List-Utils …/08-combinations.t :29:	[&&] @c.map({ is-combination-from-source($_, @source) });
colomon/List-Utils …/08-combinations.t :32:	sub are-combinations-correct-length(@c, $count) {
colomon/List-Utils …/08-combinations.t :36:	sub is-valid-combination(@c, @source, $count) {
colomon/List-Utils …/08-combinations.t :37:	are-combinations-correct-length(@c, $count)
colomon/List-Utils …/08-combinations.t :38:	&& are-combinations-from-source(@c, @source)
colomon/List-Utils …/08-combinations.t :39:	&& are-bits-of-each-combination-unique(@c)
colomon/List-Utils …/08-combinations.t :40:	&& are-unique-combinations(@c)
colomon/List-Utils …/08-combinations.t :44:	ok are-unique-combinations([[<a b>], [<a c>], [<b c>]]), "Make sure are-unique-combinations helper works";
colomon/List-Utils …/08-combinations.t :45:	nok are-unique-combinations([[<a b>], [<b a>], [<b c>]]), "Make sure are-unique-combinations helper works";
colomon/List-Utils …/08-combinations.t :46:	ok is-combination-from-source(<a b>, <a b c>), "Make sure is-combination-from-source helper works";
colomon/List-Utils …/08-combinations.t :47:	nok is-combination-from-source(<a d>, <a b c>), "Make sure is-combination-from-source helper works";
colomon/List-Utils …/08-combinations.t :48:	ok are-combinations-correct-length([[<a b>], [<a c>], [<b c>]], 2), "Make sure are-combinations-correct-length helper works";
colomon/List-Utils …/08-combinations.t :49:	nok are-combinations-correct-length([[<a b>], [<a c>], [<b c d>]], 2), "Make sure are-combinations-correct-length helper works";
colomon/List-Utils …/08-combinations.t :50:	ok is-valid-combination([[<a b>], [<a c>], [<b c>]], "a".."c", 2), "Make sure is-valid-combination helper works";
colomon/List-Utils …/08-combinations.t :51:	nok is-valid-combination([[<a b>], [<a c>], [<b d>]], "a".."c", 2), "Make sure is-valid-combination helper works";
colomon/List-Utils …/08-combinations.t :52:	nok is-valid-combination([[<a b>], [<a b>], [<b c>]], "a".."c", 2), "Make sure is-valid-combination helper works";
colomon/List-Utils …/08-combinations.t :53:	nok is-valid-combination([[<a b>], [<b c>]], "a".."c", 2), "Make sure is-valid-combination helper works";
colomon/List-Utils …/08-combinations.t :56:	my @c = combinations(<a b c d>, 0);
colomon/List-Utils …/08-combinations.t :57:	is +@c, 1, "1 0-count combinations of a b c d";
colomon/List-Utils …/08-combinations.t :64:	my @c = combinations(<a b c d>, 1);
colomon/List-Utils …/08-combinations.t :65:	is +@c, 4, "4 1-count combinations of a b c d";
colomon/List-Utils …/08-combinations.t :72:	my @c = combinations(<a b c d>, 2);
colomon/List-Utils …/08-combinations.t :73:	is +@c, 6, "6 2-count combinations of a b c d";
colomon/List-Utils …/08-combinations.t :80:	my @c = combinations(<a b c d>, 3);
colomon/List-Utils …/08-combinations.t :81:	is +@c, 4, "4 3-count combinations of a b c d";
colomon/List-Utils …/08-combinations.t :88:	my @c = combinations(<a b c d>, 4);
colomon/List-Utils …/08-combinations.t :89:	is +@c, 1, "1 4-count combinations of a b c d";
colomon/List-Utils …/08-combinations.t :96:	ok is-valid-combination(combinations('a'..'g', $count), 'a'..'g', $count), "7 choose $count correct";
colomon/List-Utils …/08-combinations.t :100:	my @c = combinations('a'..'z', 1);
colomon/List-Utils …/08-combinations.t :101:	is +@c, 26, "26 1-count combinations of a-z";
colomon/List-Utils …/08-combinations.t :108:	my @c = combinations('a'..'z', 2);
colomon/List-Utils …/08-combinations.t :109:	is +@c, 26 choose 2, "{26 choose 2} 2-count combinations of a-z";
colomon/List-Utils …/08-combinations.t :115:	my @c := combinations('a'..'z', 3);
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]) });
cosimo/perl6-digest-md5 …/TODO :7:	on newer parrot/rakudo combinations
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-tinycc-resources-win64 …/COPYING :74:	a shared library, the combination of the two is legally speaking a
cygx/p6-tinycc-resources-win64 …/COPYING :75:	combined work, a derivative of the original library. The ordinary
cygx/p6-tinycc-resources-win64 …/COPYING :77:	entire combination fits its criteria of freedom. The Lesser General
cygx/p6-tinycc-resources-win64 …/COPYING :113:	be combined with the library in order to run.
cygx/p6-tinycc-resources-win64 …/COPYING :271:	6. As an exception to the Sections above, you may also combine or
cygx/p6-tinycc-resources-win64 …/COPYING :335:	facilities not covered by this License, and distribute such a combined
cygx/p6-tinycc-resources-win64 …/COPYING :340:	a) Accompany the combined library with a copy of the same work
cygx/p6-tinycc-resources-win64 …/COPYING :341:	based on the Library, uncombined with any other library
cygx/p6-tinycc-resources-win64 …/COPYING :345:	b) Give prominent notice with the combined library of the fact
cygx/p6-tinycc-resources-win64 …/COPYING :347:	where to find the accompanying uncombined form of the same work.
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 " ";
dagurval/p6-webservice-justcoin …/README.pod :31:	Perl6 is awesome, and bitcoins are neat too. This module let's you combine the two worlds. I, the author, use this module to buy a small amount of BTC every day in a cron job.
drforr/perl6-ANTLR4 …/CSharp4.g4 :713:	| combined_join_clause
drforr/perl6-ANTLR4 …/CSharp4.g4 :729:	combined_join_clause
drforr/perl6-ANTLR4 …/CSharp4.g4 :1173:	// combines all available modifiers
drforr/perl6-ANTLR4 …/UCBLogo.g4 :54:	put("combine", 2);
drforr/perl6-ANTLR4 …/Verilog2001.g4 :604:	udp_body : combinational_body | sequential_body ;
drforr/perl6-ANTLR4 …/Verilog2001.g4 :605:	combinational_body : 'table' Combinational_entry+ 'endtable' ;
drforr/perl6-ANTLR4 …/Perl6.pm6 :660:	# XXX other combinations, exponents explode, oh the humanity.
drforr/perl6-Perl6-Parser …/README.md :206:	I'm eventually going to remove all the compound classes such as L<_Atom_SigFinal> because that's where the combinatoric explosion will star…
drforr/perl6-Perl6-Parser …/Parser.pm6 :112:	We can combine these facts and reason that we have to search for the bit of code where we find an C<infix> operator and two list elements. …
drforr/perl6-Perl6-Parser …/Factory.pm6 :2379:	# XXX Should combine with identifier?
drforr/perl6-Perl6-Parser …/Factory.pm6 :2417:	# XXX Should combine with identifier?
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 :249:	map { combine(@t[$_], @t[$_+1]) if @t[$_] && @t[$_+1] == @t[$_] }, ^@t-1;
drforr/perl6-Perl6-Parser …/rosetta-1.t :255:	sub combine ($v is rw, $w is rw) { $v += $w; $w = ''; $score += $v; }
drforr/perl6-Perl6-Parser …/rosetta-1.t :348:	~ '(repeats allowed): ').comb(/<[1..9]>/);
drforr/perl6-Perl6-Parser …/rosetta-1.t :353:	# Generate combinations of operators
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 :72:	# Regular expression for combing the path components out of a Str.
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);
gfldex/perl6-typesafe-xhtml-writer …/xhtml1-strict.xsd :641:	content model is "head.misc" combined with a single
gfldex/perl6-xhtml-writer …/xhtml1-strict.xsd :641:	content model is "head.misc" combined with a single
goneri/p6-Email-Notmuch …/LICENSE :237:	and which are not combined with it such as to form a larger program,
goneri/p6-Email-Notmuch …/LICENSE :555:	permission to link or combine any covered work with a work licensed
goneri/p6-Email-Notmuch …/LICENSE :557:	combined work, and to convey the resulting work. The terms of this
goneri/p6-Email-Notmuch …/LICENSE :561:	combination as such.
grondilu/chess …/Chess.pm6 :11:	my @pieces = flat map { /\d/ ?? ' ' xx +$/ !! %pieces{$_} // "?" }, .comb;
grondilu/clifford …/README.md :125:	This multivector is a linear combination of the unit scalar and the basis
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 {
hoelzro/p6-linenoise …/linenoise.c :50:	* - Filter bogus Ctrl+<char> combinations.
hoelzro/p6-linenoise …/linenoise.c :230:	* handle selected CTRL-* combinations.
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;
jamesneko/dice-roller …/Roller.pm6 :168:	# A roll of one or more polyhedra, with some rule about how we combine them.
jnthn/p6-app-moarvm-heapanalyzer …/Shell.pm6 :162:	$n.Str.flip.comb(3).join(',').flip
johnspurr/Lingua-EN-Stem-Porter …/wordlist-expected.txt :5060:	cogscomb
johnspurr/Lingua-EN-Stem-Porter …/wordlist-expected.txt :5141:	comb
johnspurr/Lingua-EN-Stem-Porter …/wordlist-expected.txt :5142:	combat
johnspurr/Lingua-EN-Stem-Porter …/wordlist-expected.txt :5143:	combat
johnspurr/Lingua-EN-Stem-Porter …/wordlist-expected.txt :5144:	combat
johnspurr/Lingua-EN-Stem-Porter …/wordlist-expected.txt :5145:	combat
johnspurr/Lingua-EN-Stem-Porter …/wordlist-expected.txt :5146:	combat
johnspurr/Lingua-EN-Stem-Porter …/wordlist-expected.txt :5147:	combat
johnspurr/Lingua-EN-Stem-Porter …/wordlist-expected.txt :5148:	comb
johnspurr/Lingua-EN-Stem-Porter …/wordlist-expected.txt :5149:	combin
johnspurr/Lingua-EN-Stem-Porter …/wordlist-expected.txt :5150:	combin
johnspurr/Lingua-EN-Stem-Porter …/wordlist-expected.txt :5151:	combin
johnspurr/Lingua-EN-Stem-Porter …/wordlist-expected.txt :5152:	combin
johnspurr/Lingua-EN-Stem-Porter …/wordlist-expected.txt :5153:	combin
johnspurr/Lingua-EN-Stem-Porter …/wordlist-expected.txt :5154:	comb
johnspurr/Lingua-EN-Stem-Porter …/wordlist-expected.txt :5155:	combless
johnspurr/Lingua-EN-Stem-Porter …/wordlist-expected.txt :5156:	comboin
johnspurr/Lingua-EN-Stem-Porter …/wordlist-expected.txt :5157:	comb
johnspurr/Lingua-EN-Stem-Porter …/wordlist-expected.txt :5158:	combust
johnspurr/Lingua-EN-Stem-Porter …/wordlist-expected.txt :6213:	coxcomb
johnspurr/Lingua-EN-Stem-Porter …/wordlist-expected.txt :6214:	coxcomb
johnspurr/Lingua-EN-Stem-Porter …/wordlist-expected.txt :13090:	honeycomb
johnspurr/Lingua-EN-Stem-Porter …/wordlist-input.txt :5060:	cogscomb
johnspurr/Lingua-EN-Stem-Porter …/wordlist-input.txt :5141:	comb
johnspurr/Lingua-EN-Stem-Porter …/wordlist-input.txt :5142:	combat
johnspurr/Lingua-EN-Stem-Porter …/wordlist-input.txt :5143:	combatant
johnspurr/Lingua-EN-Stem-Porter …/wordlist-input.txt :5144:	combatants
johnspurr/Lingua-EN-Stem-Porter …/wordlist-input.txt :5145:	combated
johnspurr/Lingua-EN-Stem-Porter …/wordlist-input.txt :5146:	combating
johnspurr/Lingua-EN-Stem-Porter …/wordlist-input.txt :5147:	combats
johnspurr/Lingua-EN-Stem-Porter …/wordlist-input.txt :5148:	combed
johnspurr/Lingua-EN-Stem-Porter …/wordlist-input.txt :5149:	combin
johnspurr/Lingua-EN-Stem-Porter …/wordlist-input.txt :5150:	combinate
johnspurr/Lingua-EN-Stem-Porter …/wordlist-input.txt :5151:	combination
johnspurr/Lingua-EN-Stem-Porter …/wordlist-input.txt :5152:	combine
johnspurr/Lingua-EN-Stem-Porter …/wordlist-input.txt :5153:	combined
johnspurr/Lingua-EN-Stem-Porter …/wordlist-input.txt :5154:	combing
johnspurr/Lingua-EN-Stem-Porter …/wordlist-input.txt :5155:	combless
johnspurr/Lingua-EN-Stem-Porter …/wordlist-input.txt :5156:	comboined
johnspurr/Lingua-EN-Stem-Porter …/wordlist-input.txt :5157:	combs
johnspurr/Lingua-EN-Stem-Porter …/wordlist-input.txt :5158:	combustion
johnspurr/Lingua-EN-Stem-Porter …/wordlist-input.txt :6213:	coxcomb
johnspurr/Lingua-EN-Stem-Porter …/wordlist-input.txt :6214:	coxcombs
johnspurr/Lingua-EN-Stem-Porter …/wordlist-input.txt :13090:	honeycomb
jonathanstowe/Acme-Insult-Lala …/lala.txt :12:	dissembling dizzy-eyed coxcomb
jonathanstowe/Audio-Libshout …/Libshout.pm :350:	"The combination of parameters is not supported for this operation";
jonathanstowe/Audio-Liquidsoap …/Liquidsoap.pm :883:	$rids.comb(/\d+/).map({Int($_)});
jonathanstowe/Audio-Sndfile …/Documentation.md :322:	This describes the major format of the file as described above in type. The possible values are described below, it should be borne in mind …
jonathanstowe/Audio-Sndfile …/Documentation.md :427:	These describe the minor format or sample encoding of the format. As suggested above only certain combnations of Format and Subformat actually make sense.
jonathanstowe/Audio-Sndfile …/Info.pm :114:	in mind that only certain combinations of C<type> and C<sub-type> make
jonathanstowe/Audio-Sndfile …/Info.pm :220:	certain combnations of Format and Subformat actually make sense.
jonathanstowe/Lumberjack-Application …/README.md :77:	These components together can be combined in various ways to make for
jonathanstowe/Lumberjack-Application …/Application.pm :32:	part of the suite of modules, combining the log web receiver, a web
jonathanstowe/Lumberjack-Application …/Application.pm :39:	P6SGI application (or combined into a larger application, via
jonathanstowe/Lumberjack-Application …/Application.pm :43:	you can combine the C<Lumberjack::Application::WebSocket>,
jonathanstowe/META6 …/projects.json :11249:	"description" : "A quick and dirty way to generate an array of all n-combinations of a list or all permutations",
jonathanstowe/META6 …/projects.json :11250:	"source-url" : "git://github.com/masterduke17/list-combinations.git"
jonathanstowe/Util-Bitfield …/Bitfield.pm :65:	of the data when combining the bytes into a Perl
jonathanstowe/XML-Class …/Documentation.md :385:	This can be applied in combination with most other traits and attribute types, for example:
jonathanstowe/XML-Class …/Class.pm :579:	This can be applied in combination with most other traits and attribute
jonathanstowe/p6-GDBM …/GDBM.pm :61:	parameter is some combination of values of the C<enum>s L<GDBM::OpenMode>
jpve/perl6-net-packet …/ALL.md :667:	combinations of $.type and $.code, as per ICMP specification, else it dies.
jpve/perl6-net-packet …/ALL.md :674:	combinations of $.type and $.code, as per ICMP specification, else it dies.
jpve/perl6-net-packet …/Net-Packet-ICMP.md :58:	combinations of $.type and $.code, as per ICMP specification, else it dies.
jpve/perl6-net-packet …/Net-Packet-ICMP.md :65:	combinations of $.type and $.code, as per ICMP specification, else it dies.
jpve/perl6-net-packet …/ICMP.pm6 :97:	combinations of $.type and $.code, as per ICMP specification, else it dies.
jpve/perl6-net-packet …/ICMP.pm6 :104:	die("Cannot get/set identifier field in header for this combination of \$.type ($.type) and \$.code ($.code)")
jpve/perl6-net-packet …/ICMP.pm6 :124:	combinations of $.type and $.code, as per ICMP specification, else it dies.
jpve/perl6-net-packet …/ICMP.pm6 :131:	die("Cannot get/set sequence number field in header for this combination of \$.type ($.type) and \$.code ($.code)")
kalkin/Ddt …/CLI.pm6 :108:	$name = $name.comb[0..*-5].join;
kalkin/Ddt …/Distribution.pm6 :32:	has Bool $.relaxed-name = '-' ∈ $!META6.name.comb;
kalkin/License-Software …/COPYING.LESSER :27:	A "Combined Work" is a work produced by combining or linking an
kalkin/License-Software …/COPYING.LESSER :104:	recombine or relink the Application with a modified version of
kalkin/License-Software …/COPYING.LESSER :120:	Combined Work produced by recombining or relinking the
kalkin/License-Software …/COPYING.LESSER :133:	License, and convey such a combined library under terms of your
kalkin/License-Software …/COPYING.LESSER :136:	a) Accompany the combined library with a copy of the same work based
kalkin/License-Software …/COPYING.LESSER :137:	on the Library, uncombined with any other library facilities,
kalkin/License-Software …/COPYING.LESSER :140:	b) Give prominent notice with the combined library that part of it
kalkin/License-Software …/COPYING.LESSER :142:	accompanying uncombined form of the same work.
kalkin/License-Software …/AGPLv3.pm6 :230:	and which are not combined with it such as to form a larger program,
kalkin/License-Software …/AGPLv3.pm6 :559:	permission to link or combine any covered work with a work licensed
kalkin/License-Software …/AGPLv3.pm6 :561:	combined work, and to convey the resulting work. The terms of this
kalkin/License-Software …/AGPLv3.pm6 :563:	but the work with which it is combined will remain governed by version
kalkin/License-Software …/Apache2.pm6 :93:	Contribution(s) alone or by combination of their Contribution(s)
kalkin/License-Software …/GPLv3.pm6 :246:	and which are not combined with it such as to form a larger program,
kalkin/License-Software …/GPLv3.pm6 :564:	permission to link or combine any covered work with a work licensed
kalkin/License-Software …/GPLv3.pm6 :566:	combined work, and to convey the resulting work. The terms of this
kalkin/License-Software …/GPLv3.pm6 :570:	combination as such.
kalkin/License-Software …/LGPLv3.pm6 :37:	A "Combined Work" is a work produced by combining or linking an
kalkin/License-Software …/LGPLv3.pm6 :114:	recombine or relink the Application with a modified version of
kalkin/License-Software …/LGPLv3.pm6 :130:	Combined Work produced by recombining or relinking the
kalkin/License-Software …/LGPLv3.pm6 :143:	License, and convey such a combined library under terms of your
kalkin/License-Software …/LGPLv3.pm6 :146:	a) Accompany the combined library with a copy of the same work based
kalkin/License-Software …/LGPLv3.pm6 :147:	on the Library, uncombined with any other library facilities,
kalkin/License-Software …/LGPLv3.pm6 :150:	b) Give prominent notice with the combined library that part of it
kalkin/License-Software …/LGPLv3.pm6 :152:	accompanying uncombined form of the same work.
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;
kolikov/perl6-Lingua-EN-Conjugate …/README.md :51:	Instead of using fixed tense blocks to conjugate an English verb, this module uses notions of "forms" which can be combined.
kolikov/perl6-Lingua-EN-Conjugate …/README.pod6 :59:	Instead of using fixed tense blocks to conjugate an English verb, this module uses notions of "forms" which can be combined.
krunen/unicode-utf8-parser …/README.md :4:	Rakudo's built-in UTF8 parser will wait for a possible combining character
krunen/unicode-utf8-parser …/parse.t :12:	if (@parse eq $s.comb) {
kuerbis/Term-Choose-Util-p6 …/Util.pm6 :435:	my Int $num_combined = [+] %numbers.values;
kuerbis/Term-Choose-Util-p6 …/Util.pm6 :436:	$result = insert-sep( $num_combined, $sep ).Str;
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 {
lancew/ScientistP6 …/Scientist.pod6 :154:	https://news.ycombinator.com/item?id=11104781
leejo/geo-ip2location-lite-p6 …/Lite.pm :71:	my $ipnum = :256[$ipaddr.comb(/\d+/)]; # convert ipv4 to int!
lestrrat/p6-Apache-LogFormat …/README.md :13:	my $fmt = Apache::LogFormat.combined;
lestrrat/p6-Apache-LogFormat …/README.md :39:	combined(): $fmt:Apache::LogFormat::Formatter
lestrrat/p6-Apache-LogFormat …/LogFormat.pm6 :11:	method combined(Apache::LogFormat:U: :$logger) {
lestrrat/p6-Apache-LogFormat …/LogFormat.pm6 :26:	my $fmt = Apache::LogFormat.combined;
lestrrat/p6-Apache-LogFormat …/LogFormat.pm6 :78:	=head2 combined(): $fmt:Apache::LogFormat::Formatter
lestrrat/p6-Apache-LogFormat …/02-predefined.t :8:	my $fmt = Apache::LogFormat.combined();
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 …/Q.pm :786:	### inserted. Quasiquotation is the practice of combining literal code
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;
mempko/PKafka …/LICENSE :28:	A "Combined Work" is a work produced by combining or linking an
mempko/PKafka …/LICENSE :105:	recombine or relink the Application with a modified version of
mempko/PKafka …/LICENSE :121:	Combined Work produced by recombining or relinking the
mempko/PKafka …/LICENSE :134:	License, and convey such a combined library under terms of your
mempko/PKafka …/LICENSE :137:	a) Accompany the combined library with a copy of the same work based
mempko/PKafka …/LICENSE :138:	on the Library, uncombined with any other library facilities,
mempko/PKafka …/LICENSE :141:	b) Give prominent notice with the combined library that part of it
mempko/PKafka …/LICENSE :143:	accompanying uncombined form of the same work.
mrhdias/perl6-Imlib2 …/Imlib2.pod :290:	subtractive and a combination of the both (called reshade) rendering.
nkh/P6-Data-Dump-Tree …/diff_string.pl :45:	return ($s1.comb(1), $s2.comb(1)) ;
nkh/P6-Data-Dump-Tree …/Tree.pm :618:	# combing an empty line returns nothing but we still want a line
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 }
nkh/P6-Data-Dump-Tree …/Foldable.pm :75:	You can call I<set> with a combination of named arguments, eg: you don't need
nobodyinperson/perl6-fortran-grammar …/LICENSE :237:	and which are not combined with it such as to form a larger program,
nobodyinperson/perl6-fortran-grammar …/LICENSE :555:	permission to link or combine any covered work with a work licensed
nobodyinperson/perl6-fortran-grammar …/LICENSE :557:	combined work, and to convey the resulting work. The terms of this
nobodyinperson/perl6-fortran-grammar …/LICENSE :561:	combination as such.
perl6-all-modules/github/p6-c-parser/LICENSE	A "Combined Work" is a work produced by combining or linking an
perl6-all-modules/github/p6-c-parser/LICENSE	recombine or relink the Application with a modified version of
perl6-all-modules/github/p6-c-parser/LICENSE	Combined Work produced by recombining or relinking the
perl6-all-modules/github/p6-c-parser/LICENSE	License, and convey such a combined library under terms of your
perl6-all-modules/github/p6-c-parser/LICENSE	a) Accompany the combined library with a copy of the same work based
perl6-all-modules/github/p6-c-parser/LICENSE	on the Library, uncombined with any other library facilities,
perl6-all-modules/github/p6-c-parser/LICENSE	b) Give prominent notice with the combined library that part of it
perl6-all-modules/github/p6-c-parser/LICENSE	accompanying uncombined form of the same work.
p6-css/CSS-Declarations-p6 …/README.md :201:	- `:!optimize` - turn off optimization. Don't, combine simple properties into compound properties (`border-style`, `border-width`, ... => `border`), or combine edges (`margin-top`, `margin-left`, ... => `margin`).
p6-css/CSS-Grammar-p6 …/Grammar.pm :102:	proto rule combinator {*}
p6-css/CSS-Grammar-p6 …/Grammar.pm :103:	rule combinator:sym<adjacent> { '+' }
p6-css/CSS-Grammar-p6 …/Grammar.pm :104:	rule combinator:sym<child> { '>' }
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-Grammar-p6 …/Actions.pm :257:	# combinators
p6-css/CSS-Grammar-p6 …/Actions.pm :258:	method combinator:sym<adjacent>($/) { make '+' }
p6-css/CSS-Grammar-p6 …/Actions.pm :259:	method combinator:sym<child>($/) { make '>' }
p6-css/CSS-Grammar-p6 …/Actions.pm :260:	method combinator:sym<not>($/) { make '-' } # css21
p6-css/CSS-Grammar-p6 …/CSS21.pm :32:	# inherited combinators: '+' (adjacent)
p6-css/CSS-Grammar-p6 …/CSS21.pm :33:	token combinator:sym<not> { '-' }
p6-css/CSS-Grammar-p6 …/CSS21.pm :71:	rule selector{ <simple-selector> +% <op=.combinator>? }
p6-css/CSS-Grammar-p6 …/compat.json :46:	// CSS1 doesn't understand '+' combinator
p6-css/CSS-Grammar-p6 …/compat.json :48:	// '>' combinator also introduced with css2.1
p6-css/CSS-Module-CSS3-Selectors-p6 …/Selectors.pm :16:	# inherited combinators: '+' (adjacent), '>' (child)
p6-css/CSS-Module-CSS3-Selectors-p6 …/Selectors.pm :17:	rule combinator:sym<sibling> { '~' }
p6-css/CSS-Module-CSS3-Selectors-p6 …/Actions.pm :8:	method combinator:sym<sibling>($/) { make '~' }
p6-css/CSS-Specification-p6 …/Specification.pm :45:	rule term-options { <term=.term-combo> +% '|' }
p6-css/CSS-Specification-p6 …/Specification.pm :46:	rule term-combo { <term=.term-required> +% '||' }
p6-css/CSS-Specification-p6 …/Actions.pm :87:	method term-combo($/) {
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 …/Changes :71:	has "\n\r" as a combining newline character.
p6-pdf/PDF-Grammar-p6 …/Actions.pm :36:	my @hex-codes = $xdigits.comb.map: -> $a, $b = '0' { :16($a ~ $b) };
p6-pdf/PDF-Grammar-p6 …/Content.pm :35:	# So theoretically, we only have to deal with a few combinations...
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-community-modules/testml-pm6 …/irc.7 :13:	10:04 <@ingy> so my other stuff takes little regexp bits and combinates them into bigger rules
perl6-community-modules/testml-pm6 …/irc.7 :14:	10:05 <@ingy> but the combination is pretty much hand driven
perl6-community-modules/testml-pm6 …/irc.7 :17:	10:07 <@ingy> they get combinated in an obvious way into http://github.com/ingydotnet/cdent/blob/master/src/grammar/javascript.yaml (a grammar for cdent-javascript)
perl6-community-modules/testml-pm6 …/irc.7 :19:	combinated.
perl6-community-modules/testml-pm6 …/irc.7 :20:	10:09 <@ingy> 'combination' is turning several smaller regexps/rules into a bigger one
perl6-community-modules/testml-pm6 …/irc.7 :21:	10:10 <@ingy> in theory, the whole grammar could be combinated into one big (and fast!) regexp
perl6-community-modules/testml-pm6 …/irc.7 :40:	10:37 < masak> LTM is a name for a bunch of strategies for combining the academic view of regexes with the computer engineering view of regexes, getting the best out of both.
perl6-community-modules/testml-pm6 …/irc.7 :49:	10:40 <@ingy> I've actually been doing this p5 combination stuff for over a year
perl6-community-modules/testml-pm6 …/Bridge.pm :17:	our sub combine {
perl6-community-modules/testml-pm6 …/arguments.tml :4:	*what.combine(*who) == *greeting;
perl6-community-modules/testml-pm6 …/arguments.tml :5:	*what.combine('and', *else) == *greeting;
perl6-community-modules/testml-pm6 …/arguments.tml :6:	# *what.combine('and', *else.upper) == *upper_greeting;
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 :776:	useful in combination with the C<with> command:
perl6/doc …/5to6-perlfunc.pod6 :1430:	the substring is not found. This is very useful in combination with the
perl6/doc …/5to6-perlfunc.pod6 :1691:	they are in Perl 5. For that behavior, see C<comb>. Details on C<split>
perl6/doc …/concurrency.pod6 :159:	In addition to C<await>, two class methods combine several
perl6/doc …/concurrency.pod6 :501:	The C<.poll> method can be used in combination with C<.receive> method, as a
perl6/doc …/grammar_tutorial.pod6 :31:	at once, or combining patterns, or testing for patterns that may surround
perl6/doc …/grammar_tutorial.pod6 :60:	or backwards in a string, or things that need to be combined from many of
perl6/doc …/io-guide.pod6 :201:	L«.comb|/type/IO::Handle#method_comb»,
perl6/doc …/list.pod6 :37:	C<List>s of C<List>s can also be created by combining comma and semicolon.
perl6/doc …/modules.pod6 :373:	You can combine `EXPORT` with type captures for interesting
perl6/doc …/objects.pod6 :48:	@words.push("said", $formatted-text.comb(/\w+/));
perl6/doc …/objects.pod6 :343:	time, combined with either C<:U> (for class methods) or C<:D> (for
perl6/doc …/operators.pod6 :124:	combined operator in the background, allowing the mechanism to be applied to
perl6/doc …/operators.pod6 :226:	Infix operators can be combined with the assignment operator to modify a
perl6/doc …/operators.pod6 :1200:	L<Buf|/type/Buf>, a combined buffer is returned.
perl6/doc …/operators.pod6 :1210:	X<Function combinator operator>
perl6/doc …/operators.pod6 :1212:	The function composition operator C«infix:<∘>» or C«infix:<o>» combines two
perl6/doc …/operators.pod6 :1232:	sub g($str){ $str.comb }
perl6/doc …/performance.pod6 :81:	perl6 --profile --profile-filename=demo.sql -e 'say (^20).combinations(3).elems'
perl6/doc …/py-nutshell.pod6 :457:	Postfix statement modifiers and blocks can be combined to make list comprehensions.
perl6/doc …/rb-nutshell.pod6 :717:	escaped, for example. Regexes can be easily combined and declared in ways to
perl6/doc …/regexes.pod6 :661:	You can combine both anchors:
perl6/doc …/regexes.pod6 :1175:	but is otherwise the same as C« $0 < 12 ?? $0 !! $0 - 12 ». When combined with
perl6/doc …/regexes.pod6 :1526:	compare base characters, and ignore additional marks such as combining
perl6/doc …/subscripts.pod6 :466:	C<:exists> can be combined with the L<#:delete> and L<#:p>/L<#:kv> adverbs -
perl6/doc …/subscripts.pod6 :508:	Can be combined with the L<#:exists> and L<#:p>/L<#:kv>/L<#:k>/L<#:v> adverbs -
perl6/doc …/subscripts.pod6 :534:	Can be combined with the L<#:exists> and L<#:delete> adverbs.
perl6/doc …/subscripts.pod6 :567:	Can be combined with the L<#:exists> and L<#:delete> adverbs.
perl6/doc …/syntax.pod6 :122:	statements, that could end with a bare block. For example, in combination with
perl6/doc …/syntax.pod6 :736:	Operators can be composed. A common example of this is combining an infix
perl6/doc …/syntax.pod6 :737:	(binary) operator with assignment. You can combine assignment with any binary
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 …/traps.pod6 :673:	Infix operators, both built in and user defined, can be combined with the
perl6/doc …/traps.pod6 :1327:	here as well (especially when using in combination with C<run>):
perl6/doc …/traps.pod6 :1427:	beware unintentional combination of C<LEAVE> phasers and C<exit> calls.
perl6/doc …/unicode.pod6 :95:	can combine numeric and named styles as well:
perl6/doc …/unicode_ascii.pod6 :36:	aren't decimal digit characters, so can't be combined.) For example:
perl6/doc …/unicode_ascii.pod6 :82:	⁰ | U+2070 | **0 | can be combined with ⁰..⁹
perl6/doc …/unicode_ascii.pod6 :83:	¹ | U+00B9 | **1 | can be combined with ⁰..⁹
perl6/doc …/unicode_ascii.pod6 :84:	² | U+00B2 | **2 | can be combined with ⁰..⁹
perl6/doc …/unicode_ascii.pod6 :85:	³ | U+00B3 | **3 | can be combined with ⁰..⁹
perl6/doc …/unicode_ascii.pod6 :86:	⁴ | U+2074 | **4 | can be combined with ⁰..⁹
perl6/doc …/unicode_ascii.pod6 :87:	⁵ | U+2075 | **5 | can be combined with ⁰..⁹
perl6/doc …/unicode_ascii.pod6 :88:	⁶ | U+2076 | **6 | can be combined with ⁰..⁹
perl6/doc …/unicode_ascii.pod6 :89:	⁷ | U+2077 | **7 | can be combined with ⁰..⁹
perl6/doc …/unicode_ascii.pod6 :90:	⁸ | U+2078 | **8 | can be combined with ⁰..⁹
perl6/doc …/unicode_ascii.pod6 :91:	⁹ | U+2079 | **9 | can be combined with ⁰..⁹
perl6/doc …/unicode_entry.pod6 :84:	example, the Greek letter λ (lambda) is entered via the key combination:
perl6/doc …/unicode_entry.pod6 :118:	letter λ (lambda), one uses the following key combination:
perl6/doc …/unicode_entry.pod6 :169:	following key combination (whitespace has been added for clarity):
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 …/Any.pod6 :932:	=head2 method combinations
perl6/doc …/Any.pod6 :936:	method combinations(--> Seq)
perl6/doc …/Any.pod6 :939:	L«C<List.combinations>|/type/List#routine_combinations» on it.
perl6/doc …/Any.pod6 :941:	say Any.combinations; # OUTPUT: «(() ((Any)))␤»
perl6/doc …/Blob.pod6 :172:	n Extracts two elements and combines them in "network" (big-endian) byte order into a single integer
perl6/doc …/Blob.pod6 :173:	N Extracts four elements and combines them in "network" (big-endian) byte order into a single integer
perl6/doc …/Code.pod6 :68:	You can handle any combination of assumed and not assumed positional parameters:
perl6/doc …/Code.pod6 :87:	my &comber = Str.^lookup('comb').assuming: *, /P \w+/;
perl6/doc …/Code.pod6 :88:	say comber 'Perl is awesome! Python is great! And PHP is OK too';
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 …/Hash.pod6 :436:	L<Iterables|/type/Iterable> and categorization combines features
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 :70:	Support for combinations of modes I<other> than what is listed above
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 …/Handle.pod6 :199:	=head3 Waiting for potential combiners
perl6/doc …/Handle.pod6 :201:	If your handle's encoding allows combining characters to be read, perl6 will
perl6/doc …/Handle.pod6 :203:	that inputting an "e" followed by a combining acute will give you an e with an
perl6/doc …/Handle.pod6 :205:	a dangling combiner. However, it also means that when the user inputs just an
perl6/doc …/Handle.pod6 :206:	"e" and has no intention to also input a combining acute, your program will be
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 …/Async.pod6 :207:	not be emitted since the next packet may include a combining character
perl6/doc …/Cygwin.pod6 :92:	(C<"\">), even if they have combining character on them, optionally preceded by
perl6/doc …/Unix.pod6 :167:	combining character on it:
perl6/doc …/Win32.pod6 :126:	(C<"\">), even if they have combining character on them, optionally preceded by
perl6/doc …/Iterable.pod6 :19:	method iterator(){ self.comb.iterator }
perl6/doc …/List.pod6 :833:	Generates a single "combined" value from a list of arbitrarily many of values,
perl6/doc …/List.pod6 :834:	by iteratively applying a function which knows how to combine I<two> values.
perl6/doc …/List.pod6 :910:	Generates a list of all intermediate "combined" values along with the final
perl6/doc …/List.pod6 :911:	result by iteratively applying a function which knows how to combine I<two>
perl6/doc …/List.pod6 :960:	=head2 routine combinations
perl6/doc …/List.pod6 :964:	multi sub combinations($from, $of = 0..* --> Seq:D)
perl6/doc …/List.pod6 :965:	multi method combinations(List:D: Int() $of --> Seq:D)
perl6/doc …/List.pod6 :966:	multi method combinations(List:D: Range:D $of = 0..* --> Seq:D)
perl6/doc …/List.pod6 :968:	Returns a L<Seq> with all C<$of>-combinations of the invocant list.
perl6/doc …/List.pod6 :970:	case combinations of the range of item numbers it represents will be returned (i.e. C<2.6 .. 4>
perl6/doc …/List.pod6 :971:	will return 2-, 3-, and 4-item combinations>). Otherwise, C<$of> is coerced to an L<Int>.
perl6/doc …/List.pod6 :973:	.say for <a b c>.combinations: 2;
perl6/doc …/List.pod6 :979:	Above, there are three possible ways to combine the 2-items lists from the original list, which
perl6/doc …/List.pod6 :981:	combinations.
perl6/doc …/List.pod6 :983:	With L<Range> argument, we get both three 2-item combinations and one 3-item combination:
perl6/doc …/List.pod6 :985:	.say for <a b c>.combinations: 2..3;
perl6/doc …/List.pod6 :997:	the exception that if C<$from> is not an L<Iterable>, it gets coerced to an C<Int> and combinations
perl6/doc …/List.pod6 :1000:	.say for combinations 3, 2
perl6/doc …/List.pod6 :1117:	The C<X> operator can be combined with another operator as a meta-operator to perform a reduction as well:
perl6/doc …/List.pod6 :1212:	C<roundrobin> can be useful in combining messy data to the point where a manual
perl6/doc …/Mix.pod6 :18:	element, with a combined weight.
perl6/doc …/MixHash.pod6 :15:	same element, with a combined weight.
perl6/doc …/Promise.pod6 :13:	combining promises, and waiting for results.
perl6/doc …/Routine.pod6 :88:	.signature.say for "foo".^can("comb")[0].cando: \(Cool, "o");
perl6/doc …/Signature.pod6 :519:	Slurpy parameters have special behaviors when combined with some
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);
perl6/doc …/Supply.pod6 :725:	=head1 Methods that combine supplies
perl6/doc …/Supply.pod6 :739:	Creates a supply that emits combined values as soon as there is a new value
perl6/doc …/Supply.pod6 :741:	created, but this can be changed by specifying your own combiner with the
perl6/doc …/Supply.pod6 :749:	Creates a supply that emits combined values as soon as there is a new value
perl6/doc …/Supply.pod6 :751:	created, but this can be changed by specifying your own combiner with the
perl6/doc …/Supply.pod6 :753:	the initial state of the combined values. By default, all supplies have to
perl6/doc …/Supply.pod6 :754:	have at least one value emitted on them before the first combined values is
perl6/doc …/Uni.pod6 :10:	strictly made of Unicode codepoints. That is, base characters and combining
perl6/doc …/Version.pod6 :42:	Creates a Version from a string C<$s>. The string is combed
perl6/doc …/Whatever.pod6 :15:	position in combination with most operators, the compiler will transform the
perl6/doc …/EXAMPLES.md :9:	combination of `=begin code` and `=end code` to better control which
perl6/doc …/aspell.t :36:	# generate a combined words file
perl6/doc …/words.pws :184:	combinator
perl6/doc …/words.pws :185:	combinators
perl6/gtk-simple …/README.md :11:	ComboBoxText | A simple combo box
perl6/gtk-simple …/06-combo.pl6 :11:	my $combo = GTK::Simple::ComboBoxText.new();
perl6/gtk-simple …/06-combo.pl6 :14:	$combo.append-text("Entry " ~ $item);
perl6/gtk-simple …/06-combo.pl6 :18:	$combo.set-active(5);
perl6/gtk-simple …/06-combo.pl6 :22:	$combo.changed.tap({
perl6/gtk-simple …/06-combo.pl6 :23:	$label.text = $combo.active-text();
perl6/gtk-simple …/06-combo.pl6 :28:	my $pre-set-combo = GTK::Simple::ComboBoxText.new();
perl6/gtk-simple …/06-combo.pl6 :32:	$pre-set-combo.append-text( $item )
perl6/gtk-simple …/06-combo.pl6 :36:	$pre-set-combo.set-active( $index );
perl6/gtk-simple …/06-combo.pl6 :42:	$pre-set-combo.changed.tap: {
perl6/gtk-simple …/06-combo.pl6 :43:	$lbl2.text = 'ComboBoxText has selection ' ~ $pre-set-combo.active-text() ~ ', which has index ' ~ $pre-set-combo.get-active();
perl6/gtk-simple …/06-combo.pl6 :47:	$app.set-content(GTK::Simple::VBox.new($label, $combo, $lbl2, $pre-set-combo));
perl6/gtk-simple …/ComboBoxText.pm6 :5:	use GTK::Simple::Raw :combo-box-text, :DEFAULT;
perl6/gtk-simple …/ComboBoxText.pm6 :16:	gtk_combo_box_text_new_with_entry()
perl6/gtk-simple …/ComboBoxText.pm6 :19:	gtk_combo_box_text_new()
perl6/gtk-simple …/ComboBoxText.pm6 :25:	gtk_combo_box_text_append_text($!gtk_widget, $text);
perl6/gtk-simple …/ComboBoxText.pm6 :29:	gtk_combo_box_text_prepend_text($!gtk_widget, $text);
perl6/gtk-simple …/ComboBoxText.pm6 :33:	gtk_combo_box_text_insert_text($!gtk_widget, $position, $text);
perl6/gtk-simple …/ComboBoxText.pm6 :37:	gtk_combo_box_text_remove($!gtk_widget, $position);
perl6/gtk-simple …/ComboBoxText.pm6 :41:	gtk_combo_box_text_remove_all($!gtk_widget)
perl6/gtk-simple …/ComboBoxText.pm6 :45:	gtk_combo_box_text_get_active_text($!gtk_widget);
perl6/gtk-simple …/ComboBoxText.pm6 :49:	gtk_combo_box_set_active($!gtk_widget,$index)
perl6/gtk-simple …/ComboBoxText.pm6 :53:	gtk_combo_box_get_active($!gtk_widget)
perl6/gtk-simple …/Raw.pm6 :309:	sub gtk_combo_box_text_new()
perl6/gtk-simple …/Raw.pm6 :311:	is export(:combo-box-text)
perl6/gtk-simple …/Raw.pm6 :315:	sub gtk_combo_box_text_new_with_entry()
perl6/gtk-simple …/Raw.pm6 :317:	is export(:combo-box-text)
perl6/gtk-simple …/Raw.pm6 :321:	sub gtk_combo_box_text_prepend_text(GtkWidget $widget, Str $text)
perl6/gtk-simple …/Raw.pm6 :323:	is export(:combo-box-text)
perl6/gtk-simple …/Raw.pm6 :326:	sub gtk_combo_box_text_append_text(GtkWidget $widget, Str $text)
perl6/gtk-simple …/Raw.pm6 :328:	is export(:combo-box-text)
perl6/gtk-simple …/Raw.pm6 :331:	sub gtk_combo_box_text_insert_text(GtkWidget $widget, int32 $position, Str $text)
perl6/gtk-simple …/Raw.pm6 :333:	is export(:combo-box-text)
perl6/gtk-simple …/Raw.pm6 :336:	sub gtk_combo_box_set_active(GtkWidget $widget, int32 $index)
perl6/gtk-simple …/Raw.pm6 :338:	is export(:combo-box-text)
perl6/gtk-simple …/Raw.pm6 :341:	sub gtk_combo_box_get_active(GtkWidget $widget)
perl6/gtk-simple …/Raw.pm6 :343:	is export(:combo-box-text)
perl6/gtk-simple …/Raw.pm6 :347:	sub gtk_combo_box_text_get_active_text(GtkWidget $widget)
perl6/gtk-simple …/Raw.pm6 :349:	is export(:combo-box-text)
perl6/gtk-simple …/Raw.pm6 :353:	sub gtk_combo_box_text_remove(GtkWidget $widget, int32 $position)
perl6/gtk-simple …/Raw.pm6 :355:	is export(:combo-box-text)
perl6/gtk-simple …/Raw.pm6 :358:	sub gtk_combo_box_text_remove_all(GtkWidget $widget)
perl6/gtk-simple …/Raw.pm6 :360:	is export(:combo-box-text)
perlpilot/p6-HexDump-Tiny …/Tiny.pm :4:	my @chars = $value.comb;
pierre-vigier/Perl6-Acme-Sudoku …/Sudoku.pm6 :107:	#initialize easy solution with naive method, to prepare backtracking and reduce combinations
pierre-vigier/Perl6-Math-Matrix …/README.md :470:	Methods that return lists of matrices, which in their product or otherwise can be recombined to the original matrix. In case of cholesky only one matrix is returned, becasue the other one is its transposed.
pierre-vigier/Perl6-Math-Matrix …/README.md :479:	$L is a left triangular matrix and $R is a right one Without pivotisation the marix has to be invertible (square and full ranked). In case you whant two unipotent triangular matrices and a diagonal (D): use the :diagonal option, which can be freely combined with :pivot.
pierre-vigier/Perl6-Math-Matrix …/Matrix.pod :492:	can be recombined to the original matrix. In case of cholesky only one
pierre-vigier/Perl6-Math-Matrix …/Matrix.pod :505:	use the :diagonal option, which can be freely combined with :pivot.
ppentchev/perl6-Getopt-Std …/01-getopts.t :56:	my %exp-opts = $t.optstring.comb(/ . ':'? /).flatmap(-> $opt {
prodotiscus/perl6-Dictionary-Create …/LICENSE :80:	Contribution(s) alone or by combination of their Contribution(s)
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 {
raydiak/Math-Symbolic …/README.md :72:	variable exists, as well as attempting to combine instances via distributive
raydiak/Math-Symbolic …/README.md :93:	does a very small number of rearrangements of combinations of operations, like
raydiak/pray …/README :178:	of the separate classes might be combined into a single class with one or two
retupmoca/P6-Compress-Zlib-Raw …/Raw.pm6 :221:	our sub adler32_combine(ulong, ulong, int32) returns long is native(&find-lib) is export { * }
retupmoca/P6-Compress-Zlib-Raw …/Raw.pm6 :223:	our sub crc32_combine(ulong, ulong, int32) returns long is native(&find-lib) is export { * }
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;
scmorrison/JS-Minify …/README.md :59:	The `input` parameter is mandatory. The `copyright`, `strip_debug`, and `stream` parameters are optional and can be used in any combination.
scovit/Scheduler-DRMAA …/COPYING :237:	and which are not combined with it such as to form a larger program,
scovit/Scheduler-DRMAA …/COPYING :555:	permission to link or combine any covered work with a work licensed
scovit/Scheduler-DRMAA …/COPYING :557:	combined work, and to convey the resulting work. The terms of this
scovit/Scheduler-DRMAA …/COPYING :561:	combination as such.
shinobi/Data-StaticTable …/StaticTable.pm6 :675:	You can combine this with C<generate-index>
shinobi/Data-StaticTable …/StaticTable.pm6 :779:	This is very useful to combine with the C<take> method.
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 …/Sum.pm6 :412:	nor combines multiple addends into a packed addend. Addends are passed
skids/perl6sum …/Sum.pm6 :569:	Any leftover bits will be kept to combine with further fragments.
skids/perl6sum …/Sum.pm6 :642:	This role may be combined with other C<Sum::Marshal::Pack::*> roles,
skids/perl6sum …/Sum.pm6 :682:	combine with further addends.
skids/perl6sum …/Adler.pm6 :62:	and this value are combined in a bitwise XOR when a result is
skids/perl6sum …/CRC.pm6 :49:	and this value are combined in a bitwise XOR when a result is
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 :217:	is +$o2.finalize, 138, "can combine 8 bits";
skids/perl6sum …/sum.t :220:	is +$o2.finalize, 146, "can combine 8 bits then add an Int";
skids/perl6sum …/sum.t :223:	is +$o2.finalize, 146, "can add 8 combined bits after an Int";
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';
skinkade/p6-Crypt-Bcrypt …/crypt_blowfish.c :578:	* Valid combinations of settings are:
softmoth/p6-Template-Mustache …/Mustache.pm :102:	my @delim = $0.comb(/\S+/);
softmoth/p6-Template-Mustache …/inverted.json :1:	{"__ATTN__":"Do not edit this file; changes belong in the appropriate YAML file.","overview":"Inverted Section tags and End Section tags are used in …
softmoth/p6-Template-Mustache …/sections.json :1:	{"__ATTN__":"Do not edit this file; changes belong in the appropriate YAML file.","overview":"Section tags and End Section tags are used in co…
soundart/perl6-tweetnacl …/PublicKey.pm6 :52:	receiver combine them into a new ciphertext and decrypt into the
spebern/Parser-FreeXL-Native …/COPYING :14:	1.2. "Contributor Version" means the combination of the Original
spebern/Parser-FreeXL-Native …/COPYING :19:	combination of the Original Code and Modifications, in each case
spebern/Parser-FreeXL-Native …/COPYING :33:	1.7. "Larger Work" means a work which combines Covered Code or
spebern/Parser-FreeXL-Native …/COPYING :107:	combination of the Original Code with other software or devices.
spebern/Parser-FreeXL-Native …/COPYING :122:	and/or in combination with its Contributor Version (or portions
spebern/Parser-FreeXL-Native …/COPYING :123:	of such combination), to make, use, sell, offer for sale, have
spebern/Parser-FreeXL-Native …/COPYING :125:	Contributor (or portions thereof); and 2) the combination of
spebern/Parser-FreeXL-Native …/COPYING :127:	Version (or portions of such combination).
spebern/Parser-FreeXL-Native …/COPYING :137:	Contributor Version or ii) the combination of Modifications made
spebern/Parser-FreeXL-Native …/COPYING :254:	You may create a Larger Work by combining Covered Code with other code
spebern/Parser-FreeXL-Native …/config.sub :123:	# Here we must recognize all the valid KERNEL-OS combinations.
spebern/Parser-FreeXL-Native …/config.sub :242:	# Decode aliases for certain CPU-COMPANY combinations.
spebern/Parser-FreeXL-Native …/configure :11371:	# The compiler driver will combine and reorder linker options,
spebern/Parser-FreeXL-Native …/configure :14532:	# The compiler driver will combine and reorder linker options,
spebern/Parser-FreeXL-Native …/ltmain.sh :1795:	# where, for any given $build/$host combination the 'X_to_Y' value is the
spebern/Parser-FreeXL-Native …/ltmain.sh :1796:	# same. If conversion functions are added for new $build/$host combinations,
spebern/Parser-FreeXL-Native …/libtool.m4 :403:	[m4_ifval([$3], [lt_combine([$1], [$2], [_], $3)])])
spebern/Parser-FreeXL-Native …/libtool.m4 :5392:	# The compiler driver will combine and reorder linker options,
spebern/Parser-FreeXL-Native …/libtool.m4 :6650:	# The compiler driver will combine and reorder linker options,
spebern/Parser-FreeXL-Native …/ltsugar.m4 :61:	# lt_combine(SEP, PREFIX-LIST, INFIX, SUFFIX1, [SUFFIX2...])
spebern/Parser-FreeXL-Native …/ltsugar.m4 :63:	# Produce a SEP delimited list of all paired combinations of elements of
spebern/Parser-FreeXL-Native …/ltsugar.m4 :66:	# Needed until we can rely on m4_combine added in Autoconf 2.62.
spebern/Parser-FreeXL-Native …/ltsugar.m4 :67:	m4_define([lt_combine],
spebern/Parser-FreeXL-Native …/mainpage.doxy :492:	- each XF record specifies an unique combination of font, alignment, color
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;
sufrostico/perl6-snowball …/LICENSE :237:	and which are not combined with it such as to form a larger program,
sufrostico/perl6-snowball …/LICENSE :555:	permission to link or combine any covered work with a work licensed
sufrostico/perl6-snowball …/LICENSE :557:	combined work, and to convey the resulting work. The terms of this
sufrostico/perl6-snowball …/LICENSE :561:	combination as such.
sufrostico/perl6-wiringpi …/LICENSE :237:	and which are not combined with it such as to form a larger program,
supernovus/flower …/TALES.pm6 :140:	$string.comb(/ [ '{{'.*?'}}' | '${'.*?'}' | '$('.*?')' | ':'\w+'('.*?')' | \'.*?\' | \S+ ] /);
supernovus/hinges …/README.md :6:	It's a modular system based on XML SAX streams, it allows for combining
supernovus/hinges …/XMLParser.pm :58:	my $line-num = +$text.substr(0, $t.from).comb(/\n/) + 1;
supernovus/perl6-psgi …/populate-psgi-env.t :122:	my $combined-opt = 'with PSGI Classic and P6SGI default versions';
supernovus/perl6-psgi …/populate-psgi-env.t :123:	my %combined-env;
supernovus/perl6-psgi …/populate-psgi-env.t :125:	populate-psgi-env(%combined-env, :psgi-classic);
supernovus/perl6-psgi …/populate-psgi-env.t :127:	p6sgi-v04-version(%combined-env, $combined-opt);
supernovus/perl6-psgi …/populate-psgi-env.t :128:	p6sgi-v07-version(%combined-env, $combined-opt);
supernovus/perl6-psgi …/populate-psgi-env.t :129:	psgi-classic-version(%combined-env, $combined-opt);
supernovus/perl6-timezone …/asia :370:	# I think you're combining two subjects that need to treated
supernovus/perl6-timezone …/europe :2138:	# Tobias Conradi combines Wikipedia's
supernovus/perl6-timezone …/northamerica :359:	# From Andy Lipscomb (2011-01-24):
supernovus/template6 …/Parser.pm6 :178:	my @stmts = $statement.split(/\n/).map({ self.remove-comment(.comb(/\".*?\" | \'.*?\' | \S+/)) }).flat;
tadzik/File-Find …/01-file-find.t :37:	equals @test, <t/dir1/foodir>, 'types: dir, combined with name';
tadzik/File-Find …/01-file-find.t :42:	'types: file, combined with name';
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 …/01-file-find.t :37:	equals @test, <t/dir1/foodir>, 'types: dir, combined with name';
tadzik/panda …/01-file-find.t :42:	'types: file, combined with name';
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;
titsuki/p6-Algorithm-LBFGS …/lbfgs.h :326:	* minimizes the objective function F(x) combined with the L1 norm |x|
titsuki/p6-Algorithm-LBFGS …/lbfgs.h :555:	a function F(x) combined with L1-norm |x| of the variables,
tokuhirom/p6-Crust …/Builder.pm6 :134:	enable "AccessLog", format => "combined";
tokuhirom/p6-Crust …/Builder.pm6 :271:	}, 'AccessLog', format => "combined";
tokuhirom/p6-Crust …/AccessLog.pm6 :14:	when any(!.Bool, "combined")
tokuhirom/p6-Crust …/AccessLog.pm6 :15:	{ $formatter = Apache::LogFormat.combined }
tokuhirom/p6-Crust …/AccessLog.pm6 :72:	:format('combined'),
tokuhirom/p6-Crust …/AccessLog.pm6 :78:	enable 'AccessLog', :format('combined'), :logger(-> $log-line { ... });
tokuhirom/p6-Crust …/AccessLog.pm6 :84:	can be specified using Apache-like format strings (or C<combined> or
tokuhirom/p6-Crust …/AccessLog.pm6 :85:	C<common> for the default formats). If none is specified C<combined> is
tokuhirom/p6-Crust …/AccessLog.pm6 :95:	enable "AccessLog", :format('combined');
tokuhirom/p6-Crust …/AccessLog.pm6 :99:	Takes a format string (or a preset template C<combined> or C<custom>)
tokuhirom/p6-Crust …/Conditional.pm6 :38:	}, "AccessLog", format => "combined";
tokuhirom/p6-Crust …/Conditional.pm6 :51:	Crust::Middleware::AccessLog.new($app, format => "combined");
tokuhirom/p6-Crust …/Conditional.pm6 :58:	enable-if -> %env { %env<REMOTE_ADDR> eq '127.0.0.1' }, 'AccessLog', :format('combined');
tokuhirom/p6-Crust …/basic.t :9:	enable "AccessLog", format => "combined";
tokuhirom/p6-Crust …/basic.t :48:	enable-if -> %env { %env<REMOTE_ADDR> eq '127.0.0.1' }, "AccessLog", format => "combined";
tokuhirom/p6-Crust …/basic.t :84:	enable-if -> %env { %env<REMOTE_ADDR> eq '192.168.11.1' }, "AccessLog", format => "combined";
tokuhirom/p6-Crust …/middleware.t :14:	enable 'AccessLog', :format('combined'), :logger(-> $log-line { ... });
tokuhirom/p6-Crust …/accesslog.t :12:	sub make-check-combined-logs($buf) {
tokuhirom/p6-Crust …/accesslog.t :50:	runit(&code, make-check-combined-logs($buf), ("p6w.errors" => $buf.supplier));
tokuhirom/p6-Crust …/accesslog.t :57:	format => "combined",
tokuhirom/p6-Crust …/accesslog.t :59:	runit(&code, make-check-combined-logs($buf), ("p6w.errors" => $buf.supplier));
tokuhirom/p6-Crust …/accesslog.t :68:	runit(&code, make-check-combined-logs($buf), ("p6w.errors" => $buf.supplier));
tokuhirom/p6-Crust …/accesslog.t :77:	runit(&code, make-check-combined-logs($buf), ("p6w.errors" => $buf.supplier));
tokuhirom/p6-Crust …/accesslog.t :87:	runit(&code, make-check-combined-logs($buf));
tokuhirom/p6-HTTP-Server-Tiny …/Tiny.pm6 :372:	# TODO combine response header and small request body
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 :1653:	<p>If both <code>:nth</code> and <code>:x</code> are present, the matching routine looks for submatches that match with <code>:nth</code>. If the num…
tony-o/perl6-html-parser-xml …/S05.html :3620:	<p>Both <code>&#60;</code> and <code>&#62;</code> are metacharacters, and are usually (but not always) used in matched pairs. (Some combina…
tony-o/perl6-html-parser-xml …/S05.html :4431:	<li>Character classes can be combined (additively or subtractively) within a single set of angle brackets. Whitespace is ignored. For example:
tony-o/perl6-html-parser-xml …/S05.html :4463:	<p>However, in order to combine classes you must prefix a named character class with <code>+</code> or <code>-</code>. Whitespace is required before any <code>-</code> that would be misparsed as an identifier extender.</p>
tony-o/perl6-html-parser-xml …/S05.html :4528:	<li>Multiple of these terms may be combined with pluses and minuses:
tony-o/perl6-html-parser-xml …/S05.html :4546:	<p>Terms may also be combined using <code>&#38;</code> for set intersection, <code>|</code> for set union, and <code>^</code> for symmetric…
tony-o/perl6-html-parser-xml …/S05.html :4611:	<li>The special assertion <code>&#60;.&#62;</code> matches any logical grapheme (including a Unicode combining character sequences):
tony-o/perl6-html-parser-xml …/S05.html :4613:	<p class="smartlink-file"><a href="https://github.com/perl6/roast/blob/master/S05-metasyntax/combchar.t#L5-L28"><code>S05-metasyntax/combchar.t</code> lines <code>5&ndash;28</code></a>
tony-o/perl6-html-parser-xml …/S05.html :4623:	<pre> / seekto = &#60;.&#62; / # Maybe a combined char</pre>
tony-o/perl6-html-parser-xml …/S05.html :5524:	<li>Many <code>\p</code> and <code>\P</code> properties become intrinsic grammar rules such as (<code>&#60;alpha&#62;</code> and <code>&#60;-alpha&#6…
tony-o/perl6-html-parser-xml …/S05.html :8679:	<p>Aliases can be named or numbered. They can be scalar-, array-, or hash-like. And they can be applied to either capturing or non-capturing constructs. The following sections highlight special features of the semantics of some of those combinations.</p>
tony-o/perl6-html-parser-xml …/S05.html :10648:	<pre> $str.comb(/pat/, :match)</pre>
tony-o/perl6-html-parser-xml …/advent.html :439:	<p>This also shows that positionals and named arguments can be combined in the same sub.</p>
tony-o/perl6-html-parser-xml …/advent.html :593:	<h3>Enter the combinators!</h3>
tony-o/perl6-html-parser-xml …/advent.html :606:	<p>Some of the most powerful &#8211; and tricky to implement &#8211; combinators are those that involve multiple supplies. For example, <st…
tony-o/perl6-html-parser-xml …/advent.html :620:	<p>Supplies are one of the most recently implemented things in Rakudo, and what&#8217;s done so far works on Rakudo on the JVM. With time, we&#8217;l…
tony-o/perl6-html-parser-xml …/advent.html :746:	<p>The :$foo syntax has already been introduced a few days ago by the post on adverbly adverbs. The syntax here is a combination of the sho…
ugexe/Perl6-Base64 …/Base64.pm6 :39:	$str.comb(/@alpha/).rotor(4, :partial).map: -> $chunk {
ugexe/zef …/README.pod :102:	A request may contain any number and combination of these. Paths and URLs will be resolved first so they are available
ugexe/zef …/README.pod :373:	In most cases the default configuration combined with command line options should be enough for most users.
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(/<-[_]>/)];
yaml/yaml-libyaml-perl6 …/README.md :40:	Originally LibYAML combined loading and parsing, dumping and emitting. The load
zoffixznet/perl6-Color …/Utilities.pm6 :28:	my ( $r, $g, $b, $a ) = map { :16($_) }, $hex.comb(/../);
zoffixznet/perl6-IO-Path-ChildSecure …/01-operation.t :94:	'resolved parent fails (given path is not a child, via combiners)';
zoffixznet/perl6-IRC-Client-Plugin-Factoid …/bot.pl6 :13:	:channels($channel.comb: /<-[,]>+/),
zoffixznet/perl6-IRC-Client …/01-main.md :543:	Nick, username, and host combined into a full usermask, e.g.
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-NASA …/01-apod.t :21:	~ " Later, the best images of land and sky were digitally combined."
zoffixznet/perl6-NASA …/01-apod.t :25:	~ " resulting image, possibly combined with the knowledge that some"
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);
zoffixznet/perl6-Test-Output …/README.md :80:	Uses `is` function from `Test` module to test whether the combined
zoffixznet/perl6-Test-Output …/README.md :133:	Uses `like` function from `Test` module to test whether the combined
zoffixznet/perl6-Test-When …/README.md :64:	combined. Whether your tests run depends on the set
zoffixznet/perl6-p6lert …/README.md :51:	`UInt` positional argument. Can only be combined with `--no-color` argument.
zostay/P6W …/P6W.pod :299:	The way in which middleware is defined and applied is left up to the middleware author. The example in the previous section uses a combination of priming and defining a closure. This is, by no means, the only way to define P6W middleware in Perl 6.
zostay/P6W …/README.md :328:	The way in which middleware is defined and applied is left up to the middleware author. The example in the previous section uses a combination of priming and defining a closure. This is, by no means, the only way to define P6W middleware in Perl 6.
zostay/p6-DOM-Tiny …/CSS.pm6 :7:	has @.combine;
zostay/p6-DOM-Tiny …/CSS.pm6 :9:	submethod BUILD(:@combine) {
zostay/p6-DOM-Tiny …/CSS.pm6 :10:	PRE { @combine.elems !%% 2 }
zostay/p6-DOM-Tiny …/CSS.pm6 :11:	@!combine = @combine.reverse;
zostay/p6-DOM-Tiny …/CSS.pm6 :17:	my sub next-combination(@next, $current) {
zostay/p6-DOM-Tiny …/CSS.pm6 :19:	try-combination(@next[0], @next[1], @next[2..*], $current);
zostay/p6-DOM-Tiny …/CSS.pm6 :22:	my multi try-combination('', $test, @next, $current) {
zostay/p6-DOM-Tiny …/CSS.pm6 :28:	return True if next-combination(@next, $ancestor);
zostay/p6-DOM-Tiny …/CSS.pm6 :34:	my multi try-combination('>', $test, @next, $current) {
zostay/p6-DOM-Tiny …/CSS.pm6 :37:	next-combination(@next, $current.parent);
zostay/p6-DOM-Tiny …/CSS.pm6 :40:	my multi try-combination('+', $test, @next, $current) {
zostay/p6-DOM-Tiny …/CSS.pm6 :45:	next-combination(@next, $previous-sibling);
zostay/p6-DOM-Tiny …/CSS.pm6 :48:	my multi try-combination('~', $test, @next, $current) {
zostay/p6-DOM-Tiny …/CSS.pm6 :55:	return True if next-combination(@next, $sibling);
zostay/p6-DOM-Tiny …/CSS.pm6 :62:	return False unless $current ~~ @!combine[0];
zostay/p6-DOM-Tiny …/CSS.pm6 :63:	return True if @!combine.elems == 1;
zostay/p6-DOM-Tiny …/CSS.pm6 :64:	next-combination(@!combine[1..*], $current);
zostay/p6-DOM-Tiny …/CSS.pm6 :312:	combine => flat roundrobin(
zostay/p6-DOM-Tiny …/HTML.pm6 :663:	make (~$/).comb(/ <-[ < > = \s / ]>+ /).first(*.chars > 0)
zostay/p6-DOM-Tiny …/052-dom-sibling-combinator.t :7:	# Sibling combinator
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-ArrayHash …/README.md :113:	This provides the usual value lookup by key. You can use this to retrieve a value, assign a value, or bind a value. You may also combine this with the hash adverbs `:delete` and `:exists`.
zostay/perl6-ArrayHash …/README.md :120:	This returns the value lookup by index. You can use this to retrieve the pair at the given index or assign a new pair or even bind a pair. It may be combined with the array adverbs `:delete` and `:exists` as well.
zostay/perl6-ArrayHash …/ArrayHash.pm6 :91:	pick roll reduce combinations
zostay/perl6-ArrayHash …/ArrayHash.pm6 :160:	This provides the usual value lookup by key. You can use this to retrieve a value, assign a value, or bind a value. You may also combine this with the hash adverbs C<:delete> and C<:exists>.
zostay/perl6-ArrayHash …/ArrayHash.pm6 :174:	This returns the value lookup by index. You can use this to retrieve the pair at the given index or assign a new pair or even bind a pair. It may be combined with the array adverbs C<:delete> and C<:exists> as well.
zostay/perl6-IO-Glob …/Glob.pm6 :184:	my @class = $<class>.Str.comb;
CIAvash/App-Football …/COPYING :237:	and which are not combined with it such as to form a larger program,
CIAvash/App-Football …/COPYING :555:	permission to link or combine any covered work with a work licensed
CIAvash/App-Football …/COPYING :557:	combined work, and to convey the resulting work. The terms of this
CIAvash/App-Football …/COPYING :561:	combination as such.
CIAvash/WebService-FootballData …/COPYING :237:	and which are not combined with it such as to form a larger program,
CIAvash/WebService-FootballData …/COPYING :555:	permission to link or combine any covered work with a work licensed
CIAvash/WebService-FootballData …/COPYING :557:	combined work, and to convey the resulting work. The terms of this
CIAvash/WebService-FootballData …/COPYING :561:	combination as such.
CIAvash/WebService-FootballData …/COPYING.LESSER :27:	A "Combined Work" is a work produced by combining or linking an
CIAvash/WebService-FootballData …/COPYING.LESSER :104:	recombine or relink the Application with a modified version of
CIAvash/WebService-FootballData …/COPYING.LESSER :120:	Combined Work produced by recombining or relinking the
CIAvash/WebService-FootballData …/COPYING.LESSER :133:	License, and convey such a combined library under terms of your
CIAvash/WebService-FootballData …/COPYING.LESSER :136:	a) Accompany the combined library with a copy of the same work based
CIAvash/WebService-FootballData …/COPYING.LESSER :137:	on the Library, uncombined with any other library facilities,
CIAvash/WebService-FootballData …/COPYING.LESSER :140:	b) Give prominent notice with the combined library that part of it
CIAvash/WebService-FootballData …/COPYING.LESSER :142:	accompanying uncombined form of the same work.