Actions(stub)/Adverbial Pair/Argument/Parameter

Author: lizmat

doc/Language/glossary.pod

@@ -18,6 +18,8 @@ implemented using L<roles|Role> with L<stubbed|Stub> methods.
         method bark { say "woof" }   # *MUST* be implemented by class
     }
 
+=head1 Actions
+
 =head1 Advent Calendar
 
 In the context of Perl 6, a yearly set of blog posts for each day from
@@ -48,6 +50,21 @@ followed by a name (for the key):
 
 Also see L<Colon Pair and Colon List>.
 
+=head1 Adverbial Pair
+
+A generalized form of L</pair notation>.  They all start with the colon, like:
+
+  adverbial pair  | pair notation
+  ================|==============
+    :foo<bar>     | foo => 'bar'
+    :foo(42)      | foo => 42
+    :42foo        | foo => 42
+    :$foo         | foo => $foo
+    :foo          | foo => True
+    :!foo         | foo => False
+
+Also see L</Adverb> and L</Colon Pair and Colon List>.
+
 =head1 Anonymous
 
 A subroutine, method or submethod is called I<anonymous> if it can't be
@@ -59,7 +76,8 @@ called by name.
     # anonymous subroutine, stored in a named scalar
     my $double = sub ($x) { 2 * $x };
 
-Note that it is still allowed to have a name
+Note that it is still allowed to have a name, but you cannot call it by
+that name:
 
     # anonymous, but knows its own name
     my $s = anon sub triple($x) { 3 * $x }
@@ -91,6 +109,26 @@ initial barrage of RFC's that came out of the Perl community.  Now only kept
 as an historical document for reference.  See also L<Exegesis> and
 L<Synopsis>.
 
+=head1 Argument
+
+A value that you pass on to a L<subroutine|Subroutine>, L<method|Method>
+or a L<callable block|Callable>.  As opposed to the L<Parameter> that is
+specified in the definition of a subroutine/method/callable block.
+
+    sub foo($bar) { say $bar }     # $bar is a parameter
+    foo(42);                       # 42 is an argument
+
+=head1 Array
+
+L<Array|/type/Array> is a subclass of L<List|/type/List> that is mutable.
+This means you can e.g. C<.push> and C<.pop> on an array, whereas you cannot
+do that on a list.  This is separate from the type of elements in the array:
+if they are containers, then they are also mutable, but they don't have to
+be.  Arrays are typically recognizable by the L<@> L<sigil|Sigil>.
+
+    my @array = 1,2,3;
+    say @a;             # [1 2 3]
+
 =head1 Arity
 
 The number of L<positional|Positional> operands expected by an
@@ -485,6 +523,8 @@ Examples of things that are not lvalues:
     sub f { }; f();          # "normal" subs are not writable
     sub f($x) { $x = 3 };    # error - parameters are read-only by default
 
+These are typically called L<rvalues|rvalue>.
+
 =head1 Mainline
 
 The C<mainline> is the program text that is not part of any kind of block.
@@ -504,6 +544,16 @@ pre-compiled file).
 
 See L<Attribute>.
 
+=head1 Parameter
+
+L<Parameter|/type/Parameter> is a class to define parameters to
+L<subroutines|Subroutine>, L<methods|Method> and a L<callable blocks|Callable>.
+As opposed to the L<arguments|Argument> you specify when calling a
+subroutine/method/callable block.
+
+    sub foo($bar) { say $bar }     # $bar is a parameter
+    foo(42);                       # 42 is an argument
+
 =head1 Property
 
 See L<Attribute>.