Eliminates another category, refs #1410

And chekcs that #1358 is well closed.

Author: JJ

doc/Language/variables.pod6

@@ -1102,7 +1102,6 @@ L<Sub|/type/Sub> attached to the current routine. It does support the method
 C<.name> to obtain the name of the called routine, as well as C<.signature> and
 others method related to C<Sub>:
 
-
     sub awesome-sub { say &?ROUTINE.name }
     awesome-sub # OUTPUT: awesome-sub
 
@@ -1117,7 +1116,7 @@ sub do-work {
 do-work;
 =end code
 
-=head3 X<&?BLOCK|&?BLOCK>
+=head3 X<&?BLOCK>
 
 The special compile variable C<?&BLOCK> behaves similarly to
 C<?&ROUTINE> but it allows to introspect a single block of code.
@@ -1140,26 +1139,25 @@ for '.' {
 
 
 All dynamically scoped variables have the C<*> twigil, and their name is written
-uppercase.
+in uppercase.
 
 X<|$*ARGFILES>X<|@*ARGS>
 =head3 Argument related variables
 
-=item C<$*ARGFILES>
-An L<IO::ArgFiles> (an empty subclass of L<IO::CatHandle>)
-that uses C<@*ARGS> as source files, if
-it contains any files, or C<$*IN> otherwise. When C<$*IN>
-is used, its C<:nl-in>, C<:chomp>, C<:encoding>,
-and C<:bin> will be set on the L<IO::ArgFiles> object.
+=item C<$*ARGFILES> An L<IO::ArgFiles> (an empty subclass of L<IO::CatHandle>)
+that uses C<@*ARGS> as source files, if it contains any files, or C<$*IN>
+otherwise. When C<$*IN> is used, its C<:nl-in>, C<:chomp>, C<:encoding>, and
+C<:bin> will be set on the L<IO::ArgFiles> object.
 
 =item C<@*ARGS>
 Arguments from the command line.
 
 X<|$*IN>X<|$*OUT>X<|$*ERR>
 =head3 Special File Handles: STDIN, STDOUT and STDERR
 
-For more information about special filehandles please see also
-the L<Input and Output|/language/io> page and the L<IO::Special> class. L<IO::Handle> contains several examples of using C<$*IN> for reading standard input.
+For more information about special filehandles please see also the L<Input and
+Output|/language/io> page and the L<IO::Special> class. L<IO::Handle> contains
+several examples of using C<$*IN> for reading standard input.
 
 
 =item C<$*IN>
@@ -1233,10 +1231,9 @@ X<|$*PROGRAM>
 location (in the form of an C<IO::Path> object) of the Perl program being executed;
 
 X<|$*EXIT>
-=item C<&*EXIT>
-code that will be executed when doing an exit().  Intended
-to be used in situations where Perl 6 is embedded in
-another language runtime (such as Inline::Perl6 in Perl 5);
+=item C<&*EXIT> code that will be executed when doing an exit().  Intended to
+be used in situations where Perl 6 is embedded in another language runtime
+(such as Inline::Perl6 in Perl 5);
 
 X<|$*EXECUTABLE>
 =item C<$*EXECUTABLE>
@@ -1258,23 +1255,23 @@ C<sub MAIN> and C<sub USAGE>. The variable is I<read-only>;
 X<|$*USER>
 =item C<$*USER>
 the user that is running the program. It's an object
-that evaluates to "username (uid)".  It will evaluate
+that evaluates to C<username (uid)>.  It will evaluate
 to the username only if treated as a string and the
 numeric user id if treated as a number;
 
 X<|$*GROUP>
 =item C<$*GROUP>
 the primary group of the user who is running the program.
-It's an object that evaluates to "groupname (gid)".
+It's an object that evaluates to C<groupname (gid)>.
 It will evaluate to the groupname only if treated as a
 string and the numeric group id if treated as a number;
 
 X<|$*HOME>
 =item C<$*HOME>
 an L<IO::Path> object representing the "home directory"
 of the user that is running the program. Uses
- C«%*ENV<HOME>» if set. On Windows, uses
- C«%*ENV<HOMEDRIVE> ~ %*ENV<HOMEPATH>». If the
+C«%*ENV<HOME>» if set. On Windows, uses
+C«%*ENV<HOMEDRIVE> ~ %*ENV<HOMEPATH>». If the
 home directory cannot be determined, it will be L<Any>;
 
 X<|$*SPEC>
@@ -1299,18 +1296,19 @@ X<|$*SCHEDULER>
 a L<ThreadPoolScheduler> object representing the current default scheduler (see note below);
 
 X<|$*SAMPLER>
-=item C<$*SAMPLER>
-the current L<Telemetry::Sampler> used for making
-snapshots of system state.  Only available if
-L<Telemetry> has been loaded.
+=item C<$*SAMPLER>: the current L<Telemetry::Sampler> used for
+making snapshots of system state.  Only available if L<Telemetry> has been
+loaded.
 
 
 Note on usage of C<$*SCHEDULER>:
 
-For the current (2018.04) Rakudo, by default this imposes a maximum of 64 threads on the methods
-C<.hyper>, C<.race> and other thread-pool classes that use that scheduler such as C<Promise>s or C<Supplie>s. To change the maximum number of threads, you can either set the
-environment variable C<RAKUDO_MAX_THREADS> before running perl6 or create a scoped copy
-with the default changed before using them:
+For the current (2018.04) Rakudo, by default this imposes a maximum of 64
+threads on the methods C<.hyper>, C<.race> and other thread-pool classes that
+use that scheduler such as C<Promise>s or C<Supplie>s. To change the maximum
+number of threads, you can either set the environment variable
+C<RAKUDO_MAX_THREADS> before running perl6 or create a scoped copy with the
+default changed before using them:
 
     my $*SCHEDULER = ThreadPoolScheduler.new( max_threads => 128 );
 
@@ -1322,17 +1320,27 @@ It is helpful to know our naming conventions in order to understand what codes
 do directly. However, there is not yet a conventions list covering anywhere.
 Still we list several conventions that are widely held.
 
-=item1 Subs and methods from the built-ins library try to have single-word names when a good one could be found. In cases where there are two or more words making up a name, they are separated by a "-".
+=item1 Subs and methods from the built-ins library try to have single-word names
+when a good one could be found. In cases where there are two or more words
+making up a name, they are separated by a "-".
 
-=item1 Compounds are treated as a single word, thus C<substr>, C<subbuf>, and C<deepmap> (just like we write "starfish", not "star fish" in English).
+=item1 Compounds are treated as a single word, thus C<substr>, C<subbuf>, and
+C<deepmap> (just like we write "starfish", not "star fish" in English).
 
-=item1 Subs and methods that are automatically called for you at special times are written in uppercase. This includes the C<MAIN> sub, the C<AT-POS> and related methods for implementing container types, along with C<BUILD> and C<DESTROY>.
+=item1 Subs and methods that are automatically called for you at special times
+are written in uppercase. This includes the C<MAIN> sub, the C<AT-POS> and
+related methods for implementing container types, along with C<BUILD> and
+C<DESTROY>.
 
-=item1 Type names are camel case, except for native types, which are lowercase. For the exception, you can remember it by: they are stored in a more compact way, so they names look smaller too.
+=item1 Type names are camel case, except for native types, which are lowercase.
+For the exception, you can remember it by: they are stored in a more compact
+way, so they names look smaller too.
 
-=item1 Built-in dynamic variables and compile-time variables are always uppercase, such like C<$*OUT>, C<$?FILE>.
+=item1 Built-in dynamic variables and compile-time variables are always
+uppercase, such like C<$*OUT>, C<$?FILE>.
 
-=item1 Methods from the MOP and other internals use "_" to separate multiple words, such like C<add_method>.
+=item1 Methods from the MOP and other internals use "_" to separate multiple
+words, such like C<add_method>.
 
 =end pod