Re-indexing "trait is default"

There was a bogus category generated, as well as some other
problems. There's still a problem referenced in #1823 comments, but at
least a new bogus category (which wasn't even in #1410) has been
eliminated.

Author: JJ

doc/Language/functions.pod6

@@ -266,13 +266,14 @@ happy-birthday( 'Jack', 25 );                  # OUTPUT: «Happy 25th Birthday J
 
 =end code
 
-The first two versions of the C<happy-birthday> sub differs only in the arity (number of
-arguments), while the third version uses named arguments and is chosen only when named
-arguments are used, even if the arity is the same of another C<multi> candidate.
+The first two versions of the C<happy-birthday> sub differs only in the arity
+(number of arguments), while the third version uses named arguments and is
+chosen only when named arguments are used, even if the arity is the same of
+another C<multi> candidate.
 
-When two sub have the same arity, the type of the arguments drive the dispatch; when
-there are named arguments they drive the dispatch even when their type is the same as another
-candidate:
+When two sub have the same arity, the type of the arguments drive the dispatch;
+when there are named arguments they drive the dispatch even when their type is
+the same as another candidate:
 
 =begin code
 multi happy-birthday( Str $name, Int $age ) {
@@ -334,8 +335,8 @@ object:
     $congrats.congratulate('promotion','Cindy'); # OUTPUT: «Hooray for your promotion, Cindy␤»
     $congrats.congratulate('birthday','Bob');    # OUTPUT: «Happy birthday, Bob␤»
 
-Unlike C<sub>, if you use named parameters with multi methods, the parameters must
-be required parameters to behave as expected.
+Unlike C<sub>, if you use named parameters with multi methods, the parameters
+must be required parameters to behave as expected.
 
 Please note that a non-multi sub or operator will hide multi candidates of the
 same name in any parent scope or child scope. The same is true for imported
@@ -360,10 +361,11 @@ arguments. Consider this basic example:
     =for code :skip-test
     congratulate('being a cool number', 42);         # Proto match error
 
-The proto insists that all C<multi congratulate> conform to the basic signature of two strings,
-optionally followed by further parameters. The C<|> is an un-named C<Capture>
-parameter, and allows a C<multi> to take additional arguments. The first two calls
-succeed, but the third fails (at compile time) because C<42> doesn't match C<Str>.
+The proto insists that all C<multi congratulate> conform to the basic signature
+of two strings, optionally followed by further parameters. The C<|> is an
+un-named C<Capture> parameter, and allows a C<multi> to take additional
+arguments. The first two calls succeed, but the third fails (at compile time)
+because C<42> doesn't match C<Str>.
 
 =for code :skip-test
 say &congratulate.signature # OUTPUT: «(Str $reason, Str $name, | is raw)␤»
@@ -402,13 +404,12 @@ many modules, will follow.
 
 =head2 Slurpy Conventions
 
-Perhaps the most important one of these conventions is the way slurpy list arguments are
-handled.  Most of the time, functions will not automatically flatten
-slurpy lists.
-The rare exceptions are those functions that don't have a
-reasonable behavior on lists of lists (e.g., L<chrs|/routine/chrs>)
-or where there is a conflict with an established idiom (e.g., L<pop|/routine/pop>
-being the inverse of L<push|/routine/push>).
+Perhaps the most important one of these conventions is the way slurpy list
+arguments are handled.  Most of the time, functions will not automatically
+flatten slurpy lists. The rare exceptions are those functions that don't have a
+reasonable behavior on lists of lists (e.g., L<chrs|/routine/chrs>) or where
+there is a conflict with an established idiom (e.g., L<pop|/routine/pop> being
+the inverse of L<push|/routine/push>).
 
 If you wish to match this look and feel, any L<Iterable|/type/Iterable> argument must
 be broken out element-by-element using a C<**@> slurpy, with two nuances:
@@ -532,7 +533,7 @@ Routines are code objects that conform to L<type Routine|/type/Routine>, most
 notably L<Sub|/type/Sub>, L<Method|/type/Method>, L<Regex|/type/Regex> and
 L<Submethod|/type/Submethod>.
 
-They carry additional functionality in addition to what L<Block|/type/Block>
+They carry extra functionality in addition to what L<Block|/type/Block>
 supplies: they can come as L<multis|#Multi-dispatch>,
 you can L<wrap|/type/Routine#method_wrap> them, and exit early with C<return>:
 
@@ -550,7 +551,7 @@ you can L<wrap|/type/Routine#method_wrap> them, and exit early with C<return>:
 
 Here, C<return> doesn't just leave the block inside which it was called, but
 the whole routine. In general, blocks are transparent to C<return>, they
-attach to the outer routine.
+attach to the outermost routine.
 
 X<|use soft (pragma)>
 Routines can be inlined and as such provide an obstacle for wrapping. Use the
@@ -643,13 +644,13 @@ prefix the operator name with a C<&>-sigil.
     say "abc" ieq "Abc";
     # OUTPUT: «True␤»
 
+X«|is tighter»X«|is equiv»X«|is looser»
 =head2 Precedence
 
-X«|is tighter»X«|is equiv»X«|is looser»
-Operator precedence in Perl 6 is specified relatively to existing operators.
-The traits C<is tighter>, C<is equiv> and C<is looser> can be provided with an
-operator, the new operators precedence is related to. More than one trait can
-be applied.
+Operator precedence in Perl 6 is specified relatively to existing operators. The
+traits C<is tighter>, C<is equiv> and C<is looser> can be provided with an
+operator to indicate how the precedence of the new operators is related to
+other, existing ones. More than one trait can be applied.
 
 For example, C«infix:<*>» has a tighter precedence than C«infix:<+>»,
 and squeezing one in between works like this:
@@ -740,12 +741,13 @@ class SomeClass does AnotherRole { ... }
 has $!another-attribute handles <close>;
 #                       ^^^^^^^ trait
 
-... and also C<is tighter>, C<is looser>, C<is equiv> and C<is assoc> from the previous
-section.
+... and also C<is tighter>, C<is looser>, C<is equiv> and C<is assoc> from the
+previous section.
 
 Traits are subs of the form C<< trait_mod<VERB> >>, where C<VERB> stands for the
 name like C<is>, C<does> or C<handles>. It receives the modified thing as
-argument, and the name as a named argument. See L<Sub|/type/Sub#Traits> for details.
+argument, and the name as a named argument. See L<Sub|/type/Sub#Traits> for
+details.
 
 =begin code
 multi sub trait_mod:<is>(Routine $r, :$doubles!) {

doc/Type/Attribute.pod6

@@ -34,7 +34,8 @@ say $a.get_value($instance);        # OUTPUT: «[1 2 3]␤»
 
 =head1 Traits
 
-=head2 X<Trait is default|is default (Attribute)>
+X<|is default (Attribute)>
+=head2 X<Trait is default>
 
 An attribute that is assigned L<Nil|/type/Nil> will revert to its default value
 set with the trait C<is default>.

doc/Type/Routine.pod6

@@ -17,7 +17,8 @@ Routine is also the level at which
 L<multiness|/language/glossary#Multi-Dispatch> (multi subs and multi methods)
 are handled.
 
-=head2 X<Trait is default|is default (Routine)>
+X<|is default (Routine)>
+=head2 X<Trait is default>
 
 There is a special trait for C<Routine>s called C<is default>. This trait is
 designed as a way to disambiguate C<multi> calls that would normally

doc/Type/Variable.pod6

@@ -13,17 +13,10 @@ variable itself. The run-time class of a variable is L<Scalar>.
 Class C<Variable> holds the compile-time information that traits can use to
 introspect and manipulate variables.
 
-=head1 Routines
+=head1 Traits
 
-=head2 method name
-
-    method name(Variable:D: str)
-
-Returns the name of the variable, including the sigil.
-
-=head2 X<trait is default|is default (Variable)>
-
-    multi sub trait_mod:<is>(Variable:D, :$default!)
+X<|is default (Variable)>
+=head2 X<Trait is default>
 
 Sets the default value with which a variable is initialized, and to which it
 is reset when L<Nil|/type/Nil> is assigned to it. Trait arguments are evaluated at compile
@@ -87,6 +80,14 @@ Sets the type constraint of a container bound to a variable.
     CATCH { default { say .^name, ' ', .Str } }
     # OUTPUT: «X::TypeCheck::Assignment Type check failed in assignment to $i; expected Int but got Str ("forty plus two")␤»
 
+=head1 Methods
+
+=head2 method name
+
+    method name(Variable:D: str)
+
+Returns the name of the variable, including the sigil.
+
 =end pod
 
 # vim: expandtab softtabstop=4 shiftwidth=4 ft=perl6