Clarifications and reflow

Author: JJ

doc/Language/operators.pod6

@@ -2328,8 +2328,8 @@ L<traps|/language/traps#Loose_boolean_operators>.
 
     multi sub prefix:<so>(Mu $x --> Bool:D)
 
-Evaluates its argument in boolean context (and thus collapses L<Junction|/type/Junction>s),
-and returns the result.
+Evaluates its argument in boolean context (and thus collapses
+L<Junction|/type/Junction>s), and returns the result.
 
 =head1 Comma operator precedence
 
@@ -2346,11 +2346,12 @@ Constructs a higher-order L<Cool|/type/Cool> from its arguments.
     my %a = :11a, :22b;
     say %(%a, :33x);  # OUTPUT: «{a => 11, b => 22, x => 33}␤»
 
-In the first case it returns a L<List|/type/List>, in the second case, since the arguments
-are L<Pair|/type/Pair>s, it builds a L<Hash|/type/Hash>.
+In the first case it returns a L<List|/type/List>, in the second case, since the
+arguments are L<Pair|/type/Pair>s, it builds a L<Hash|/type/Hash>.
 
 It can also be used for constructing variables from other variables, collating
-elements of different types, in this case a L<Hash|/type/Hash> and a L<Pair|/type/Pair>:
+elements of different types, in this case a L<Hash|/type/Hash> and a
+L<Pair|/type/Pair>:
 
 =begin code :preamble<my %hash>
 my %features = %hash, :wields("hammer");
@@ -2378,11 +2379,9 @@ other positions, it's a syntax error.
 
     sub infix:<Z>(**@lists --> Seq:D) is assoc<chain>
 
-X<Zip operator>.
-
-Interleaves the lists passed to C<Z> like a zipper, stopping as soon as the
-first input list is exhausted. The returned C<Seq> contains a nested list with
-values for all C<Z> operators in a chain.
+The X<Zip operator> interleaves the lists passed to C<Z> like a zipper, stopping
+as soon as the first input list is exhausted. The returned C<Seq> contains a
+nested list with values for all C<Z> operators in a chain.
 
 =for code
 say (1, 2 Z <a b c> Z <+ ->).perl;
@@ -2419,7 +2418,8 @@ lists are replaced by the value from applying the operator to the list:
     # produces (1a9 1b9 1c9 2a9 2b9 2c9 3a9 3b9 3c9)
 
 =head2 infix C«...»
-X<|...,operators>X<|...^,operators>X<|…,operators>X<|…^,operators>X<|lazy list,…>
+X<|...,operators>X<|...^,operators>X<|…,operators>X<|…^,operators>
+X<|lazy list,…>
 
     multi sub infix:<...>(**@) is assoc<list>
     multi sub infix:<...^>(**@) is assoc<list>
@@ -2428,11 +2428,11 @@ The X<sequence operator>, which can be written either as C<...> or as
 C<…> (with variants C<...^> and C<…^>) will produce (possibly lazy)
 generic sequences on demand.
 
-The left-hand side will always include the initial elements; it may
-include a generator too. The right-hand side will have an endpoint,
-which can be C<Inf> or C<*> for "infinite" lists (that is, I<lazy> lists
-whose elements are only produced on demand), an expression which will
-end the sequence when C<True>, or other elements such as
+The left-hand side will always include the initial elements; it may include a
+generator too (after the first element or elements). The right-hand side will
+have an endpoint, which can be C<Inf> or C<*> for "infinite" lists (that is,
+I<lazy> lists whose elements are only produced on demand), an expression which
+will end the sequence when C<True>, or other elements such as
 L<Junctions|/type/Junction>.
 
 The sequence operator invokes the generator with as many arguments as necessary.

doc/Language/variables.pod6

@@ -1223,8 +1223,8 @@ sub module-source {
 
 =head2 Dynamic variables
 
-All dynamically scoped variables have the C<*> twigil, and their name is written
-in uppercase.
+All dynamically scoped variables have the C<*> twigil, and their name is
+(conventionally) written in uppercase.
 
 X<|$*ARGFILES>X<|@*ARGS>
 =head3 Argument related variables

doc/Type/IO/ArgFiles.pod6

@@ -6,9 +6,9 @@
 
    class IO::ArgFiles is IO::CatHandle { }
 
-This class exists for backwards compatibility reasons and provides no methods.
-All the functionality is inherited from L<IO::CatHandle>. It can be used, for
-instance, this way:
+This class exists for backwards compatibility reasons and provides no additional
+methods to the base class. All the functionality is inherited from
+L<IO::CatHandle>. It can be used, for instance, this way:
 
 =for code
 my $argfiles = IO::ArgFiles.new(@*ARGS);
@@ -27,10 +27,10 @@ my $argfiles = IO::CatHandle.new(@*ARGS);
 
 =head2 C<$*ARGFILES>
 
-This class is the magic behind the C<$*ARGFILES> variable, which
-provides a way to iterate over files passed in to the program on the command
-line (i.e. elements of L<C«@*ARGS»|/language/variables#index-entry-%40%2AARGS>).
-Thus the examples above can be simplified like so:
+This class is the magic behind the C<$*ARGFILES> variable, which provides a way
+to iterate over files passed in to the program on the command line (i.e.
+elements of L<C«@*ARGS»|/language/variables#index-entry-%40%2AARGS>). Thus the
+examples above can be simplified like so:
 
     .say for $*ARGFILES.lines;
 
@@ -42,7 +42,7 @@ Thus the examples above can be simplified like so:
     # or
     say $*ARGFILES.slurp;
 
-Save one of the variations in a file, say C<argfiles.p6>.  Then create
+Save one of the variations above in a file, say C<argfiles.p6>.  Then create
 another file (named, say C<sonnet18.txt> with the contents:
 
 =for code :lang<text>