Adds information on 'bareword' Pair declaration, closes #2520

Author: JJ

doc/Type/Pair.pod6

@@ -20,6 +20,11 @@ There are many syntaxes for creating C<Pair>s:
     :key<value1 value2>;      # But this is  key => <value1 value2>
     :foo(127);                # short for  foo => 127
     :127foo;                  # the same   foo => 127
+
+You can also use an I<identifier-like literal> as key; this will not need the
+quotes as long as it follows the syntax of
+L<ordinary identifiers|/syntax/%20identifiers.html#Ordinary_identifiers>:
+
     (foo => 127)              # the same   foo => 127
 
 Variants of this are
@@ -62,9 +67,9 @@ Any variable can be turned into a C<Pair> of its name and its value.
     say $p; # OUTPUT: «bar => 10␤»
 
 
-It is worth noting that when assigning a L<Scalar|/type/Scalar> as value of a C<Pair>
-the value holds the container of the value itself. This means that it is possible to change the
-value from outside of the C<Pair> itself:
+It is worth noting that when assigning a L<Scalar|/type/Scalar> as value of a
+C<Pair> the value holds the container of the value itself. This means that it is
+possible to change the value from outside of the C<Pair> itself:
 
 =begin code
 my $v = 'value A';
@@ -75,12 +80,13 @@ $v = 'value B';
 $pair.say; # OUTPUT: a => value B
 =end code
 
-Please also note that this behavior is totally unrelated to the way used to build the C<Pair> itself
-(i.e., explicit usage of C<new>, use of colon, fat arrow), as well as if the C<Pair> is bound
-to a variable.
+Please also note that this behavior is totally unrelated to the way used to
+build the C<Pair> itself (i.e., explicit usage of C<new>, use of colon, fat
+arrow), as well as if the C<Pair> is bound to a variable.
 
-It is possible to change the above behaviour forcing the C<Pair> to remove the scalar container
-and to hold the effective value itself via the method L<freeze|/type/Pair#method_freeze>:
+It is possible to change the above behaviour forcing the C<Pair> to remove the
+scalar container and to hold the effective value itself via the method
+L<freeze|/type/Pair#method_freeze>:
 
 =begin code
 my $v = 'value B';
@@ -116,18 +122,19 @@ it and checks invocant's value C<.ACCEPTS> that value:
     say %(:42a) ~~ :42a; # OUTPUT: «True␤»
     say %(:42a) ~~ :10a; # OUTPUT: «False␤»
 
-If C<topic> is another L<Pair|/type/Pair>, checks the invocant's value C<.ACCEPTS> the
-C<topic's> value. Note that the keys are not considered and can be different:
+If C<topic> is another L<Pair|/type/Pair>, checks the invocant's value
+C<.ACCEPTS> the C<topic's> value. Note that the keys are not considered and can
+be different:
 
     say :42a ~~ :42a; # OUTPUT: «True␤»
     say :42z ~~ :42a; # OUTPUT: «True␤»
     say :10z ~~ :42a; # OUTPUT: «False␤»
 
 If C<topic> is any other value, uses the invocant's key as the name of the
 method to call on C<topic> and check's its L«C<.Bool>|/routine/Bool» is the same
-as C<.Bool> of the invocant's value. This form can be used to check L<Bool|/type/Bool> values
-of multiple methods on the same object, such as L<IO::Path>, by using
-L<Junctions|/type/Junction>:
+as C<.Bool> of the invocant's value. This form can be used to check
+L<Bool|/type/Bool> values of multiple methods on the same object, such as
+L<IO::Path>, by using L<Junctions|/type/Junction>:
 
     say "foo" .IO ~~ :f & :rw; # OUTPUT: «False␤»
     say "/tmp".IO ~~ :!f;      # OUTPUT: «True␤»