Don't use X<;>

Part of #4099

Author: coke

doc/Language/classtut.rakudoc

@@ -79,9 +79,9 @@ my $eat =
 $eat.perform();
 =end code
 
-X<|Tutorial,class;Tutorial,state>
-=head1 X<Class|Tutorial,class;Tutorial,state>
+=head1 X<Class|Tutorial,class>
 
+X<|Tutorial,state>
 Raku, like many other languages, uses the C<class> keyword to define a
 class. The block that follows may contain arbitrary code, just as with
 any other block, but classes commonly contain state and behavior
@@ -90,8 +90,10 @@ through the C<has> keyword, and behaviors, introduced through the C<method>
 keyword.
 
 
-=head1 X<Attributes|Tutorial,attributes;Tutorial,encapsulation;Tutorial,has>
+=head1 X<Attributes|Tutorial,attributes>
 
+X<|Tutorial,encapsulation>
+X<|Tutorial,has>
 In the C<Task> class, the first three lines inside the block all
 declare attributes (called I<fields> or I<instance storage> in other
 languages) using the C<has> declarator. Just as a C<my> variable cannot be
@@ -100,8 +102,10 @@ accessible from outside of the class (this is in contrast to many other
 languages). This I<encapsulation> is one of the key principles of object
 oriented design.
 
-=head2 X<Twigil C<$!>|Tutorial,twigils;Tutorial,!;Tutorial,&>
+=head2 X<Twigil C<$!>|Tutorial,twigils>
 
+X<|Tutorial,!>
+X<|Tutorial,&>
 The first declaration specifies instance storage for a callback (i.e.
 a bit of code to invoke in order to perform the task that an object
 represents):
@@ -174,7 +178,8 @@ so external code can modify the value of the attribute.
 =for code
 has &!callback is built;
 
-X<|Types,traits;Types,is built>
+X<|Types,traits>
+X<|Types,is built>
 By default private attributes are not automatically set by the default constructor. (They are private after
 all.) In the above example we want to allow the user to provide the initial value but keep the attribute
 otherwise private. The L<C<is built>|/type/Attribute#trait_is_built> trait allows to do just that.
@@ -192,7 +197,8 @@ The C<is built> trait was introduced in Rakudo release 2020.01.
 
 =head2 C<is required> trait
 
-X<|Types,traits;Types,is required>
+X<|Types,traits>
+X<|Types,is required>
 Providing a value for an attribute during initialization is optional by default. Which in the task example
 makes sense for all three, the C<&!callback>, the C<@!dependencies> and the C<$.done> attribute. But lets say
 we want to add another attribute, C<$.name>, that holds a tasks name and we want to force the user to
@@ -357,8 +363,9 @@ C<$!done> attribute to C<True>, so that subsequent invocations of C<perform>
 on this object (if this C<Task> is a dependency of another C<Task>, for
 example) will not repeat the task.
 
-=head2 X<Private methods|Tutorial,FQN;Tutorial,Private methods>
+=head2 X<Private methods|Tutorial,FQN>
 
+X<|Tutorial,Private methods>
 Just like attributes, methods can also be private. Private methods are declared
 with a prefixed exclamation mark. They are called with C<self!> followed by the
 method's name. In the following implementation of a C<MP3TagData> class to
@@ -596,8 +603,9 @@ eating dinner. NOM!
 =end code
 
 
-=head2 X<A word on types|Tutorial,type object;Tutorial,DEFINITE>
+=head2 X<A word on types|Tutorial,type object>
 
+X<|Tutorial,DEFINITE>
 Declaring a class creates a new I<type object> which, by default, is installed
 into the current package (just like a variable declared with C<our> scope).
 This type object is an "empty instance" of the class. For example, types such as

doc/Language/functions.rakudoc

@@ -139,8 +139,9 @@ sub format(Str $s) { ... }
 Details about the syntax and use of signatures can be found in the
 L<documentation on the C<Signature> class|/type/Signature>.
 
-=head3 X<Automatic signatures|Variables,@_;Variables,%_>
+=head3 X<Automatic signatures|Variables,@_>
 
+X<|Variables,%_>
 If no signature is provided but either of the two automatic variables C<@_> or
 C<%_> are used in the function body, a signature with C<*@_> or C<*%_> will be
 generated. Both automatic variables can be used at the same time.
@@ -883,7 +884,10 @@ prefix the operator name with an C<&>-sigil.
     say "abc" ieq "Abc";
     # OUTPUT: «True␤»
 
-=head2 X<Precedence|Traits,is tighter;Traits,is equiv;Traits,is looser>
+=head2 X<Precedence|Traits,is tighter>
+
+X<|Traits,is equiv>
+X<|Traits,is looser>
 
 Operator precedence in Raku is specified relative to existing operators. The
 traits C<is tighter>, C<is equiv> and C<is looser> can be provided with an

doc/Language/glossary.rakudoc

@@ -174,8 +174,9 @@ sub the-answer() { 42 }                            # arity of 0
 The arity of a L<C<Callable>|/type/Callable> is one of the main selectors in
 L<multi-dispatch|#Multi-dispatch>.
 
-=head1 X<ASCII operator|Language,ASCII operator;Language,Texas operator>
+=head1 X<ASCII operator|Language,ASCII operator>
 
+X<|Language,Texas operator>
 =begin comment
 “Texas” was used in the past but is now discouraged.
 Remove the link when “Texas” goes completely out of use.
@@ -255,8 +256,9 @@ MoarVM or the Java Virtual Machine, the two VMs currently supported.
 
 A butterfly image intended primarily to represent Raku, The Language.
 
-=head1 X<Colon pair and colon list|Reference,Colon Pair;Reference,Colon List>
+=head1 X<Colon pair and colon list|Reference,Colon Pair>
 
+X<|Reference,Colon List>
 A colon pair is a shorthand syntax used to create or visually present
 a L<C<Pair>|/type/Pair> object. The two most common forms are:
 
@@ -470,8 +472,9 @@ acting like a regular user (as far as the IRC server is concerned) and
 performing some tasks that may involve answering to users requests.
 Examples can be found L<on the IRC page of raku.org|https://raku.org/community/irc>.
 
-=head2 X<Compilation unit or I<compunit>|Reference,compunit (glossary);Reference,compilation unit>
+=head2 X<Compilation unit or I<compunit>|Reference,compunit (glossary)>
 
+X<|Reference,compilation unit>
 A L<compunit|https://github.com/rakudo/rakudo/blob/master/docs/module_management.md>
 is a piece of Raku code that is analyzed and compiled as a single unit.
 Typically, this piece of code will be contained in a single file, but code
@@ -612,8 +615,9 @@ See also L<https://en.wikipedia.org/wiki/Larry_Wall>.
 Performing L<lexical analysis|https://en.wikipedia.org/wiki/Lexical_analysis>,
 a step which usually precedes parsing.
 
-=head1 X<LHS|Reference,LHS;Reference,Left-hand side>
+=head1 X<LHS|Reference,LHS>
 
+X<|Reference,Left-hand side>
 As an acronym left-hand side, it usually refers to the left-hand side of
 an expression, and more specifically to the left-hand side of
 expressions such as C<$lhs = "this would be the right-hand side">. Since
@@ -700,8 +704,9 @@ MoarVM has some similarities with the Hotspot VM so you may peruse its
 L<glossary|http://openjdk.java.net/groups/hotspot/docs/HotSpotGlossary.html>
 for entries missing from the present one.
 
-=head1 X<Multi-dispatch|Reference,Multi-Dispatch;Reference,MMD>
+=head1 X<Multi-dispatch|Reference,Multi-Dispatch>
 
+X<|Reference,MMD>
 The mechanism used to invoke different routines (L<C<Method>|/type/Method>s or
 L<C<Sub>|/type/Sub>s) of the same name, selecting the correct one based on the
 L<C<Parameter>|/type/Parameter> prototype and the arguments it was called with.
@@ -900,8 +905,9 @@ loads modules, managing their installation and precompilation. They are
 structured as linked lists, including chain of repositories ending in
 the default C<Compunit::Repository::Installation>.
 
-=head1 X<RHS|Reference,RHS;Reference,Right-hand side>
+=head1 X<RHS|Reference,RHS>
 
+X<|Reference,Right-hand side>
 Acronym for right-hand side, usually refers to the right-hand side of
 assignment operators and expressions such as C<my $bound := $rhs> or
 C<my $a = 5; $a //= $rhs>. See
@@ -1029,8 +1035,9 @@ L<Exegeses|#Exegesis>.
 A piece of code that isn't immediately executed, but doesn't have an independent
 scope.
 
-=head1 X<Tight and loose precedence|Reference,Tight;Reference,Loose>
+=head1 X<Tight and loose precedence|Reference,Tight>
 
+X<|Reference,Loose>
 In this context, tight or tighter refers to
 L<precedence rules|/language/functions#Precedence>
 and is the opposite of C<looser>. Precedence rules for new terms are

doc/Language/grammars.rakudoc

@@ -91,8 +91,10 @@ should only be used to parse text; if you wish to extract complex data, you can
 add actions within the grammar or use an L<action
 object|/language/grammars#Action_objects> in conjunction with the grammar.
 
-=head2 X«Proto regexes|Syntax,:sym<>;Language,proto regex;Syntax,grammar»
+=head2 X«Proto regexes|Syntax,:sym<>»
 
+X«|Language,proto regex»
+X«|Syntax,grammar»
 L<C<Grammar>|/type/Grammar>s are composed of rules, tokens and regexes; these are
 actually methods, since grammars are classes.
 

doc/Language/hashmap.rakudoc

@@ -275,8 +275,10 @@ You can assign to multiple keys at the same time with a slice.
     my %h; %h<a b c> = 2 xx *; %h.raku.say;  # OUTPUT: «{:a(2), :b(2), :c(2)}␤»
     my %h; %h<a b c> = ^3;     %h.raku.say;  # OUTPUT: «{:a(0), :b(1), :c(2)}␤»
 
-=head2 X<Non-string keys (object hash)|Language,non-string keys;Language,object hash;Syntax,:{}>
+=head2 X<Non-string keys (object hash)|Language,non-string keys>
 
+X<|Language,object hash>
+X<|Syntax,:{}>
 By default keys in C<{ }> are forced to strings. To compose a hash with
 non-string keys, use a colon prefix:
 

doc/Language/list.rakudoc

@@ -571,8 +571,9 @@ they are Lists and are accepted wherever lists are.
 A fourth, more subtle, way they differ is that when working with Arrays, it
 can sometimes be harder to maintain laziness or work with infinite sequences.
 
-=head2 X<Typing|Language,typed array;Syntax,[ ] (typed array)>
+=head2 X<Typing|Language,typed array>
 
+X<|Syntax,[ ] (typed array)>
 Arrays may be typed such that their slots perform a typecheck whenever
 they are assigned to.  An Array that only allows L<C<Int>|/type/Int> values to be assigned
 is of type C<Array[Int]> and one can create one with C<Array[Int].new>.  If

doc/Language/objects.rakudoc

@@ -165,8 +165,11 @@ This restricts their visibility to the current lexical scope, which can be
 useful if the class is an implementation detail nested inside a module or
 another class.
 
-=head2 X<Attributes|Language,Attribute;Other languages,Property;Other languages,Member;Other languages,Slot>
+=head2 X<Attributes|Language,Attribute>
 
+X<|Other languages,Property>
+X<|Other languages,Member>
+X<|Other languages,Slot>
 Attributes are variables that exist per instance of a class; when instantiated
 to a value, the association between the variable and its value is called a
 X<property|Language,Property>. They are where the state of an object is stored. In Raku, all

doc/Language/operators.rakudoc

@@ -432,17 +432,23 @@ There are shortcuts for C<!==> and C<!eq>, namely C<!=> and C<ne>.
     my $today = Date.today;
     say so $release !before $today;     # OUTPUT: «False␤»
 
-=head2 X<Reversed operators|Metaoperators,R;Metaoperators,reverse metaoperator>
+=head2 X<Reversed operators|Metaoperators,R>
 
+X<|Metaoperators,reverse metaoperator>
 Any infix operator may be called with its two arguments reversed by
 prefixing with C<R>. Associativity of operands is reversed as well.
 
     say 4 R/ 12;               # OUTPUT: «3␤»
     say [R/] 2, 4, 16;         # OUTPUT: «2␤»
     say [RZ~] <1 2 3>,<4 5 6>  # OUTPUT: «(41 52 63)␤»
 
-=head2 X<<<Hyper operators|Operators,<<;Operators,>>;Operators,«;Operators,»;Operators,»=«;Operators,«=»>>>
+=head2 X«Hyper operators|Operators,<<»
 
+X«|Operators,>>»
+X<|Operators,«>
+X<|Operators,»>
+X<|Operators,»=«>
+X<|Operators,«=»>
 Hyper operators include C<«> and C<»>, with their ASCII variants C«<<» and
 C«>>». They apply a given operator enclosed (or preceded or followed, in the
 case of unary operators) by C<«> and/or C<»> to one or two lists, returning the
@@ -621,8 +627,9 @@ default:
 
 See L<infix:<Z>|#infix_Z> for more about this usage.
 
-=head2 X<Sequential operators|Metaoperators,S;Metaoperators,sequential metaoperator>
+=head2 X<Sequential operators|Metaoperators,S>
 
+X<|Metaoperators,sequential metaoperator>
 The sequential metaoperator, C<S>, will suppress any concurrency or reordering
 done by the optimizer. Most simple infix operators are supported.
 
@@ -642,7 +649,8 @@ compiler understand you.
 
 =head2 term C«< >»
 
-The X<quote-words|Terms,qw;Terms,quote-words> construct breaks up the contents on whitespace
+X<|Terms,quote-words>
+The X<quote-words|Terms,qw> construct breaks up the contents on whitespace
 and returns a L<C<List>|/type/List> of the words. If a word looks like a number
 literal or a L<C<Pair>|/type/Pair> literal, it's converted to the appropriate number.
 
@@ -666,7 +674,9 @@ being interpreted as a named argument.
 
 =head2 term C«{ }»
 
-L<C<Block>|/type/Block> or L<C<Hash>|/type/Hash> constructor. X<|Terms,block constructor;Terms,hash constructor>
+X<|Terms,block constructor>
+X<|Terms,hash constructor>
+L<C<Block>|/type/Block> or L<C<Hash>|/type/Hash> constructor.
 
 If the content is empty, or contains a single list that starts with a L<C<Pair>|/type/Pair>
 literal or C<%>-sigiled variable, and the L«C<$_> variable|/syntax/$_» or
@@ -707,7 +717,8 @@ Terms have their L<own extended documentation|/language/terms>.
                             :$k, :$v, :$kv, :$p, :$exists, :$delete)
 
 Universal interface for positional access to zero or more elements of
-@container, a.k.a. "X<array indexing operator|Postcircumfix operators,array indexing operator;Postcircumfix operators,array subscript operator>".
+@container, a.k.a. "X<array indexing operator|Postcircumfix operators,array indexing operator>".
+X<|Postcircumfix operators,array subscript operator>
 
     my @alphabet = 'a' .. 'z';
     say @alphabet[0];                   # OUTPUT: «a␤»
@@ -729,7 +740,8 @@ operator's behavior and for how to implement support for it in custom types.
                             :$k, :$v, :$kv, :$p, :$exists, :$delete)
 
 Universal interface for associative access to zero or more elements of a
-%container, a.k.a. "X<hash indexing operator|Postcircumfix operators,hash indexing operator;Postcircumfix operators,hash subscript operator>".
+%container, a.k.a. "X<hash indexing operator|Postcircumfix operators,hash indexing operator>".
+X<|Postcircumfix operators,hash subscript operator>
 
     my %color = kiwi => "green", banana => "yellow", cherry => "red";
     say %color{"banana"};                 # OUTPUT: «yellow␤»

doc/Language/packages.rakudoc

@@ -198,8 +198,9 @@ In the same vein, class and method names can be interpolated too:
     $what-method = 'another-method';
     say a-class."$what-method"(); # OUTPUT: «in-another-method␤»
 
-=head2 X<Direct lookup|Syntax,::($c).m;Syntax,A."$m"()>
+=head2 X<Direct lookup|Syntax,::($c).m>
 
+X<|Syntax,A."$m"()>
 To do direct lookup in a package's symbol table without scanning, treat the
 package name as a hash:
 

doc/Language/quoting.rakudoc

@@ -19,7 +19,9 @@ described in more detail in the following sections.
 For information about quoting as applied in regexes, see the L<regular
 expression documentation|/language/regexes>.
 
-=head2 X<Literal strings: Q|Syntax,Q;Syntax,｢ ｣>
+=head2 X<Literal strings: Q|Syntax,Q>
+
+X<|Syntax,｢ ｣>
 
 =for code :skip-test<listing>
 Q[A literal string]
@@ -131,8 +133,10 @@ say Q:a "Array contains @þ.elems()"; # OUTPUT: «Array contains 2␤»
 The same code without the parentheses will simply not interpolate, absent the
 post-circumfix operator.
 
+=head2 X<Escaping: q|Syntax,q>
+
 X<|Syntax,escaping quote>
-=head2 X<Escaping: q|Syntax,q;Syntax,' '>
+X<|Syntax,' '>
 
 =begin code
 'Very plain';
@@ -172,7 +176,9 @@ HTML markup is involved, to avoid interpretation of angle brackets as hash keys:
     say '<code>$var</code> is <var>\qq[$var.uc()]</var>';
     # OUTPUT: «<code>$var</code> is <var>FOO</var>␤»
 
-=head2 X<Interpolation: qq|Syntax,qq;Syntax," ">
+=head2 X<Interpolation: qq|Syntax,qq>
+
+X<|Syntax," ">
 
 =begin code
 my $color = 'blue';
@@ -453,8 +459,9 @@ just literal quote characters:
     my $b = "1 \"2 3\"";
     say qqww{"$b" $b}.raku; # OUTPUT: «("1 \"2 3\"", "1", "\"2", "3\"")␤»
 
-=head2 X<<<Word quoting with interpolation and quote protection: « »|Syntax,<< >>;Syntax,« »>>>
+=head2 X<<<Word quoting with interpolation and quote protection: « »|Syntax,<< >>>>>
 
+X<<<|Syntax,« »>>>
 This style of quoting is like C<qqww>, but with the added benefit of
 constructing L<allomorphs|/language/glossary#Allomorph> (making it
 functionally equivalent to L<qq:ww:v|#index-entry-:val_(quoting_adverb)>). The