Modified examples with hashes to use %() hash literal syntax

Modified section in syntax file to replace instances of the { }
operator with the preferred hash literal constructor %(). Documentation
of the { } is still in doc/Type/Hash.pod6.

Modified existing examples to use the %() hash literal as mentioned in
Issue #1380.

Author: jstuder-gh

doc/Language/5to6-nutshell.pod6

@@ -452,8 +452,8 @@ right-hand side of the assignment will be interpreted as a L<Block|/type/Block>,
 not a Hash:
 
     my @people = [
-        { id => "1A", firstName => "Andy", lastName => "Adams" },
-        { id => "2B", firstName => "Beth", lastName => "Burke" },
+        %( id => "1A", firstName => "Andy", lastName => "Adams" ),
+        %( id => "2B", firstName => "Beth", lastName => "Burke" ),
         # ...
     ];
 

doc/Language/faq.pod6

@@ -215,7 +215,7 @@ for dumping, whose output is similar to L<perl>, but with more information.
 
 Examples:
 
-    my $foo = { foo => 'bar' };
+    my $foo = %( foo => 'bar' );
     say $foo.perl;   # OUTPUT: «${:foo("bar")}␤»
     say $foo;        # OUTPUT: «{foo => bar}␤»
 

doc/Language/modules.pod6

@@ -335,9 +335,9 @@ passing C<:DEFAULT> to C<use> along with your positional parameters.
     class MyModule::Class {}
 
     sub EXPORT($short_name?) {
-        {
+        %(
           do $short_name => MyModule::Class if $short_name
-        }
+        )
     }
 
     sub always is export(:MANDATORY) { say "works" }
@@ -364,9 +364,9 @@ L<Cool>s.
     # lib/MakeQuestionable.pm
     sub EXPORT(::Questionable) {
         my multi postfix:<?>(Questionable $_) { .so };
-        {
+        %(
           '&postfix:<?>' => &postfix:<?>,
-        }
+        )
     }
     =end code
 

doc/Language/syntax.pod6

@@ -525,23 +525,24 @@ Use the L<Slip> prefix operator (C<|>) to flatten the needed items:
 
 =head3 Hash literals
 
-A pair of curly braces can surround a list of pairs to form a
-L<Hash|/type/Hash> literal; typically there is a comma-delimited list of pairs
-inside. If a non-pair is used, it is assumed to be a key and the next element
-is the value. Most often this is used with simple arrow pairs.
+A leading associative sigil and pair of parenthesis C<%( )> can surround a C<List> of
+C<Pairs> to form a L<Hash|/type/Hash> literal; typically there is a comma-delimited
+C<List> of C<Pairs> inside. If a non-pair is used, it is assumed to be a key and
+the next element is the value. Most often this is used with simple arrow pairs.
 
-    say { a => 3, b => 23, :foo, :dog<cat>, "french", "fries" };
+    say %( a => 3, b => 23, :foo, :dog<cat>, "french", "fries" );
     # OUTPUT: «a => 3, b => 23, dog => cat, foo => True, french => fries␤»
 
-    say {a => 73, foo => "fish"}.keys.join(" ");   # OUTPUT: «a foo␤»
-    #   ^^^^^^^^^^^^^^^^^^^^^^^^ Hash constructor
+    say %(a => 73, foo => "fish").keys.join(" ");   # OUTPUT: «a foo␤»
+    #   ^^^^^^^^^^^^^^^^^^^^^^^^^ Hash constructor
 
-When assigning to a C<%> sigil variable, the curly braces are optional.
+When assigning to a C<%> sigiled variable on the LHS, the sigil and parenthesis
+surrounding the RHS C<Pairs> are optional.
 
     my %ages = fred => 23, jean => 87, ann => 4;
 
-By default keys in C<{ }> are forced to strings. To compose a hash with
-non-string keys, use a colon prefix:
+By default, keys in C<%( )> are forced to strings. To compose a hash with
+non-string keys, use curly brace delimiters with a colon prefix C<:{ }> :
 
     my $when = :{ (now) => "Instant", (DateTime.now) => "DateTime" };
 

doc/Type/Any.pod6

@@ -309,7 +309,7 @@ Defined as:
 Forces given object to be evaluated in item context and returns the value of it.
 
     say item([1,2,3]).perl;              # OUTPUT: «$[1, 2, 3]␤»
-    say item({ apple => 10 }).perl;      # OUTPUT: «${:apple(10)}␤»
+    say item( %( apple => 10 ) ).perl;   # OUTPUT: «${:apple(10)}␤»
     say item("abc").perl;                # OUTPUT: «"abc"␤»
 
 You can also use C<$> as item contextualizer.

doc/Type/Hash.pod6

@@ -78,22 +78,22 @@ not a Hash:
 
 =begin code :skip-test
 my @people = [
-    { id => "1A", firstName => "Andy", lastName => "Adams" },
-    { id => "2B", firstName => "Beth", lastName => "Burke" },
+    %( id => "1A", firstName => "Andy", lastName => "Adams" ),
+    %( id => "2B", firstName => "Beth", lastName => "Burke" ),
     # ...
 ];
 
 sub lookup-user (Hash $h) { #`(Do something...) $h }
 
 my @names = map {
     # While this creates a hash:
-    my $query = { name => "$person<firstName> $person<lastName>" };
+    my  $query = { name => "$person<firstName> $person<lastName>" };
     say $query.^name;      # OUTPUT: «Hash␤»
-    # And this also makes a hash
+
     # Doing this will create a Block. Oh no!
-    my $query = { name => "$_<firstName> $_<lastName>" };
+    my  $query2 = { name => "$_<firstName> $_<lastName>" };
     say $query2.^name;       # OUTPUT: «Block␤»
-    say $query2<name>;      # fails
+    say $query2<name>;       # fails
 
     CATCH { default { put .^name, ': ', .Str } };
     # OUTPUT: «X::AdHoc: Type Block does not support associative indexing.␤»
@@ -540,7 +540,7 @@ arguments|/type/Signature#Positional_vs._Named> to C<.append>.
 
     my %h = a => 1;
     %h.append('b', 2, 'c', 3);
-    %h.append({d => 4});
+    %h.append( %(d => 4) );
     say %h;
     # OUTPUT: «{a => 1, b => 2, c => 3, d => 4}␤»
     %h.append('a', 2);

doc/Type/List.pod6

@@ -764,7 +764,7 @@ comparator.
 
 Example:
 
-    my @list = {a => 42}, {b => 13}, {a => 42};
+    my @list = %(a => 42), %(b => 13), %(a => 42);
     say @list.unique(:with(&[eqv]))               # OUTPUT: «({a => 42} {b => 13})␤»
 
 B<Note:> since C<:with> L<Callable> has to be tried with all the items in the list,
@@ -789,7 +789,7 @@ Examples:
     say <a b b c c b a>.repeated;                   # OUTPUT: «(b c b a)␤»
     say <a A B b c b C>.repeated(:as(&lc));         # OUTPUT: «(A b b C)␤»
 
-    my @list = {a => 42}, {b => 13}, {a => 42};
+    my @list = %(a => 42), %(b => 13), %(a => 42);
     say @list.repeated(:with(&[eqv]))               # OUTPUT: «({a => 42})␤»
 
 =head2 routine squish

doc/Type/Mixy.pod6

@@ -19,7 +19,7 @@ C<Mixy> are L<Real>s rather than L<Int>s.
 Returns the sum of all the weights
 
     mix('a', 'b', 'c', 'a', 'a', 'd').total == 6; # RESULT: «True»
-    {a => 5.6, b => 2.4}.Mix.total == 8;          # RESULT: «True»
+    %(a => 5.6, b => 2.4).Mix.total == 8;         # RESULT: «True»
 
 =head2 method roll
 

doc/Type/Mu.pod6

@@ -80,7 +80,7 @@ empty L<string|/type/Str> or numerical zeros
     say Mu.new.Bool;                # OUTPUT: «True␤»
     say [1, 2, 3].Bool;             # OUTPUT: «True␤»
     say [].Bool;                    # OUTPUT: «False␤»
-    say { 'hash' => 'full' }.Bool;  # OUTPUT: «True␤»
+    say %( hash => 'full' ).Bool;   # OUTPUT: «True␤»
     say {}.Bool;                    # OUTPUT: «False␤»
     say "".Bool;                    # OUTPUT: «False␤»
     say 0.Bool;                     # OUTPUT: «False␤»
@@ -147,9 +147,9 @@ write a Perl expression that produces a particular value
 
 Forces the invocant to be evaluated in item context and returns the value of it.
 
-    say [1,2,3].item.perl;         # OUTPUT: «$[1, 2, 3]␤»
-    say { apple => 10 }.item.perl; # OUTPUT: «${:apple(10)}␤»
-    say "abc".item.perl;           # OUTPUT: «"abc"␤»
+    say [1,2,3].item.perl;          # OUTPUT: «$[1, 2, 3]␤»
+    say %( apple => 10 ).item.perl; # OUTPUT: «${:apple(10)}␤»
+    say "abc".item.perl;            # OUTPUT: «"abc"␤»
 
 =head2 method self