Checks out for #2277, reflows meanwhile

Author: JJ

doc/Type/Bag.pod6

@@ -110,7 +110,7 @@ This method is inherited from L<Any|/type/Any#routine_reverse>, however,
 C<Mix>es do not have an inherent order and you should not trust it
 returning a consistent output.
 
-=head1 See Also
+=head1 See also
 
 L<Sets, Bags, and Mixes|/language/setbagmix>
 

doc/Type/Mix.pod6

@@ -6,16 +6,16 @@
 
     class Mix does Mixy { }
 
-A C<Mix> is an immutable mix, meaning a collection of distinct elements in no
-particular order that each have a real-number weight assigned to them. (For
-I<mutable> mixes, see L<MixHash> instead.)
+A C<Mix> is an immutable mix, meaning a collection of distinct elements
+in no particular order that each have a real-number weight assigned to
+them. (For I<mutable> mixes, see L<MixHash> instead.)
 
 C<Mix>es are often used for performing weighted random selections - see
 L<.roll|roll>.
 
-Objects/values of any type are allowed as mix elements. Within a C<Mix>, items
-that would compare positively with the L<===> operator are considered the same
-element, with a combined weight.
+Objects/values of any type are allowed as mix elements. Within a C<Mix>,
+items that would compare positively with the L<===> operator are
+considered the same element, with a combined weight.
 
 =begin code
 my $recipe = (butter => 0.22, sugar => 0.1,
@@ -28,8 +28,8 @@ say $recipe.total;      # OUTPUT: «0.615␤»
 =end code
 
 C<Mix>es can be treated as object hashes using the C<{ }> postcircumfix
-operator, which returns the corresponding numeric weight for keys that are
-elements of the mix, and C<0> for keys that aren't:
+operator, which returns the corresponding numeric weight for keys that
+are elements of the mix, and C<0> for keys that aren't:
 
     my $recipe = (butter => 0.22, sugar => 0.1,
                   flour => 0.275, sugar => 0.02).Mix;
@@ -39,21 +39,22 @@ elements of the mix, and C<0> for keys that aren't:
 
 =head1 Creating C<Mix> objects
 
-C<Mix>es can be composed using the L<mix|#sub mix> subroutine (or C<Mix.new>,
-for which it is a shorthand). Any positional parameters, regardless of their
-type, become elements of the mix - with a weight of C<1> for each time the
-parameter occurred:
+C<Mix>es can be composed using the L<mix|#sub mix> subroutine (or
+C<Mix.new>, for which it is a shorthand). Any positional parameters,
+regardless of their type, become elements of the mix - with a weight of
+C<1> for each time the parameter occurred:
 
     my $n = mix "a", "a", "b" => 0, "c" => 3.14;
     say $n.keys.map(&WHAT);  # OUTPUT: «((Str) (Pair) (Pair))␤»
     say $n.pairs;            # OUTPUT: «(a => 2 (c => 3.14) => 1 (b => 0) => 1)␤»
 
-Alternatively, the C<.Mix> coercer (or its functional form, C<Mix()>) can be
-called on an existing object to coerce it to a C<Mix>. Its semantics depend on
-the type and contents of the object. In general it evaluates the object in list
-context and creates a mix with the resulting items as elements, although for
-Hash-like objects or Pair items, only the keys become elements of the mix, and
-the (cumulative) values become the associated numeric weights:
+Alternatively, the C<.Mix> coercer (or its functional form, C<Mix()>)
+can be called on an existing object to coerce it to a C<Mix>. Its
+semantics depend on the type and contents of the object. In general it
+evaluates the object in list context and creates a mix with the
+resulting items as elements, although for Hash-like objects or Pair
+items, only the keys become elements of the mix, and the (cumulative)
+values become the associated numeric weights:
 
     my $n = ("a", "a", "b" => 0, "c" => 3.14).Mix;
     say $n.keys.map(&WHAT);  # OUTPUT: «((Str) (Str))␤»
@@ -82,27 +83,33 @@ Defined as:
 
     method Bag (--> Bag:D)
 
-Coerces the C<Mix> to a L«C<Bag>|/type/Bag». The weights are convert to L«C<Int>|/type/Int»,
-which means the number of keys in the resulting C<Bag> can be fewer than in the
-original C<Mix>, if any of the weights are negative or truncate to zero.
+Coerces the C<Mix> to a L«C<Bag>|/type/Bag». The weights are convert to
+L«C<Int>|/type/Int», which means the number of keys in the resulting
+C<Bag> can be fewer than in the original C<Mix>, if any of the weights
+are negative or truncate to zero.
 
 =head2 method BagHash
 
 Defined as:
 
     method BagHash (--> BagHash:D)
 
-Coerces the C<Mix> to a L«C<BagHash>|/type/BagHash». The weights are convert to L«C<Int>|/type/Int»,
-which means the number of keys in the resulting C<BagHash> can be fewer than in the
-original C<Mix>, if any of the weights are negative or truncate to zero.
+Coerces the C<Mix> to a L«C<BagHash>|/type/BagHash». The weights are
+convert to L«C<Int>|/type/Int», which means the number of keys in the
+resulting C<BagHash> can be fewer than in the original C<Mix>, if any of
+the weights are negative or truncate to zero.
 
 =head2 method reverse
 
-I<Note>: This method is inherited from L<Any|/type/Any#routine_reverse>, however, C<Mix>es do not have an inherent order and you should not trust it returning a consistent output.
+I<Note>: This method is inherited from L<Any|/type/Any#routine_reverse>,
+however, C<Mix>es do not have an inherent order and you should not trust
+it returning a consistent output.
 
 =head2 Note on order
 
-Same as the other elements in the L<Bag/Mix suite|/language/setbagmix>, order is not guaranteed or consistent and you shouldn't rely on methods like C<reverse> above returning always the same result.
+Same as the other elements in the L<Bag/Mix suite|/language/setbagmix>,
+order is not guaranteed or consistent and you shouldn't rely on methods
+like C<reverse> above returning always the same result.
 
 =head1 See Also