Some work on the glossary

As part of moving stuff from S99 in here

Author: lizmat

doc/Language/glossary.pod

@@ -20,6 +20,7 @@ Note that it is still allowed to have a name
     # anonymous, but knows its own name
     my $s = anon sub triple($x) { 3 * $x }
     say $s.name;        # triple
+    say triple(42);     # Undeclared routine: triple
 
 =head1 Adverb
 
@@ -38,7 +39,10 @@ reason colon pair notation is also known as the adverbial pair form:
     :a(4)          # Same as "a" => 4
 
 Some other forms that use a colon in ways that have adverb-like semantics
-are called adverbial forms.
+are called adverbial forms.  One special form starts with an integer value,
+followed by a name (for the key):
+
+    :20seconds     # same as seconds => 20
 
 =head1 Autothreading
 
@@ -49,7 +53,7 @@ these calls is assembled in a junction of the same type as the original
 junction.
 
     sub f($x) { 2 * $x };
-    if f(1|2|3) == 4 {
+    if f(1|2|3) == 4 {    # same as f(1) == 4 || f(2) == 4 || f(3) == 4
         say 'success';
     }
 
@@ -64,8 +68,8 @@ arguments into multiple calls to a function is called I<autothreading>.
 A colon pair is a shorthand syntax used to create or visually present
 a Pair object.  The two most common forms are:
 
-    :a(4)          # Same as "a" => 4,   same as Pair.new(:key<a>,:value(4))
-    :a<4>          # Same as "a" => "4", same as Pair.new(:key<a>,:value<4>)
+    :a(4)          # Same as "a" => 4,   same as Pair.new("a",4)
+    :a<4>          # Same as "a" => "4", same as Pair.new("a","4")
 
 This is also known as the adverbial pair form.  Note: when the part after
 the colon and before the brackets is not a legal identifier, other
@@ -81,6 +85,15 @@ does not need commas, or even spaces:
 
     :a(4):c:!d:c   # Same as a => 4, c => True, d => False, c => True
 
+Finally, if there is a variable with the same name as an intended adverbial
+pair, you don't have to specify the name twice, but just specify the adverb
+with the appropriate sigil:
+
+    :$foo          # same as foo => $foo
+    :@bar          # same as bar => @bar
+    :%mapper       # same as mapper => %mapper
+    :&test         # same as test => &test
+
 =head1 Constraint
 
 Constraints are a restriction placed on acceptable types for a parameter
@@ -89,11 +102,22 @@ following example, a constraint is used to make sure an error occurs if
 anyone ever calls a subroutine named C<abbreviate> with a string which is
 shorter than 10 characters:
 
-    sub abbreviate (Str $thing where { .chars >= 10 }) { ... }
+    sub abbreviate(Str $thing where { .chars >= 10 }) { ... }
 
 The C<Str> in the above example is also a constraint, but is usually
 referred to as a "type constraint."
 
+Note that you can elso differentiate candidates in a C<multi-dispatch>
+by using a different constraint:
+
+    multi sub abbreviate(Str $thing where { .chars >= 10 }) {
+        "$thing.substr(0,10)..."
+    }
+    multi sub abbreviate(Str $thing) { $thing }  # no constraint
+
+    say abbreviate("Worthington";    # Worthingto...
+    say abbreviate("Mäsak");         # Mäsak
+
 =head1 Instance
 
 An I<instance> of a class is also called an I<object> in some other
@@ -129,13 +153,17 @@ in Perl 6.  It is what C<self> refers to in a method.
 
     say 'str'.uc;   # 'str' is the invocant of method uc
 
+    class A { method show { self } }
+    say A.new.show;       # A.new
+
 =head1 Literal
 
 A I<literal> is a piece of code that directly stands for an (often built-in)
 object and also refers to the object itself.
 
     my $x = 2;      # the 2 is a literal
     say $x;         # $x is not a literal, but a variable
+    my $s = "Foo";  # the "Foo" is a literal, the $s is a variable
 
 =head1 lvalue
 
@@ -174,16 +202,26 @@ The C<mainline> is the program text that is not part of any kind of block.
     }
     f();        # in mainline again
 
+You can also have the mainline of any package-like declarator, such as
+C<class>, C<module>, C<grammar>, etc.  These are typically run just after
+the class/module/grammar have been compiled (or when loaded from a
+pre-compiled file).
+
 =head1 Slurpy
 
 A parameter of a sub or method is said to be I<slurpy> if it can consume an
 arbitrary number of arguments. It is indicated by an asterisk C<*> in front
 of the parameter name.
 
-    sub sum (*@numbers) {
+    sub sum(*@numbers) {
         return [+] @numbers;
     }
 
+This can also be used to collect all possible named parameters in a call:
+
+    sub allnameds(*%named) { .say for %named.sort }
+    allnameds a => 42, :666b, :c<foo>;  # a => 42, b => 666, c => foo
+
 =head1 Type Object
 
 A I<type object> is an object representing a class, role, package, grammar