Mostly minor fixes, a slightly more substantial fix in Bag.pod

Author: MasterDuke17

doc/Type/AST.pod

@@ -7,11 +7,11 @@
     class AST { }
 
 An C<AST> or I<Abstract Syntax Tree> is a partially processed representation
-of a program. ASTs are return values of the C<quasi> quoting construct,
+of a program.  ASTs are return values of the C<quasi> quoting construct,
 and are typically used within macros to generate code that is inserted
 in the calling location of the macro.
 
-There is no API defined for ASTs yet. Hopefully that will emerge as
+There is no API defined for ASTs yet.  Hopefully that will emerge as
 part of the work on macros.
 
 =end pod

doc/Type/Array.pod

@@ -23,7 +23,7 @@ Usage:
     pop ARRAY
     ARRAY.pop
 
-Removes and returns the last item from the array. Fails for an empty array.
+Removes and returns the last item from the array.  Fails for an empty array.
 
 Example:
 
@@ -58,7 +58,7 @@ Example:
     @foo.push: 'd';
     say @foo;                   # a b c d
 
-Note that C<push> does not attempt to flatten its argument list. If you pass
+Note that C<push> does not attempt to flatten its argument list.  If you pass
 an array or list as the thing to push, it becomes one additional element:
 
     my @a = <a b c>;
@@ -92,10 +92,10 @@ Usage:
     ARRAY.append(LIST)
     append ARRAY, LIST
 
-Appends the argument list to the array passed as first argument. This modifies
-the array in-place. Returns the modified array.
+Appends the argument list to the array passed as the first argument.  This
+modifies the array in-place.  Returns the modified array.
 
-The difference to method C<push> is that with an array or list argument,
+The difference from method C<push> is that with an array or list argument,
 C<append> appends several elements (one for each array or list element),
 whereas C<push> appends just one element.
 
@@ -119,14 +119,14 @@ Usage:
     shift ARRAY
     ARRAY.shift
 
-Removes and returns the first item from the array. Fails for an empty arrays.
+Removes and returns the first item from the array.  Fails for an empty arrays.
 
 Example:
 
     my @foo = <a b>;
-    say @foo.shift;     # a
-    say @foo.shift;     # b
-    say @foo.shift;     # Element shifted from empty list
+    say @foo.shift;             # a
+    say @foo.shift;             # b
+    say @foo.shift;             # Element shifted from empty list
 
 =head2 routine unshift
 
@@ -191,14 +191,14 @@ Usage:
     ARRAY.splice(START, ELEMS?, REPLACEMENT?)
 
 Deletes C<$elems> elements starting from index C<$start> from the C<Array>,
-returns them and replaces them by C<@replacement>. If C<$elems> is omitted,
+returns them and replaces them by C<@replacement>.  If C<$elems> is omitted,
 all the elements starting from index C<$start> are deleted.
 
 Example:
 
     my @foo = <a b c d e f g>;
-    say @foo.splice(2, 3, <M N O P>);       # c d e
-    say @foo;                               # a b M N O P f g
+    say @foo.splice(2, 3, <M N O P>);        # c d e
+    say @foo;                                # a b M N O P f g
     
 =head2 method shape
 
@@ -215,8 +215,8 @@ Returns the shape of the array as a list.
 Example:
 
     my @foo[2;3] = ( < 1 2 3 >, < 4 5 6 > ); # Array with fixed dimensions
-    say @foo.shape; # (2 3)
-    my @bar = ( < 1 2 3 >, < 4 5 6 > ); # Normal array (of arrays)
-    say @bar.shape; # (*)
+    say @foo.shape;                          # (2 3)
+    my @bar = ( < 1 2 3 >, < 4 5 6 > );      # Normal array (of arrays)
+    say @bar.shape;                          # (*)
 
 =end pod

doc/Type/Attribute.pod

@@ -42,7 +42,7 @@ Usage:
 
     ATTRIBUTE.name
 
-Returns the name of the attribute. Note that this is always the private name,
+Returns the name of the attribute.  Note that this is always the private name,
 so if an attribute is declared as C<has $.a>, the name returned is C<$!a>.
 
 =head2 method package
@@ -107,7 +107,7 @@ Usage:
 Returns the value stored in this attribute of object C<$instance>.
 
 Note that this method violates encapsulation of the object, and should be
-used with care. Here be dragons.
+used with care.  Here be dragons.
 
 =head2 method set_value
 
@@ -122,13 +122,13 @@ Usage:
 Binds the value C<new_val> to this attribute of object C<$instance>.
 
 Note that this method violates encapsulation of the object, and should be
-used with care. Here be dragons.
+used with care.  Here be dragons.
 
 =head2 trait is required
 
     multi sub trait_mod:<is> (Attribute $attr, :$required!)
 
-Marks an attribute as being required. If a value is not provided
+Marks an attribute as being required.  If a value is not provided
 during object construction, an exception is thrown.
 
     class Foo {
@@ -149,7 +149,7 @@ constructors written using L<bless>.
     multi sub trait_mod:<is> (Attribute:D $attr, :$rw!)
 
 Marks an attribute as read/write as opposed to the default
-C<readonly>. The default accessor for the attribute will return a
+C<readonly>.  The default accessor for the attribute will return a
 writable value.
 
    class Foo {

doc/Type/Backtrace.pod

@@ -9,7 +9,7 @@
 A backtrace shows the dynamic call stack, usually leading up to a point
 where an exception was thrown.
 
-It is a List of L<Backtrace::Frame> objects. Its default stringification
+It is a List of L<Backtrace::Frame> objects.  Its default stringification
 excludes backtrace frames that are deemed unnecessary or confusing, for
 example routines like C<&die> are hidden by default.
 

doc/Type/Bag.pod

@@ -8,15 +8,15 @@
 
 A C<Bag> is an immutable bag/multiset, meaning a collection of distinct elements
 in no particular order that each have an integer weight assigned to them
-signifying how many copies of that element are considered "in the bag". (For
+signifying how many copies of that element are considered "in the bag".  (For
 I<mutable> bags, see L<BagHash> instead.)
 
 C<Bag>s are often used for performing weighted random selections - see
 L<.pick|method pick> and L<.roll|method roll>.
 
-Objects/values of any type are allowed as bag elements. Within a C<Bag>, items
+Objects/values of any type are allowed as bag elements.  Within a C<Bag>, items
 that would compare positively with the L<===> operator are considered the same
-element, with the number of how many there were as its weight. But of course
+element, with the number of how many there are as its weight.  But of course
 you can also easily get back the expanded list of items (without the order):
 
 =begin code
@@ -30,8 +30,9 @@ say $breakfast.kxxv.sort;  # bacon eggs spam spam spam spam
 =end code
 
 C<Bag>s can be treated as object hashes using the C<{ }> postcircumfix operator,
-which returns the corresponding integer weight for keys that are elements of the
-bag, and C<0> for keys that aren't:
+or the C< < > > operator for literal string keys, which returns the
+corresponding integer weight for keys that are elements of the bag, and C<0> for
+keys that aren't:
 
     say $breakfast<bacon>;    # 1
     say $breakfast<spam>;     # 4
@@ -40,7 +41,7 @@ bag, and C<0> for keys that aren't:
 =head1 Creating C<Bag> objects
 
 C<Bag>s can be composed using the L<bag|#sub bag> subroutine (or C<Bag.new>, for
-which it is a shorthand). Any positional parameters, regardless of their type,
+which it is a shorthand).  Any positional parameters, regardless of their type,
 become elements of the bag:
 
     my $n = bag "a" => 0, "b" => 1, "c" => 2, "c" => 2;
@@ -49,8 +50,8 @@ become elements of the bag:
     say $n.values.perl;      # (1, 1, 1, 1).list
 
 Alternatively, the C<.Bag> coercer (or its functional form, C<Bag()>) can be
-called on an existing object to coerce it to a C<Bag>. Its semantics depend on
-the type and contents of the object. In general it evaluates the object in list
+called on an existing object to coerce it to a C<Bag>.  Its semantics depend on
+the type and contents of the object.  In general it evaluates the object in list
 context and creates a bag with the resulting items as elements, although for
 Hash-like objects or Pair items, only the keys become elements of the bag, and
 the (cumulative) values become the associated integer weights:
@@ -62,7 +63,7 @@ the (cumulative) values become the associated integer weights:
 
 Furthermore, you can get a C<Bag> by using bag operators (see next section) on
 objects of other types such as L<List>, which will internally call C<.Bag>
-on them before performing the operation. Be aware of the tight precedence of
+on them before performing the operation.  Be aware of the tight precedence of
 those operators though, which may require you to use parens around arguments:
 
     say (1..5) (+) 4;  # bag(1, 2, 3, 4(2), 5)
@@ -71,7 +72,7 @@ those operators though, which may require you to use parens around arguments:
 
 Perl 6 provides common set and bag operators, which can take C<Bag>s (or any
 other collections) as input, and return result as C<Bool>, C<Set> or C<Bag>
-values. For example:
+values.  For example:
 
 =begin code
 my ($a, $b) = bag(2, 2, 4), bag(2, 3, 3, 4);

doc/Type/BagHash.pod

@@ -11,9 +11,9 @@ elements in no particular order that each have an integer weight assigned to
 them signifying how many copies of that element are considered "in the bag".
 (For I<immutable> bags, see L<Bag> instead.)
 
-Objects/values of any type are allowed as bag elements. Within a C<BagHash>,
+Objects/values of any type are allowed as bag elements.  Within a C<BagHash>,
 items that would compare positively with the L<===> operator are considered the
-same element, with the number of how many there were as its weight. But of
+same element, with the number of how many there were as its weight.  But of
 course you can also easily get back the expanded list of items (without the
 order):
 
@@ -29,8 +29,8 @@ say $breakfast.kxxv.sort;  # bacon eggs spam spam spam spam
 
 C<BagHash>es can be treated as object hashes using the C<{ }> postcircumfix
 operator, which returns the corresponding integer weight for keys that are
-elements of the bag, and C<0> for keys that aren't. It can also be used to
-modify weights; Setting a weight to C<0> automatically removes that element from
+elements of the bag, and C<0> for keys that aren't.  It can also be used to
+modify weights; setting a weight to C<0> automatically removes that element from
 the bag, and setting a weight to a positive number adds that element if it
 didn't already exist:
 
@@ -46,7 +46,7 @@ say $breakfast.kxxv.sort;  # eggs sausage sausage spam spam spam spam
 
 =head1 Creating C<BagHash> objects
 
-C<BagHash>es can be composed using C<BagHash.new>. Any positional parameters,
+C<BagHash>es can be composed using C<BagHash.new>.  Any positional parameters,
 regardless of their type, become elements of the bag:
 
     my $n = BagHash.new: "a" => 0, "b" => 1, "c" => 2, "c" => 2;
@@ -55,8 +55,8 @@ regardless of their type, become elements of the bag:
     say $n.values.perl;      # (1, 1, 1, 1).list
 
 Alternatively, the C<.BagHash> coercer (or its functional form, C<BagHash()>)
-can be called on an existing object to coerce it to a C<BagHash>. Its semantics
-depend on the type and contents of the object. In general it evaluates the
+can be called on an existing object to coerce it to a C<BagHash>.  Its semantics
+depend on the type and contents of the object.  In general it evaluates the
 object in list context and creates a bag with the resulting items as elements,
 although for Hash-like objects or Pair items, only the keys become elements of
 the bag, and the (cumulative) values become the associated integer weights:

doc/Type/Baggy.pod

@@ -6,7 +6,7 @@
 
     class Baggy does QuantHash { }
 
-A role for collections of weighted objects. See L<Bag>, L<BagHash>, and
+A role for collections of weighted objects.  See L<Bag>, L<BagHash>, and
 L<Mixy>.
 
 =head1 Methods

doc/Type/Blob.pod

@@ -23,7 +23,7 @@ Usage:
 
 Creates a C<Blob> from a list of integers.
 
-=head2 method  Bool
+=head2 method Bool
 
 Defined as:
 
@@ -103,7 +103,7 @@ Extracts features from the blob according to the template string, and
 returns them as a list.
 
 The template string consists of zero or more units that begin with an ASCII
-letter, and are optionally followed by a quantifier. The quantifier can be
+letter, and are optionally followed by a quantifier.  The quantifier can be
 C<*> (which typically stands for "use up the rest of the Blob here"), or a
 positive integer (without a C<+>).
 

doc/Type/Block.pod

@@ -6,7 +6,7 @@
 
     class Block is Code { }
 
-A C<Block> is a code object meant for small-scale code reuse. A block is
+A C<Block> is a code object meant for small-scale code reuse.  A block is
 created syntactically by a list of statements enclosed in curly braces.
 
 Without an explicit signature or placeholder arguments, a block has C<$_>