Explain convenience behaviors in associative subscripting section

(could use some links, but too tired)

Also, provide an example of off-end access of a native array.

Author: skids

lib/Language/subscripts.pod

@@ -46,7 +46,7 @@ allows arbitrary objects as keys, etc.:
     say %grade{"Ben"};  #-> B+
     
     my $stats = ( Date.today => 4.18, Date.new(2015,  4,  5) => 17.253 ).Mix;
-    say $stats{ Date.new(2015, 4, 5) };  #-> 17.253
+    say $stats{ Date.new(2015, 4, 4) + 1 };  #-> 17.253
 
 For passing single-word string keys to C<{ }>, you can also use the
 L<angle-bracketed word quoting constructs|/language/quoting#Word_quoting:_qw>
@@ -62,6 +62,40 @@ C<{ }> form at compile-time:
     %hash«foo $var»;    # same as %hash{ «foo $var» }
     %hash<<foo $var>>;  # same as %hash{ <<foo $var>> }
 
+You may have noted above that we avoided having to quote C<Zoe> by using
+the C<=>> operator, but that same operator did not just put invisible
+quotes around C<Date.new(2015,  4,  5)>, and we were able to find the
+same element using C<$stats{ Date.new(2015, 4, 4) + 1 }>.  This is because
+C<=>> only puts invisible quotes around single words, and by "word" we
+mean an identifier/name.  The C<=>> operator is there to prevent us from
+accidentally calling functions or using constants with that name.
+
+Hash subscripts do not do the same thing as C<=>>.  The default C<Hash>
+has been made to behave the way new users have come to expect
+from using other languages, and for general ease of use.  On a
+default C<Hash>, subscripts coerce keys into strings, as long as
+those keys produce something C<Cool>.  You can use C<.perl> on a
+collection to be sure whether the keys are strings or objects:
+
+    ( 1  => 1 ).perl.say             #-> 1 => 1
+    my %h; %h{1}   = 1; say %h.perl; #-> { "1" => 1 }
+    ( 1/2 => 1 ).perl.say            #-> 0.5 => 1
+    my %h; %h{1/2} = 1; say %h.perl; #-> { "0.5" => 1 }
+    ( pi => 1 ).perl.say             #-> :pi(1)
+    my %h; %h{pi}  = 1; say %h.perl; #-> { "3.14159265358979" => 1 }
+
+While the invisible quotes around single names is built into C<=>>,
+string conversion is not built into the braces: it is a behavior
+of the default C<Hash>.  Not all types of hashes or collections
+do so:
+
+    my %h := MixHash.new;
+    $h{pi} = 1; %h.perl.say;         #-> (3.14159265358979e0=>1).MixHash
+
+(Any name that C<=>> would convert to a string can also be used to build
+a pair using "adverbial notation" and will appear that way when viewed
+through C<.perl>, which is why we see C<:pi(1)> above.)
+
 =end item1
 
 Subscripts can be applied to any expression that returns a subscriptable
@@ -97,8 +131,9 @@ is L<Any>):
 However, other types of collections may react differently to subscripts that
 address nonexistent elements:
 
-    say (0, 10, 20)[3];       #-> Nil
-    say bag(<a a b b b>)<c>;  #-> 0
+    say (0, 10, 20)[3];          #-> Nil
+    say bag(<a a b b b>)<c>;     #-> 0
+    say array[uint8].new(1,2)[2] #-> 0
 
 To silently skip nonexistent elements in a subscripting operation, see
 L<#Truncating slices> and the L<#:v> adverb.