x-head
=begin rakudoc
duplicated-comp-index => / <head> [ 'X<' .+? '|' .+? '>' [',' \s+ ]? [\s+ 'and' \s+]? ]** 2..* $ /
=head2 X<proceed|Control flow,proceed> and X<succeed|Control flow,succeed>
proceed and succeed
=head2 X<sub USAGE|Tutorial,USAGE> and X<C«$*USAGE»|Tutorial,$*USAGE>
sub USAGE and $*USAGE|Tutorial,$*USAGE
=head2 X<C<hyper>|Syntax,hyper (statement prefix)>, X<C<race>|Syntax,race (statement prefix)>
hyper|Syntax,hyper (statement prefix), race|Syntax,race (statement prefix)
=head1 X<Lexical scope|Tutorial,my (Basics)> and X<block|Tutorial,block (Basics)>
Lexical scope and block
=head2 X<Sigils|Tutorial,sigils (Basics)> and X<identifiers|Tutorial,identifiers (Basics)>
Sigils and identifiers
=head2 X<Filehandle|Tutorial,filehandle (Basics)> and X<assignment|Tutorial,assignment (Basics)>
Filehandle and assignment
=head1 X<Arrays|Tutorial,array (Basics)>, X<methods|Tutorial,method (Basics)> and X<invocants|Tutorial,invocant (Basics)>
Arrays, methods and invocants
=head2 X<C<Any>|Tutorial,Any (Basics)> and X<C<+=>|Tutorial,+= (Basics)>
Any|Tutorial,Any (Basics) and +=|Tutorial,+= (Basics)
=head2 X<Fat arrow|Tutorial,fat arrow (Basics)>, X<pairs|Tutorial,pair (Basics)> and X<autovivification|Tutorial,autovivification (Basics)>
Fat arrow, pairs and autovivification
=head2 X<Postincrement|Tutorial,postincrement (Basics)> and X<preincrement|Tutorial,preincrement (Basics)>
Postincrement and preincrement
=head2 X<Double-quoted strings|Tutorial,double-quoted strings> and X<single-quoted strings|Tutorial,single-quoted strings>
Double-quoted strings and single-quoted strings
comp-index-text => / <head> X [ [ '<' .+? '|' .+? '>' ] | [ '«' .+? '|' .+? '»' ] ] .+ $ /
=head2 X<Mixins|Language,Mixins> of roles
Mixins of roles
=head2 X<<<Hyper operators|Operators,<<;Operators,>>;Operators,«;Operators,»;Operators,»=«;Operators,«=»>>>
<<Hyper operators>;Operators,«;Operators,»;Operators,»=«;Operators,«=»>>>
=head1 X<Alternation: C<||>|Regexes,||>
Alternation: |||Regexes,||
=head2 X<<<Word quoting with interpolation and quote protection: qqww|Syntax,qqww>>>
<<Word quoting with interpolation and quote protection: qqww|Syntax,qqww>>
=head2 X<<<Word quoting with interpolation and quote protection: « »|Syntax,<< >>;Syntax,« »>>>
<<Word quoting with interpolation and quote protection: « »>;Syntax,« »>>>
=head2 X<COMPOSE|Phasers,COMPOSE> (Not yet implemented)
COMPOSE (Not yet implemented)
=head2 X<C<is implementation-detail>|Traits,is implementation-detai> trait
is implementation-detail|Traits,is implementation-detai trait
=head1 X<C<for>|Tutorial,for (Basics)> and blocks
for|Tutorial,for (Basics) and blocks
text-comp-index-text => / <head> .+? X [ '<' .+? '|' .+? '>' ] | [ '«' .+? '|' .+? '»' ] .+ $ /
=head2 prefix X<C«++»|Prefix operators,prefix ++>
prefix ++|Prefix operators,prefix ++
=head2 prefix X<C«--»|Prefix operators,prefix -->
prefix --|Prefix operators,prefix --
=head2 postfix X<C«++»|Postfix operators,postfix ++>
postfix ++|Postfix operators,postfix ++
=head2 postfix X<C«--»|Postfix operators,postfix -->
postfix --|Postfix operators,postfix --
=head2 infix C«(|)», infix C«∪»
infix (|), infix ∪
=head2 infix X<C«and»|Operators,and>
infix and|Operators,and
=head2 infix X<C«andthen»|Operators,andthen>
infix andthen|Operators,andthen
=head2 infix X<C«notandthen»|Infix operators,notandthen>
infix notandthen|Infix operators,notandthen
=head1 The X<C<is> trait|Traits,is (trait)>
The is trait|Traits,is (trait)
=head1 Pragma X<C<v6>|Tutorial,v6 (Basics)>
Pragma v6|Tutorial,v6 (Basics)
=head2 The X<C<also>|Tutorial,also declarator> declarator
The also|Tutorial,also declarator declarator
=head3 trait X<C<handles>|Traits,handles trait>
trait handles|Traits,handles trait
=head3 X<trait C<is>|Traits,is (class)>
trait is|Traits,is (class)
=head2 Embedding CStructs and CUnions with X<C<HAS>|Syntax,HAS>
Embedding CStructs and CUnions with HAS|Syntax,HAS
text-simple-index => / <head> .+? X [ [ '<' .+ '>' ] | [ '«' .+ '»' ] ] $ /
=head3 trait X«C<is rw>|Traits,is rw (class)»
trait is rw|Traits,is rw (class)
simple-index-only => / <head> X [[ '<' .+ '>' ] | [ '«' .+ '»' ]] $ /
=head2 X<Type objects|Language,Type objects>
Type objects
=head1 X<Classes|Syntax,class>
Classes
=head2 X<Attributes|Language,Attribute;Other languages,Property;Other languages,Member;Other languages,Slot>
Attributes
=head2 X<C<self>|Syntax,self>
self|Syntax,self
=head2 X<Private methods|Language,Private methods>
Private methods
=head2 X<Submethods|Language,Submethods>
Submethods
=head2 X<Delegation|Language,delegation (trait handles)>
Delegation
=head2 X<Object construction|Language,new (method)>
Object construction
=head1 X<Roles|Syntax,role>
Roles
=head2 X<Parameterized roles|Language,Parameterized Roles>
Parameterized roles
=head1 X<Named Regexes|Syntax,token>
Named Regexes
=head2 X<Rules|Syntax,rule>
Rules
=head1 X<Creating grammars|Language,Creating grammars>
Creating grammars
=head2 X«Proto regexes|Syntax,:sym<>;Language,proto regex;Syntax,grammar»
Proto regexes|Syntax,:sym<>;Language,proto regex;Syntax,grammar
=head3 X«C<TOP>|Regexes,TOP»
TOP|Regexes,TOP
=head3 X«C<ws>|Regexes,ws»
ws|Regexes,ws
=head3 X«C<sym>|Regexes,<sym>»
sym|Regexes,<sym>
=head3 X«"Always succeed" assertion|Regexes,<?>»
"Always succeed" assertion|Regexes,<?>
=head1 X<Action objects|Regexes,Actions>
Action objects
=head1 X<Running programs|Reference,Running programs>
Running programs
=head2 X<v6.x|Pragmas,v6.x>
v6.x
=head2 X<MONKEY-GUTS|Pragmas,MONKEY-GUTS>
MONKEY-GUTS
=head2 X<MONKEY-SEE-NO-EVAL|Pragmas,MONKEY-SEE-NO-EVAL>
MONKEY-SEE-NO-EVAL
=head2 X<MONKEY-TYPING|Pragmas,MONKEY-TYPING>
MONKEY-TYPING
=head2 X<MONKEY|Pragmas,MONKEY>
MONKEY
=head2 X<dynamic-scope|Pragmas,dynamic-scope>
dynamic-scope
=head2 X<experimental|Pragmas,experimental>
experimental
=head2 X<fatal|Pragmas,fatal>
fatal
=head2 X<isms|Pragmas,isms>
isms
=head2 X<lib|Pragmas,lib>
lib
=head2 X<newline|Pragmas,newline>
newline
=head2 X<nqp|Pragmas,nqp>
nqp
=head2 X<precompilation|Pragmas,precompilation>
precompilation
=head2 X<soft|Pragmas,soft>
soft
=head2 X<strict|Pragmas,strict>
strict
=head2 X<trace|Pragmas,trace>
trace
=head2 X<v6|Pragmas,v6>
v6
=head2 X<variables|Pragmas,variables>
variables
=head2 X<worries|Pragmas,worries>
worries
=head2 X<Negated relational operators|Metaoperators,! (negation metaoperator)>
Negated relational operators
=head2 X<Reversed operators|Metaoperators,R;Metaoperators,reverse metaoperator>
Reversed operators
=head2 X<Cross metaoperators|Metaoperators,X (cross metaoperator)>
Cross metaoperators
=head2 X<Zip metaoperator|Metaoperators,Z (zip metaoperator)>
Zip metaoperator
=head2 X<Sequential operators|Metaoperators,S;Metaoperators,sequential metaoperator>
Sequential operators
=head1 X<Abstract class|Reference,Abstract Class>
Abstract class
=head1 X<Advent calendar|Reference,Advent Calendar>
Advent calendar
=head1 X<Adverb|Language,Adverb>
Adverb
=head1 X<Adverbial pair|Language,Adverbial Pair>
Adverbial pair
=head1 X<Allomorph|Language,Allomorph>
Allomorph
=head1 X<Anonymous|Reference,Anonymous>
Anonymous
=head1 X<API|Reference,API>
API
=head1 X<Apocalypse|Reference,Apocalypse>
Apocalypse
=head1 X<Arity|Reference,Arity>
Arity
=head1 X<ASCII operator|Language,ASCII operator;Language,Texas operator>
ASCII operator
=head1 X<Autothreading|Language,Autothreading>
Autothreading
=head1 X<Backtracking|Reference,Backtracking>
Backtracking
=head1 X<binder|Reference,binder>
binder
=head1 X<block|Reference,block>
block
=head1 X<bytecode|Reference,bytecode>
bytecode
=head1 X<Camelia|Reference,Camelia>
Camelia
=head1 X<Colon pair and colon list|Reference,Colon Pair;Reference,Colon List>
Colon pair and colon list
=head1 X<Community|Reference,Community>
Community
=head1 X<Damian Conway|Reference,Damian Conway>
Damian Conway
=head1 X<decont|Reference,decont>
decont
=head1 X<diffy|Reference,diffy>
diffy
=head1 X<Exegesis|Reference,Exegesis>
Exegesis
=head1 X<fiddly|Reference,fiddly>
fiddly
=head1 X<Handle|Reference,Handle>
Handle
=head1 X<Huffmanize|Reference,Huffmanize>
Huffmanize
=head1 X<iffy|Reference,iffy>
iffy
=head1 X<import|Reference,import>
import
=head1 X<infix stopper|Reference,infix>
infix stopper
=head1 X<Instance|Reference,instance>
Instance
=head1 X<Interface|Reference,Interface>
Interface
=head1 X<Invocant|Reference,Invocant>
Invocant
=head1 X<IRC|Reference,IRC>
IRC
=head1 X<IRC lingo|Reference,IRC lingo>
IRC lingo
=head2 X<ALAP|Reference,ALAP>
ALAP
=head2 X<autopun|Reference,autopun>
autopun
=head2 X<backlog|Reference,backlog>
backlog
=head2 X<Bot|Reference,Bot>
Bot
=head2 X<Compilation unit or I<compunit>|Reference,compunit (glossary);Reference,compilation unit>
Compilation unit or compunit|Reference,compunit (glossary);Reference,compilation unit
=head2 X<DWIM|Reference,DWIM>
DWIM
=head2 X<flap|Reference,flap>
flap
=head2 X<fossil|Reference,fossil>
fossil
=head2 X<FSVO|Reference,FSVO>
FSVO
=head2 X<FTFY|Reference,FTFY>
FTFY
=head2 X<gradual typing|Reference,gradual typing>
gradual typing
=head2 X<IIRC|Reference,IIRC>
IIRC
=head2 X<IMHO|Reference,IMHO>
IMHO
=head2 X<IWBN|Reference,IWBN>
IWBN
=head2 X<LHF|Reference,LHF>
LHF
=head2 X<LGTM|Reference,LGTM>
LGTM
=head2 X<LTA|Reference,LTA>
LTA
=head2 X<NST|Reference,NST>
NST
=head2 X<Opt|Reference,Opt>
Opt
=head2 X<PB|Reference,PB>
PB
=head2 X<PR|Reference,PR>
PR
=head2 X<P5|Reference,P5>
P5
=head2 X<P6|Reference,P6>
P6
=head2 X<RSN|Reference,RSN>
RSN
=head2 X<RT|Reference,RT>
RT
=head2 X<TIMTOWTDI|Reference,TIMTOWTDI>
TIMTOWTDI
=head2 X<TMI|Reference,TMI>
TMI
=head2 X<TMTOWTDI|Reference,TMTOWTDI>
TMTOWTDI
=head2 X<UGT|Reference,UGT>
UGT
=head2 X<WFM|Reference,WFM>
WFM
=head2 X<WIP|Reference,WIP>
WIP
=head2 X<WP|Reference,WP>
WP
=head2 X<WW|Reference,WW>
WW
=head1 X<Larry Wall|Reference,Larry Wall>
Larry Wall
=head1 X<Lexing|Reference,Lexing>
Lexing
=head1 X<Literal|Reference,Literal>
Literal
=head1 X<LHS|Reference,LHS>
LHS
=head1 X<lvalue|Reference,lvalue>
lvalue
=head1 X<Mainline|Reference,Mainline>
Mainline
=head1 X<Mayspec|Reference,Mayspec>
Mayspec
=head1 X<MoarVM|Reference,MoarVM>
MoarVM
=head1 X<Multi-dispatch|Reference,Multi-Dispatch;Reference,MMD>
Multi-dispatch
=head1 X<multi-method|Reference,multi-method>
multi-method
=head1 X<Née|Reference,Née>
Née
=head1 X<NFG|Reference,NFG>
NFG
=head1 X<Niecza|Reference,Niecza>
Niecza
=head1 X<Not Quite Perl|Reference,NQP>
Not Quite Perl
=head1 X<NQP|Reference,Not Quite Perl>
NQP
=head1 X<NYI|Reference,NYI>
NYI
=head1 X<opcode|Reference,opcode>
opcode
=head1 X<Operator|Reference,Operator>
Operator
=head1 X<Parse tree|Reference,Parse Tree>
Parse tree
=head1 X<Parameter|Reference,Parameter>
Parameter
=head1 X<Parrot|Reference,Parrot>
Parrot
=head1 X<PAST|Reference,PAST>
PAST
=head1 X<Perl|Reference,Perl>
Perl
=head1 X<Perl 6|Reference,Perl 6>
Perl 6
=head1 X<PERL|Reference,PERL>
PERL
=head1 X<POD|Reference,POD>
POD
=head1 X<POV|Reference,POV>
POV
=head1 X<Propspec|Reference,Propspec>
Propspec
=head1 X<Pull request|Reference,Pull request>
Pull request
=head1 X<priming|Reference,priming>
priming
=head1 X<property|Reference,property>
property
=head1 X<pugs|Reference,pugs>
pugs
=head1 X<QAST|Reference,QAST>
QAST
=head1 X<Rakudo|Reference,Rakudo>
Rakudo
=head1 X<Reify|Reference,Reify>
Reify
=head1 X<Repository|Reference,Repository>
Repository
=head1 X<RHS|Reference,RHS>
RHS
=head1 X<roast|Reference,roast>
roast
=head1 X<Roles|Reference,role>
Roles
=head1 X<rvalue|Reference,rvalue>
rvalue
=head1 X<SAP|Reference,SAP>
SAP
=head1 X<Semilist|Reference,Semilist>
Semilist
=head1 X<Sigil|Reference,Sigil>
Sigil
=head1 X<Sigilless variable|Reference,Sigilless Variable>
Sigilless variable
=head1 X<Spesh|Reference,Spesh>
Spesh
=head1 X<STD|Reference,STD>
STD
=head1 X<Stub|Reference,Stub>
Stub
=head1 X<Symbol|Reference,Symbol>
Symbol
=head1 X<Synopsis|Reference,Synopsis>
Synopsis
=head1 X<Syntax analysis|Reference,Syntax Analysis>
Syntax analysis
=head1 X<Test suite|Reference,test suite>
Test suite
=head1 X<TheDamian|Reference,TheDamian>
TheDamian
=head1 X<TimToady|Reference,TimToady>
TimToady
=head1 X<token|Reference,Token>
token
=head1 X<Thunk|Reference,Thunk>
Thunk
=head1 X<Tight and loose precedence|Reference,Tight;Reference,Loose>
Tight and loose precedence
=head1 X<Truthy and Falsy|Reference,Truthy;Reference,Falsy>
Truthy and Falsy
=head1 X<twine|Reference,twine>
twine
=head1 X<Type objects|Reference,Type Objects>
Type objects
=head1 X<Type smiley|Reference,Type Smiley>
Type smiley
=head1 X<value|Reference,value>
value
=head1 X<UB|Reference,UB>
UB
=head1 X<Value type|Reference,Value type>
Value type
=head1 X<Variable|Reference,Variable>
Variable
=head1 X<Variable interpolation|Reference,Variable Interpolation>
Variable interpolation
=head1 X<Virtual machine|Reference,Virtual Machine>
Virtual machine
=head2 X<WAT|Reference,WAT>
WAT
=head1 X<whitespace|Reference,whitespace>
whitespace
=head1 X<6model|Reference,6model>
6model
=head1 X<Sink|Language,sink context>
Sink
=head1 X<Number|Language,number context>
Number
=head1 X<String|Language,string context>
String
=head1 X<Boolean|Language,Boolean context>
Boolean
=head1 X<List|Language,list context>
List
=head1 X<Twigils|Syntax,Twigil>
Twigils
=head4 X«Positional attributes|Variables,$0;Variables,$1»
Positional attributes
=head4 X«Named attributes|Variables,$<named>»
Named attributes|Variables,$<named>
=head3 X<C<%?RESOURCES>|Variables,%?RESOURCES>
%?RESOURCES|Variables,%?RESOURCES
=head3 X<&?ROUTINE|Variables,&?ROUTINE>
&?ROUTINE
=head3 X<&?BLOCK|Variables,&?BLOCK>
&?BLOCK
=head3 X<$?DISTRIBUTION|Variables,$?DISTRIBUTION>
$?DISTRIBUTION
=head2 X<Subroutines|Syntax,sub>
Subroutines
=head2 X«Blocks and lambdas|Syntax,->»
Blocks and lambdas|Syntax,->
=head3 X<Automatic signatures|Variables,@_;Variables,%_>
Automatic signatures
=head2 X<Arguments|Language,Argument>
Arguments
=head2 X<Multi-dispatch|Syntax,multi>
Multi-dispatch
=head3 X<proto|Syntax,proto>
proto
=head3 X<only|Syntax,only>
only
=head2 X<Closures|Language,closures>
Closures
=head2 X<Precedence|Traits,is tighter;Traits,is equiv;Traits,is looser>
Precedence
=head2 X<sub callsame|Subroutines,callsame>
sub callsame
=head2 X<sub callwith|Subroutines,callwith>
sub callwith
=head2 X<sub nextsame|Subroutines,nextsame>
sub nextsame
=head2 X<sub nextwith|Subroutines,nextwith>
sub nextwith
=head2 X<sub samewith|Subroutines,samewith>
sub samewith
=head2 X<sub nextcallee|Subroutines,nextcallee>
sub nextcallee
=head2 X<Wrapped routines|Language,wrapped routines>
Wrapped routines
=head2 X<Working with modules|Language,import>
Working with modules
=head1 X<Lexical conventions|Syntax,/ /;Syntax,rx;Syntax,m>
Lexical conventions
=head1 X<Wildcards|Regexes,.>
Wildcards
=head3 X<C<\n> and C<\N>|Regexes,\n;Regexes,\N>
\n and \N|Regexes,\n;Regexes,\N
=head3 X<C<\t> and C<\T>|Regexes,\t;Regexes,\T>
\t and \T|Regexes,\t;Regexes,\T
=head3 X<C<\h> and C<\H>|Regexes,\h;Regexes,\H>
\h and \H|Regexes,\h;Regexes,\H
=head3 X<C<\v> and C<\V>|Regexes,\v;Regexes,\V>
\v and \V|Regexes,\v;Regexes,\V
=head3 X<C<\s> and C<\S>|Regexes,\s;Regexes,\S>
\s and \S|Regexes,\s;Regexes,\S
=head3 X<C<\d> and C<\D>|Regexes,\d;Regexes,\D>
\d and \D|Regexes,\d;Regexes,\D
=head3 X<C<\w> and C<\W>|Regexes,\w;Regexes,\W>
\w and \W|Regexes,\w;Regexes,\W
=head3 X<C<\c> and C<\C>|Regexes,\c;Regexes,\C>
\c and \C|Regexes,\c;Regexes,\C
=head3 X<C<\x> and C<\X>|Regexes,\x;Regexes,\X>
\x and \X|Regexes,\x;Regexes,\X
=head2 X«Unicode properties|Regexes,<:property>»
Unicode properties|Regexes,<:property>
=head2 X«Enumerated character classes and ranges|Regexes,<[ ]>;Regexes,<-[ ]>»
Enumerated character classes and ranges|Regexes,<[ ]>;Regexes,<-[ ]>
=head2 X<One or more: C<+>|Regexes,+>
One or more: +|Regexes,+
=head2 X<Zero or more: C<*>|Regexes,*>
Zero or more: *|Regexes,*
=head2 X<Zero or one: C<?>|Regexes,? (quantifier)>
Zero or one: ?|Regexes,? (quantifier)
=head2 X<General quantifier: C<** min..max>|Regexes,**>
General quantifier: ** min..max|Regexes,**
=head2 X<Modified quantifier: C<%>, C<%%>|Regexes,%;Regexes,%%>
Modified quantifier: %, %%|Regexes,%;Regexes,%%
=head2 X<Greedy versus frugal quantifiers: C<?>|Regexes,?>
Greedy versus frugal quantifiers: ?|Regexes,?
=head1 X<Longest alternation: C<|>|Regexes,|>
Longest alternation: ||Regexes,|
=head1 X<Conjunction: C<&&>|Regexes,&&>
Conjunction: &&|Regexes,&&
=head1 X<Conjunction: C<&>|Regexes,&>
Conjunction: &|Regexes,&
=head2 X<Start of string and end of string|Regexes,^;Regexes,$>
Start of string and end of string
=head2 X<Start of line and end of line|Regexes,^^;Regexes,$$>
Start of line and end of line
=head2 X«Word boundary|Regexes,<?wb>;Regexes,<!wb>»
Word boundary|Regexes,<?wb>;Regexes,<!wb>
=head2 X«Lookaround assertions|Regexes,positive lookaround assertion <?>;Regexes,negative lookaround assertion <!>;Regexes,?[ »
Lookaround assertions|Regexes,positive lookaround assertion <?>;Regexes,negative lookaround assertion <!>;Regexes,?[
=head2 X«Lookahead assertions|Regexes,before;Regexes,<?before>»
Lookahead assertions|Regexes,before;Regexes,<?before>
=head2 X«Lookbehind assertions|Regexes,after;Regexes,<?after>»
Lookbehind assertions|Regexes,after;Regexes,<?after>
=head2 X«Capturing|Regexes,( )»
Capturing
=head2 X«Non-capturing grouping|Regexes,[ ]»
Non-capturing grouping
=head2 X<Named captures|Regexes,Named captures>
Named captures
=head2 X«Capture markers: C«<( )>»|Regexes,<( )>»
Capture markers: C«<( )>|Regexes,<( )>»
=head2 X<Lexical conventions|Syntax,s/ / />
Lexical conventions
=head2 X«C<S///> non-destructive substitution|Regexes,S/// non-destructive substitution»
S/// non-destructive substitution|Regexes,S/// non-destructive substitution
=head1 X<Tilde for nesting structures|Regexes,tilde;Regexes,~>
Tilde for nesting structures
=head1 X«Recursive Regexes|Regexes,recursive;Regexes,tilde tilde;Regexes,~~;Regexes,<~~>»
Recursive Regexes|Regexes,recursive;Regexes,tilde tilde;Regexes,~~;Regexes,<~~>
=head1 X<Subrules|Syntax,regex>
Subrules
=head1 X<Regex interpolation|Regexes,Regex Interpolation>
Regex interpolation
=head2 X<Regex adverbs|Regexes,Regex adverbs>
Regex adverbs
=head3 X<Ignorecase|Adverbs,:ignorecase;Adverbs,:i>
Ignorecase
=head3 X<Ignoremark|Adverbs,:ignoremark;Adverbs,:m>
Ignoremark
=head3 X<Ratchet|Adverbs,:ratchet;Adverbs,:r>
Ratchet
=head3 X<Sigspace|Adverbs,:sigspace;Adverbs,:s>
Sigspace
=head3 X<Positional adverbs|Adverbs,:1st;Adverbs,:2nd;Adverbs,:3rd;Adverbs,:nth>
Positional adverbs
=head3 X<Counting|Adverbs,:x>
Counting
=head3 X<Continue|Adverbs,:continue;Adverbs,:c>
Continue
=head3 X<Exhaustive|Adverbs,:exhaustive;Adverbs,:ex>
Exhaustive
=head3 X<Global|Adverbs,:global;Adverbs,:g>
Global
=head3 X<Pos|Adverbs,:pos;Adverbs,:p>
Pos
=head3 X<Overlap|Adverbs,:overlap;Adverbs,:ov>
Overlap
=head3 X<Samecase|Adverbs,:samecase;Adverbs,:ii>
Samecase
=head3 X<Samemark|Adverbs,:samemark;Adverbs,:mm>
Samemark
=head3 X<Samespace|Adverbs,:samespace;Adverbs,:ss>
Samespace
=head3 X<Disable backtracking: C<:>|Regexes,:;Regexes,disable backtracking>
Disable backtracking: :|Regexes,:;Regexes,disable backtracking
=head3 X<Enable greedy backtracking: C<:!>|Regexes,:!;Regexes,greedy backtracking>
Enable greedy backtracking: :!|Regexes,:!;Regexes,greedy backtracking
=head3 X<Enable frugal backtracking: C<:?>|Regexes,:?;Regexes,frugal backtracking>
Enable frugal backtracking: :?|Regexes,:?;Regexes,frugal backtracking
=head1 X<Statements|Control flow,statements>
Statements
=head1 X<Blocks|Control flow,blocks>
Blocks
=head1 X<Phasers|Control flow,Phasers>
Phasers
=head1 X<do|Control flow,do>
do
=head1 X<start|Control flow,start>
start
=head1 X<if|Control flow,if>
if
=head2 X<C<else/elsif>|Control flow,else elsif>
else/elsif|Control flow,else elsif
=head1 X<C<unless>|Control flow,unless>
unless|Control flow,unless
=head1 X<C<with orwith without>|Control flow,with orwith without>
with orwith without|Control flow,with orwith without
=head1 X<when|Control flow,when>
when
=head1 X<for|Control flow,for>
for
=head1 X<gather/take|Control flow,gather take>
gather/take
=head1 X<supply/emit|Control flow,supply emit>
supply/emit
=head1 X<given|Control flow,given>
given
=head2 X<default and when|Control flow,default when>
default and when
=head2 X<given as a statement|Control flow,given statement>
given as a statement
=head1 X<loop|Control flow,loop>
loop
=head1 X<while, until|Control flow,while until>
while, until
=head1 X<repeat/while, repeat/until|Control flow,repeat>
repeat/while, repeat/until
=head1 X<return|Control flow,return>
return
=head1 X<return-rw|Control flow,return-rw>
return-rw
=head1 X<fail|Control flow,fail>
fail
=head1 X<once|Control flow,once>
once
=head1 X<next|Control flow,next>
next
=head1 X<last|Control flow,last>
last
=head1 X<redo|Control flow,redo>
redo
=head2 X<Literal strings: Q|Syntax,Q;Syntax,｢ ｣>
Literal strings: Q
=head2 X<Escaping: q|Syntax,q;Syntax,' '>
Escaping: q
=head2 X<Interpolation: qq|Syntax,qq;Syntax," ">
Interpolation: qq
=head2 X<Word quoting with quote protection: qww|Syntax,qww>
Word quoting with quote protection: qww
=head2 X<Word quoting with interpolation: qqw|Syntax,qqw>
Word quoting with interpolation: qqw
=head2 X<Shell quoting: qx|Syntax,qx>
Shell quoting: qx
=head2 X<Shell quoting with interpolation: qqx|Syntax,qqx>
Shell quoting with interpolation: qqx
=head2 X<Heredocs: :to|Syntax,heredocs :to>
Heredocs: :to
=head2 X<Unquoting|Language,Unquoting>
Unquoting
=head2 X<C<%*SUB-MAIN-OPTS>|Variables,%*SUB-MAIN-OPTS>
%*SUB-MAIN-OPTS|Variables,%*SUB-MAIN-OPTS
=head3 X<C<named-anywhere>|Reference,named-anywhere>
named-anywhere|Reference,named-anywhere
=head3 X<C<bundling>|Programs,command-line argument bundling>
bundling|Programs,command-line argument bundling
=head3 X<C<coerce-allomorphs-to>|Programs,command-line argument coercion>
coerce-allomorphs-to|Programs,command-line argument coercion
=head3 X<C<allow-no>|Programs,allow no- to negate>
allow-no|Programs,allow no- to negate
=head3 X<C<numeric-suffix-as-value>|Programs,simpler way for numeric values>
numeric-suffix-as-value|Programs,simpler way for numeric values
=head2 X<C<is hidden-from-USAGE>|Reference,hidden-from-USAGE>
is hidden-from-USAGE|Reference,hidden-from-USAGE
=head1 X<Unit-scoped definition of C<MAIN>|Reference,unit (MAIN)>
Unit-scoped definition of MAIN|Reference,unit (MAIN)
=head2 X<sub ARGS-TO-CAPTURE|Subroutines,ARGS-TO-CAPTURE>
sub ARGS-TO-CAPTURE
=head2 X<sub RUN-MAIN|Subroutines,RUN-MAIN>
sub RUN-MAIN
=head2 X<sub GENERATE-USAGE|Subroutines,GENERATE-USAGE>
sub GENERATE-USAGE
=head1 X<Loading and basic importing|Language,compunit>
Loading and basic importing
=head2 X<C<need>|Syntax,need>
need|Syntax,need
=head2 X<C<use>|Syntax,use>
use|Syntax,use
=head2 X<C<require>|Syntax,require>
require|Syntax,require
=head3 X<EXPORT|Subroutines,sub EXPORT>
EXPORT
=head3 X<C<whenever>|Control flow,whenever>
whenever|Control flow,whenever
=head3 X<C<react>|Control flow,react>
react|Control flow,react
=head2 X<UTF8-C8|Reference,UTF8-C8>
UTF8-C8
=head2 X<WHAT|Syntax,WHAT>
WHAT
=head2 X<WHICH|Syntax,WHICH>
WHICH
=head2 X<WHO|Syntax,WHO>
WHO
=head2 X<WHERE|Syntax,WHERE>
WHERE
=head2 X<HOW|Syntax,HOW>
HOW
=head2 X<WHY|Syntax,WHY>
WHY
=head2 X<DEFINITE|Syntax,DEFINITE>
DEFINITE
=head2 X<VAR|Syntax,VAR>
VAR
=head2 X<BEGIN|Phasers,BEGIN>
BEGIN
=head2 X<CHECK|Phasers,CHECK>
CHECK
=head2 X<INIT|Phasers,INIT>
INIT
=head2 X<END|Phasers,END>
END
=head2 X<ENTER|Phasers,ENTER>
ENTER
=head2 X<LEAVE|Phasers,LEAVE>
LEAVE
=head2 X<KEEP|Phasers,KEEP>
KEEP
=head2 X<UNDO|Phasers,UNDO>
UNDO
=head2 X<PRE|Phasers,PRE>
PRE
=head2 X<POST|Phasers,POST>
POST
=head2 X<FIRST|Phasers,FIRST>
FIRST
=head2 X<NEXT|Phasers,NEXT>
NEXT
=head2 X<LAST|Phasers,LAST>
LAST
=head2 X<CATCH|Phasers,CATCH>
CATCH
=head2 X<CONTROL|Phasers,CONTROL>
CONTROL
=head2 X<LAST|Asynchronous phasers,LAST>
LAST
=head2 X<QUIT|Asynchronous phasers,QUIT>
QUIT
=head2 X<CLOSE|Asynchronous phasers,CLOSE>
CLOSE
=head2 X<DOC|Asynchronous phasers,DOC>
DOC
=head2 X<Unspace|Syntax,\>
Unspace
=head2 X<Identifiers|Language,identifiers>
Identifiers
=head3 X<Number literals|Syntax,Number literals>
Number literals
=head3 X<Pair literals|Syntax,Pair literals>
Pair literals
=head3 X<C<package>, C<module>, C<class>, C<role>, and C<grammar> declaration|Syntax,unit;Syntax,module;Syntax,package>
package, module, class, role, and grammar declaration|Syntax,unit;Syntax,module;Syntax,package
=head2 X<C<lazy>|Syntax,lazy (statement prefix)>
lazy|Syntax,lazy (statement prefix)
=head2 X<C<eager>|Syntax,eager (statement prefix)>
eager|Syntax,eager (statement prefix)
=head2 X<C<quietly>|Syntax,quietly (statement prefix)>
quietly|Syntax,quietly (statement prefix)
=head2 X<C<try>|Syntax,try (statement prefix)>
try|Syntax,try (statement prefix)
=head2 X<C<do>|Syntax,do (statement prefix)>
do|Syntax,do (statement prefix)
=head2 X<C<sink>|Syntax,sink (statement prefix)>
sink|Syntax,sink (statement prefix)
=head2 X<C<react>|Syntax,react (statement prefix)>
react|Syntax,react (statement prefix)
=head1 X<Catching exceptions|Language,CATCH>
Catching exceptions
=head1 X<C<try> blocks|Language,try blocks>
try blocks|Language,try blocks
=head2 X<Single Argument Rule|Language,Single Argument Rule>
Single Argument Rule
=head1 X<Lazy lists|Language,laziness in Iterable objects>
Lazy lists
=head2 X<Typing|Language,typed array;Syntax,[ ] (typed array)>
Typing
=head2 X<Fixed size arrays|Language,Shaped arrays>
Fixed size arrays
=head2 X<Coercion type|Language,Coercion type>
Coercion type
=head2 X<Unflattened slurpy|Syntax,**@>
Unflattened slurpy
=head1 X<Long names|Language,Long names>
Long names
=head1 X<Capture parameters|Syntax,|>
Capture parameters
=head2 X<Filetests|Other languages,filetests - perlfunc>
Filetests
=head2 X<abs|Other languages,abs - perlfunc>
abs
=head2 X<accept|Other languages,accept - perlfunc>
accept
=head2 X<alarm|Other languages,alarm - perlfunc>
alarm
=head2 X<atan2|Other languages,atan2 - perlfunc>
atan2
=head2 X<bind|Other languages,bind - perlfunc>
bind
=head2 X<binmode|Other languages,binmode - perlfunc>
binmode
=head2 X<bless|Other languages,bless - perlfunc>
bless
=head2 X<break|Other languages,break - perlfunc>
break
=head2 X<caller|Other languages,caller - perlfunc>
caller
=head2 X<chdir|Other languages,chdir - perlfunc>
chdir
=head2 X<chmod|Other languages,chmod - perlfunc>
chmod
=head2 X<chomp|Other languages,chomp - perlfunc>
chomp
=head2 X<chop|Other languages,chop - perlfunc>
chop
=head2 X<chr|Other languages,chr - perlfunc>
chr
=head2 X<chroot|Other languages,chroot - perlfunc>
chroot
=head2 X<close|Other languages,close - perlfunc>
close
=head2 X<closedir|Other languages,closedir - perlfunc>
closedir
=head2 X<connect|Other languages,connect - perlfunc>
connect
=head2 X<continue|Other languages,continue - perlfunc>
continue
=head2 X<cos|Other languages,cos - perlfunc>
cos
=head2 X<crypt|Other languages,crypt - perlfunc>
crypt
=head2 X<dbm functions|Other languages,dbm - perlfunc>
dbm functions
=head2 X<defined|Other languages,defined - perlfunc>
defined
=head2 X<delete|Other languages,delete - perlfunc>
delete
=head2 X<die|Other languages,die - perlfunc>
die
=head2 X<do|Other languages,do - perlfunc>
do
=head2 X<dump|Other languages,dump - perlfunc>
dump
=head2 X<each|Other languages,each - perlfunc>
each
=head2 X<eof|Other languages,eof - perlfunc>
eof
=head2 X<eval|Other languages,eval - perlfunc>
eval
=head2 X<evalbytes|Other languages,evalbytes - perlfunc>
evalbytes
=head2 X<exec|Other languages,exec - perlfunc>
exec
=head2 X<exists|Other languages,exists - perlfunc>
exists
=head2 X<exit|Other languages,exit - perlfunc>
exit
=head2 X<exp|Other languages,exp - perlfunc>
exp
=head2 X<fc|Other languages,fc - perlfunc>
fc
=head2 X<fcntl|Other languages,fcntl - perlfunc>
fcntl
=head2 X<__FILE__|Other languages,__FILE__ - perlfunc>
__FILE__
=head2 X<fileno|Other languages,fileno - perlfunc>
fileno
=head2 X<flock|Other languages,flock - perlfunc>
flock
=head2 X<fork|Other languages,fork - perlfunc>
fork
=head2 X<formats|Other languages,formats - perlfunc>
formats
=head2 X<getc|Other languages,getc - perlfunc>
getc
=head2 X<getpeername|Other languages,getpeername - perlfunc>
getpeername
=head2 X<getpgrp|Other languages,getpgrp - perlfunc>
getpgrp
=head2 X<getppid|Other languages,getppid - perlfunc>
getppid
=head2 X<getpriority|Other languages,getpriority - perlfunc>
getpriority
=head2 X<get and set functions|Other languages,get and set - perlfunc>
get and set functions
=head2 X<getsock*|Other languages,getsock - perlfunc>
getsock*
=head2 X<glob|Other languages,glob - perlfunc>
glob
=head2 X<gmtime|Other languages,gmtime - perlfunc>
gmtime
=head2 X<goto|Other languages,goto - perlfunc>
goto
=head2 X<grep|Other languages,grep - perlfunc>
grep
=head2 X<hex|Other languages,hex - perlfunc>
hex
=head2 X<import|Other languages,import - perlfunc>
import
=head2 X<index|Other languages,index - perlfunc>
index
=head2 X<int|Other languages,int - perlfunc>
int
=head2 X<ioctl|Other languages,ioctl - perlfunc>
ioctl
=head2 X<join|Other languages,join - perlfunc>
join
=head2 X<keys|Other languages,keys - perlfunc>
keys
=head2 X<kill|Other languages,kill - perlfunc>
kill
=head2 X<last|Other languages,last - perlfunc>
last
=head2 X<lc|Other languages,lc - perlfunc>
lc
=head2 X<lcfirst|Other languages,lcfirst - perlfunc>
lcfirst
=head2 X<length|Other languages,length - perlfunc>
length
=head2 X<__LINE__|Other languages,__LINE__ - perlfunc>
__LINE__
=head2 X<link|Other languages,link - perlfunc>
link
=head2 X<listen|Other languages,listen - perlfunc>
listen
=head2 X<local|Other languages,local - perlfunc>
local
=head2 X<localtime|Other languages,localtime - perlfunc>
localtime
=head2 X<lock|Other languages,lock - perlfunc>
lock
=head2 X<log|Other languages,log - perlfunc>
log
=head2 X<lstat|Other languages,lstat - perlfunc>
lstat
=head2 X<m//|Other languages,m// - perlfunc>
m//
=head2 X<map|Other languages,map - perlfunc>
map
=head2 X<mkdir|Other languages,mkdir - perlfunc>
mkdir
=head2 X<msg*|Other languages,msg* - perlfunc>
msg*
=head2 X<my|Other languages,my - perlfunc>
my
=head2 X<next|Other languages,next - perlfunc>
next
=head2 X<no|Other languages,no - perlfunc>
no
=head2 X<oct|Other languages,oct - perlfunc>
oct
=head2 X<open|Other languages,open - perlfunc>
open
=head2 X<opendir|Other languages,opendir - perlfunc>
opendir
=head2 X<ord|Other languages,ord - perlfunc>
ord
=head2 X<our|Other languages,our - perlfunc>
our
=head2 X<pack|Other languages,pack - perlfunc>
pack
=head2 X<package|Other languages,package - perlfunc>
package
=head2 X<__PACKAGE__|Other languages,__PACKAGE__ - perlfunc>
__PACKAGE__
=head2 X<pipe|Other languages,pipe - perlfunc>
pipe
=head2 X<pop|Other languages,pop - perlfunc>
pop
=head2 X<pos|Other languages,pos - perlfunc>
pos
=head2 X<print|Other languages,print - perlfunc>
=head2 X<printf|Other languages,printf - perlfunc>
printf
=head2 X<prototype|Other languages,prototype - perlfunc>
prototype
=head2 X<push|Other languages,push - perlfunc>
push
=head2 X<quoting|Other languages,quoting - perlfunc>
quoting
=head2 X<rand|Other languages,rand - perlfunc>
rand
=head2 X<read|Other languages,read - perlfunc>
read
=head2 X<readdir|Other languages,readdir - perlfunc>
readdir
=head2 X<readline|Other languages,readline - perlfunc>
readline
=head2 X<readlink|Other languages,readlink - perlfunc>
readlink
=head2 X<readpipe|Other languages,readpipe - perlfunc>
readpipe
=head2 X<recv|Other languages,recv - perlfunc>
recv
=head2 X<redo|Other languages,redo - perlfunc>
redo
=head2 X<ref|Other languages,ref - perlfunc>
ref
=head2 X<rename|Other languages,rename - perlfunc>
rename
=head2 X<requires|Other languages,requires - perlfunc>
requires
=head2 X<reset|Other languages,reset - perlfunc>
reset
=head2 X<return|Other languages,return - perlfunc>
return
=head2 X<reverse|Other languages,reverse - perlfunc>
reverse
=head2 X<rewinddir|Other languages,rewinddir - perlfunc>
rewinddir
=head2 X<rindex|Other languages,rindex - perlfunc>
rindex
=head2 X<rmdir|Other languages,rmdir - perlfunc>
rmdir
=head2 X<s///|Other languages,s/// - perlfunc>
s///
=head2 X<say|Other languages,say - perlfunc>
say
=head2 X<scalar|Other languages,scalar - perlfunc>
scalar
=head2 X<seek|Other languages,seek - perlfunc>
seek
=head2 X<seekdir|Other languages,seekdir - perlfunc>
seekdir
=head2 X<select|Other languages,select - perlfunc>
select
=head2 X<semget|Other languages,semget - perlfunc>
semget
=head2 X<semop|Other languages,semop - perlfunc>
semop
=head2 X<send|Other languages,send - perlfunc>
send
=head2 X<setpgrp|Other languages,setpgrp - perlfunc>
setpgrp
=head2 X<setpriority|Other languages,setpriority - perlfunc>
setpriority
=head2 X<setsockopt|Other languages,setsockopt - perlfunc>
setsockopt
=head2 X<shift|Other languages,shift - perlfunc>
shift
=head2 X<shm*|Other languages,shm* - perlfunc>
shm*
=head2 X<shutdown|Other languages,shutdown - perlfunc>
shutdown
=head2 X<sin|Other languages,sin - perlfunc>
sin
=head2 X<sleep|Other languages,sleep - perlfunc>
sleep
=head2 X<sockets|Other languages,sockets - perlfunc>
sockets
=head2 X<sort|Other languages,sort - perlfunc>
sort
=head2 X<splice|Other languages,splice - perlfunc>
splice
=head2 X<split|Other languages,split - perlfunc>
split
=head2 X<sprintf|Other languages,sprintf - perlfunc>
sprintf
=head2 X<sqrt|Other languages,sqrt - perlfunc>
sqrt
=head2 X<srand|Other languages,srand - perlfunc>
srand
=head2 X<state|Other languages,state - perlfunc>
state
=head2 X<study|Other languages,study - perlfunc>
study
=head2 X<sub|Other languages,sub - perlfunc>
sub
=head2 X<__SUB__|Other languages,__SUB__ - perlfunc>
__SUB__
=head2 X<substr|Other languages,substr - perlfunc>
substr
=head2 X<symlink|Other languages,symlink - perlfunc>
symlink
=head2 X<syscall|Other languages,syscall - perlfunc>
syscall
=head2 X<sys*|Other languages,sys* - perlfunc>
sys*
=head2 X<system|Other languages,system - perlfunc>
system
=head2 X<syswrite|Other languages,syswrite - perlfunc>
syswrite
=head2 X<tell|Other languages,tell - perlfunc>
tell
=head2 X<telldir|Other languages,telldir - perlfunc>
telldir
=head2 X<tie|Other languages,tie - perlfunc>
tie
=head2 X<time|Other languages,time - perlfunc>
time
=head2 X<times|Other languages,times - perlfunc>
times
=head2 X<tr///|Other languages,tr/// - perlfunc>
tr///
=head2 X<truncate|Other languages,truncate - perlfunc>
truncate
=head2 X<uc|Other languages,uc - perlfunc>
uc
=head2 X<ucfirst|Other languages,ucfirst - perlfunc>
ucfirst
=head2 X<undef|Other languages,undef - perlfunc>
undef
=head2 X<unlink|Other languages,unlink - perlfunc>
unlink
=head2 X<unpack|Other languages,unpack - perlfunc>
unpack
=head2 X<unshift|Other languages,unshift - perlfunc>
unshift
=head2 X<untie|Other languages,untie - perlfunc>
untie
=head2 X<use|Other languages,use - perlfunc>
use
=head2 X<utime|Other languages,utime - perlfunc>
utime
=head2 X<values|Other languages,values - perlfunc>
values
=head2 X<vec|Other languages,vec - perlfunc>
vec
=head2 X<wait|Other languages,wait - perlfunc>
wait
=head2 X<waitpid|Other languages,waitpid - perlfunc>
waitpid
=head2 X<wantarray|Other languages,wantarray - perlfunc>
wantarray
=head2 X<warn|Other languages,warn - perlfunc>
warn
=head2 X<write|Other languages,write - perlfunc>
write
=head2 X<y///|Other languages,y/// - perlfunc>
y///
=head1 X<Statements|Tutorial,statement (Basics)>
Statements
=head2 X<Scalar|Tutorial,scalar (Basics)>
Scalar
=head2 X<String literals|Tutorial,string literal (Basics)>
String literals
=head1 X<Hashes|Tutorial,hash (Basics)>
Hashes
=head1 X<Topic variable|Tutorial,topic variable (Basics)>
Topic variable
=head2 X<Variable interpolation|Tutorial,variable interpolation (Basics)>
Variable interpolation
=head2 X<Non-string keys (object hash)|Language,non-string keys;Language,object hash;Syntax,:{}>
Non-string keys (object hash)
=head2 X<Interpolating into names|Language,interpolating into names>
Interpolating into names
=head2 X<Direct lookup|Syntax,::($c).m;Syntax,A."$m"()>
Direct lookup
=head2 X<B<pack>|Language,pack>
pack|Language,pack
=head2 X<B<macros>|Language,macros>
macros|Language,macros
=head2 X<B<cached>|Language,:cached>
cached|Language,:cached
=head2 X<B<rakuast>|Language,:rakuast>
rakuast|Language,:rakuast
=head1 X<Class|Tutorial,class;Tutorial,state>
Class
=head1 X<Attributes|Tutorial,attributes;Tutorial,encapsulation;Tutorial,has>
Attributes
=head2 X<Twigil C<$!>|Tutorial,twigils;Tutorial,!;Tutorial,&>
Twigil $!|Tutorial,twigils;Tutorial,!;Tutorial,&
=head2 X<C<is rw> trait|Tutorial,is rw>
is rw trait|Tutorial,is rw
=head2 X<Private methods|Tutorial,FQN;Tutorial,Private methods>
Private methods
=head1 X<Construction|Tutorial,Constructor>
Construction
=head2 X<C<TWEAK>|Tutorial,TWEAK>
TWEAK|Tutorial,TWEAK
=head2 X<C<BUILD>|Tutorial,BUILD>
BUILD|Tutorial,BUILD
=head1 X<Destruction|Tutorial,DESTROY>
Destruction
=head2 X<A word on types|Tutorial,type object;Tutorial,DEFINITE>
A word on types
=head1 X<Inheritance|Tutorial,inheritance>
Inheritance
=head2 X<Overriding default gist method|Reference,Overriding default gist method>
Overriding default gist method
=head2 X<Zen slices|Language,Zen slices>
Zen slices
=head3 X<$ARG, $_|Other languages,$_ (Perl)>
$ARG, $_
=head3 X<@ARG, @_|Other languages,@_ (Perl)>
@ARG, @_
=head3 X<$LIST_SEPARATOR, $"|Other languages,$" (Perl)>
$LIST_SEPARATOR, $"
=head3 X<$PROCESS_ID, $PID, $$|Other languages,$$ (Perl)>
$PROCESS_ID, $PID, $$
=head3 X<$PROGRAM_NAME, $0|Other languages,$0 (Perl)>
$PROGRAM_NAME, $0
=head3 X<@INC|Other languages,@INC (Perl)>
@INC
=head3 X<%INC|Other languages,%INC (Perl)>
%INC
=head1 X<INTRODUCTION|Programs,rakudoc>
INTRODUCTION
=head2 X<trait is default|Traits,is default>
trait is default
=head2 X<Trait is default|Traits,is default>
Trait is default
=head2 X<Trait is required|Traits,is required>
Trait is required
=head2 X<trait is DEPRECATED|Traits,is DEPRECATED>
trait is DEPRECATED
=head2 X<trait is rw|Traits,is rw>
trait is rw
=head2 X<trait is built|Traits,is built>
trait is built
got-index => / <head> .*? X [ '<' | '«' ] /
=head1 X<|Language,Whitespace> Whitespace characters
Whitespace characters
=end rakudoc